assignment_data/deep_dive_functions.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": 35,
   "id": "09466b90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before calling f()\n",
      "-- Inside f()\n",
      "After calling f()\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    s = '-- Inside f()'\n",
    "    print(s)\n",
    "\n",
    "print('Before calling f()')\n",
    "f()\n",
    "print('After calling f()')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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\n",
    "\n",
    "# check what happens when calling with key-val args\n",
    "    \n",
    "# Wht if one key used is not present in the val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "df494d4b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'THIS IS AWESOME!'"
      ]
     },
     "execution_count": 2,
     "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')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "79744459",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SOUPER COOL!'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shout = trysay\n",
    "\n",
    "shout('Souper Cool')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "298c338f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'trysay'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shout.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "02d740da",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'LETS SEE!'"
      ]
     },
     "execution_count": 6,
     "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": 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\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": 1,
   "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": 6,
   "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": 144,
   "id": "2c92bdaa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 6, 3, 4, 5] 3 4\n"
     ]
    }
   ],
   "source": [
    "tls = [7, 6, 3, 4, 5]\n",
    "print(tls, 3, 4)\n",
    "print(*tls, 3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "35702c9b",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (751668651.py, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[148], line 3\u001b[0;36m\u001b[0m\n\u001b[0;31m    **tls\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "tls = dict(a=7, b=6, k=3, h=4, e=5)\n",
    "print(tls.items())\n",
    "# **tls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "f0f5a52f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3__4__5]"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(3,4,5,sep=\"__\", end=\"]\",)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8a399e0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "ranks = dict(math=10,\n",
    "             phy=17,\n",
    "             eng=5,\n",
    "             chem=25,\n",
    "             computer=1,\n",
    "             play_time=0)\n",
    "\n",
    "def subject_ranks(s1, s2, s3, *args, **kwargs):\n",
    "    ranktot = 0\n",
    "    if s1 in ranks:\n",
    "        ranktot += ranks[s1]\n",
    "    if s2 in ranks:\n",
    "        ranktot += ranks[s2]\n",
    "    if s3 in ranks:\n",
    "        ranktot += ranks[s3]\n",
    "    print(args, 'are args')    \n",
    "    print(kwargs, 'are kwargs')    \n",
    "    return ranktot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "50ab045c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "() are args\n",
      "{} are kwargs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "52"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arguments = ('phy', 'chem', 'math')\n",
    "subject_ranks(*arguments)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7d8aee76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('comp', 'bio', 'play-time') are args\n",
      "{} are kwargs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "52"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arguments = ('phy', 'chem', 'math', 'comp', 'bio', 'play-time')\n",
    "subject_ranks(*arguments)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d0d99489",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "() are args\n",
      "{'x': 1, 'y': 2, 'z': 3} are kwargs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "52"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arguments = ('phy', 'chem', 'math')\n",
    "subject_ranks(*arguments, x=1, y=2, z=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "07d86531",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('phy', 'chem', 'math') are args\n",
      "{'a': 7, 'b': 6, 'k': 3, 'h': 4, 'e': 5} are kwargs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subject_ranks('f', 'i', 'k', *arguments, **tls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "8770c1bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "() are args\n",
      "{'a': 7, 'b': 6, 'k': 3, 'h': 4, 'e': 5} are kwargs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "52"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subject_ranks(*arguments, **tls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "256e7d5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "def many_args(*tple):\n",
    "    print(len(tple))\n",
    "\n",
    "# guess what will be output, and then execute\n",
    "\n",
    "# many_args(*(5, 6, 7, 9, 1, 2))\n",
    "\n",
    "# many_args((5, 6, 7, 9, 1, 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",
    "#home work functions warmup\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
}