Mega_Assignment(Python).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Mega Assignment (Python)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. **Which of the following terms are related to dictionaries?**\n",
    "    1. **value**\n",
    "    2. item\n",
    "    3. index\n",
    "    4. **key**\n",
    "  \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. **Just like lists, + operator is used to extend dictionaries?**\n",
    "   1. True\n",
    "   2. **False**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. **To access items from a dictionary, we specify the index of that item within [] like myDict[0]?**\n",
    "   1. True\n",
    "   2. **False**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. **When we use [] to access the value from a dictionary which does not exist in that dictionary….?**\n",
    "   1. Value within [] is added to the dictionary\n",
    "   2. Value None is returned\n",
    "   3. New dictionary is created\n",
    "   4. **None of above**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. **What does return the pop method of a dictionary?**\n",
    "   1. list\n",
    "   2. tuple containing the pair of last item of the dictionary\n",
    "   3. dictionary\n",
    "   4. **value of the key, if it exists in the dictionary**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. **What does return popitem method return?**\n",
    "   1. dictionary\n",
    "   2. tupple containing the pair of last item of the dictionary\n",
    "   3. list\n",
    "   4. value of key, if it exists in the dictionary\n",
    "   5. **This is repition of above question.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. **Which of the following 2 methods can be used to iterate through the items of a dictionary?**\n",
    "   1. items()\n",
    "   2. **values()**\n",
    "   3. indexes()\n",
    "   4. **keys()**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. **Which one of the following is used to enclose a dictionary?**\n",
    "   1. () parenthesis\n",
    "   2. **{} curly brackets**\n",
    "   3. [] square brackets\n",
    "   4. “” quotation marks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  9. Write Python Program add key-value pair in dictionary and check if a Given Key or Value or Both exists in a Dictionary or Not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter the key 'in string' to be added. fName\n",
      "Please enter the value 'in string' to be entered. Zafar\n",
      "Updated Dictionary is: \n",
      "{'fName': 'Zafar'}\n"
     ]
    }
   ],
   "source": [
    "key = input(\"Please enter the key 'in string' to be added. \")\n",
    "value = input(\"Please enter the value 'in string' to be entered. \")\n",
    "myDict = {}\n",
    "myDict.update({key:value})\n",
    "print(\"Updated Dictionary is: \")\n",
    "print(myDict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 10. Write a Python Program to Count the Frequency of Words Appearing in a String Using a Dictionary and print only the words having Even (divisible by 2) frequency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cities = [\"Islamabad\",\"Karachi\",\"Lahore\",\"Peshawar\",\"Quetta\", \"Karachi\", \"Peshawar\"]\n",
    "i = 0\n",
    "while i<len(cities):\n",
    "    print(i)\n",
    "    i += 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "11. **What will be output of following? X = [Feb, Apr, Mar, May, Jun, Jul, Aug, Jan]**\n",
    "    1. X[0:3]      = **['Feb', 'Apr', 'Mar']**\n",
    "    2. X[2:8]      = **['Mar', 'May', 'Jun', 'Jul', 'Aug', 'Jan']**\n",
    "    3. X[4:9]      = **['Jun', 'Jul', 'Aug', 'Jan']**\n",
    "    4. X[1:7:2]    = **['Apr', 'May', 'Jul']**\n",
    "    5. X[-1:-7]    = **[ ]**\n",
    "    6. X[-7:7]     = **['Apr', 'Mar', 'May', 'Jun', 'Jul', 'Aug']**\n",
    "    7. X[-1:-8:-2] = **['Jan', 'Jul', 'May', 'Apr']**\n",
    "    8. X[:4]       = **['Feb', 'Apr', 'Mar', 'May']**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "12. Remove the correct number from the list X\n",
    "    - x = [ 9,2,8,4,5]\n",
    "    - x.__?__\n",
    "    - print(x)\n",
    "    - output = [2,8,4,5]\n",
    "    - **Answer (Correct Option):**\n",
    "      1. .delete(9)\n",
    "      2. .rm(9)\n",
    "      3. **.remove(9)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "13. **Find correct answer:**\n",
    "    - p = 3\n",
    "    - q = 'hello!'\n",
    "    - print(p  ?  q)\n",
    "    - **Answer (Correct Option):**\n",
    "      1. * \n",
    "      2. **\n",
    "      3. +\n",
    "      4. **Correct option is A.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "14. **y = \"this is a random sentence\"**\n",
    "    - print (y__?__)\n",
    "    - Output: THIS IS A RANDOM SENTENCE\n",
    "    - **Answer (Correct Option):**\n",
    "    1. **.upper()**\n",
    "    2. .upcase()\n",
    "    3. .capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "15. **Print following statements:**\n",
    "    - p = True\n",
    "    - q = ‘True’\n",
    "    - r = 2\n",
    "    - s = 2.0\n",
    "      1. print(type(p))  =  **<class 'bool'>**\n",
    "      2. print(type(q))  =  **<class 'str'>**\n",
    "      3. print(type(r))  =  **<class 'int'>**\n",
    "      4. print(type(s))  =  **<class 'float'>**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "16. **What are the optional arguments to the function?**\n",
    "    - function_1(R1, q, p=None, R2= None)\n",
    "      1. q and R2\n",
    "      2. **p and R2**\n",
    "      3. p and R1\n",
    "      4. R1 and q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "17. **Which command invokes method X() of the object p?**\n",
    "    1. X(p)\n",
    "    2. p$x()\n",
    "    3. X().p\n",
    "    4. **p.x()**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "18. **X=4 , Y= 2**\n",
    "    1. print(X % Y)  =  **0**\n",
    "    2. print(X / Y)  =  **2.0**\n",
    "    3. print(X // Y) =  **2**\n",
    "    4. print(Y % X)  =  **2**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [[4, 1, 1], [5, 9, 0]]\n",
    "for i in x[0:1]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "21. **Which of these about a dictionary is false?**\n",
    "    1. The values of a dictionary can be accessed using keys\n",
    "    2. The keys of a dictionary can be accessed using values\n",
    "    3. Dictionaries aren’t ordered\n",
    "    4. **Dictionaries are mutable**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "22. **What is the output of the following:**\n",
    "    - D = dict()\n",
    "    - for i in range(3):\n",
    "      - for j in range(2):\n",
    "        - D[i] = j\n",
    "        - **Answer (Choose Correct):**\n",
    "           1. {0: 1, 1: 1, 2: 1}\n",
    "           2. {1: 0, 1: 1, 1: 2}\n",
    "           3. {0: 1, 1: 2, 2: 3}\n",
    "           4. **{1: 2, 1: 1, 1: 0}**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "23. **You are writing a function that increments player score in a soccer game.**\n",
    "    1. If no value is specified for points, then point must start with 1\n",
    "    2. If no value is specified for bonus, then bonus should be True\n",
    "       1. **01 def increment_score ( bonus , score , points ):**\n",
    "          - To meet the first requirement line 01 must be change to\n",
    "            - def increment_score ( bonus , score , points = 1 ): (True or False)  **Answer: True**\n",
    "          - To meet the second requirement line 01 must be change to\n",
    "            - def increment_score ( bonus = True , score , points = 1 ): (True or False)  **Answer: False**\n",
    "          - Once a parameter is defined with default value, any parameter to the right must also be defined with default values (True or False) **Answer: True**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "24. **What will be output?**\n",
    "    - def avg ( x , y , z = 50 ):\n",
    "      - adding = x + y + z\n",
    "      - avg_value = adding / 3\n",
    "      - return avg_value\n",
    " - y = avg ( x = 5 , y = 9 , z = 20 )\n",
    " - print(y)\n",
    " - **Answer = 11.333333333333334**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 25. What will be output? Describe it with reason and logic behind."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name is: Ali, Marks: 44.5\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "The sequence of 'Parameters' has been changed, as the Arbitrary Arguments '*opt_values' in this case is always placed\n",
    "at the end, to store more than one arguments from the user at run-time.\n",
    "Note: Adding an asteric '*' before the parameter name in the function definition receives a 'tuple of arguments', \n",
    "and can access the items accordingly.\n",
    "'''\n",
    "def avg (name, *opt_values):\n",
    "    avg_value = sum (opt_values) / len(opt_values)\n",
    "    print('Name is: ' + name + ', Marks: ' + str(avg_value))\n",
    "avg('Ali',5 , 9 , 20, 34, 87, 112)     # sequence of arguments is also altered to store mutiple values at end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 26. Solution of following function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The winner was Manchester\n",
      "The score was 1-0\n"
     ]
    }
   ],
   "source": [
    "def display_result(winner, score, **other_info):\n",
    "    print(\"The winner was \" + winner)  # output will be 'The winner was Manchester'\n",
    "    print(\"The score was \" + score)    # output will be 'The score was 1-0'\n",
    "display_result(winner='Manchester', score=\"1-0\", overtime =\"yes\", injuries=\"none\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 27.  The position of parameters and arguments is re-arranged. Just think and find the logic behind output or error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-4-f1a239ab44fa>, line 7)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-4-f1a239ab44fa>\"\u001b[1;36m, line \u001b[1;32m7\u001b[0m\n\u001b[1;33m    def display_result(winner, **other_info, score):\u001b[0m\n\u001b[1;37m                                                 ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "Here, parameters in 'display_result' function are used in incorrect order. Because, parameter 'other_info' has been \n",
    "used as to store multiple arguments in a dictionary, and it should be placed at the end of parameters. Whereas, \n",
    "it has been used in middle of the parameters, therefore, it will generate error 'invalid syntax'\n",
    "'''\n",
    "\n",
    "def display_result(winner, **other_info, score):\n",
    "    print(\"The winner was \" + winner)\n",
    "    print(\"The score was \" + score)\n",
    "display_result(winner=\"Manchester\", overtime =\"yes\", injuries=\"none\" , score=\"1-0\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "28. **What will be the output of the following Python expression if X=123?**\n",
    "    - print('%06d'%X)\n",
    "    - **Answer (Correct Option):**\n",
    "      1. 123000\n",
    "      2. **000123**\n",
    "      3. 000000123\n",
    "      4. 123000000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "29. **What will be the output of the following Python expression if x=22.19?**\n",
    "    - print(\"%5.2f\"%x)\n",
    "    - **Answer (Correct Option):**\n",
    "      1. 22.1900\n",
    "      2. 22.00000\n",
    "      3. **22.19**\n",
    "      4. 22.20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "30. **What will be the output of the following Python code?**\n",
    "    - '{0:f}, {1:2f}, {2:05.2f}'.format(1.23456, 1.23456, 1.23456)\n",
    "    - **Answer (Correct Option):**\n",
    "      1. Error\n",
    "      2. '1.234560, 1.22345, 1.23'\n",
    "      3. No output\n",
    "      4. **'1.234560, 1.234560, 01.23'**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 31.  Write down the output of each line after each iterations. Do multiple experiments to change values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "'while false' means the condition is false which will end the loop.\n",
    "when the while iterates, in this case, the result of 'i%2=0' therefore, break statement will be executed and loop will end.\n",
    "And it will print the first value of i i.e. '1' and then it will increment the value of i with 2 at each iteration.\n",
    "\"\"\"\n",
    "\n",
    "i = 1\n",
    "while False:\n",
    "    if i%2 == 0:\n",
    "        break\n",
    "print(i)\n",
    "i += 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 32. Write down the output of each line after each iterations. Do multiple experiments to change values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a a a a a a "
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "In 'while loop' variable 'i' is initialized with 'a' and value 'a' exists in values of variable 'x'.\n",
    "As the length of 'x' is 6, and value 'a' is placed at 'index[0] therefore, the while loop will iterate '6' times.\n",
    "When the loop will iterate:\n",
    "1st time value of 'i' i.e. 'a'    is found in   value of 'x' i.e. 'abcdef'\n",
    "2nd time value of 'i'             is found in   value of 'x' i.e. 'abcde' as last value at index '-1' is excluded from 'x'\n",
    "3rd time value of 'i'             is found in   value of 'x' i.e. 'abcd' as last value at index '-1' is excluded from 'x'\n",
    "4th time value of 'i'             is found in   value of 'x' i.e. 'abc' as last value at index '-1' is excluded from 'x'\n",
    "5th time value of 'i'             is found in   value of 'x' i.e. 'ab' as last value at index '-1' is excluded from 'x'\n",
    "6th time value of 'i'             is found in   value of 'x' i.e. 'a' as last value at index '-1' is excluded from 'x'\n",
    "\n",
    "\n",
    "the loop result will be printed on the same line, as (end=\" \") has been used in print statement.\n",
    "\"\"\"\n",
    "\n",
    "x = \"abcdef\"\n",
    "i = \"a\"\n",
    "while i in x:\n",
    "    x = x[:-1]    # upon each iteration it will exclude last value of string 'abcdef' placed at index '-1' and will\n",
    "                  # update the variable 'x' and resultantly value of 'i' will be searched in new variable 'x'\n",
    "    print(i, end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SUPPOSE WE EXERCISE THE ABOVE CODE WITH NEW VALUE OF 'i' i.e. 'd', SEE HOW WILL IT BEHAVE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d d d "
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "In 'while loop' variable 'i' is initialized with 'd' and value 'd' exists in values of variable 'x'.\n",
    "As the length of 'x' is 6, But the while loop will iterate only for '3' times and character 'd' will be exclued from the\n",
    "value of 'x' with each incremental iteration.\n",
    "\n",
    "When the loop will iterate:\n",
    "1st time value of 'i' i.e. 'd'    is found in   value of 'x' i.e. 'abcdef' and char 'f' will be excluded from 'x'\n",
    "2nd time value of 'i' i.e. 'd'    is found in   value of 'x' i.e. 'abcde' and char 'e' will be excluded from 'x'\n",
    "3rd time value of 'i' i.e. 'd'    is found in   value of 'x' i.e. 'abcd' and char 'd' will be excluded from 'x'\n",
    "4th time value of 'i' i.e. 'd'    is NOT FOUND in   'x' i.e. 'abc' therefore, loop will END.\n",
    "\n",
    "the loop result will be printed on the same line, as (end=\" \") has been used in print statement.\n",
    "\"\"\"\n",
    "\n",
    "x = \"abcdef\"\n",
    "i = \"d\"\n",
    "while i in x:\n",
    "    x = x[:-1]    # upon each iteration it will exclude last value of string 'abcdef' placed at index '-1' and will\n",
    "                  # update the variable 'x' and resultantly value of 'i' will be searched in new variable 'x'\n",
    "    print(i, end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "33. **Write down the output of each line after each iterations. Do multiple experiments to change values.**\n",
    "    - for i in ''.join(reversed(list('abcd'))):\n",
    "      - print (i)\n",
    "      - **Answer:**\n",
    "                d\n",
    "                c\n",
    "                b\n",
    "                a "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 34. Flow of the program. Write the output of each line after every iteration of 'i'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Flow of Program:\n",
    "1st time  value 0   don't satisfy the condition 'i==5' therefore, '0' will be printed and loop will move to next iteration\n",
    "2nd time  value 1   don't satisfy the condition 'i==5' therefore, '1' will be printed and loop will move to next iteration\n",
    "3rd time  value 2   don't satisfy the condition 'i==5' therefore, '2' will be printed and loop will move to next iteration\n",
    "4th time  value 3   don't satisfy the condition 'i==5' therefore, '3' will be printed and loop will move to next iteration\n",
    "5th time  value 4   don't satisfy the condition 'i==5' therefore, '4' will be printed and loop will move to next iteration\n",
    "6th time  value 5   satisfy the condition 'i==5' therefore, control will move to 'break' statement and loop will END.\n",
    "\n",
    "ONLY FIVE SUCCESSFUL ITERATIONS WILL PRINT VALUES FROM 0 ~ 4.\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "for i in range(10):\n",
    "    if i == 5:\n",
    "        break\n",
    "    else:\n",
    "        print(i)\n",
    "else:\n",
    "    print(\"Here\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 35. What is the output? And understand the functionality of lambda function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "'z' is a 'lambda' function. 'lambda' function doesn't own any 'name' and is written in single line.\n",
    "this 'lambda' function has only one 'parameter' i.e. 'x'\n",
    "it will perform the operation of multiplication of given varialbe 'y' and user-provided argument \n",
    "against 'parameter' i.e. 'x'\n",
    "'y' has value '6'\n",
    "\"\"\"\n",
    "\n",
    "y = 6                           # 'y' is a variable which is initialized with value '6'\n",
    "z = lambda x: x * y\n",
    "print(z(8))                     # user provided value '8' which will be placed as argument of variable 'x'\n",
    "                                # 'x' will be multiplied with 'y' and will generate output as '48'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 36. Write output and give proper logic of whatever the output comes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "A function named 'change' is defined with parameter 'i'\n",
    "'1' will be added in given / initialized value of 'i' i.e. '0'\n",
    "'change' function is a 'RETURN' function and will return the value of i\n",
    "\"\"\"\n",
    "\n",
    "i = 0\n",
    "def change(i):\n",
    "    i=i+1\n",
    "    return i\n",
    "change(4)        # this will input '4' as argument of 'i' and '1' will be added in value of 'i' and will return '5'\n",
    "print(i)         # this will print the initial value of 'i' i.e. '0', placed before the 'change' function \n",
    "                 # and 'change' function will not effect the outside varialbe 'i' having initialized with '0'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 40. What will be output? Define this output clearly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "(2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "'change' function is defined with two 'parameters' i.e. 'one' and 'two'.\n",
    "The parameter 'two' is suffix of \"*\" which means it will store multiple arguments and will store it in tupple.\n",
    "By default, first argument separated with comma will automatically stored in parameter 'one' and \n",
    "rest single or multiple arguments will be stored in '*two' parameter.\n",
    "\"\"\"\n",
    "\n",
    "def change(one, *two):\n",
    "    print(type(two))           # this will print type of parameter '*two' which be a 'tuple'\n",
    "    print(two)                 # this will print values of paramter '*two' which will be (2,3,4) because '1' is stored in \n",
    "                               # parameter 'one'\n",
    "change(1,2,3,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 41. What will be output? Define this output clearly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "'find' function is defined with two 'parameters' i.e. 'a' and 'b'.\n",
    "The parameter 'b' is prefixed with \"**\" which means it will accept multiple arguments and will store them in dictionary.\n",
    "By default, first argument separated with comma will automatically stored in parameter 'a' and \n",
    "rest single or multiple arguments will be stored in '**b' parameter.\n",
    "\"\"\"\n",
    "\n",
    "def find(a, **b):                       # definition of function 'find' with two parameters i.e. 'a' and '**b'\n",
    "    print(type(b))                      # this function will print the type of parameter 'b' which will be a 'Dictionary'\n",
    "find('letters',A='1',B='2')             # this will have no output, because 'find' function has not any return type\n",
    "                                        # rather it has a print type output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 42. Write output and define each line’s output for each iteration of ‘i’."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0]\n",
      "[0, 1]\n",
      "[0, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "This piece of program has two parts:\n",
    "1) defined a function 'foo'. 'foo' function has two parameters i.e. 'i' and 'x'\n",
    "   'x' will store its arguments in a list\n",
    "   \n",
    "2) created a 'for' loop with range numbers from numbers  '0','1','2'\n",
    "   Flow of for loop:\n",
    "1st time value of 'i' i.e. '0'   is found in range(3) and will be 'appended' in variable 'x' by using 'foo' function &\n",
    "value of 'x' will be [0]\n",
    "\n",
    "2nd time value of 'i' i.e. '1'   is found in range(3) and will be 'appended' in variable 'x' by using 'foo' function & \n",
    "value of 'x' will now be [0,1]\n",
    "\n",
    "3rd time value of 'i' i.e. '2'   is found in range(3) and will be 'appended' in variable 'x' by using 'foo' function &\n",
    "value of 'x' will be [0,1,2]\n",
    "\n",
    "4th time value of 'i' i.e. '3'   is NOT Found in range(3) and loop will be terminated\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "def foo(i, x=[]):   # function 'foo' is defined with two parameters i.e. 'i' and 'x', 'x' will store arguments in 'list'\n",
    "    x.append(i)     # this will append values of 'i' in 'x' which is a list\n",
    "    return x        # this function will return x, a 'list'\n",
    "for i in range(3):  # this is a 'for' loop with range from numbers  '0','1','2'\n",
    "    print(foo(i))   # this will output the whole 'flow of for loop'  i.e.\n",
    "                    # [0]\n",
    "                    # [0,1]\n",
    "                    # [0,1,2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 43. Evaluate the following Python arithmetic expression: and write which segment will execute first? (Brackets, Exponents, Multiplication, Addition / Subtraction, Left to right rule)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "First of all, product of '(1*2)' is evaluated as '2' & similarly, product of '(2**2)' is evaluated as '4'\n",
    "Then, 'Power' of '2' with '2' is evaluated as '4', similarly, 'Power' of '4' is evaluated with '3' as '12' \n",
    "Then, first part of expression has been evalued as (3 * 4) i.e. 12\n",
    "In last, first and last part have been evaluated by 'subtraction' and value found '0'\n",
    "\"\"\"\n",
    "# Product of 'Brackets' will be evaluated first, then its 'exponents' will be find\n",
    "(3*(1*2)**2 - (2**2)*3)           # output will be 'zero'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 44.You are creating a function that manipulates a number. The function has the following requirements:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- A float is passed into the function\n",
    "- The function must take the absolute value of the float\n",
    "- Any decimal points after the integer must be removed\n",
    "  1. math.fmod(x)\n",
    "  2. math.frexp(x)\n",
    "  3. math.floor(x)\n",
    "  4. math.ceil(x)\n",
    "  5. math.fabs(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "fmod() takes exactly 2 arguments (1 given)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-46-b662978178ab>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 10\u001b[1;33m \u001b[0mmath_func\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m12.5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     11\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-46-b662978178ab>\u001b[0m in \u001b[0;36mmath_func\u001b[1;34m(x, y)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mmath\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mmath_func\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m     \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmath\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfmod\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m     \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmath\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfrexp\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmath\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfloor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: fmod() takes exactly 2 arguments (1 given)"
     ]
    }
   ],
   "source": [
    "import math\n",
    "def math_func(x,y=None):\n",
    "    x = math.fmod(x)\n",
    "    x = math.frexp(x)\n",
    "    x = math.floor(x)\n",
    "    x = math.ceil(x)\n",
    "    x = math.fabs(x)\n",
    "    \n",
    "    return x\n",
    "math_func(12.5, 5)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 45. You are writing code that generates a random integer with a minimum value of 5 and a maximum value of 11."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Which two functions should you use? Each correct answer presents a complete solution. (Choose two.)**\n",
    "  1. **random.randint(5, 12)**\n",
    "  2. random.randint(5, 11)\n",
    "  3. **random.randrange(5, 12, 1)**\n",
    "  4. random.randrange(5, 11, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 46. Write a program that receives marks from user and check the grade."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "randint."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}