function.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fc028c17",
   "metadata": {},
   "outputs": [],
   "source": [
    "def bmi(height, weight):\n",
    "    x = weight / (height ** 2)\n",
    "    print(\"your bmi is :\",x)\n",
    "    if x <= 18.5 :\n",
    "        print(\"Underweight\")\n",
    "    elif x > 18.5 and x < 25 :\n",
    "        print(\"normal\")\n",
    "    elif x >= 25 and x < 30:\n",
    "        print(\"Overweight\")\n",
    "    elif x >= 30:\n",
    "        print(\"Obese\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bc9474f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "your bmi is : 25.470268905441234\n",
      "Overweight\n"
     ]
    }
   ],
   "source": [
    "bmi(1.78,80.7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "37fc25f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def bmi_calculator(height,weight):\n",
    "    return weight/(height**2)\n",
    "\n",
    "def bmi(height, weight):\n",
    "    x = bmi_calculator(height,weight)\n",
    "    print(\"your bmi is :\",x)\n",
    "    if x <= 18.5 :\n",
    "        print(\"Underweight\")\n",
    "    elif x > 18.5 and x < 25 :\n",
    "        print(\"normal\")\n",
    "    elif x >= 25 and x < 30:\n",
    "        print(\"Overweight\")\n",
    "    elif x >= 30:\n",
    "        print(\"Obese\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a7446afa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "your bmi is : 25.470268905441234\n",
      "Overweight\n"
     ]
    }
   ],
   "source": [
    "bmi(1.78,80.7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "37907af4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "your bmi is : 24.61810377477591\n",
      "normal\n"
     ]
    }
   ],
   "source": [
    "bmi(1.78,78)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4b1f374b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#If you do not know how many arguments that will be passed into your function, \n",
    "#add a * before the parameter name in the function definition\n",
    "def print_name(*names):\n",
    "    for n in names:\n",
    "        print(\"the name is :\", n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b011c17a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the name is : reza\n",
      "the name is : eli\n"
     ]
    }
   ],
   "source": [
    "print_name(\"reza\",\"eli\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "90f37a73",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Passing a List as an Argument\n",
    "names = [\"reza\",\"raheleh\"]\n",
    "def print_name(names):\n",
    "    for n in names:\n",
    "        print(\"the name is :\",n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d39bac82",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the name is : reza\n",
      "the name is : raheleh\n"
     ]
    }
   ],
   "source": [
    "print_name(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "56b03c8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def square_list(num):\n",
    "    result = []\n",
    "    for i in num:\n",
    "        result.append(i**2)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3c2c3fc6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "x = square_list(range(0,10))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "754e4693",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Recursion\n",
    "def factorial(number):\n",
    "    if number == 1:\n",
    "        return 1\n",
    "    return number * factorial(number - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "04967357",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "468df91b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_two_list(list_a,list_b):\n",
    "    return(list(map(sum,zip(list_a,list_b))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "9e295202",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_a = [1,2,3]\n",
    "list_b = range(0,3)\n",
    "add_two_list(list_a,list_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1faa7604",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.3"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#https://docs.python.org/3/library/functions.html\n",
    "#for study built in function in python\n",
    "#Return the absolute value of a number\n",
    "abs(-12.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f9791c65",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [1,1,0,1,1]\n",
    "#Return True if all elements of the iterable are true\n",
    "all(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "05856c6b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Return True if any element of the iterable is true\n",
    "any(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "de97f484",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'104'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#return a string containing a printable representation of an object\n",
    "my_str = 104\n",
    "ascii(my_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "c7d84a40",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'h'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Return the string representing a character whose Unicode code point is the integer i.\n",
    "chr(my_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "aceb3818",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "104"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given a string representing one Unicode character, return an integer representing \n",
    "#the Unicode code point of that character\n",
    "ord('h')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5f79f846",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['In',\n",
       " 'Out',\n",
       " '_',\n",
       " '_1',\n",
       " '_10',\n",
       " '_11',\n",
       " '_12',\n",
       " '_13',\n",
       " '_14',\n",
       " '_16',\n",
       " '_2',\n",
       " '_3',\n",
       " '_4',\n",
       " '_5',\n",
       " '_6',\n",
       " '_7',\n",
       " '_8',\n",
       " '_9',\n",
       " '__',\n",
       " '___',\n",
       " '__builtin__',\n",
       " '__builtins__',\n",
       " '__doc__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " '_dh',\n",
       " '_i',\n",
       " '_i1',\n",
       " '_i10',\n",
       " '_i11',\n",
       " '_i12',\n",
       " '_i13',\n",
       " '_i14',\n",
       " '_i15',\n",
       " '_i16',\n",
       " '_i17',\n",
       " '_i18',\n",
       " '_i19',\n",
       " '_i2',\n",
       " '_i20',\n",
       " '_i3',\n",
       " '_i4',\n",
       " '_i5',\n",
       " '_i6',\n",
       " '_i7',\n",
       " '_i8',\n",
       " '_i9',\n",
       " '_ih',\n",
       " '_ii',\n",
       " '_iii',\n",
       " '_oh',\n",
       " 'exit',\n",
       " 'get_ipython',\n",
       " 'my_list',\n",
       " 'my_str',\n",
       " 'quit',\n",
       " 'temp_list',\n",
       " 'txt',\n",
       " 'txt2',\n",
       " 'x',\n",
       " 'y']"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Without arguments, return the list of names in the current local scope\n",
    "dir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "96fab91c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'__name__': '__main__',\n",
       " '__doc__': 'Automatically created module for IPython interactive environment',\n",
       " '__package__': None,\n",
       " '__loader__': None,\n",
       " '__spec__': None,\n",
       " '__builtin__': <module 'builtins' (built-in)>,\n",
       " '__builtins__': <module 'builtins' (built-in)>,\n",
       " '_ih': ['',\n",
       "  '#https://docs.python.org/3/library/functions.html\\n#for study built in function in python\\nabs(12)',\n",
       "  '#https://docs.python.org/3/library/functions.html\\n#for study built in function in python\\nabs(-12)',\n",
       "  '#https://docs.python.org/3/library/functions.html\\n#for study built in function in python\\nabs(-12.3)',\n",
       "  'my_list = [1,1,0,0,1]\\nall(my_list)',\n",
       "  'my_list = [1,1,1,1,1]\\nall(my_list)',\n",
       "  'my_list = [1,1,0,1,1]\\n#Return True if all elements of the iterable are true\\nall(my_list)',\n",
       "  'any(my_list)',\n",
       "  'my_str = \"f\"\\nascii(my_str)',\n",
       "  'my_str = 104\\nascii(my_str)',\n",
       "  'chr(my_str)',\n",
       "  'dir()',\n",
       "  'divmod(3,2)',\n",
       "  'divmod(3,3)',\n",
       "  'divmod(6,3)',\n",
       "  'temp_list = list(enumerate(my_list))\\nprint(temp_list)',\n",
       "  \"x = 2\\ny = 3\\neval('x+y')\",\n",
       "  'format(12.345,2)',\n",
       "  'txt = \"For only {price:.2f} dollars!\"\\nprint(txt.format(price = 49))',\n",
       "  'txt = \"For only {price:.2f} dollars!\"\\nprint(txt.format(price = 49))\\ntxt2 = \"My name is {0}, I\\'m {1}\".format(\"John\",36)\\nprint(txt2)',\n",
       "  '#Without arguments, return the list of names in the current local scope\\ndir()',\n",
       "  'global()',\n",
       "  'globals()'],\n",
       " '_oh': {1: 12,\n",
       "  2: 12,\n",
       "  3: 12.3,\n",
       "  4: False,\n",
       "  5: True,\n",
       "  6: False,\n",
       "  7: True,\n",
       "  8: \"'f'\",\n",
       "  9: '104',\n",
       "  10: 'h',\n",
       "  11: ['In',\n",
       "   'Out',\n",
       "   '_',\n",
       "   '_1',\n",
       "   '_10',\n",
       "   '_2',\n",
       "   '_3',\n",
       "   '_4',\n",
       "   '_5',\n",
       "   '_6',\n",
       "   '_7',\n",
       "   '_8',\n",
       "   '_9',\n",
       "   '__',\n",
       "   '___',\n",
       "   '__builtin__',\n",
       "   '__builtins__',\n",
       "   '__doc__',\n",
       "   '__loader__',\n",
       "   '__name__',\n",
       "   '__package__',\n",
       "   '__spec__',\n",
       "   '_dh',\n",
       "   '_i',\n",
       "   '_i1',\n",
       "   '_i10',\n",
       "   '_i11',\n",
       "   '_i2',\n",
       "   '_i3',\n",
       "   '_i4',\n",
       "   '_i5',\n",
       "   '_i6',\n",
       "   '_i7',\n",
       "   '_i8',\n",
       "   '_i9',\n",
       "   '_ih',\n",
       "   '_ii',\n",
       "   '_iii',\n",
       "   '_oh',\n",
       "   'exit',\n",
       "   'get_ipython',\n",
       "   'my_list',\n",
       "   'my_str',\n",
       "   'quit'],\n",
       "  12: (1, 1),\n",
       "  13: (1, 0),\n",
       "  14: (2, 0),\n",
       "  16: 5,\n",
       "  20: ['In',\n",
       "   'Out',\n",
       "   '_',\n",
       "   '_1',\n",
       "   '_10',\n",
       "   '_11',\n",
       "   '_12',\n",
       "   '_13',\n",
       "   '_14',\n",
       "   '_16',\n",
       "   '_2',\n",
       "   '_3',\n",
       "   '_4',\n",
       "   '_5',\n",
       "   '_6',\n",
       "   '_7',\n",
       "   '_8',\n",
       "   '_9',\n",
       "   '__',\n",
       "   '___',\n",
       "   '__builtin__',\n",
       "   '__builtins__',\n",
       "   '__doc__',\n",
       "   '__loader__',\n",
       "   '__name__',\n",
       "   '__package__',\n",
       "   '__spec__',\n",
       "   '_dh',\n",
       "   '_i',\n",
       "   '_i1',\n",
       "   '_i10',\n",
       "   '_i11',\n",
       "   '_i12',\n",
       "   '_i13',\n",
       "   '_i14',\n",
       "   '_i15',\n",
       "   '_i16',\n",
       "   '_i17',\n",
       "   '_i18',\n",
       "   '_i19',\n",
       "   '_i2',\n",
       "   '_i20',\n",
       "   '_i3',\n",
       "   '_i4',\n",
       "   '_i5',\n",
       "   '_i6',\n",
       "   '_i7',\n",
       "   '_i8',\n",
       "   '_i9',\n",
       "   '_ih',\n",
       "   '_ii',\n",
       "   '_iii',\n",
       "   '_oh',\n",
       "   'exit',\n",
       "   'get_ipython',\n",
       "   'my_list',\n",
       "   'my_str',\n",
       "   'quit',\n",
       "   'temp_list',\n",
       "   'txt',\n",
       "   'txt2',\n",
       "   'x',\n",
       "   'y']},\n",
       " '_dh': ['C:\\\\Users\\\\FourR'],\n",
       " 'In': ['',\n",
       "  '#https://docs.python.org/3/library/functions.html\\n#for study built in function in python\\nabs(12)',\n",
       "  '#https://docs.python.org/3/library/functions.html\\n#for study built in function in python\\nabs(-12)',\n",
       "  '#https://docs.python.org/3/library/functions.html\\n#for study built in function in python\\nabs(-12.3)',\n",
       "  'my_list = [1,1,0,0,1]\\nall(my_list)',\n",
       "  'my_list = [1,1,1,1,1]\\nall(my_list)',\n",
       "  'my_list = [1,1,0,1,1]\\n#Return True if all elements of the iterable are true\\nall(my_list)',\n",
       "  'any(my_list)',\n",
       "  'my_str = \"f\"\\nascii(my_str)',\n",
       "  'my_str = 104\\nascii(my_str)',\n",
       "  'chr(my_str)',\n",
       "  'dir()',\n",
       "  'divmod(3,2)',\n",
       "  'divmod(3,3)',\n",
       "  'divmod(6,3)',\n",
       "  'temp_list = list(enumerate(my_list))\\nprint(temp_list)',\n",
       "  \"x = 2\\ny = 3\\neval('x+y')\",\n",
       "  'format(12.345,2)',\n",
       "  'txt = \"For only {price:.2f} dollars!\"\\nprint(txt.format(price = 49))',\n",
       "  'txt = \"For only {price:.2f} dollars!\"\\nprint(txt.format(price = 49))\\ntxt2 = \"My name is {0}, I\\'m {1}\".format(\"John\",36)\\nprint(txt2)',\n",
       "  '#Without arguments, return the list of names in the current local scope\\ndir()',\n",
       "  'global()',\n",
       "  'globals()'],\n",
       " 'Out': {1: 12,\n",
       "  2: 12,\n",
       "  3: 12.3,\n",
       "  4: False,\n",
       "  5: True,\n",
       "  6: False,\n",
       "  7: True,\n",
       "  8: \"'f'\",\n",
       "  9: '104',\n",
       "  10: 'h',\n",
       "  11: ['In',\n",
       "   'Out',\n",
       "   '_',\n",
       "   '_1',\n",
       "   '_10',\n",
       "   '_2',\n",
       "   '_3',\n",
       "   '_4',\n",
       "   '_5',\n",
       "   '_6',\n",
       "   '_7',\n",
       "   '_8',\n",
       "   '_9',\n",
       "   '__',\n",
       "   '___',\n",
       "   '__builtin__',\n",
       "   '__builtins__',\n",
       "   '__doc__',\n",
       "   '__loader__',\n",
       "   '__name__',\n",
       "   '__package__',\n",
       "   '__spec__',\n",
       "   '_dh',\n",
       "   '_i',\n",
       "   '_i1',\n",
       "   '_i10',\n",
       "   '_i11',\n",
       "   '_i2',\n",
       "   '_i3',\n",
       "   '_i4',\n",
       "   '_i5',\n",
       "   '_i6',\n",
       "   '_i7',\n",
       "   '_i8',\n",
       "   '_i9',\n",
       "   '_ih',\n",
       "   '_ii',\n",
       "   '_iii',\n",
       "   '_oh',\n",
       "   'exit',\n",
       "   'get_ipython',\n",
       "   'my_list',\n",
       "   'my_str',\n",
       "   'quit'],\n",
       "  12: (1, 1),\n",
       "  13: (1, 0),\n",
       "  14: (2, 0),\n",
       "  16: 5,\n",
       "  20: ['In',\n",
       "   'Out',\n",
       "   '_',\n",
       "   '_1',\n",
       "   '_10',\n",
       "   '_11',\n",
       "   '_12',\n",
       "   '_13',\n",
       "   '_14',\n",
       "   '_16',\n",
       "   '_2',\n",
       "   '_3',\n",
       "   '_4',\n",
       "   '_5',\n",
       "   '_6',\n",
       "   '_7',\n",
       "   '_8',\n",
       "   '_9',\n",
       "   '__',\n",
       "   '___',\n",
       "   '__builtin__',\n",
       "   '__builtins__',\n",
       "   '__doc__',\n",
       "   '__loader__',\n",
       "   '__name__',\n",
       "   '__package__',\n",
       "   '__spec__',\n",
       "   '_dh',\n",
       "   '_i',\n",
       "   '_i1',\n",
       "   '_i10',\n",
       "   '_i11',\n",
       "   '_i12',\n",
       "   '_i13',\n",
       "   '_i14',\n",
       "   '_i15',\n",
       "   '_i16',\n",
       "   '_i17',\n",
       "   '_i18',\n",
       "   '_i19',\n",
       "   '_i2',\n",
       "   '_i20',\n",
       "   '_i3',\n",
       "   '_i4',\n",
       "   '_i5',\n",
       "   '_i6',\n",
       "   '_i7',\n",
       "   '_i8',\n",
       "   '_i9',\n",
       "   '_ih',\n",
       "   '_ii',\n",
       "   '_iii',\n",
       "   '_oh',\n",
       "   'exit',\n",
       "   'get_ipython',\n",
       "   'my_list',\n",
       "   'my_str',\n",
       "   'quit',\n",
       "   'temp_list',\n",
       "   'txt',\n",
       "   'txt2',\n",
       "   'x',\n",
       "   'y']},\n",
       " 'get_ipython': <bound method InteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x000002263AFF3FA0>>,\n",
       " 'exit': <IPython.core.autocall.ZMQExitAutocall at 0x2263b0af820>,\n",
       " 'quit': <IPython.core.autocall.ZMQExitAutocall at 0x2263b0af820>,\n",
       " '_': ['In',\n",
       "  'Out',\n",
       "  '_',\n",
       "  '_1',\n",
       "  '_10',\n",
       "  '_11',\n",
       "  '_12',\n",
       "  '_13',\n",
       "  '_14',\n",
       "  '_16',\n",
       "  '_2',\n",
       "  '_3',\n",
       "  '_4',\n",
       "  '_5',\n",
       "  '_6',\n",
       "  '_7',\n",
       "  '_8',\n",
       "  '_9',\n",
       "  '__',\n",
       "  '___',\n",
       "  '__builtin__',\n",
       "  '__builtins__',\n",
       "  '__doc__',\n",
       "  '__loader__',\n",
       "  '__name__',\n",
       "  '__package__',\n",
       "  '__spec__',\n",
       "  '_dh',\n",
       "  '_i',\n",
       "  '_i1',\n",
       "  '_i10',\n",
       "  '_i11',\n",
       "  '_i12',\n",
       "  '_i13',\n",
       "  '_i14',\n",
       "  '_i15',\n",
       "  '_i16',\n",
       "  '_i17',\n",
       "  '_i18',\n",
       "  '_i19',\n",
       "  '_i2',\n",
       "  '_i20',\n",
       "  '_i3',\n",
       "  '_i4',\n",
       "  '_i5',\n",
       "  '_i6',\n",
       "  '_i7',\n",
       "  '_i8',\n",
       "  '_i9',\n",
       "  '_ih',\n",
       "  '_ii',\n",
       "  '_iii',\n",
       "  '_oh',\n",
       "  'exit',\n",
       "  'get_ipython',\n",
       "  'my_list',\n",
       "  'my_str',\n",
       "  'quit',\n",
       "  'temp_list',\n",
       "  'txt',\n",
       "  'txt2',\n",
       "  'x',\n",
       "  'y'],\n",
       " '__': 5,\n",
       " '___': (2, 0),\n",
       " '_i': 'global()',\n",
       " '_ii': '#Without arguments, return the list of names in the current local scope\\ndir()',\n",
       " '_iii': 'txt = \"For only {price:.2f} dollars!\"\\nprint(txt.format(price = 49))\\ntxt2 = \"My name is {0}, I\\'m {1}\".format(\"John\",36)\\nprint(txt2)',\n",
       " '_i1': '#https://docs.python.org/3/library/functions.html\\n#for study built in function in python\\nabs(12)',\n",
       " '_1': 12,\n",
       " '_i2': '#https://docs.python.org/3/library/functions.html\\n#for study built in function in python\\nabs(-12)',\n",
       " '_2': 12,\n",
       " '_i3': '#https://docs.python.org/3/library/functions.html\\n#for study built in function in python\\nabs(-12.3)',\n",
       " '_3': 12.3,\n",
       " '_i4': 'my_list = [1,1,0,0,1]\\nall(my_list)',\n",
       " 'my_list': [1, 1, 0, 1, 1],\n",
       " '_4': False,\n",
       " '_i5': 'my_list = [1,1,1,1,1]\\nall(my_list)',\n",
       " '_5': True,\n",
       " '_i6': 'my_list = [1,1,0,1,1]\\n#Return True if all elements of the iterable are true\\nall(my_list)',\n",
       " '_6': False,\n",
       " '_i7': 'any(my_list)',\n",
       " '_7': True,\n",
       " '_i8': 'my_str = \"f\"\\nascii(my_str)',\n",
       " 'my_str': 104,\n",
       " '_8': \"'f'\",\n",
       " '_i9': 'my_str = 104\\nascii(my_str)',\n",
       " '_9': '104',\n",
       " '_i10': 'chr(my_str)',\n",
       " '_10': 'h',\n",
       " '_i11': 'dir()',\n",
       " '_11': ['In',\n",
       "  'Out',\n",
       "  '_',\n",
       "  '_1',\n",
       "  '_10',\n",
       "  '_2',\n",
       "  '_3',\n",
       "  '_4',\n",
       "  '_5',\n",
       "  '_6',\n",
       "  '_7',\n",
       "  '_8',\n",
       "  '_9',\n",
       "  '__',\n",
       "  '___',\n",
       "  '__builtin__',\n",
       "  '__builtins__',\n",
       "  '__doc__',\n",
       "  '__loader__',\n",
       "  '__name__',\n",
       "  '__package__',\n",
       "  '__spec__',\n",
       "  '_dh',\n",
       "  '_i',\n",
       "  '_i1',\n",
       "  '_i10',\n",
       "  '_i11',\n",
       "  '_i2',\n",
       "  '_i3',\n",
       "  '_i4',\n",
       "  '_i5',\n",
       "  '_i6',\n",
       "  '_i7',\n",
       "  '_i8',\n",
       "  '_i9',\n",
       "  '_ih',\n",
       "  '_ii',\n",
       "  '_iii',\n",
       "  '_oh',\n",
       "  'exit',\n",
       "  'get_ipython',\n",
       "  'my_list',\n",
       "  'my_str',\n",
       "  'quit'],\n",
       " '_i12': 'divmod(3,2)',\n",
       " '_12': (1, 1),\n",
       " '_i13': 'divmod(3,3)',\n",
       " '_13': (1, 0),\n",
       " '_i14': 'divmod(6,3)',\n",
       " '_14': (2, 0),\n",
       " '_i15': 'temp_list = list(enumerate(my_list))\\nprint(temp_list)',\n",
       " 'temp_list': [(0, 1), (1, 1), (2, 0), (3, 1), (4, 1)],\n",
       " '_i16': \"x = 2\\ny = 3\\neval('x+y')\",\n",
       " 'x': 2,\n",
       " 'y': 3,\n",
       " '_16': 5,\n",
       " '_i17': 'format(12.345,2)',\n",
       " '_i18': 'txt = \"For only {price:.2f} dollars!\"\\nprint(txt.format(price = 49))',\n",
       " 'txt': 'For only {price:.2f} dollars!',\n",
       " '_i19': 'txt = \"For only {price:.2f} dollars!\"\\nprint(txt.format(price = 49))\\ntxt2 = \"My name is {0}, I\\'m {1}\".format(\"John\",36)\\nprint(txt2)',\n",
       " 'txt2': \"My name is John, I'm 36\",\n",
       " '_i20': '#Without arguments, return the list of names in the current local scope\\ndir()',\n",
       " '_20': ['In',\n",
       "  'Out',\n",
       "  '_',\n",
       "  '_1',\n",
       "  '_10',\n",
       "  '_11',\n",
       "  '_12',\n",
       "  '_13',\n",
       "  '_14',\n",
       "  '_16',\n",
       "  '_2',\n",
       "  '_3',\n",
       "  '_4',\n",
       "  '_5',\n",
       "  '_6',\n",
       "  '_7',\n",
       "  '_8',\n",
       "  '_9',\n",
       "  '__',\n",
       "  '___',\n",
       "  '__builtin__',\n",
       "  '__builtins__',\n",
       "  '__doc__',\n",
       "  '__loader__',\n",
       "  '__name__',\n",
       "  '__package__',\n",
       "  '__spec__',\n",
       "  '_dh',\n",
       "  '_i',\n",
       "  '_i1',\n",
       "  '_i10',\n",
       "  '_i11',\n",
       "  '_i12',\n",
       "  '_i13',\n",
       "  '_i14',\n",
       "  '_i15',\n",
       "  '_i16',\n",
       "  '_i17',\n",
       "  '_i18',\n",
       "  '_i19',\n",
       "  '_i2',\n",
       "  '_i20',\n",
       "  '_i3',\n",
       "  '_i4',\n",
       "  '_i5',\n",
       "  '_i6',\n",
       "  '_i7',\n",
       "  '_i8',\n",
       "  '_i9',\n",
       "  '_ih',\n",
       "  '_ii',\n",
       "  '_iii',\n",
       "  '_oh',\n",
       "  'exit',\n",
       "  'get_ipython',\n",
       "  'my_list',\n",
       "  'my_str',\n",
       "  'quit',\n",
       "  'temp_list',\n",
       "  'txt',\n",
       "  'txt2',\n",
       "  'x',\n",
       "  'y'],\n",
       " '_i21': 'global()',\n",
       " '_i22': 'globals()'}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "globals()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ec57a639",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 0)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Take two (non complex) numbers as arguments and return a pair of numbers consisting of \n",
    "#their quotient and remainder when using integer division\n",
    "divmod(6,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "7d4979f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 1), (1, 1), (2, 0), (3, 1), (4, 1)]\n"
     ]
    }
   ],
   "source": [
    "temp_list = list(enumerate(my_list))\n",
    "print(temp_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "cc634cd2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 2\n",
    "y = 3\n",
    "#The expression argument is parsed and evaluated as a Python expression\n",
    "eval('x+y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a9b98a44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For only 49.00 dollars!\n",
      "My name is John, I'm 36\n"
     ]
    }
   ],
   "source": [
    "#The format() method formats the specified value(s) and \n",
    "#insert them inside the string's placeholder.\n",
    "txt = \"For only {price:.2f} dollars!\"\n",
    "print(txt.format(price = 49))\n",
    "txt2 = \"My name is {0}, I'm {1}\".format(\"John\",36)\n",
    "print(txt2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a6da929f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0xff'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Convert an integer number to a lowercase hexadecimal string prefixed with “0x”\n",
    "hex(255)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "bbcccf1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0o377'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Convert an integer number to an octal string prefixed with “0o”\n",
    "oct(255)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "a66104bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [1,2,3,4]\n",
    "max(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "16b48524",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "88a5e2bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1234'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Return a string containing a printable representation of an object.\n",
    "repr(1234)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "46763f4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['4', '3', '2', '1']\n"
     ]
    }
   ],
   "source": [
    "my_list = list(reversed(repr(1234)))\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "4b410b91",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13.17"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(13.1654,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "4fb7e2bf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '2', '3', '4']"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "80556eae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Sums start and the items of an iterable from left to right and returns the total\n",
    "sum([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "4bd17083",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#A lambda function can take any number of arguments, but can only have one expression.\n",
    "#The expression is executed and the result is returned\n",
    "my_fun = lambda x : x**2\n",
    "my_fun(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "29e196b2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Lambda functions can take any number of arguments\n",
    "my_pow = lambda x,y : x**y\n",
    "my_pow(2,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "dad9b6e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#The power of lambda is better shown when you use them \n",
    "#as an anonymous function inside another function.\n",
    "def my_fun(text):\n",
    "    return lambda x : text.find(x)\n",
    "search = my_fun(\"my name is reza\")\n",
    "search('r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "476d828f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#mini project, creating shopping list\n",
    "hardware_store_list = {}\n",
    "supermarket_list = {}\n",
    "def show_list(shopping_list,include_quantity=True):\n",
    "    for item,quantity in shopping_list.items():\n",
    "        if include_quantity:\n",
    "            print(f\"{quantity}x {item}\")\n",
    "        else:\n",
    "            print(item)\n",
    "def add_item(item,quantity,shopping_list):\n",
    "    if not item:\n",
    "        quantity = 0\n",
    "    if item in shopping_list.keys():\n",
    "        shopping_list[item] +=quantity\n",
    "    else: shopping_list[item] = quantity\n",
    "    return shopping_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0abcf8b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1x Nails\n",
      "1x Screwdriver\n",
      "3x Glue\n",
      "1x Bread\n",
      "2x Milk\n"
     ]
    }
   ],
   "source": [
    "hardware_store_list = add_item(\"Nails\", 1, hardware_store_list)\n",
    "hardware_store_list = add_item(\"Screwdriver\", 1, hardware_store_list)\n",
    "hardware_store_list = add_item(\"Glue\", 3, hardware_store_list)\n",
    "\n",
    "supermarket_list = add_item(\"Bread\", 1, supermarket_list)\n",
    "supermarket_list = add_item(\"Milk\", 2, supermarket_list)\n",
    "\n",
    "show_list(hardware_store_list)\n",
    "show_list(supermarket_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "8e7b2f0e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "3x Shirt\n",
      "1x USB cable\n",
      "\n",
      "3x Shirt\n",
      "1x USB cable\n"
     ]
    }
   ],
   "source": [
    "def show_list(shopping_list, include_quantities=True):\n",
    "    print()\n",
    "    for item_name, quantity in shopping_list.items():\n",
    "        if include_quantities:\n",
    "            print(f\"{quantity}x {item_name}\")\n",
    "        else:\n",
    "            print(item_name)\n",
    "\n",
    "def add_item(item_name, quantity, shopping_list={}):\n",
    "    if item_name in shopping_list.keys():\n",
    "        shopping_list[item_name] += quantity\n",
    "    else:\n",
    "        shopping_list[item_name] = quantity\n",
    "\n",
    "    return shopping_list\n",
    "\n",
    "clothes_shop_list = add_item(\"Shirt\", 3)\n",
    "electronics_store_list = add_item(\"USB cable\", 1)\n",
    "show_list(clothes_shop_list)\n",
    "show_list(electronics_store_list)\n",
    "#in the add_item function, shopping_list has the defualt value, you sent an immutable value\n",
    "#like list or dictionary to prarameter, so this problem accure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b201199c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "3x Shirt\n",
      "\n",
      "1x USB cable\n"
     ]
    }
   ],
   "source": [
    "# to solve this problem, use None\n",
    "def show_list(shopping_list, include_quantities=True):\n",
    "    print()\n",
    "    for item_name, quantity in shopping_list.items():\n",
    "        if include_quantities:\n",
    "            print(f\"{quantity}x {item_name}\")\n",
    "        else:\n",
    "            print(item_name)\n",
    "\n",
    "def add_item(item_name, quantity, shopping_list=None):\n",
    "    if shopping_list is None:\n",
    "        shopping_list = {}\n",
    "    if item_name in shopping_list.keys():\n",
    "        shopping_list[item_name] += quantity\n",
    "    else:\n",
    "        shopping_list[item_name] = quantity\n",
    "\n",
    "    return shopping_list\n",
    "\n",
    "clothes_shop_list = add_item(\"Shirt\", 3)\n",
    "electronics_store_list = add_item(\"USB cable\", 1)\n",
    "show_list(clothes_shop_list)\n",
    "show_list(electronics_store_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "31ef23c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Coffee', 'Tea', 'Cake', 'Bread']\n",
      "Coffee Tea Cake Bread\n"
     ]
    }
   ],
   "source": [
    "#it is possible to define a function that accepts any number of optional arguments. \n",
    "#You can even define functions that accept any number of keyword arguments. \n",
    "#Keyword arguments are arguments that have a keyword and a value associated with them\n",
    "some_items = [\"Coffee\", \"Tea\", \"Cake\", \"Bread\"]\n",
    "print(some_items)\n",
    "#unpacking\n",
    "#it unpacks the sequence into its individual components\n",
    "print(*some_items)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1f8f1791",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "1x Coffee\n",
      "1x Tea\n",
      "1x Cake\n",
      "1x Bread\n"
     ]
    }
   ],
   "source": [
    "shopping_list = {}\n",
    "\n",
    "def show_list(shopping_list, include_quantities=True):\n",
    "    print()\n",
    "    for item_name, quantity in shopping_list.items():\n",
    "        if include_quantities:\n",
    "            print(f\"{quantity}x {item_name}\")\n",
    "        else:\n",
    "            print(item_name)\n",
    "\n",
    "def add_items(shopping_list, *item_names):\n",
    "    for item_name in item_names:\n",
    "        shopping_list[item_name] = 1\n",
    "\n",
    "    return shopping_list\n",
    "\n",
    "shopping_list = add_items(shopping_list, \"Coffee\", \"Tea\", \"Cake\", \"Bread\")\n",
    "show_list(shopping_list)\n",
    "#in the add_items we use unpacking to send more keywork argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "1b9ef12a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first argument\n",
      "second argument\n",
      "\n",
      "first argument\n",
      "second argument\n",
      "\n",
      "first argument\n",
      "second argument\n"
     ]
    }
   ],
   "source": [
    "def test_arguments(a, b):\n",
    "    print(a)\n",
    "    print(b)\n",
    "\n",
    "test_arguments(\"first argument\", \"second argument\")\n",
    "print()\n",
    "test_arguments(a=\"first argument\", b=\"second argument\")\n",
    "print()\n",
    "#In the first function call, the arguments are passed by position, \n",
    "#whereas in the second one they’re passed by keyword. \n",
    "#If you use keyword arguments, you no longer need to input arguments in the order they are defined\n",
    "test_arguments(b=\"second argument\", a=\"first argument\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "e000ddf8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "1x coffee\n",
      "2x tea\n",
      "1x cake\n",
      "3x bread\n"
     ]
    }
   ],
   "source": [
    "#When defining a function, you can include any number of\n",
    "#optional keyword arguments to be included using kwargs, \n",
    "#which stands for keyword arguments\n",
    "#The parameter name kwargs is preceded by two asterisks (**). \n",
    "#The double star or asterisk operates similarly to the single asterisk you used earlier\n",
    "#to unpack items from a sequence. The double star is used to unpack items from a mapping. \n",
    "#A mapping is a data type that has paired values as items, such as a dictionary.\n",
    "shopping_list = {}\n",
    "\n",
    "def show_list(shopping_list, include_quantities=True):\n",
    "    print()\n",
    "    for item_name, quantity in shopping_list.items():\n",
    "        if include_quantities:\n",
    "            print(f\"{quantity}x {item_name}\")\n",
    "        else:\n",
    "            print(item_name)\n",
    "\n",
    "def add_items(shopping_list, **things_to_buy):\n",
    "    for item_name, quantity in things_to_buy.items():\n",
    "        shopping_list[item_name] = quantity\n",
    "\n",
    "    return shopping_list\n",
    "\n",
    "shopping_list = add_items(shopping_list, coffee=1, tea=2, cake=1, bread=3)\n",
    "show_list(shopping_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1932ec95",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}