hints.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 1.1.\n",
    "\n",
    "def to_celsius(fahr):\n",
    "    \"\"\"\n",
    "    Convert a given temperature from Fahrenheit to Celsius.\n",
    "    \n",
    "    :param fahr: int or float of temperature in degree Fahrenheit\n",
    "    :return: int or float of temperature in degree Celsius\n",
    "    \"\"\"\n",
    "    \n",
    "    # the arithmetic operators can be used to write the formula\n",
    "    # the built-in return function can be used to specify desired output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 4.15.\n",
    "\n",
    "def mul_table():\n",
    "    # Print the first row\n",
    "    print(\" \", *(f\"{i:3}\" for i in range(1,10)))\n",
    "    # Print the header bar\n",
    "    print(\" \", \"+\"*4*9, end=\"\")\n",
    "    print()\n",
    "    \n",
    "    for i in range(1,10):\n",
    "        # Print the first column\n",
    "        print(f\"{i}:\", end=\"\")\n",
    "        # Print the entries\n",
    "        print(*(f\"{i*j:3}\" for j in range(1,10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    1   2   3   4   5   6   7   8   9\n",
      "  ++++++++++++++++++++++++++++++++++++\n",
      "1:  1   2   3   4   5   6   7   8   9\n",
      "2:  2   4   6   8  10  12  14  16  18\n",
      "3:  3   6   9  12  15  18  21  24  27\n",
      "4:  4   8  12  16  20  24  28  32  36\n",
      "5:  5  10  15  20  25  30  35  40  45\n",
      "6:  6  12  18  24  30  36  42  48  54\n",
      "7:  7  14  21  28  35  42  49  56  63\n",
      "8:  8  16  24  32  40  48  56  64  72\n",
      "9:  9  18  27  36  45  54  63  72  81\n"
     ]
    }
   ],
   "source": [
    "mul_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 1.2.\n",
    "\n",
    "def compare(x,y):\n",
    "    \"\"\"\n",
    "    Compare the size of two given numbers.\n",
    "    \n",
    "    :param x: first number (int or float)\n",
    "    :param y: second number (int or float)\n",
    "    :return: string describing the relationship between two numbers\n",
    "    \"\"\"\n",
    "    \n",
    "    # the if-elif-else statement can be used to specify desired conditions\n",
    "    # the equality and inequality operators can be used for comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 1.3.\n",
    "\n",
    "def divisible(x,y):\n",
    "    \"\"\"\n",
    "    Check if the second number is divisible by the first number.\n",
    "    \n",
    "    :param x: first number (int or float)\n",
    "    :param y: second number (int or float)\n",
    "    :return: boolean describing the divisibility between the numbers\n",
    "    \"\"\"\n",
    "    \n",
    "    # the modulo operator can be used for the condition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 1.4.\n",
    "\n",
    "def numlist_size(l):\n",
    "    \"\"\"\n",
    "    Print the size of each number in a given\n",
    "    \n",
    "    :param l: list of numbers (int or float)\n",
    "    :return: strings describing the size for each number in order\n",
    "    \"\"\"\n",
    "    \n",
    "    # the for loop can be used to iterate the list\n",
    "    # the if-else statement can be used repeatedly\n",
    "    # using print instead of return enables the function to give multiple outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 1.5.\n",
    "\n",
    "def solve2(a,b,c):\n",
    "    \"\"\"\n",
    "    Find the real roots of the quadratic equation ax^2 + bx + c.\n",
    "    \n",
    "    :param a: leading coefficient (int or float)\n",
    "    :param b: middle coefficient (int or float)\n",
    "    :param c: constant coefficient (int or float)\n",
    "    :return: list of the real roots of the quadratic equation\n",
    "    \"\"\"\n",
    "    \n",
    "    # import math package to use math.sqrt() function\n",
    "    # the number of real roots can be described by the discriminant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 7, 26, 63]\n",
      "[0, 7, 26, 63]\n"
     ]
    }
   ],
   "source": [
    "# Exercise 2.1.\n",
    "\n",
    "def cube_min_1(l):\n",
    "    \"\"\"\n",
    "    Cube and subtract each number in a given list by one (without list comprehension).\n",
    "    \n",
    "    :param l: list of numbers (int or float)\n",
    "    :return: list of the newly cubed minus one numbers\n",
    "    \"\"\"\n",
    "    \n",
    "    # the append() method can be used to create a new list\n",
    "\n",
    "\n",
    "def cube_min_1_comp(l):\n",
    "    \"\"\"\n",
    "    Cube and subtract each number in a given list by one (with list comprehension).\n",
    "    \n",
    "    :param l: list of numbers (int or float)\n",
    "    :return: list of the newly one less than a cubed numbers\n",
    "    \"\"\"\n",
    "    \n",
    "    # the for loop can be used inside a list to generate the elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n",
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "# Exercise 2.2.\n",
    "\n",
    "def squares(m,n):\n",
    "    \"\"\"\n",
    "    Square the numbers between a given interval (without list comprehension).\n",
    "    \n",
    "    :param m: first number in the interval (preferably int)\n",
    "    :param n: last number in the interval (preferably int)\n",
    "    :return: list of the newly squared numbers\n",
    "    \"\"\"\n",
    "    \n",
    "    # the range() function can be used to iterate through desired intervals\n",
    "    # the similar idea can be applied as the previous, otherwise\n",
    "\n",
    "\n",
    "def squares_comp(m,n):\n",
    "    \"\"\"\n",
    "    Square the numbers between a given interval (with list comprehension).\n",
    "    \n",
    "    :param m: first number in the interval (preferably int)\n",
    "    :param n: last number in the interval (preferably int)\n",
    "    :return: list of the newly squared numbers\n",
    "    \"\"\"\n",
    "    \n",
    "    # the similar idea can be applied as the previous"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 16, 81, 256, 625]\n",
      "[1, 16, 81, 256, 625]\n"
     ]
    }
   ],
   "source": [
    "# Exercise 2.3.\n",
    "\n",
    "def powers(m,n,k):\n",
    "    \"\"\"\n",
    "    Square the numbers between a given interval (with list comprehension).\n",
    "    \n",
    "    :param m: first number in the interval (preferably int)\n",
    "    :param n: last number in the interval (preferably int)\n",
    "    :return: list of the newly squared numbers\n",
    "    \"\"\"\n",
    "    \n",
    "    # the similar idea can be applied as the previous\n",
    "    \n",
    "\n",
    "def powers_comp(m,n,k):\n",
    "    \"\"\"\n",
    "    Square the numbers between a given interval (with list comprehension).\n",
    "    \n",
    "    :param m: first number in the interval (preferably int)\n",
    "    :param n: last number in the interval (preferably int)\n",
    "    :return: list of the newly squared numbers\n",
    "    \"\"\"\n",
    "    \n",
    "    # the similar idea can be applied as the previous"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# Exercise 2.4.\n",
    "\n",
    "def index_of(x, l):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "# Exercise 2.5.\n",
    "\n",
    "def indices_of(x, l):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'a', 3, 4, 'a']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exercise 2.6.\n",
    "\n",
    "def substitute(l, x, y):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'a', 3, 4, 'a']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exercise 2.7.\n",
    "\n",
    "def substitute_upd(l, x, y):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[35, 42, 49]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exercise 2.8.\n",
    "\n",
    "def divisibles_by(l,n):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 4, 7, 14]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exercise 2.9.\n",
    "\n",
    "def divisors(n):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(6, 12), (17, 18), (28, 56), (39, 56), (50, 93)]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exercise 2.10.\n",
    "\n",
    "def sigma(n):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 28, 496, 8128]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exercise 2.11.\n",
    "\n",
    "def is_perfect(n):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30 -> [1, 2, 3, 5, 6, 10, 15]\n",
      "31 -> [1]\n",
      "32 -> [1, 2, 4, 8, 16]\n",
      "33 -> [1, 3, 11]\n",
      "34 -> [1, 2, 17]\n",
      "35 -> [1, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "# Exercise 2.12.\n",
    "\n",
    "def divisors_ival(n,m):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.13."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.14."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.15."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.16."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.17."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.18."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.19."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.20."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.21."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.22."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.23."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.24."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.25."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.26."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.27."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.28."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.29."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exercise 2.30.\n",
    "\n",
    "def permutations(n):\n",
    "    l = []\n",
    "    \n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            if i != j:\n",
    "                for k in range(n):\n",
    "                    if i != k and j != k:\n",
    "                        l.append([i,j,k])\n",
    "                        \n",
    "    return l\n",
    "\n",
    "permutations(3)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "62"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = [41,55,73,62,62,82,73,6,40,87,15]\n",
    "\n",
    "lst[4 if len(lst)%2==1 else 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "46"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = 26\n",
    "for i in range(5,7):\n",
    "    for j in range(1,5):\n",
    "        res = res + j\n",
    "        \n",
    "res\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.1. (Without list comprehension)\n",
    "\n",
    "def cube_min_1(l):\n",
    "    new_l = []\n",
    "    \n",
    "    for i in l:\n",
    "        new_l.append(i**3-1)\n",
    "    \n",
    "    return new_l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.1. (With list comprehension)\n",
    "\n",
    "def cube_min_1_comp(l):\n",
    "    return [i**3-1 for i in l]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [2, 3, 4, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 26, 63, 124]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cube_min_1(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 26, 63, 124]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cube_min_1_comp(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 4, 'a', 3]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def substitute(ls, a, b):\n",
    "    for x in range(len(ls)):\n",
    "        if a == ls[x]:\n",
    "            ls[x]=b\n",
    "\n",
    "my = [2,4,2,3]\n",
    "\n",
    "substitute(my, 2, \"a\")\n",
    "\n",
    "my"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.31."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.32."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.33."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.34."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.35."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.36."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2.37."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 3.1. Hints\n",
    "\n",
    "def average():                            # create the average function\n",
    "    _sum = 0                              # sum up the numbers given\n",
    "    count = 0                             # count how many numbers are given\n",
    "    x = True                              # variable to store the given numbers\n",
    "    \n",
    "    while x:                              # while the given number is nonempty\n",
    "        x = input(\"Enter a number: \")     # update x to ask for numbers\n",
    "        \n",
    "        ...                               # modify _sum and count here\n",
    "        \n",
    "    return f\"The average is {_sum/count}\" # finally return the average"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 4.31.\n",
    "\n",
    "def squares(lst, n):\n",
    "    pass\n",
    "\n",
    "squares(list(range(1,8,3)), 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 7]"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(1,8,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2, 3, 0], [2, 3, 4]]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[[x%y for x in range(2,6) if x**2 < 24] for y in range(4,6)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([sum([x%y for x in range(2,6) if x**2 < 24]) for y in range(4,6)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-10-261c0980b508>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mlists\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-10-261c0980b508>\u001b[0m in \u001b[0;36mlists\u001b[0;34m(m, n)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mlists\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mm\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0mm\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "def lists(m,n):\n",
    "    \n",
    "    m[n] = 1\n",
    "    return m[n]\n",
    "    \n",
    "lists((4, 8, 4, 3),1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(*l,m=1):\n",
    "    return len(l)*m\n",
    "\n",
    "f(4, 8, 4, 3, m=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}