Project_3_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "56451008-c883-4140-96b1-6179078565ad",
   "metadata": {},
   "source": [
    "## Q1. Which keyword is used to create a function? Create a function to return a list of odd numbers in the range of 1 to 25."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "286b78a4-2d07-4196-92dd-ef511b5aafee",
   "metadata": {},
   "outputs": [],
   "source": [
    "#def keyword is used to create a function\n",
    "\n",
    "def odd_nu():\n",
    "    l=[]\n",
    "    for i in range(1,26):\n",
    "        if i%2!=0:\n",
    "            l.append(i)\n",
    "    return l \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2eaa06fa-4d4b-42da-a205-e42ecec1aadd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "odd_nu()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03f52777-e1cb-42af-b269-4c0b2ba265a2",
   "metadata": {},
   "source": [
    "## Q2. Why *args and **kwargs is used in some functions? Create a function each for *args and **kwargs to demonstrate their use."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ab5591c-5245-467f-9337-83f060f3bead",
   "metadata": {},
   "source": [
    "#### When we dont know the number of elements to define in a function we use *args (here the name after * can be any) and when we want the elements accepted in the form of dictionary (ie.key value pair we use **kwargs here the name after ** can be any)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "200988df-d112-4c35-8c83-835203f52f3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(a,b,c):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f988cc4e-e5ed-4744-b7dc-daed1fa0b4d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "func(1,2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "89c80618-92ca-410d-a8bb-93e66414ef37",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "func() takes 3 positional arguments but 4 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[5], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: func() takes 3 positional arguments but 4 were given"
     ]
    }
   ],
   "source": [
    "func(1,2,3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "80ad9a9f-fe38-40ec-bf5f-c7c21840a55a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#to solve the above error we use *args\n",
    "def func1(*args):\n",
    "    return args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e4ae3ebf-9949-4c54-ad0e-0d84e49a1e88",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(func1())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "fe0a4580-477b-4054-b4e3-07c27eeeb6c7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 'abc', 43.2)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func1(1,2,3,\"abc\",43.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "041d9b46-129a-440a-ac07-501b8c8e6116",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 'abc', 43.2, 431, 43112, 4223, 'sjhje')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#we can pass any number of elements while calling function\n",
    "func1(1,2,3,\"abc\",43.2,431,43112,4223,\"sjhje\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "325c645a-5fc4-4af3-8e23-ac64f08593ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "def func2(**kwargs):\n",
    "    return kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "fad12d44-67bb-4417-82e7-6869cccaee07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 12, 'b': 34, 'c': 55, 'd': 90}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func2(a=12,b=34,c=55,d=90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a5e5345e-cb4f-408f-837a-a821cb9683d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(func2())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b285064f-1130-4078-ac31-b9a4a23c775e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#We can use both together also\n",
    "\n",
    "def func3(*args,**kwargs):\n",
    "    return args,kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "38ec207a-1ad5-472d-9884-022e5e7d0ae6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1, 2, 4, 5, 6), {'z': 13, 'y': 83, 'x': 39})"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func3(1,2,4,5,6,z=13,y=83,x=39)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24045219-7648-450e-91c1-76f8cc2dd0de",
   "metadata": {},
   "source": [
    "## Q3. What is an iterator in python? Name the method used to initialise the iterator object and the method used for iteration. Use these methods to print the first five elements of the given list [2, 4, 6, 8, 10, 12, 14, 16,18, 20]."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c94b1df-cec5-43ff-ab62-802e4a010425",
   "metadata": {},
   "source": [
    "\n",
    "#### Iterator is an object thorugh which we can traves all values in the object.\n",
    "#### iter method is used to initialize the iterator object.\n",
    "#### next method is used for iteration. Returns the next item in the sequence or object.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "2aa337d3-6b91-4284-abc1-17721f101dc1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list_iterator'>\n",
      "Manually 2\n",
      "From loop : 4\n",
      "From loop : 6\n",
      "From loop : 8\n",
      "From loop : 10\n"
     ]
    }
   ],
   "source": [
    "l = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]\n",
    "\n",
    "# Create an iterator object\n",
    "iter_list = iter(l)\n",
    "\n",
    "print(type(iter_list))\n",
    "\n",
    "print(\"Manually\",next(iter_list))#print 1st element 2\n",
    "\n",
    "for i in range(4): #for printing the next 4 elements\n",
    "    print(\"From loop :\",next(iter_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bef9b9a5-ff0a-4cce-9d69-328a428e9c66",
   "metadata": {},
   "source": [
    "## Q4. What is a generator function in python? Why yield keyword is used? Give an example of a generator function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f0f9487-6ab9-49e8-84a0-1a1a055d6c92",
   "metadata": {},
   "source": [
    "\n",
    "#### Generator functions are functions which returns generator object through which we can iterate over values. \n",
    "#### It is useful when we we want to produce a large sequence of values, but we dont want to store all of them in memory at once.\n",
    "#### Because storing all of them at once in memory will take a lot of processing time.\n",
    "#### Iterating it gives us one value at a time\n",
    "#### Yield returns a value and pauses the execution while maintaining the internal states.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "91465b1b-d1ee-4583-a0e2-17b952e05cc1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "<generator object fibo at 0x7f167db3cb30>\n",
      "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n"
     ]
    }
   ],
   "source": [
    "#fibonacci series using generator function\n",
    "def fibo(n):\n",
    "    a,b=0,1\n",
    "    for i in range(n):\n",
    "        yield a\n",
    "        a,b = b,a+b\n",
    "\n",
    "\n",
    "print(type(fibo(1)))#checking type\n",
    "print(fibo(10))#cant access object directly\n",
    "print(list(fibo(10)))#using list to access object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b67941bd-15ca-48c7-84aa-ddab203202f1",
   "metadata": {},
   "source": [
    "## Q5. Create a generator function for prime numbers less than 1000. Use the next() method to print the first 20 prime numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bb0e7959-c8d0-496b-aebc-97de1ad3f491",
   "metadata": {},
   "outputs": [],
   "source": [
    "max_no = 1000\n",
    "\n",
    "# Function to check if number is prime number or not\n",
    "def is_prime(num):\n",
    "    if num <= 1:\n",
    "        return False\n",
    "    if num == 2:\n",
    "        return True\n",
    "    for i in range(2,num):\n",
    "        if num % i == 0:\n",
    "            return False\n",
    "    return True    \n",
    "\n",
    "# Generator Function \n",
    "def prime_num(max_num):\n",
    "    for i in range(max_num):\n",
    "        if is_prime(i):\n",
    "            yield i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "1e1a04ac-279c-4848-b5a1-6165f33dd028",
   "metadata": {},
   "outputs": [],
   "source": [
    "prime_gen=prime_num(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "7269a620-fd1f-4e4d-8185-fc0d1a5f29e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "generator"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(prime_gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6e4281aa-e983-4dad-997f-18cff570b278",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n",
      "13\n",
      "17\n",
      "19\n",
      "23\n",
      "29\n",
      "31\n",
      "37\n",
      "41\n",
      "43\n",
      "47\n",
      "53\n",
      "59\n",
      "61\n",
      "67\n",
      "71\n"
     ]
    }
   ],
   "source": [
    "for i in range(20):\n",
    "    print(next(prime_gen))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}