Week 3 (Assignment 1).ipynb

{
 "cells": [
  {
   "cell_type": "raw",
   "id": "3eb2dfec",
   "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": "markdown",
   "id": "9b6c1303",
   "metadata": {},
   "source": [
    "Answer: "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80801d38",
   "metadata": {},
   "source": [
    "The keyword used to create a function in Python is def. Here's a function that returns a list of odd numbers in the range of 1 to 25:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7e3a6749",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_odd_numbers():\n",
    "    odd_numbers=[]\n",
    "    for i in range(1, 26):\n",
    "        if i%2!=0:\n",
    "            odd_numbers.append(i)\n",
    "    return odd_numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4a6fb4a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_odd_numbers()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4eeb4821",
   "metadata": {},
   "source": [
    "Q2. Why *args and **kwargs is used in some functions? Create a function each for *args and **kwargs \n",
    "to demonstrate their use"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "211c8bb9",
   "metadata": {},
   "source": [
    "Answer:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f93f429",
   "metadata": {},
   "source": [
    "   *args is used to pass a variable number of non-keyword arguments to a function. It allows you to pass any number of positional arguments, which are then treated as a tuple inside the function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be67f25b",
   "metadata": {},
   "source": [
    "    **kwargs is used to pass a variable number of keyword arguments to a function. It allows you to pass any number of keyword arguments, which are then treated as a dictionary inside the function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dcfce5e",
   "metadata": {},
   "source": [
    "create functions to demonstrate their use:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c460ecd3",
   "metadata": {},
   "source": [
    "Function using *args:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8645f868",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_all(*args):\n",
    "    total = 0\n",
    "    for num in args:\n",
    "        total += num\n",
    "    return total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "52f9d8f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_all(1,2,3,4,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50216300",
   "metadata": {},
   "source": [
    "Function using **kwargs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "18cff537",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(**kwargs):\n",
    "    return kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0d2c03ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "115a793b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': [1, 2, 3, 4, 5], 'b': 'Praveen', 'c': 34.7}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test(a=[1,2,3,4,5],b=\"Praveen\",c=34.7)"
   ]
  },
  {
   "cell_type": "raw",
   "id": "ab328f7b",
   "metadata": {},
   "source": [
    "Q3.  What is an iterator in python? Name the method used to initialise the iterator object and the method \n",
    "used for iteration. Use these methods to print the first five elements of the given list [2, 4, 6, 8, 10, 12, 14, \n",
    "16, 18, 20]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24b44c09",
   "metadata": {},
   "source": [
    "Answer:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cca0d54f",
   "metadata": {},
   "source": [
    " In Python, an iterator is an object that allows you to iterate over collections of data, such as lists, tuples, dictionaries, and sets.\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "579189bc",
   "metadata": {},
   "source": [
    "__iter__(): This method is used to initialize the iterator object. It returns the iterator object itself.\n",
    "\n",
    "__next__(): This method is used for iteration. It returns the next value from the sequence. When there are no more elements to return, it raises the StopIteration exception to signal the end of the iteration.\n",
    "\n",
    "To print the first five elements of the given list [2, 4, 6, 8, 10, 12, 14, 16, 18, 20], we can use an iterator and the mentioned methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "55b46854",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "my_list=[2,4,6,8,10,12,14,16,18,20]\n",
    "my_iterator=iter(my_list)\n",
    "for my_list in range(5):\n",
    "    element=next(my_iterator)\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc3b06cf",
   "metadata": {},
   "source": [
    "In the code above, we first create an iterator using the iter() function on the list my_list. Then, we use a for loop to iterate five times, and in each iteration, we use the next() function to get the next element from the iterator and print it."
   ]
  },
  {
   "cell_type": "raw",
   "id": "785a8d5f",
   "metadata": {},
   "source": [
    "Q4.  What is a generator function in python? Why yield keyword is used? Give an example of a generator \n",
    "function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14881d71",
   "metadata": {},
   "source": [
    "Answer:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b534460b",
   "metadata": {},
   "source": [
    "A Python generator function allows you to declare a function that behaves like an iterator, providing a faster and easier way to create iterators."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74232dba",
   "metadata": {},
   "source": [
    "Yield keyword is used to a generator function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "e5478d41",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_count(n):\n",
    "    count=1\n",
    "    while count<=n:\n",
    "        yield count\n",
    "        count=count+1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "8c10e6e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "c=test_count(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "ddee5f76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in c:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "3aca14f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "generator"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(c)"
   ]
  },
  {
   "cell_type": "raw",
   "id": "0732f0eb",
   "metadata": {},
   "source": [
    "Q5. Create a generator function for prime numbers less than 1000. Use the next() method to print the \n",
    "first 20 prime numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fe7748a",
   "metadata": {},
   "source": [
    "Answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "fe964d31",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_primes(limit):\n",
    "    l=[True]*(limit+1)\n",
    "    l[0]=l[1]=False\n",
    "    \n",
    "    for num in range(2,int(limit**0.5)+1):\n",
    "        if l[num]:\n",
    "            for multiple in range(num*num,limit+1,num):\n",
    "                l[multiple]=False\n",
    "    for num in range(2, limit+1):\n",
    "        if l[num]:\n",
    "            yield num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "a6f197a8",
   "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": [
    "prime_gen = generate_primes(1000)\n",
    "\n",
    "for _ in range(20):\n",
    "    prime = next(prime_gen)\n",
    "    print(prime)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "c130a919",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "generator"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(prime_gen)"
   ]
  },
  {
   "cell_type": "raw",
   "id": "db3c3bce",
   "metadata": {},
   "source": [
    "Q6. Write a python program to print the first 10 Fibonacci numbers using a while loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d440a9ee",
   "metadata": {},
   "source": [
    "Answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "27638999",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_fib1():\n",
    "    a,b=0,1\n",
    "    while True:\n",
    "        yield a\n",
    "        a,b=b,a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "f2faed86",
   "metadata": {},
   "outputs": [],
   "source": [
    "fib=test_fib1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "b06a0e8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(next(fib))"
   ]
  },
  {
   "cell_type": "raw",
   "id": "1d6875fc",
   "metadata": {},
   "source": [
    "Q7. Write a List Comprehension to iterate through the given string: ‘pwskills’.\n",
    "\n",
    "Expected output: ['p', 'w', 's', 'k', 'i', 'l', 'l', 's'] "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afb8568e",
   "metadata": {},
   "source": [
    "Answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "e51b74c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['p', 'w', 's', 'k', 'i', 'l', 'l', 's']\n"
     ]
    }
   ],
   "source": [
    "input_string=\"pwskills\"\n",
    "input_result=[char for char in input_string]\n",
    "print(input_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "373500a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q8. Write a python program to check whether a given number is Palindrome or not using a while loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ad1a70f",
   "metadata": {},
   "source": [
    "Answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "ca1733a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12321 is a palindrome.\n",
      "12345 is not a palindrome.\n"
     ]
    }
   ],
   "source": [
    "def is_palindrome(num):\n",
    "    o_num=num\n",
    "    r_num=0\n",
    "    \n",
    "    while num>0:\n",
    "        digit=num%10\n",
    "        r_num=r_num*10+digit\n",
    "        num=num//10\n",
    "    return o_num==r_num\n",
    "num1=12321\n",
    "num2=12345\n",
    "\n",
    "if is_palindrome(num1):\n",
    "    print(f\"{num1} is a palindrome.\")\n",
    "else:\n",
    "    print(f\"{num1} is not a palindrome.\")\n",
    "    \n",
    "if is_palindrome(num2):\n",
    "    print(f\"{num2} is a palindrome.\")\n",
    "else:\n",
    "    print(f\"{num2} is not a palindrome.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27b6a775",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q9. Write a code to print odd numbers from 1 to 100 using list comprehension."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0326412",
   "metadata": {},
   "source": [
    "Answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "5229fd11",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99]\n"
     ]
    }
   ],
   "source": [
    "odd_numbers=[num for num in range(1,101)if num%2!=0]\n",
    "print(odd_numbers)"
   ]
  }
 ],
 "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}