assignment_data/deep_dive_functions with homework.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "55e51611",
   "metadata": {},
   "source": [
    "Python functions are 1st class Objects, meaning\n",
    "\n",
    "> Can be assigned to variable \n",
    "\n",
    "> Store in datastructure \n",
    "\n",
    "> pass them as args to other functions\n",
    "\n",
    "> return them from other functions"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f20b5c4d",
   "metadata": {},
   "source": [
    "Why of the functions?\n",
    "   \n",
    "   > Abstraction and Reusability: functionality abstraction\n",
    "\n",
    "   > Modularity: breaking complex to simple\n",
    "\n",
    "   > NS SeperatioN: A namespace is a region of a program in which identifiers have meaning\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "365d0f3c",
   "metadata": {},
   "source": [
    "def <function_name>([parameters]):\n",
    "\n",
    "    <statement(s)>\n",
    "\n",
    "\n",
    "<function_name>([arguments])\n",
    "\n",
    "\n",
    "<arguments> are the values passed into the function. They correspond to the <parameters> in the Python function definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "733ecce9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3000"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "sys.getrecursionlimit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "09466b90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before calling f()\n",
      "-- Inside f()\n",
      "After calling f()\n"
     ]
    }
   ],
   "source": [
    "def f():       # f as a function is defined\n",
    "    s = '-- Inside f()'       #local var s assigned a string\n",
    "    print(s)               # s is printed\n",
    "    \n",
    "print('Before calling f()')       \n",
    "f()\n",
    "# print(f())\n",
    "print('After calling f()')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b56acdd0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Store in a datastructure\n",
    "a=[f,f]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "292981f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function f at 0x106ac7e20>\n"
     ]
    }
   ],
   "source": [
    "print(a[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "90a6fd3b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# positional args\n",
    "\n",
    "def f(qty, item, price):\n",
    "    print(f'{qty} {item} cost ${price:.2f}')\n",
    "\n",
    "# check what happens when one arg is not given when called  -->TypeError: f() missing 1 required positional argument: 'price'\n",
    "\n",
    "# check what happens when calling with key-val args  --> f(qty=2,item=4, price=5)\n",
    "    \n",
    "# Wht if one key used is not present in the val  -->f(qty=2,item=4)  ----> TypeError: f() missing 1 required positional argument: 'price'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c392a616",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "f() missing 1 required positional argument: 'price'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[19], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m f(qty\u001b[39m=\u001b[39m\u001b[39m2\u001b[39m,item\u001b[39m=\u001b[39m\u001b[39m4\u001b[39m)\n",
      "\u001b[0;31mTypeError\u001b[0m: f() missing 1 required positional argument: 'price'"
     ]
    }
   ],
   "source": [
    "f(qty=2,item=4)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "df494d4b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'THIS IS AWESOME!'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# assigning function to variables\n",
    "\n",
    "def trysay(text_data):\n",
    "    return text_data.upper() + '!'\n",
    "\n",
    "trysay('this is awesome')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "9fa3292d",
   "metadata": {},
   "source": [
    "trysay1 = (text_data):\n",
    "\n",
    "    return text_data.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "79744459",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SOUPER COOL!'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shout = trysay\n",
    "\n",
    "shout('Souper Cool')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "298c338f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'trysay'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shout.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "66d55f0a",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "str.translate() takes exactly one argument (0 given)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[40], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m zoo_funk[\u001b[39m2\u001b[39m](\u001b[39m'\u001b[39m\u001b[39mlets see\u001b[39m\u001b[39m'\u001b[39m)\n",
      "\u001b[0;31mTypeError\u001b[0m: str.translate() takes exactly one argument (0 given)"
     ]
    }
   ],
   "source": [
    "zoo_funk[2]('lets see')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "c65da494",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['let', ' go']"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "str1=\"lets go\"   # replace g with c\n",
    "# for i in str1:\n",
    "#     print(i)\n",
    "#     if i =='g':\n",
    "#         str1(i)='c'\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "333acfb9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'letsgo'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# str1[2]='g'\n",
    "\n",
    "# print(' '.join(['g','c']))\n",
    "\"\".join(str1.split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "141ff9a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# HomeWork : create a function similar to replace - It can be a long func \n",
    "def repl1(str1,old,new):   # loop through the str1 and look for old, drop old and insert new \n",
    "    # return new.join(str1.split(old))\n",
    "    l1 = list(str1)\n",
    "    for i,c in enumerate(l1):\n",
    "        if c == old:\n",
    "            l1[i]=new\n",
    "    return \"\".join(l1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "5c80a9e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'lels go'"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repl1(str1,'t','l')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "02d740da",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'LETS SEE!'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zoo_funk = [shout, str.replace, str.translate]\n",
    "\n",
    "zoo_funk[0]('lets see')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0a52c539",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(fx):\n",
    "    fx = 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "850c9e5f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a=5\n",
    "type(f(a))\n",
    "# a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a530cf98",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Pass-By-Value & Reference in Python\n",
    "\n",
    "def f(fx):\n",
    "    fx = 15    # ---> what is happening here?\n",
    "\n",
    "a = 5\n",
    "f(a)\n",
    "a\n",
    "\n",
    "# Argument passing in Python is somewhat of a hybrid between pass-by-value and pass-by-reference. \n",
    "\n",
    "# Python’s argument-passing mechanism has been called pass-by-assignment. This is because parameter \n",
    "# names are bound to objects on function entry in Python, and assignment is also the process of \n",
    "# binding a name to an object.\n",
    "\n",
    "# Argument passing in Python can be summarized as follows. Passing an immutable object, like an int,\n",
    "# str, tuple, or frozenset, to a Python function acts like pass-by-value\n",
    "\n",
    "# Passing a mutable object such as a list, dict, or set acts somewhat—but not exactly—like pass-by-reference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "81307340",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "fx=5\n",
    "\n",
    "def g():\n",
    "    global fx # global, local, non local keywords\n",
    "    fx = 15\n",
    "    \n",
    "g()\n",
    "print(fx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "00275c2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Return statements don’t need to be at the end of a function. \n",
    "# They can appear anywhere in a function body, and even multiple times\n",
    "\n",
    "def z(x):\n",
    "    if x < 8:\n",
    "        return\n",
    "    if x > 100:\n",
    "        return\n",
    "    print(0)\n",
    "\n",
    "z(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "be624a1c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# can return any OBJECT \n",
    "def zer():\n",
    "    return dict(fo5=7, rom=6, srd=62)\n",
    "\n",
    "zer()['fo5']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "d963c39f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# None is Falsy\n",
    "\n",
    "def s():\n",
    "    return\n",
    "\n",
    "def g():\n",
    "    pass\n",
    "\n",
    "if s():\n",
    "    print('yse')\n",
    "\n",
    "if g():\n",
    "    print('thes')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d7c3d978",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.333333333333333"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def avg(a, b, c):\n",
    "    return (a + b + c) / 3\n",
    "\n",
    "#  Python function definition is preceded by an asterisk (*), it indicates argument tuple packing\n",
    "\n",
    "x = (5, 6, 2)\n",
    "# this is unpacking\n",
    "avg(*x)\n",
    "\n",
    "# definition has individual named params, \n",
    "# and you are sending *tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "bb673026",
   "metadata": {},
   "outputs": [],
   "source": [
    "def avg(a,b):\n",
    "    return (a+b)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d34522ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Home Work - Write a func to find avg of any number of args and return the avg --- use packing - unpacking\n",
    "import numpy as np\n",
    "def avg(*args):\n",
    "    # print(np.mean(*args))\n",
    "    print(sum(*args)/len(*args))\n",
    "    \n",
    "# avg(4,5,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1e703409",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22.4\n"
     ]
    }
   ],
   "source": [
    "a = (4,6,5,32,65)\n",
    "avg(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "31f25833",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.666666666666667\n"
     ]
    }
   ],
   "source": [
    "avg((4,7,9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "5e03cc93",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "avg() missing 1 required positional argument: 'b'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[71], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m avg(a)\n",
      "\u001b[0;31mTypeError\u001b[0m: avg() missing 1 required positional argument: 'b'"
     ]
    }
   ],
   "source": [
    "avg(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "cff080bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg(*a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "f456bf7e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2,)\n",
      "<class 'tuple'>\n",
      "None\n",
      "(2, 6, 7)\n",
      "<class 'tuple'>\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def sum1(*args):\n",
    "    print(args)\n",
    "    print(type(args))\n",
    "    \n",
    "print(sum1(2))\n",
    "print(sum1(2,6,7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "d99dd0c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 2 5\n"
     ]
    }
   ],
   "source": [
    "def multiply1(a,b,c):\n",
    "    print(a,b,c)\n",
    "    \n",
    "dict1={\"a\":3, \"b\":2, \"c\":5}\n",
    "multiply1(**dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "90598edc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def mult1(**kwargs):\n",
    "    multip = 1\n",
    "    for i in (kwargs):\n",
    "        multip = multip * kwargs[i]\n",
    "    return multip\n",
    "    \n",
    "mult1(a=2, b=3, c=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "19d57b05",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def mult2(a,b,c):\n",
    "    return a*b*c\n",
    "\n",
    "di = {\"a\":2, \"b\":3, \"c\":4}\n",
    "mult2(**di)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "8f6d35f3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1=[3,4,5]\n",
    "mult2(*l1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "f0f58df0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Home Work --> do packing and unpacking for both args and kwargs and apply func multiplication and subtraction\n",
    "def mult_a(*args):\n",
    "    return np.prod(*args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "1dae88b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "840"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=(4,5,6,7)\n",
    "mult_a(a)\n",
    "# mult_a(4,5,6,7) -----> error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "41fa237d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(sum1(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7ccf842d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 6, 8, 7)\n",
      "5\n",
      "6\n",
      "8\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "def e(*args):\n",
    "    print(args)\n",
    "    for x in args:\n",
    "        print(x)\n",
    "# here it is tuple \"packing\"\n",
    "e(5, 6, 8, 7)\n",
    "# definition has *args, and you are sending \n",
    "# tuple of value as args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ef77ef48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'x': 5, 'y': 6, 'z': 8, 's': 7}\n",
      "x 5\n",
      "y 6\n",
      "z 8\n",
      "s 7\n"
     ]
    }
   ],
   "source": [
    "def e(**kwargs):\n",
    "    print(kwargs)\n",
    "    for x, y in kwargs.items():\n",
    "        print(x, y)\n",
    "\n",
    "# here it is dictionary \"packing\"\n",
    "e(x=5, y=6, z=8, s=7)\n",
    "# definition has **kwargs\n",
    "# you are sending in multiple k-v pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b74f4a93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 6 8\n"
     ]
    }
   ],
   "source": [
    "def e(x, y, b):\n",
    "    print(x, y, b)\n",
    "\n",
    "# here it is dictionary \"unpacking\"\n",
    "xdi = dict(x=5, y=6, b=8)\n",
    "\n",
    "e(**xdi)\n",
    "\n",
    "# definition contains individual parameters \n",
    "# and its called with **kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "47e856e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 1\n",
      "b = 2\n",
      "args = ('foo', 'bar', 'baz', 'qux')\n",
      "kwargs = {'x': 100, 'y': 200, 'z': 300}\n"
     ]
    }
   ],
   "source": [
    "# putting all together\n",
    "\n",
    "def f(a, b, *args, **kwargs):\n",
    "    print(F'a = {a}')\n",
    "    print(F'b = {b}')\n",
    "    print(F'args = {args}')\n",
    "    print(F'kwargs = {kwargs}')\n",
    "\n",
    "f(1, 2, 'foo', 'bar', 'baz', 'qux', x=100, y=200, z=300)\n",
    "\n",
    "a = 1\n",
    "b = 2\n",
    "args = ('foo', 'bar', 'baz', 'qux')\n",
    "kwargs = {'x': 100, 'y': 200, 'z': 300}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "919b37c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a -> 1\n",
      "b -> 2\n",
      "x -> 3\n",
      "y -> 4\n"
     ]
    }
   ],
   "source": [
    "def f(**kwargs):\n",
    "    for k, v in kwargs.items():\n",
    "            print(k, '->', v)\n",
    "\n",
    "d1 = {'a': 1, 'b': 2}\n",
    "d2 = {'x': 3, 'y': 4}\n",
    "\n",
    "f(**d1, **d2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "645d7467",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "positional argument follows keyword argument (400124697.py, line 10)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[20], line 10\u001b[1;36m\u001b[0m\n\u001b[1;33m    f(x=1, 2, z=3)\u001b[0m\n\u001b[1;37m                 ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m positional argument follows keyword argument\n"
     ]
    }
   ],
   "source": [
    "# To designate some parameters as positional-only, you specify a bare slash (/) in the parameter list of a function definition. \n",
    "# Any parameters to the left of the slash (/) must be specified positionally.\n",
    "\n",
    "# This is Python 3.8\n",
    "def f(x, y, /, z):\n",
    "    \"\"\"\n",
    "    Perform a foo transformation.\n",
    "    Keyword arguments:\n",
    "    x -- magnitude along the x axis (default=0)\n",
    "    y -- magnitude along the y axis (default=1)\n",
    "    z -- magnitude along the z axis (default=1)\n",
    "    \"\"\"\n",
    "    print(f'x: {x}')\n",
    "    print(f'y: {y}')\n",
    "    print(f'z: {z}')\n",
    "\n",
    "f(x=1, 2, z=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "dc3dcc9f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'THIS IS INSIDE!'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# passing funcs as params\n",
    "\n",
    "def greeter(get_func):\n",
    "    tem_var = get_func('This is inside')\n",
    "    return tem_var\n",
    "\n",
    "greeter(zoo_funk[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "e9176384",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Taking abstraction to next level\n",
    "from string import ascii_letters\n",
    "# print(ascii_letters)\n",
    "\n",
    "def encode_text(text):\n",
    "    ascii_dict = {}\n",
    "    updated_letter = ascii_letters\n",
    "    updated_letter += ' '\n",
    "    for ind, x in enumerate(updated_letter):\n",
    "        ascii_dict[x] = ind\n",
    "    incode = '' \n",
    "    for ch in text:\n",
    "        incode += str(ascii_dict[ch])\n",
    "    return incode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a018bac1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'457818528185281318834'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeter(encode_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f776662",
   "metadata": {},
   "outputs": [],
   "source": [
    "def speak(text):\n",
    "    def whisper(t):\n",
    "        return t.lower() + '...'\n",
    "    return whisper(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "863877c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_speak_func(volume):\n",
    "    def whisper(text):\n",
    "        return text.lower() + '...'\n",
    "    def yell(text):\n",
    "        return text.upper() + '!'\n",
    "    if volume > 0.5:\n",
    "        return yell\n",
    "    else:\n",
    "        return whisper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4de9b5bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SUPER NICE!'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# How to call the nested function\n",
    "\n",
    "get_func = get_speak_func(0.7)\n",
    "get_func('super nice')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "77c5a315",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'super wow...'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loudFunc = get_speak_func(0.3)\n",
    "loudFunc('super wow')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "000216f6",
   "metadata": {},
   "source": [
    "#### Capturing states...\n",
    "\n",
    "Inner functions capture and carry \n",
    "\n",
    "A closure remembers the values from its enclosing lexical scope even when the program flow is no longer in that scope."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "f408b2a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating factories\n",
    "def make_adder(n):\n",
    "    # which variable is in this scope\n",
    "    def add(x):\n",
    "        # which variables are in this scope\n",
    "        return x + n\n",
    "    return add\n",
    "\n",
    "plus3 = make_adder(3)\n",
    "\n",
    "plus3(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "c61eb4d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Functions are objects while the reverse is not true, objects are not functions\n",
    "\n",
    "class Adder:\n",
    "    def __init__(self, n):\n",
    "        self.n = n\n",
    "    def __call__(self, x):\n",
    "        return self.n + x\n",
    "\n",
    "plus3 = Adder(3)\n",
    "\n",
    "plus3(6)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5f44d433",
   "metadata": {},
   "source": [
    "#### Enter lambdas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "0ff68066",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add = lambda x, y: x + y\n",
    "add(5, 2)\n",
    "# here is that I didn’t have to bind the function object to a name before I used it\n",
    "(lambda x, y: x + y)(7, 6)\n",
    "# how does lambda return? There is always implicit return statement, \n",
    "# so its called single expression functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "68ad42e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(4, 'a'), (2, 'b'), (3, 'c'), (1, 'd')]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuples = [(1, 'd'),\n",
    "          (2, 'b'),\n",
    "          (4, 'a'),\n",
    "          (3, 'c')]\n",
    "\n",
    "sorted(tuples, key=lambda x: x[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "2e305760",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def make_adder(n):\n",
    "    return lambda x: x + n\n",
    "\n",
    "plus5 = make_adder(5)\n",
    "plus5(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e137fdbc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06ddcd45",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}