Part1-Functional/06-FirstClassFunctions/FirstClassFunction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "558437d8-eb99-4899-954f-c75800f6b321",
   "metadata": {},
   "source": [
    "# Topics in this section"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2fe6be8",
   "metadata": {},
   "source": [
    "> 📍 Suggest download it first and then use it 📍"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ade6536",
   "metadata": {},
   "source": [
    "- **[First-Class Functions](#fisrt-class-functions)**\n",
    "    - **[First-Class Objects](#first-class-objects)**\n",
    "    - **[Higher-Order Functions](#higher-order-functions)**\n",
    "- **[Function Annotations and Documentation](#docstrings-and-annotations)**\n",
    "    - **[Docstrings](#docstrings)**\n",
    "    - **[Function Annotations](#function-annotations)**\n",
    "- **[Lambda Expressions and Anonymous Functions](#lambda-expression)**\n",
    "    - **[What Is It?](#what-are-lambda-expression)**\n",
    "    - **[Lambda and Sorting](#lambda-and-sorting)**\n",
    "    - **[Challenge](#challenge-randomizing-an-iterable-using-sorted-shuffle)**\n",
    "- **[Function Introspection](#function-introspection)**\n",
    "    - **[Function Attributs](#functions-attributes)**\n",
    "    - **[Inspect Module](#inspect-module)**\n",
    "    - **[Functions Comments](#function-comments)**\n",
    "    - **[Callable Signatures](#callable-signatures)**\n",
    "- **[Callables](#callables)**\n",
    "    - **[What Are Callables?](#what-are-callables)**\n",
    "    - **[Types of Callables](#different-types-of-callables)**\n",
    "- **[Built-in Higher Order Functions](#built-in-higher-order-functions)**\n",
    "    - **[`Map`](#the-map-funcntion)**\n",
    "    - **[`Filters`](#the-filter-function)**\n",
    "    - **[`Zip`](#the-zip-function)**\n",
    "    - **[List Comprehension, `map`](#list-comprehension-alternative-to-map)**\n",
    "    - **[List Comprehension, `filter`](#list-comprehension-alternative-to-filter)**\n",
    "    - **[Combining `map` and `filter`](#combining-map-and-filter)**\n",
    "- **[Reducing Function](#reducing-functions-in-python)**\n",
    "    - **[What Are Reducing Function?](#what-are-reducing-functions)**\n",
    "    - **[The `functools` Module](#the-functools-module)**\n",
    "    - **[Built-in Reducing Functions](#built-in-reducing-functions)**\n",
    "    - **[Examples](#examples)**\n",
    "    - **[The Reduce Initializer](#the-reduce-initializer)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0acf98e",
   "metadata": {},
   "source": [
    "## Fisrt-Class Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "add6fe4a-89c1-4c32-ae93-89401c1c69bf",
   "metadata": {},
   "source": [
    "### First-Class Objects"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f29a9a7b-56d3-45c8-8187-367e4b3f5774",
   "metadata": {},
   "source": [
    "What is **first-class objects** mean?\n",
    "- Can be passed to a function as an argument\n",
    "- Can be retured from a function\n",
    "- Can be assigned to a variable\n",
    "- Can be stored in a data structure (such as **`list`**, **`tuple`**, **`dictionary`**, etc.)\n",
    "\n",
    "Types such as **`int`**, **`float`**, **`str`**, **`tuple`**, **`list`** and many more are **first-class objects.\n",
    "\n",
    "**Functions** are also **first-class objects**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c97d20e-6717-4c2f-b546-a1475d7f95fc",
   "metadata": {},
   "source": [
    "### Higher-Order Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecd41125-3509-4281-b1fb-97395fbce7f0",
   "metadata": {},
   "source": [
    "**Higher-order functions** are functions that:\n",
    "- Take a functions as an **argument**\n",
    "- **Return** a function (**decorators**)\n",
    "\n",
    "**[see this](#built-in-higher-order-functions)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06cf2307-abe3-495f-8ade-79d5358b2048",
   "metadata": {},
   "source": [
    "## Docstrings and Annotations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4715285e-818f-4f93-b4f7-09060214ce66",
   "metadata": {},
   "source": [
    "### Docstrings"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a288d14d",
   "metadata": {},
   "source": [
    "we have seen the **`help(x)`** fucntion before $\\longrightarrow$ returns some documentation (if available) for **`x`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d41e2aac-faf6-4246-badf-c0b7c7d4bf2c",
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2023-11-05T04:39:43.152735Z",
     "iopub.status.busy": "2023-11-05T04:39:43.152497Z",
     "iopub.status.idle": "2023-11-05T04:39:43.170591Z",
     "shell.execute_reply": "2023-11-05T04:39:43.169841Z",
     "shell.execute_reply.started": "2023-11-05T04:39:43.152715Z"
    },
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class int in module builtins:\n",
      "\n",
      "class int(object)\n",
      " |  int([x]) -> integer\n",
      " |  int(x, base=10) -> integer\n",
      " |  \n",
      " |  Convert a number or string to an integer, or return 0 if no arguments\n",
      " |  are given.  If x is a number, return x.__int__().  For floating point\n",
      " |  numbers, this truncates towards zero.\n",
      " |  \n",
      " |  If x is not a number or if base is given, then x must be a string,\n",
      " |  bytes, or bytearray instance representing an integer literal in the\n",
      " |  given base.  The literal can be preceded by '+' or '-' and be surrounded\n",
      " |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.\n",
      " |  Base 0 means to interpret the base from the string as an integer literal.\n",
      " |  >>> int('0b100', base=0)\n",
      " |  4\n",
      " |  \n",
      " |  Built-in subclasses:\n",
      " |      bool\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __abs__(self, /)\n",
      " |      abs(self)\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __and__(self, value, /)\n",
      " |      Return self&value.\n",
      " |  \n",
      " |  __bool__(self, /)\n",
      " |      True if self else False\n",
      " |  \n",
      " |  __ceil__(...)\n",
      " |      Ceiling of an Integral returns itself.\n",
      " |  \n",
      " |  __divmod__(self, value, /)\n",
      " |      Return divmod(self, value).\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __float__(self, /)\n",
      " |      float(self)\n",
      " |  \n",
      " |  __floor__(...)\n",
      " |      Flooring an Integral returns itself.\n",
      " |  \n",
      " |  __floordiv__(self, value, /)\n",
      " |      Return self//value.\n",
      " |  \n",
      " |  __format__(self, format_spec, /)\n",
      " |      Default object formatter.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getnewargs__(self, /)\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __index__(self, /)\n",
      " |      Return self converted to an integer, if self is suitable for use as an index into a list.\n",
      " |  \n",
      " |  __int__(self, /)\n",
      " |      int(self)\n",
      " |  \n",
      " |  __invert__(self, /)\n",
      " |      ~self\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __lshift__(self, value, /)\n",
      " |      Return self<<value.\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __neg__(self, /)\n",
      " |      -self\n",
      " |  \n",
      " |  __or__(self, value, /)\n",
      " |      Return self|value.\n",
      " |  \n",
      " |  __pos__(self, /)\n",
      " |      +self\n",
      " |  \n",
      " |  __pow__(self, value, mod=None, /)\n",
      " |      Return pow(self, value, mod).\n",
      " |  \n",
      " |  __radd__(self, value, /)\n",
      " |      Return value+self.\n",
      " |  \n",
      " |  __rand__(self, value, /)\n",
      " |      Return value&self.\n",
      " |  \n",
      " |  __rdivmod__(self, value, /)\n",
      " |      Return divmod(value, self).\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rfloordiv__(self, value, /)\n",
      " |      Return value//self.\n",
      " |  \n",
      " |  __rlshift__(self, value, /)\n",
      " |      Return value<<self.\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __ror__(self, value, /)\n",
      " |      Return value|self.\n",
      " |  \n",
      " |  __round__(...)\n",
      " |      Rounding an Integral returns itself.\n",
      " |      \n",
      " |      Rounding with an ndigits argument also returns an integer.\n",
      " |  \n",
      " |  __rpow__(self, value, mod=None, /)\n",
      " |      Return pow(value, self, mod).\n",
      " |  \n",
      " |  __rrshift__(self, value, /)\n",
      " |      Return value>>self.\n",
      " |  \n",
      " |  __rshift__(self, value, /)\n",
      " |      Return self>>value.\n",
      " |  \n",
      " |  __rsub__(self, value, /)\n",
      " |      Return value-self.\n",
      " |  \n",
      " |  __rtruediv__(self, value, /)\n",
      " |      Return value/self.\n",
      " |  \n",
      " |  __rxor__(self, value, /)\n",
      " |      Return value^self.\n",
      " |  \n",
      " |  __sizeof__(self, /)\n",
      " |      Returns size in memory, in bytes.\n",
      " |  \n",
      " |  __sub__(self, value, /)\n",
      " |      Return self-value.\n",
      " |  \n",
      " |  __truediv__(self, value, /)\n",
      " |      Return self/value.\n",
      " |  \n",
      " |  __trunc__(...)\n",
      " |      Truncating an Integral returns itself.\n",
      " |  \n",
      " |  __xor__(self, value, /)\n",
      " |      Return self^value.\n",
      " |  \n",
      " |  as_integer_ratio(self, /)\n",
      " |      Return integer ratio.\n",
      " |      \n",
      " |      Return a pair of integers, whose ratio is exactly equal to the original int\n",
      " |      and with a positive denominator.\n",
      " |      \n",
      " |      >>> (10).as_integer_ratio()\n",
      " |      (10, 1)\n",
      " |      >>> (-10).as_integer_ratio()\n",
      " |      (-10, 1)\n",
      " |      >>> (0).as_integer_ratio()\n",
      " |      (0, 1)\n",
      " |  \n",
      " |  bit_count(self, /)\n",
      " |      Number of ones in the binary representation of the absolute value of self.\n",
      " |      \n",
      " |      Also known as the population count.\n",
      " |      \n",
      " |      >>> bin(13)\n",
      " |      '0b1101'\n",
      " |      >>> (13).bit_count()\n",
      " |      3\n",
      " |  \n",
      " |  bit_length(self, /)\n",
      " |      Number of bits necessary to represent self in binary.\n",
      " |      \n",
      " |      >>> bin(37)\n",
      " |      '0b100101'\n",
      " |      >>> (37).bit_length()\n",
      " |      6\n",
      " |  \n",
      " |  conjugate(...)\n",
      " |      Returns self, the complex conjugate of any int.\n",
      " |  \n",
      " |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)\n",
      " |      Return an array of bytes representing an integer.\n",
      " |      \n",
      " |      length\n",
      " |        Length of bytes object to use.  An OverflowError is raised if the\n",
      " |        integer is not representable with the given number of bytes.  Default\n",
      " |        is length 1.\n",
      " |      byteorder\n",
      " |        The byte order used to represent the integer.  If byteorder is 'big',\n",
      " |        the most significant byte is at the beginning of the byte array.  If\n",
      " |        byteorder is 'little', the most significant byte is at the end of the\n",
      " |        byte array.  To request the native byte order of the host system, use\n",
      " |        `sys.byteorder' as the byte order value.  Default is to use 'big'.\n",
      " |      signed\n",
      " |        Determines whether two's complement is used to represent the integer.\n",
      " |        If signed is False and a negative integer is given, an OverflowError\n",
      " |        is raised.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  from_bytes(bytes, byteorder='big', *, signed=False) from builtins.type\n",
      " |      Return the integer represented by the given array of bytes.\n",
      " |      \n",
      " |      bytes\n",
      " |        Holds the array of bytes to convert.  The argument must either\n",
      " |        support the buffer protocol or be an iterable object producing bytes.\n",
      " |        Bytes and bytearray are examples of built-in objects that support the\n",
      " |        buffer protocol.\n",
      " |      byteorder\n",
      " |        The byte order used to represent the integer.  If byteorder is 'big',\n",
      " |        the most significant byte is at the beginning of the byte array.  If\n",
      " |        byteorder is 'little', the most significant byte is at the end of the\n",
      " |        byte array.  To request the native byte order of the host system, use\n",
      " |        `sys.byteorder' as the byte order value.  Default is to use 'big'.\n",
      " |      signed\n",
      " |        Indicates whether two's complement is used to represent the integer.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  denominator\n",
      " |      the denominator of a rational number in lowest terms\n",
      " |  \n",
      " |  imag\n",
      " |      the imaginary part of a complex number\n",
      " |  \n",
      " |  numerator\n",
      " |      the numerator of a rational number in lowest terms\n",
      " |  \n",
      " |  real\n",
      " |      the real part of a complex number\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(int)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71f6365b-6000-4710-872f-a71304b6bdb3",
   "metadata": {
    "tags": []
   },
   "source": [
    "We can **document** our functions (modules, classes, etc.) to achive the same result using **docstring** $\\longrightarrow$ [**PEP 257**]()\n",
    "\n",
    "If the **first line** in the function body is a string (not an assignment, not a comment, just a string by itself), it will interpreted as a **docstring**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c88ff04c-d980-4038-8663-fcee5022f7a7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T04:47:19.081052Z",
     "iopub.status.busy": "2023-11-05T04:47:19.080467Z",
     "iopub.status.idle": "2023-11-05T04:47:19.084072Z",
     "shell.execute_reply": "2023-11-05T04:47:19.083382Z",
     "shell.execute_reply.started": "2023-11-05T04:47:19.081028Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def my_func(a):\n",
    "    \"documentation for my_func\"\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "df9badb3-355a-47e3-ac28-2d413068843a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T04:47:34.078952Z",
     "iopub.status.busy": "2023-11-05T04:47:34.078476Z",
     "iopub.status.idle": "2023-11-05T04:47:34.082522Z",
     "shell.execute_reply": "2023-11-05T04:47:34.081745Z",
     "shell.execute_reply.started": "2023-11-05T04:47:34.078902Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function my_func in module __main__:\n",
      "\n",
      "my_func(a)\n",
      "    documentation for my_func\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(my_func)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14a01b4d-044a-4f9d-a384-672a4155c242",
   "metadata": {},
   "source": [
    "**Multi-line** docstrings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4ecc9ac1-338e-440f-adc1-f40b7134c8ea",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T04:49:51.136614Z",
     "iopub.status.busy": "2023-11-05T04:49:51.136380Z",
     "iopub.status.idle": "2023-11-05T04:49:51.140606Z",
     "shell.execute_reply": "2023-11-05T04:49:51.139677Z",
     "shell.execute_reply.started": "2023-11-05T04:49:51.136595Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def my_func(a):\n",
    "    \"\"\"documentation for my_func\n",
    "    \"\"\"\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "69479b4e-96a4-457d-9a10-8482d2acdd54",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T04:49:51.373439Z",
     "iopub.status.busy": "2023-11-05T04:49:51.372968Z",
     "iopub.status.idle": "2023-11-05T04:49:51.379842Z",
     "shell.execute_reply": "2023-11-05T04:49:51.378709Z",
     "shell.execute_reply.started": "2023-11-05T04:49:51.373394Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function my_func in module __main__:\n",
      "\n",
      "my_func(a)\n",
      "    documentation for my_func\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(my_func)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b12ddd86-965f-4959-a092-36bf1d342746",
   "metadata": {},
   "source": [
    "#### Where are docstrings stored?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f37657d-18f4-4e71-9d25-9961680fc8e4",
   "metadata": {},
   "source": [
    "In the function's **`__doc__`** property"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f0779cb4-2011-4420-a813-c1a0c83f98e6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T04:53:13.457231Z",
     "iopub.status.busy": "2023-11-05T04:53:13.456897Z",
     "iopub.status.idle": "2023-11-05T04:53:13.460672Z",
     "shell.execute_reply": "2023-11-05T04:53:13.460156Z",
     "shell.execute_reply.started": "2023-11-05T04:53:13.457203Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def fact(n):\n",
    "    \"\"\"Calculate n! (factorial function)\n",
    "    \n",
    "    Inputs:\n",
    "        n: non-negative inteager\n",
    "    Returns:\n",
    "        the factorail of n\n",
    "    \"\"\"\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e1f557f9-da8a-435a-b957-03fc8aae9ccb",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T04:53:32.210012Z",
     "iopub.status.busy": "2023-11-05T04:53:32.209581Z",
     "iopub.status.idle": "2023-11-05T04:53:32.215587Z",
     "shell.execute_reply": "2023-11-05T04:53:32.214551Z",
     "shell.execute_reply.started": "2023-11-05T04:53:32.209965Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function fact in module __main__:\n",
      "\n",
      "fact(n)\n",
      "    Calculate n! (factorial function)\n",
      "    \n",
      "    Inputs:\n",
      "        n: non-negative inteager\n",
      "    Returns:\n",
      "        the factorail of n\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(fact)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a0b3829a-f65d-4ff6-8669-bb428d72c9ef",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T04:54:32.359245Z",
     "iopub.status.busy": "2023-11-05T04:54:32.359005Z",
     "iopub.status.idle": "2023-11-05T04:54:32.362683Z",
     "shell.execute_reply": "2023-11-05T04:54:32.362092Z",
     "shell.execute_reply.started": "2023-11-05T04:54:32.359227Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculate n! (factorial function)\n",
      "    \n",
      "    Inputs:\n",
      "        n: non-negative inteager\n",
      "    Returns:\n",
      "        the factorail of n\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(fact.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53c693cc-bc36-45fe-8a80-cc262e2de4a4",
   "metadata": {},
   "source": [
    "### Function Annotations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "303c9768-c737-477b-8d44-e3e6f7dd050f",
   "metadata": {},
   "source": [
    "Function annotations give us an additional way to document our functions $\\longrightarrow$ [**PEP 3107**]() "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98e73db7-f81f-404d-9167-41990aa230e4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T05:04:54.512513Z",
     "iopub.status.busy": "2023-11-05T05:04:54.512235Z",
     "iopub.status.idle": "2023-11-05T05:04:54.522310Z",
     "shell.execute_reply": "2023-11-05T05:04:54.519554Z",
     "shell.execute_reply.started": "2023-11-05T05:04:54.512489Z"
    },
    "tags": []
   },
   "source": [
    "```python\n",
    "def my_funct(a: <expression>, b: <expression>) -> <expression>:\n",
    "    pass\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15deeee1-7506-4fce-b6c6-0a7d92940586",
   "metadata": {},
   "source": [
    "#### Where are annotations stored?\n",
    "\n",
    "In the **`__annotations__`** property of the function $\\longrightarrow$ return **`dict`**: \n",
    "\n",
    "- **`keys`** are parameter names\n",
    "    - For a **`return`** annotation, the key is **return**\n",
    "- **`values`** are the annotations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "dac3c3a3-d025-44e3-bd5b-fe8730105d51",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T05:07:47.642462Z",
     "iopub.status.busy": "2023-11-05T05:07:47.641625Z",
     "iopub.status.idle": "2023-11-05T05:07:47.648247Z",
     "shell.execute_reply": "2023-11-05T05:07:47.646871Z",
     "shell.execute_reply.started": "2023-11-05T05:07:47.642407Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def my_func(a: \"a string\", b: \"a positive inteager\") -> \"a string\":\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "088d2f9d-d259-43dc-b74a-5277a7593d3a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T05:07:53.190372Z",
     "iopub.status.busy": "2023-11-05T05:07:53.189840Z",
     "iopub.status.idle": "2023-11-05T05:07:53.197927Z",
     "shell.execute_reply": "2023-11-05T05:07:53.196223Z",
     "shell.execute_reply.started": "2023-11-05T05:07:53.190323Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function my_func in module __main__:\n",
      "\n",
      "my_func(a: 'a string', b: 'a positive inteager') -> 'a string'\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(my_func)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4027665c-2453-441d-9efd-fbf225e8a9cd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T05:08:25.404808Z",
     "iopub.status.busy": "2023-11-05T05:08:25.404141Z",
     "iopub.status.idle": "2023-11-05T05:08:25.408933Z",
     "shell.execute_reply": "2023-11-05T05:08:25.408190Z",
     "shell.execute_reply.started": "2023-11-05T05:08:25.404744Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(my_func.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "c6589c3a-b534-462c-8a01-012bec3ac083",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T05:10:17.224233Z",
     "iopub.status.busy": "2023-11-05T05:10:17.224010Z",
     "iopub.status.idle": "2023-11-05T05:10:17.228189Z",
     "shell.execute_reply": "2023-11-05T05:10:17.227717Z",
     "shell.execute_reply.started": "2023-11-05T05:10:17.224216Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'a string', 'b': 'a positive inteager', 'return': 'a string'}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_func.__annotations__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54094f0e-88a4-4854-81de-b6b30e8e501a",
   "metadata": {},
   "source": [
    "Annotations can be any expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "b5ed6012-7711-4ff1-8982-4575f09a3a30",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T05:09:45.407889Z",
     "iopub.status.busy": "2023-11-05T05:09:45.407544Z",
     "iopub.status.idle": "2023-11-05T05:09:45.412890Z",
     "shell.execute_reply": "2023-11-05T05:09:45.411295Z",
     "shell.execute_reply.started": "2023-11-05T05:09:45.407863Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def sum(a: [int, float], b: [int, float]) -> [int, float]:\n",
    "    \"\"\"Sumation of two number\n",
    "    \n",
    "    Inputs:\n",
    "        a: int or float\n",
    "        b: int or float\n",
    "    Return:\n",
    "        a + b: int or float\n",
    "    \"\"\"\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "33c180ea-836c-4143-8290-71451c62ba53",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T05:10:00.685697Z",
     "iopub.status.busy": "2023-11-05T05:10:00.685058Z",
     "iopub.status.idle": "2023-11-05T05:10:00.692196Z",
     "shell.execute_reply": "2023-11-05T05:10:00.690390Z",
     "shell.execute_reply.started": "2023-11-05T05:10:00.685662Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sumation of two number\n",
      "    \n",
      "    Inputs:\n",
      "        a: int or float\n",
      "        b: int or float\n",
      "    Return:\n",
      "        a + b: int or float\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(sum.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "2c36e80d-1d00-4dc6-9f25-5a15a5af7480",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T05:10:50.578491Z",
     "iopub.status.busy": "2023-11-05T05:10:50.578237Z",
     "iopub.status.idle": "2023-11-05T05:10:50.583153Z",
     "shell.execute_reply": "2023-11-05T05:10:50.582471Z",
     "shell.execute_reply.started": "2023-11-05T05:10:50.578468Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': [int, float], 'b': [int, float], 'return': [int, float]}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum.__annotations__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "780db494-0846-46f0-a315-88ab47fb1ee2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T05:09:45.933891Z",
     "iopub.status.busy": "2023-11-05T05:09:45.933515Z",
     "iopub.status.idle": "2023-11-05T05:09:45.942775Z",
     "shell.execute_reply": "2023-11-05T05:09:45.941556Z",
     "shell.execute_reply.started": "2023-11-05T05:09:45.933866Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function sum in module __main__:\n",
      "\n",
      "sum(a: [<class 'int'>, <class 'float'>], b: [<class 'int'>, <class 'float'>]) -> [<class 'int'>, <class 'float'>]\n",
      "    Sumation of two number\n",
      "    \n",
      "    Inputs:\n",
      "        a: int or float\n",
      "        b: int or float\n",
      "    Return:\n",
      "        a + b: int or float\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d2bcc71-e710-4a71-bb1d-535697b794bd",
   "metadata": {},
   "source": [
    "### Where does Python use docstrings and annotations?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b01fcef5",
   "metadata": {},
   "source": [
    "It doesn't really!\n",
    "\n",
    "Mainlu used by external tools and modules\n",
    "- Example: apps that generate documentation from your code ([**Sphinx**]())\n",
    "\n",
    "Docstrings and annotaions are entirely **optional**, and do not 'force' anything in our Python code\n",
    "\n",
    "We'll look at an enhanced version of annotations in an upcoming section on [**type hints**]()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36da2a4b-4fef-499b-9fb2-34d7caa89ec0",
   "metadata": {},
   "source": [
    "## Lambda Expression"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "286cec56",
   "metadata": {},
   "source": [
    "### What are Lambda Expression?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d60bedfb-d8b9-46e1-a48a-d7bbe6befab2",
   "metadata": {},
   "source": [
    "We already know how to create **function** using **`def`** statement\n",
    "\n",
    "Lambda expressions are simply another way to create **function** $\\longrightarrow$ **anonymouse function**\n",
    "\n",
    "```python\n",
    "lambda [parameter list]: expression\n",
    "```\n",
    "\n",
    "> **`lambda`** is a **keyword**\n",
    ">\n",
    "> **`parameter list`** is **optional**\n",
    ">\n",
    "> The **`:`** is **required**, even for zero arguments\n",
    ">\n",
    "> **`expression`** is evaluated and returned when the lambda fuction **called** $\\longrightarrow$ body of the function\n",
    "\n",
    "It can be assigned to a variable\n",
    "\n",
    "It returned a **`function object`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "de0173a6-8224-4e3a-9602-540574167aef",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T09:23:10.626772Z",
     "iopub.status.busy": "2023-11-05T09:23:10.626195Z",
     "iopub.status.idle": "2023-11-05T09:23:10.642575Z",
     "shell.execute_reply": "2023-11-05T09:23:10.641264Z",
     "shell.execute_reply.started": "2023-11-05T09:23:10.626718Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>(x)>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lambda x: x ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "16af6788-5062-4c7e-8927-a3c46c1050d7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T09:24:30.617187Z",
     "iopub.status.busy": "2023-11-05T09:24:30.616849Z",
     "iopub.status.idle": "2023-11-05T09:24:30.622113Z",
     "shell.execute_reply": "2023-11-05T09:24:30.621547Z",
     "shell.execute_reply.started": "2023-11-05T09:24:30.617161Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square = lambda x: x ** 2\n",
    "square(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "62832374-b59b-4766-81c5-924e92c33201",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T09:25:42.281391Z",
     "iopub.status.busy": "2023-11-05T09:25:42.279713Z",
     "iopub.status.idle": "2023-11-05T09:25:42.286438Z",
     "shell.execute_reply": "2023-11-05T09:25:42.285666Z",
     "shell.execute_reply.started": "2023-11-05T09:25:42.281317Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_two_number = lambda x, y: x + y\n",
    "sum_two_number(5, 9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "eae76c67-7ff5-4b56-9815-0b81a05e9ae0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T09:26:29.268408Z",
     "iopub.status.busy": "2023-11-05T09:26:29.268048Z",
     "iopub.status.idle": "2023-11-05T09:26:29.272655Z",
     "shell.execute_reply": "2023-11-05T09:26:29.272071Z",
     "shell.execute_reply.started": "2023-11-05T09:26:29.268390Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empty = lambda : \"hello\"\n",
    "empty()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d465a718-3511-4453-ae86-efd23209a348",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T09:37:50.943057Z",
     "iopub.status.busy": "2023-11-05T09:37:50.942789Z",
     "iopub.status.idle": "2023-11-05T09:37:50.949586Z",
     "shell.execute_reply": "2023-11-05T09:37:50.947183Z",
     "shell.execute_reply.started": "2023-11-05T09:37:50.943040Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NIMA'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverse_str = lambda s: s[::-1].upper()\n",
    "reverse_str(\"amin\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b69619cb-2fed-4401-9348-554324a850e4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T10:00:13.613912Z",
     "iopub.status.busy": "2023-11-05T10:00:13.613133Z",
     "iopub.status.idle": "2023-11-05T10:00:13.619615Z",
     "shell.execute_reply": "2023-11-05T10:00:13.618892Z",
     "shell.execute_reply.started": "2023-11-05T10:00:13.613843Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(reverse_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b13170e-2d35-40ce-805a-cf38824889b8",
   "metadata": {},
   "source": [
    "> Note that these expressions are **`function objects`**, but are not **named** $\\longrightarrow$ **`anonymouse functions`**\n",
    "\n",
    "**Lambda**, or **anonymouse functions**, are NOT equivalent to closures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c65a7be6-2719-4969-8644-1807954c55f4",
   "metadata": {},
   "source": [
    "#### Passing lambda as an argument to another function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "7a0088b1-f960-426d-81fc-6ccdb29d10c7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T10:07:37.399978Z",
     "iopub.status.busy": "2023-11-05T10:07:37.399510Z",
     "iopub.status.idle": "2023-11-05T10:07:37.410044Z",
     "shell.execute_reply": "2023-11-05T10:07:37.409365Z",
     "shell.execute_reply.started": "2023-11-05T10:07:37.399920Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "81"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def apply_func(x, func):\n",
    "    return func(x)\n",
    "\n",
    "apply_func(3, lambda x: x**4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "175167e8-295c-4c66-9802-1c747364fc52",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T10:08:03.655182Z",
     "iopub.status.busy": "2023-11-05T10:08:03.654929Z",
     "iopub.status.idle": "2023-11-05T10:08:03.664139Z",
     "shell.execute_reply": "2023-11-05T10:08:03.662419Z",
     "shell.execute_reply.started": "2023-11-05T10:08:03.655161Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apply_func(2, lambda x: x+5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "eac8a82b-afd6-4e2c-a375-41415cb9ed0c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T10:08:55.203801Z",
     "iopub.status.busy": "2023-11-05T10:08:55.203589Z",
     "iopub.status.idle": "2023-11-05T10:08:55.207973Z",
     "shell.execute_reply": "2023-11-05T10:08:55.207484Z",
     "shell.execute_reply.started": "2023-11-05T10:08:55.203784Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NIMA'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apply_func(\"amin\", lambda s: s[::-1].upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e7b87a3-98e7-4954-882c-d17ee55428ac",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Limitations\n",
    "\n",
    "- The **`body`** of a **lambda** is limited to a **single expression**\n",
    "\n",
    "- No assignments:\n",
    "    ```python\n",
    "    lambda x: x = 5 # NOT CORRECT\n",
    "    ```\n",
    "- No annotations\n",
    "\n",
    "- Single **logical** line of code $\\longrightarrow$ line-continuation is OK, but still just **one** expression:\n",
    "    ```python\n",
    "    lambda x: x * \\\n",
    "        math.sin(x)\n",
    "    ```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7afe23d-7769-4965-b0c7-062b56b5f61e",
   "metadata": {},
   "source": [
    "### Lambda and Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6bdba6be-811e-477c-be81-64e0de590e59",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T17:10:58.810638Z",
     "iopub.status.busy": "2023-11-05T17:10:58.810241Z",
     "iopub.status.idle": "2023-11-05T17:10:58.823608Z",
     "shell.execute_reply": "2023-11-05T17:10:58.822591Z",
     "shell.execute_reply.started": "2023-11-05T17:10:58.810590Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sorted in module builtins:\n",
      "\n",
      "sorted(iterable, /, *, key=None, reverse=False)\n",
      "    Return a new list containing all items from the iterable in ascending order.\n",
      "    \n",
      "    A custom key function can be supplied to customize the sort order, and the\n",
      "    reverse flag can be set to request the result in descending order.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sorted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "854bef5e-a06d-48a3-bfd1-56ad33c91803",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T17:13:23.549930Z",
     "iopub.status.busy": "2023-11-05T17:13:23.549656Z",
     "iopub.status.idle": "2023-11-05T17:13:23.556754Z",
     "shell.execute_reply": "2023-11-05T17:13:23.555984Z",
     "shell.execute_reply.started": "2023-11-05T17:13:23.549911Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5, 7, 8]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [1, 5, 7, 2, 3, 8]\n",
    "\n",
    "sorted(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f9ffd774-da52-4149-93be-fae8daa62893",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T17:13:26.623741Z",
     "iopub.status.busy": "2023-11-05T17:13:26.623228Z",
     "iopub.status.idle": "2023-11-05T17:13:26.627813Z",
     "shell.execute_reply": "2023-11-05T17:13:26.627151Z",
     "shell.execute_reply.started": "2023-11-05T17:13:26.623718Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 5, 7, 2, 3, 8]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8f7fecc1-d618-49e9-9a97-f4487f7e3495",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T17:16:09.840630Z",
     "iopub.status.busy": "2023-11-05T17:16:09.840177Z",
     "iopub.status.idle": "2023-11-05T17:16:09.845308Z",
     "shell.execute_reply": "2023-11-05T17:16:09.844725Z",
     "shell.execute_reply.started": "2023-11-05T17:16:09.840609Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ord('a')=97, ord('c')=99, ord('B')=66, ord('D')=68\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['B', 'D', 'a', 'c']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = ['c', 'B', 'a', 'D']\n",
    "print(f\"{ord('a')=}, {ord('c')=}, {ord('B')=}, {ord('D')=}\")\n",
    "sorted(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "79809209-1666-4a3b-a7b1-95c25d0751d8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T17:24:34.046266Z",
     "iopub.status.busy": "2023-11-05T17:24:34.046037Z",
     "iopub.status.idle": "2023-11-05T17:24:34.050617Z",
     "shell.execute_reply": "2023-11-05T17:24:34.050019Z",
     "shell.execute_reply.started": "2023-11-05T17:24:34.046248Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'B', 'c', 'D']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(l, key=lambda s: s.lower()) # :) WoW"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "35d910d1-eea0-47aa-90ac-6dc21c7e447c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T17:26:36.238355Z",
     "iopub.status.busy": "2023-11-05T17:26:36.238131Z",
     "iopub.status.idle": "2023-11-05T17:26:36.242563Z",
     "shell.execute_reply": "2023-11-05T17:26:36.242085Z",
     "shell.execute_reply.started": "2023-11-05T17:26:36.238337Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'c': 100, 'a': 300, 'b': 200}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {\n",
    "    \"c\": 100,\n",
    "    \"a\": 300,\n",
    "    \"b\": 200\n",
    "}\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "cf560421-5f1b-40cc-8fa2-451203175a5d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T17:26:36.391430Z",
     "iopub.status.busy": "2023-11-05T17:26:36.390870Z",
     "iopub.status.idle": "2023-11-05T17:26:36.448262Z",
     "shell.execute_reply": "2023-11-05T17:26:36.447607Z",
     "shell.execute_reply.started": "2023-11-05T17:26:36.391410Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c']"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(d) # sorted on dict keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "e4c9b1d2-9518-443e-8377-15fd9998bcae",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T17:26:36.550337Z",
     "iopub.status.busy": "2023-11-05T17:26:36.550103Z",
     "iopub.status.idle": "2023-11-05T17:26:36.760718Z",
     "shell.execute_reply": "2023-11-05T17:26:36.759751Z",
     "shell.execute_reply.started": "2023-11-05T17:26:36.550319Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['c', 'b', 'a']"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(d, key=lambda e: d[e]) # sorted in dict values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "7878b94d-0958-4f63-a155-c21343bf374b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T17:29:36.600986Z",
     "iopub.status.busy": "2023-11-05T17:29:36.600653Z",
     "iopub.status.idle": "2023-11-05T17:29:36.610961Z",
     "shell.execute_reply": "2023-11-05T17:29:36.610130Z",
     "shell.execute_reply.started": "2023-11-05T17:29:36.600960Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(3+3j), (1-1j), 0, (3+0j)]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [3+3j, 1-1j, 0, 3+0j]\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "4c85e1c2-786c-4015-ab57-0a632f9013c8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T17:29:41.432608Z",
     "iopub.status.busy": "2023-11-05T17:29:41.432358Z",
     "iopub.status.idle": "2023-11-05T17:29:41.446732Z",
     "shell.execute_reply": "2023-11-05T17:29:41.445651Z",
     "shell.execute_reply.started": "2023-11-05T17:29:41.432590Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'<' not supported between instances of 'complex' and 'complex'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[46], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28msorted\u001b[39m(l)\n",
      "\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'complex' and 'complex'"
     ]
    }
   ],
   "source": [
    "sorted(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "fc842afd-9f4f-4456-95af-f4b812cc9237",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T17:30:31.609164Z",
     "iopub.status.busy": "2023-11-05T17:30:31.608925Z",
     "iopub.status.idle": "2023-11-05T17:30:31.614334Z",
     "shell.execute_reply": "2023-11-05T17:30:31.613592Z",
     "shell.execute_reply.started": "2023-11-05T17:30:31.609147Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, (1-1j), (3+0j), (3+3j)]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(l, key=lambda x: x.real**2 + x.imag**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbed7925-7e24-4b08-8c06-6deec6dc0eb2",
   "metadata": {},
   "source": [
    "### Challenge: Randomizing an Iterable using Sorted (Shuffle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "cb008028-fa1e-4f41-ad54-cf7af85a3a69",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T18:17:26.835678Z",
     "iopub.status.busy": "2023-11-05T18:17:26.835419Z",
     "iopub.status.idle": "2023-11-05T18:17:26.841337Z",
     "shell.execute_reply": "2023-11-05T18:17:26.840620Z",
     "shell.execute_reply.started": "2023-11-05T18:17:26.835654Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "main_l=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[8, 5, 0, 1, 7, 9, 3, 4, 2, 6]"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "main_l = list(range(10))\n",
    "print(f\"{main_l=}\")\n",
    "\n",
    "sorted(main_l, key=lambda x: random.random()) # Shuffling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "61127887-da95-4e5b-882c-65af23b86d63",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T18:17:30.448333Z",
     "iopub.status.busy": "2023-11-05T18:17:30.447852Z",
     "iopub.status.idle": "2023-11-05T18:17:30.453034Z",
     "shell.execute_reply": "2023-11-05T18:17:30.452283Z",
     "shell.execute_reply.started": "2023-11-05T18:17:30.448307Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key is called with: 0\n",
      "return value is: 0.2770338345801565\n",
      "key is called with: 1\n",
      "return value is: 0.5855696638187121\n",
      "key is called with: 2\n",
      "return value is: 0.40141038269569895\n",
      "key is called with: 3\n",
      "return value is: 0.23911963933664204\n",
      "key is called with: 4\n",
      "return value is: 0.5773959298189859\n",
      "[3, 0, 2, 4, 1]\n"
     ]
    }
   ],
   "source": [
    "# complete explain for shuffling\n",
    "from random import random\n",
    "\n",
    "def key(x):\n",
    "    print(f\"key is called with: {x}\")\n",
    "    r = random()\n",
    "    print(f\"return value is: {r}\")\n",
    "    return r\n",
    "\n",
    "lst = list(range(5))\n",
    "print(sorted(lst, key=key))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0158b02d-5366-4559-8c41-ffe989e7d74c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T18:34:25.990800Z",
     "iopub.status.busy": "2023-11-05T18:34:25.990385Z",
     "iopub.status.idle": "2023-11-05T18:34:25.995813Z",
     "shell.execute_reply": "2023-11-05T18:34:25.995121Z",
     "shell.execute_reply.started": "2023-11-05T18:34:25.990762Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 8, 0, 7, 6, 2, 9, 5, 4, 3]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "random.seed(444)\n",
    "lst = list(range(10))\n",
    "print(sorted(lst, key=lambda x: random.random()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a64fdb6d-292e-4a74-9a81-2f3195274696",
   "metadata": {},
   "source": [
    "## Function Introspection"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38220bcc-805f-47b6-b5e2-c59566627c35",
   "metadata": {},
   "source": [
    "### Functions Attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "243850b2",
   "metadata": {},
   "source": [
    "They have **attributes** like:\n",
    "- **`__doc__`**\n",
    "- **`__annotations__`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "9c84fb8a-c0bf-477e-b396-ce9055e337ba",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T17:50:43.912476Z",
     "iopub.status.busy": "2023-11-05T17:50:43.912248Z",
     "iopub.status.idle": "2023-11-05T17:50:43.915690Z",
     "shell.execute_reply": "2023-11-05T17:50:43.915029Z",
     "shell.execute_reply.started": "2023-11-05T17:50:43.912458Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def my_func(a, b):\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3f17f42",
   "metadata": {},
   "source": [
    "> We can attach our own attributes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b17fd80c-fa99-48cc-a38b-4ff3a0723e80",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T17:51:23.853809Z",
     "iopub.status.busy": "2023-11-05T17:51:23.853130Z",
     "iopub.status.idle": "2023-11-05T17:51:23.862597Z",
     "shell.execute_reply": "2023-11-05T17:51:23.861455Z",
     "shell.execute_reply.started": "2023-11-05T17:51:23.853712Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "math\n",
      "arithmetic\n"
     ]
    }
   ],
   "source": [
    "my_func.category = \"math\"\n",
    "my_func.sub_category = \"arithmetic\"\n",
    "\n",
    "print(my_func.category)\n",
    "print(my_func.sub_category)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83e72bf5-5167-4ec2-b1c2-81439e19ce2f",
   "metadata": {},
   "source": [
    "#### The **`dir()`** function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ab6934d",
   "metadata": {},
   "source": [
    "**`dir()`** is a built-in function that, given an object as an argument, will return a list of valid attributes for that object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "ef70bba1-f69b-4cf3-892b-cac46fff7478",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T17:56:02.785550Z",
     "iopub.status.busy": "2023-11-05T17:56:02.785335Z",
     "iopub.status.idle": "2023-11-05T17:56:02.789685Z",
     "shell.execute_reply": "2023-11-05T17:56:02.789126Z",
     "shell.execute_reply.started": "2023-11-05T17:56:02.785532Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__annotations__',\n",
       " '__builtins__',\n",
       " '__call__',\n",
       " '__class__',\n",
       " '__closure__',\n",
       " '__code__',\n",
       " '__defaults__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__get__',\n",
       " '__getattribute__',\n",
       " '__getstate__',\n",
       " '__globals__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__kwdefaults__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__name__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__qualname__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'category',\n",
       " 'sub_category']"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(my_func)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c31b13c-2d72-4671-bafc-6fea147b287f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T17:56:45.652500Z",
     "iopub.status.busy": "2023-11-05T17:56:45.652284Z",
     "iopub.status.idle": "2023-11-05T17:56:45.655059Z",
     "shell.execute_reply": "2023-11-05T17:56:45.654644Z",
     "shell.execute_reply.started": "2023-11-05T17:56:45.652484Z"
    },
    "tags": []
   },
   "source": [
    "**More Function Attributes:**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4df56aa-f539-4175-a494-9f25bf736619",
   "metadata": {},
   "source": [
    "- **`__name__`** $\\longrightarrow$ name of function\n",
    "- **`__defaults__`** $\\longrightarrow$ tuple containing positional parameter defaults\n",
    "- **`__kwdefaults__`** $\\longrightarrow$ dictionary containing keyword-only parameters defaults\n",
    "- **`__code__`**: itself has various properties:\n",
    "    - **`co_varnames`**: parameter and local variables\n",
    "    > patameters names **first**, followed by local variable names\n",
    "    - **`co_argcount`**: number of parameter\n",
    "    > doesn't count **`*args`**, **`**kwargs`**!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7e40930d-4d91-49d2-91c1-fc50cc37c429",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T18:13:52.407284Z",
     "iopub.status.busy": "2023-11-05T18:13:52.406717Z",
     "iopub.status.idle": "2023-11-05T18:13:52.412100Z",
     "shell.execute_reply": "2023-11-05T18:13:52.410634Z",
     "shell.execute_reply.started": "2023-11-05T18:13:52.407264Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def my_func(a: int, b: int =2, c: int =3, *, kw1, kw2=2) -> None:\n",
    "    \"\"\"only test\"\"\"\n",
    "    i = 0\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5997f3a5-f2fb-461a-8d36-cc63d42c9cac",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T18:13:52.709680Z",
     "iopub.status.busy": "2023-11-05T18:13:52.709436Z",
     "iopub.status.idle": "2023-11-05T18:13:52.718007Z",
     "shell.execute_reply": "2023-11-05T18:13:52.716018Z",
     "shell.execute_reply.started": "2023-11-05T18:13:52.709663Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'my_func'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_func.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c440e0b6-0b25-4beb-b505-7d162462a2df",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T18:13:53.098930Z",
     "iopub.status.busy": "2023-11-05T18:13:53.098671Z",
     "iopub.status.idle": "2023-11-05T18:13:53.107411Z",
     "shell.execute_reply": "2023-11-05T18:13:53.105340Z",
     "shell.execute_reply.started": "2023-11-05T18:13:53.098907Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_func.__defaults__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0511b0a1-ed23-4109-961b-3f1ec94276b7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T18:13:53.468322Z",
     "iopub.status.busy": "2023-11-05T18:13:53.467721Z",
     "iopub.status.idle": "2023-11-05T18:13:53.472120Z",
     "shell.execute_reply": "2023-11-05T18:13:53.471503Z",
     "shell.execute_reply.started": "2023-11-05T18:13:53.468302Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'kw2': 2}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_func.__kwdefaults__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b88dac28-4977-4874-9288-3f1e9ca7f511",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T18:13:53.651494Z",
     "iopub.status.busy": "2023-11-05T18:13:53.651129Z",
     "iopub.status.idle": "2023-11-05T18:13:53.655800Z",
     "shell.execute_reply": "2023-11-05T18:13:53.655294Z",
     "shell.execute_reply.started": "2023-11-05T18:13:53.651458Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'only test'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_func.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "082492e2-de72-468b-89bf-f1983f1b0e46",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T18:13:53.821318Z",
     "iopub.status.busy": "2023-11-05T18:13:53.820908Z",
     "iopub.status.idle": "2023-11-05T18:13:53.826034Z",
     "shell.execute_reply": "2023-11-05T18:13:53.825197Z",
     "shell.execute_reply.started": "2023-11-05T18:13:53.821283Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': int, 'b': int, 'c': int, 'return': None}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_func.__annotations__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "c092ae58-1873-4cfe-a70e-0f04c079912c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T18:13:53.965296Z",
     "iopub.status.busy": "2023-11-05T18:13:53.965063Z",
     "iopub.status.idle": "2023-11-05T18:13:53.969521Z",
     "shell.execute_reply": "2023-11-05T18:13:53.968806Z",
     "shell.execute_reply.started": "2023-11-05T18:13:53.965278Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<code object my_func at 0x7f22b6d46180, file \"/tmp/ipykernel_4039/1173321694.py\", line 1>"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_func.__code__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a454004f",
   "metadata": {},
   "source": [
    "This **`__code__`** object itself has various properties, wich include:\n",
    "\n",
    "- **`co_varnames`**: parameters and local variables\n",
    "    - parameters name **first**, followed by local variable names.\n",
    "- **`co_argcount`**: number of parameters\n",
    "    - does not count **`*args`** and **`**kwargs`**!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ec83acc2-e16e-40bb-92c7-a6d691a2ecc9",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T18:13:54.120153Z",
     "iopub.status.busy": "2023-11-05T18:13:54.119837Z",
     "iopub.status.idle": "2023-11-05T18:13:54.125006Z",
     "shell.execute_reply": "2023-11-05T18:13:54.124299Z",
     "shell.execute_reply.started": "2023-11-05T18:13:54.120129Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('a', 'b', 'c', 'kw1', 'kw2', 'i')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_func.__code__.co_varnames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "36220404-547d-4f6f-8688-cd97fdd8955b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T18:23:58.873357Z",
     "iopub.status.busy": "2023-11-05T18:23:58.872861Z",
     "iopub.status.idle": "2023-11-05T18:23:58.878496Z",
     "shell.execute_reply": "2023-11-05T18:23:58.878006Z",
     "shell.execute_reply.started": "2023-11-05T18:23:58.873338Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_func.__code__.co_argcount"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "186e6fbe-4c33-4bb6-9603-f555d7669058",
   "metadata": {},
   "source": [
    "### Inspect Module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "e429f6db-c8a5-4249-ae93-4d5bce09751c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-05T18:27:29.949852Z",
     "iopub.status.busy": "2023-11-05T18:27:29.949647Z",
     "iopub.status.idle": "2023-11-05T18:27:29.953246Z",
     "shell.execute_reply": "2023-11-05T18:27:29.952318Z",
     "shell.execute_reply.started": "2023-11-05T18:27:29.949834Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import inspect"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68e3eea9",
   "metadata": {},
   "source": [
    "What's difference between a **`function`** and a **`method`**?\n",
    "\n",
    "- Classes and objects have **attributes** - an object that is **bound** (to the class or the object)\n",
    "    - An **attribute** that is [**callable**](), is called a **`method`**.\n",
    "- **Routine** doesn't care about **function** or **method**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "00235ef4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_func():\n",
    "    pass\n",
    "\n",
    "class MyClass:\n",
    "    def my_func(self):\n",
    "        pass\n",
    "\n",
    "my_obj = MyClass()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1525294",
   "metadata": {},
   "source": [
    "#### **Function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "e80ae670",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inspect.isfunction(my_func)=True\n",
      "inspect.isfunction(my_obj.my_func)=False\n",
      "inspect.isfunction(MyClass().my_func)=False\n",
      "inspect.isfunction(MyClass.my_func)=True\n"
     ]
    }
   ],
   "source": [
    "print(f\"{inspect.isfunction(my_func)=}\")\n",
    "print(f\"{inspect.isfunction(my_obj.my_func)=}\") # use an object\n",
    "print(f\"{inspect.isfunction(MyClass().my_func)=}\") # as the same as above\n",
    "print(f\"{inspect.isfunction(MyClass.my_func)=}\") # important"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c53e7e9b",
   "metadata": {},
   "source": [
    "#### **Method**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eeacd1ab",
   "metadata": {},
   "source": [
    "**`my_func`** is bound to object (**`my_obj`**), an instance of **`MyClass`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "16284d7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inspect.ismethod(my_func)=False\n",
      "inspect.ismethod(my_obj.my_func)=True\n",
      "inspect.ismethod(MyClass().my_func)=True\n",
      "inspect.ismethod(MyClass.my_func)=False\n"
     ]
    }
   ],
   "source": [
    "print(f\"{inspect.ismethod(my_func)=}\")\n",
    "print(f\"{inspect.ismethod(my_obj.my_func)=}\") # use an object\n",
    "print(f\"{inspect.ismethod(MyClass().my_func)=}\") # as the same as above\n",
    "print(f\"{inspect.ismethod(MyClass.my_func)=}\") # important"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68497b7e",
   "metadata": {},
   "source": [
    "#### **Routine**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "adbeb165",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inspect.isroutine(my_func)=True\n",
      "inspect.isroutine(my_obj.my_func)=True\n",
      "inspect.isroutine(MyClass().my_func)=True\n",
      "inspect.isroutine(MyClass.my_func)=True\n"
     ]
    }
   ],
   "source": [
    "print(f\"{inspect.isroutine(my_func)=}\")\n",
    "print(f\"{inspect.isroutine(my_obj.my_func)=}\") # use an object\n",
    "print(f\"{inspect.isroutine(MyClass().my_func)=}\") # as the same as above\n",
    "print(f\"{inspect.isroutine(MyClass.my_func)=}\") # important"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2255fabd",
   "metadata": {},
   "source": [
    "We can recover the source code of our functions/methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "a4e69efc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "def my_func(a, b=1):\n",
      "    # comment inside my_func\n",
      "    pass\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(inspect.getsource(my_func))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "2cf3655d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    def my_func(self):\n",
      "        pass\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(inspect.getsource(MyClass().my_func))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfe94e3e",
   "metadata": {},
   "source": [
    "We can find out in wich module out function was created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "16c3986e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module '__main__'>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inspect.getmodule(my_func)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "5c240a28",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module '__main__'>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inspect.getmodule(my_obj.my_func)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "9bf3952e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'builtins' (built-in)>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inspect.getmodule(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7eb7009",
   "metadata": {},
   "source": [
    "### Function Comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "9aaa9d87",
   "metadata": {},
   "outputs": [],
   "source": [
    "# setting up variable\n",
    "i = 10\n",
    "\n",
    "# TODO: Implement function\n",
    "# some additional notes\n",
    "def my_func(a, b=1):\n",
    "    # comment inside my_func\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "6e5f3100",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# TODO: Implement function\n",
      "# some additional notes\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(inspect.getcomments(my_func))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cebd3d0",
   "metadata": {},
   "source": [
    "### Callable Signatures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce9ede79",
   "metadata": {},
   "source": [
    "```python\n",
    "    inspect.signature(my_func) --> Signature instance\n",
    "```\n",
    "\n",
    "Contains an attribute called **parameters**.\n",
    "\n",
    "Essentioally a dictionary of parameters names (keys), and metadata about the parameters (values).\n",
    "\n",
    "- keys $\\longrightarrow$ parameter name\n",
    "- values $\\longrightarrow$ object with attributes such as **name**, **default**, **annotation**, **kind**\n",
    "    - Kind: **Posisional or keyword**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "97d578db",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_func(a: \"a string\",\n",
    "        b: int=1,\n",
    "        *args: \"additional positional args\",\n",
    "        kw1: \"first keyword-only arg\",\n",
    "        kw2: \"second keyword-only arg\" = 10,\n",
    "        **kwargs: \"additional keyword-only args\") -> str:\n",
    "    \"\"\"does something\n",
    "    or other\n",
    "    \"\"\"\n",
    "    pass\n",
    "\n",
    "tmp = inspect.signature(my_func) # return signature instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "88c7bd7f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mappingproxy({'a': <Parameter \"a: 'a string'\">,\n",
       "              'b': <Parameter \"b: int = 1\">,\n",
       "              'args': <Parameter \"*args: 'additional positional args'\">,\n",
       "              'kw1': <Parameter \"kw1: 'first keyword-only arg'\">,\n",
       "              'kw2': <Parameter \"kw2: 'second keyword-only arg' = 10\">,\n",
       "              'kwargs': <Parameter \"**kwargs: 'additional keyword-only args'\">})"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tmp.parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "e8ce4b33",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "odict_keys(['a', 'b', 'args', 'kw1', 'kw2', 'kwargs'])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tmp.parameters.keys() # parameters name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "0b6f2909",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "param.name='a'\n",
      "param.default=<class 'inspect._empty'>\n",
      "param.annotation='a string'\n",
      "param.kind=<_ParameterKind.POSITIONAL_OR_KEYWORD: 1>\n",
      "--------------------\n",
      "param.name='b'\n",
      "param.default=1\n",
      "param.annotation=<class 'int'>\n",
      "param.kind=<_ParameterKind.POSITIONAL_OR_KEYWORD: 1>\n",
      "--------------------\n",
      "param.name='args'\n",
      "param.default=<class 'inspect._empty'>\n",
      "param.annotation='additional positional args'\n",
      "param.kind=<_ParameterKind.VAR_POSITIONAL: 2>\n",
      "--------------------\n",
      "param.name='kw1'\n",
      "param.default=<class 'inspect._empty'>\n",
      "param.annotation='first keyword-only arg'\n",
      "param.kind=<_ParameterKind.KEYWORD_ONLY: 3>\n",
      "--------------------\n",
      "param.name='kw2'\n",
      "param.default=10\n",
      "param.annotation='second keyword-only arg'\n",
      "param.kind=<_ParameterKind.KEYWORD_ONLY: 3>\n",
      "--------------------\n",
      "param.name='kwargs'\n",
      "param.default=<class 'inspect._empty'>\n",
      "param.annotation='additional keyword-only args'\n",
      "param.kind=<_ParameterKind.VAR_KEYWORD: 4>\n",
      "--------------------\n"
     ]
    }
   ],
   "source": [
    "for param in tmp.parameters.values(): # return an object\n",
    "    print(f\"{param.name=}\")\n",
    "    print(f\"{param.default=}\")\n",
    "    print(f\"{param.annotation=}\")\n",
    "    print(f\"{param.kind=}\")\n",
    "    print(\"--------------------\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "664bad6c",
   "metadata": {},
   "source": [
    "## Callables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bdf9991",
   "metadata": {},
   "source": [
    "### What are callables?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d84d3e0",
   "metadata": {},
   "source": [
    "- Any objects that can be called using **`()`** operator.\n",
    "- Callables **always** return a value.\n",
    "    - The value can be **`None`**.\n",
    "- Likes **functions** and **methods** (but it goes beyond just these two ...).\n",
    "- To see if an object is callable, we can use the built-in function; **`callable`**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b76984e0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "callable(print)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8ead9b0d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "callable(\"abc\".upper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5e4b2f28",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "callable(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "675de484",
   "metadata": {},
   "source": [
    "### Different types of **callables**:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09dedac1",
   "metadata": {},
   "source": [
    "- **Built-in** functions:\n",
    "    - **`print`** | **`len`** | **`callable`** | ...\n",
    "- **Built-in** methods:\n",
    "    - **`a_str.upper`** | **`a_list.append`** | ...\n",
    "- **User-defined** functions:\n",
    "    - Created using **`def`** or **`lambda`** expressions\n",
    "- **Methods**:\n",
    "    - Functions **bound** to an object\n",
    "- **Classes**:\n",
    "    - `MyClass(x, y, z)`\n",
    "        - `__new__(x, y, z)` $\\longrightarrow$ creates the new object\n",
    "            - `__init__(self, x, y, z)` $\\longrightarrow$ init the object\n",
    "                - returns the object (reference)\n",
    "- **Class instances**:\n",
    "    - If the class implements `__call__` method\n",
    "- **Generators**\n",
    "- **Coroutines**\n",
    "- **Asynchronous**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa34a48d",
   "metadata": {},
   "source": [
    "## Built-in Higher Order Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae7ea633",
   "metadata": {},
   "source": [
    "**Recall higher order function:**\n",
    "\n",
    "- A function that takes a function as parameters and/or return a function as its return value.\n",
    "    - **`sort`**\n",
    "    - **`map`** | **`filter`** $\\longrightarrow$ modern alternative; **list comperhensions** and **generators**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c86cb29",
   "metadata": {},
   "source": [
    "### The `map` funcntion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b637c57",
   "metadata": {},
   "source": [
    "```python\n",
    "    map(func, *iterables) -> map object\n",
    "```\n",
    "\n",
    "- **`*iterables`** $\\longrightarrow$ a variable number of objects\n",
    "\n",
    "- **`func`** $\\longrightarrow$ some function that takes **as many** arguments as there are **iterable objects** passed to **iterables**\n",
    "1\n",
    "- **`map(func, *iterables)`** $\\longrightarrow$ will return an **iterator** that calculates the function applied to each element of the iterables\n",
    "    - The iterator stops as soon as one of the iterables has been exhausted so, unequal length iterables can be used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2cb646d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "map(sq, l)=<map object at 0x7f3d86f036a0>\n",
      "list(map(sq, l))=[1, 4, 9]\n"
     ]
    }
   ],
   "source": [
    "# Example\n",
    "\n",
    "l = [1, 2, 3]\n",
    "\n",
    "def sq(x):\n",
    "    return x**2\n",
    "\n",
    "print(f\"{map(sq, l)=}\")\n",
    "print(f\"{list(map(sq, l))=}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "d28bd183",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 22, 33]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example\n",
    "\n",
    "l1 = [1, 2, 3]\n",
    "l2 = [10, 20, 30]\n",
    "\n",
    "def add(x, y):\n",
    "    return x + y\n",
    "\n",
    "list(map(add, l1, l2)) # also can write like below code\n",
    "list(map(lambda x, y: x+y, l1, l2)) # lambda expression"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32bb3cfc",
   "metadata": {},
   "source": [
    "### The `filter` function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6178a40f",
   "metadata": {},
   "source": [
    "```python\n",
    "    filter(func or None, iterable) -> filter object\n",
    "```\n",
    "\n",
    "- **`iterable`** $\\longrightarrow$ a single iterable\n",
    "- **`func`** $\\longrightarrow$ some function that takes a **single** argument\n",
    "- **`filter(func, iterable)`** $\\longrightarrow$ will return an **iterator** that contains all the elements of the iterable\n",
    "for wich the function on it is Truthy\n",
    "    - If the function is **`None`**, it simply returns the elements of **iterable** that are **Truthy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7fe8b1c8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example\n",
    "\n",
    "l = [0, 1, 2, 3, 4] # 0 is fulse and other is true\n",
    "\n",
    "list(filter(None, l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b078288a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example\n",
    "\n",
    "l = [0, 1, 2, 3, 4]\n",
    "\n",
    "def is_even(n):\n",
    "    return n % 2 == 0\n",
    "\n",
    "list(filter(is_even, l)) # also can write like below code\n",
    "list(filter(lambda n: n%2==0, l)) # lambda expression"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b858ec8f",
   "metadata": {},
   "source": [
    "### The `zip` function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0c83d6f",
   "metadata": {},
   "source": [
    "```python\n",
    "    zip(*iterables, strict=False) -> Yield tuples until an input is exhausted.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "afa39b8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 10), (2, 20), (3, 30)]\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "zip() argument 2 is shorter than argument 1",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[27], line 7\u001b[0m\n\u001b[1;32m      4\u001b[0m l2 \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m10\u001b[39m, \u001b[38;5;241m20\u001b[39m, \u001b[38;5;241m30\u001b[39m,]\n\u001b[1;32m      6\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mzip\u001b[39m(l1, l2, strict\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)))\n\u001b[0;32m----> 7\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mzip\u001b[39m(l1, l2, strict\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)))\n",
      "\u001b[0;31mValueError\u001b[0m: zip() argument 2 is shorter than argument 1"
     ]
    }
   ],
   "source": [
    "# Example\n",
    "\n",
    "l1 = [1, 2, 3, 4]\n",
    "l2 = [10, 20, 30]\n",
    "\n",
    "print(list(zip(l1, l2, strict=False)))\n",
    "print(list(zip(l1, l2, strict=True)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "674eafc1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 10, 'p'), (2, 20, 'y'), (3, 30, 't')]\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "zip() argument 2 is longer than argument 1",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[30], line 8\u001b[0m\n\u001b[1;32m      5\u001b[0m l3 \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpython\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m      7\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mzip\u001b[39m(l1, l2, l3, strict\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)))\n\u001b[0;32m----> 8\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mzip\u001b[39m(l1, l2, l3, strict\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)))\n",
      "\u001b[0;31mValueError\u001b[0m: zip() argument 2 is longer than argument 1"
     ]
    }
   ],
   "source": [
    "# Example\n",
    "\n",
    "l1 = [1, 2, 3]\n",
    "l2 = [10, 20, 30, 40]\n",
    "l3 = \"python\"\n",
    "\n",
    "print(list(zip(l1, l2, l3, strict=False)))\n",
    "print(list(zip(l1, l2, l3, strict=True)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "652db6bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'M'), (1, 'a'), (2, 'r'), (3, 'y'), (4, 'a'), (5, 'm')]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example\n",
    "\n",
    "l1 = range(100)\n",
    "l2 = \"Maryam\"\n",
    "\n",
    "list(zip(l1, l2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0ceb184",
   "metadata": {},
   "source": [
    "### List Comprehension Alternative To `map`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e9a7665",
   "metadata": {},
   "source": [
    "```python\n",
    "    [<expression> for <varname> in <iterable>]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "ab692041",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 9, 16]\n",
      "[4, 9, 16]\n",
      "[4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "# Example\n",
    "\n",
    "l = [2, 3, 4]\n",
    "\n",
    "def sq(x):\n",
    "    return x ** 2\n",
    "\n",
    "print(list(map(sq, l))) # also can use below code\n",
    "print(list(map(lambda x: x**2, l))) # lambda expression\n",
    "print([x**2 for x in l]) # list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "581b29b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11, 22, 33]\n",
      "[11, 22, 33]\n",
      "[11, 22, 33]\n",
      "[11, 22, 33]\n"
     ]
    }
   ],
   "source": [
    "# Example\n",
    "\n",
    "l1 = [1, 2, 3]\n",
    "l2 = [10, 20, 30]\n",
    "\n",
    "def add(x, y):\n",
    "    return x + y\n",
    "\n",
    "print(list(map(add, l1, l2)))\n",
    "print(list(map(lambda x, y: x+y, l1, l2)))\n",
    "print([x + y for x, y in zip(l1, l2)])\n",
    "print([sum(x) for x in zip(l1, l2)])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1ce81d8",
   "metadata": {},
   "source": [
    "### List Comprehension Alternative To `filter`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78aae7d5",
   "metadata": {},
   "source": [
    "```python\n",
    "    [<expresson1> for <varname> in <iterable> if <expression2>]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "58e231d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4]\n",
      "[0, 2, 4]\n",
      "[0, 2, 4]\n",
      "[True, False, True, False, True]\n"
     ]
    }
   ],
   "source": [
    "# Example\n",
    "\n",
    "l = [0, 1, 2, 3, 4]\n",
    "\n",
    "def is_even(x):\n",
    "    return x % 2 == 0\n",
    "\n",
    "print(list(filter(is_even, l)))\n",
    "print(list(filter(lambda x: x%2==0, l)))\n",
    "print([x for x in l if x%2==0])\n",
    "print([x%2==0 for x in l])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0c2fdd8",
   "metadata": {},
   "source": [
    "### Combining `map` and `filter`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[36, 49, 64, 81]\n",
      "[36, 49, 64, 81]\n",
      "[6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "l = range(10)\n",
    "\n",
    "# combining map and filter\n",
    "print(list(filter(\n",
    "        lambda y: y > 25, # function\n",
    "        map(lambda x: x**2, l) # iterable\n",
    "    )\n",
    "))\n",
    "\n",
    "# useing list comprehension is much clearer\n",
    "print([x**2 for x in l if x**2 > 25])\n",
    "print([x for x in l if x**2 > 25])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fc66733",
   "metadata": {},
   "source": [
    "#### 📍 NOTE 📍"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df92ce1b",
   "metadata": {},
   "source": [
    "Difference between thease two:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "517c8f3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1, 2, 3, 4]\n",
    "\n",
    "def sq(x):\n",
    "    return x ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79a4af5b",
   "metadata": {},
   "source": [
    "> When we use map it's like generator and doesn't calculate it.\n",
    "\n",
    "> Memory efficiency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6c026729",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "# Use map\n",
    "\n",
    "result = map(sq, l)\n",
    "for i in result:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8f31a0d",
   "metadata": {},
   "source": [
    "> When we use list comprehemsion, it's calculate all of theme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5379c2fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "# use list comprehension\n",
    "\n",
    "result = [x**2 for x in l]\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d19dccca",
   "metadata": {},
   "source": [
    "> We can use generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "24b840f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<generator object <genexpr> at 0x7f3822a40790>\n"
     ]
    }
   ],
   "source": [
    "# Use generator comprehension\n",
    "\n",
    "result = (x**2 for x in l)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46165ec3",
   "metadata": {},
   "source": [
    "## Reducing Functions in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23b4ca94",
   "metadata": {},
   "source": [
    "### What Are Reducing Functions?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37d13cc7",
   "metadata": {},
   "source": [
    "These are functions that recombine an iterable recursivly, ending up with a single return value.\n",
    "\n",
    "Also called **accumulators**, **aggregators** or **folding functions**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a3f9da8",
   "metadata": {},
   "source": [
    "**Example:** Finding the maximum value in an iterable\n",
    "\n",
    "$a_0, a_1, a_2, ..., a_n$\n",
    "\n",
    "```python\n",
    "max(a, b) -> maximum of a and b\n",
    "result = a0\n",
    "result = max(result, a1)\n",
    "result = max(result, a2)\n",
    "...\n",
    "result = max(result, an) -> maximum value in a0, a1, a2, ..., an\n",
    "```\n",
    "\n",
    "Because we have not studied iterables in general, we will stay with the special case of sequences.\n",
    "\n",
    "(i.e. we can use indexes to access elements in sequence)\n",
    "\n",
    "**Using a loop**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ae2e7f28",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'function'> <class 'function'>\n",
      "max_sequence(l)=10\n",
      "max(l)=10\n",
      "min_sequence(l)=5\n",
      "min(l)=5\n"
     ]
    }
   ],
   "source": [
    "l = [5, 6, 10, 6, 9]\n",
    "\n",
    "max_value = lambda a, b: a if a > b else b\n",
    "min_value = lambda a, b: a if a < b else b\n",
    "print(type(max_value), type(min_value))\n",
    "\n",
    "# calculate maximux\n",
    "def max_sequence(sequence):\n",
    "    result = sequence[0] # initializer\n",
    "    for e in sequence[1:]:\n",
    "        result = max_value(result, e)\n",
    "    return result\n",
    "\n",
    "# calculate minimum\n",
    "def min_sequence(sequence):\n",
    "    result = sequence[0] # initializer\n",
    "    for e in sequence[1:]:\n",
    "        result = min_value(result, e)\n",
    "    return result\n",
    "\n",
    "print(f\"{max_sequence(l)=}\")\n",
    "print(f\"{max(l)=}\") # :)\n",
    "print(f\"{min_sequence(l)=}\")\n",
    "print(f\"{min(l)=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39eb6972",
   "metadata": {},
   "source": [
    "All we really needed to do was to change the function that is repeatedly aaplied."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f389eec0",
   "metadata": {},
   "source": [
    "**In fact we could write:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "51428d39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_reduce(max_value, l)=10\n",
      "_reduce(min_value, l)=5\n"
     ]
    }
   ],
   "source": [
    "# Reduce Function\n",
    "def _reduce(fn, sequence):\n",
    "    result = sequence[0] # initializer\n",
    "    for e in sequence[1:]:\n",
    "        result = fn(result, e)\n",
    "    return result\n",
    "\n",
    "print(f\"{_reduce(max_value, l)=}\")\n",
    "print(f\"{_reduce(min_value, l)=}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6a5491e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_reduce(add_, l)=36\n",
      "sum(l)=36\n"
     ]
    }
   ],
   "source": [
    "# Adding all elements of a list\n",
    "\n",
    "add_ = lambda a, b: a + b\n",
    "\n",
    "print(f\"{_reduce(add_, l)=}\")\n",
    "print(f\"{sum(l)=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cfd6bfe",
   "metadata": {},
   "source": [
    "### The `functools` Module"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d43d404",
   "metadata": {},
   "source": [
    "Python implements a **`reduce`** function that will handle any iterable, but works similarly to what we just saw.\n",
    "\n",
    "**`reduce` works on any iterables**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "33331836",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reduce(max_value, l1)=10\n",
      "reduce(min_value, l1)=5\n",
      "reduce(add_, l1)=38\n",
      "------------------------\n",
      "reduce(max_value, l2)=10\n",
      "reduce(min_value, l2)=1\n",
      "reduce(add_, l2)=24\n",
      "------------------------\n",
      "reduce(max_value, l3)='y'\n",
      "reduce(min_value, l3)='h'\n",
      "reduce(add_, l3)='python'\n"
     ]
    }
   ],
   "source": [
    "# Recude Functio, Built-in, See source code is as the same as our _reduce function.\n",
    "from functools import reduce\n",
    "\n",
    "# sequences\n",
    "l1 = [5, 8, 6, 10, 9]\n",
    "l2 = {1, 4, 10, 9}\n",
    "l3 = \"python\"\n",
    "\n",
    "# fucntions\n",
    "max_value = lambda a, b: a if a>b else b\n",
    "min_value = lambda a, b: a if a<b else b\n",
    "add_ = lambda a, b: a+b\n",
    "\n",
    "# results\n",
    "print(f\"{reduce(max_value, l1)=}\")\n",
    "print(f\"{reduce(min_value, l1)=}\")\n",
    "print(f\"{reduce(add_, l1)=}\")\n",
    "\n",
    "print(\"------------------------\")\n",
    "\n",
    "print(f\"{reduce(max_value, l2)=}\")\n",
    "print(f\"{reduce(min_value, l2)=}\")\n",
    "print(f\"{reduce(add_, l2)=}\")\n",
    "\n",
    "print(\"------------------------\")\n",
    "\n",
    "print(f\"{reduce(max_value, l3)=}\") # ASCI\n",
    "print(f\"{reduce(min_value, l3)=}\")\n",
    "print(f\"{reduce(add_, l3)=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "512ccccf",
   "metadata": {},
   "source": [
    "### Built-in Reducing Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91c8a6c1",
   "metadata": {},
   "source": [
    "Python provides several common reducing functions:\n",
    "\n",
    "- **`min`**: `min([5, 8, 6, 10, 9])` $\\longrightarrow$ 5\n",
    "- **`max`**: `max([5, 8, 6, 10, 9])` $\\longrightarrow$ 10\n",
    "- **`sum`**: `min([5, 8, 6, 10, 9])` $\\longrightarrow$ 38\n",
    "- **`any`**: `any(l)` $\\longrightarrow$ **True** if **any** elements in **`l`** is truthy, **False** otherwise\n",
    "    - Like **`or`**\n",
    "- **`all`**: `all(l)` $\\longrightarrow$ **True** if **every** elements in **`l`** is truthy, **False** otherwise\n",
    "    - Like **`and`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "ca9f58c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "-----------------------\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(any([0, 0, 0]))\n",
    "print(any([0, False]))\n",
    "print(any([0, 0, 1]))\n",
    "print(any([0, 0, -1]))\n",
    "print(\"-----------------------\")\n",
    "print(all([0, 1, 1]))\n",
    "print(all([True, 1, 1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d0cebd9",
   "metadata": {},
   "source": [
    "### Examples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04f5151f",
   "metadata": {},
   "source": [
    "**Example**: Using `reduce` to replace `any`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "09442cd5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "l = [0, '', None, 100] # False, False, False, True\n",
    "result = bool(0) or bool('') or bool(None) or bool(100) # our goal\n",
    "print(result) # not efficient approch"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f41b4c7f",
   "metadata": {},
   "source": [
    "```python\n",
    "0 or '' or None or 100 -> 100\n",
    "\n",
    "bool(0) or bool('') or bool(None) or bool(100) -> True\n",
    "```\n",
    "\n",
    "Here we just need to repeatly apply the **`or`** operator to the truth values of each element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "834ecedf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Write reduce function\n",
    "def _reduce(fn, sequence):\n",
    "    result = sequence[0] # initializer\n",
    "    for e in sequence[1:]:\n",
    "        result = fn(result, e)\n",
    "    return result\n",
    "\n",
    "or_ = lambda a, b: bool(a) or bool(b)\n",
    "\n",
    "print(_reduce(or_, l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "b0b6d779",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use built-in reduce function\n",
    "from functools import reduce\n",
    "\n",
    "reduce(lambda a, b: bool(a) or bool(b), l)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ceea05d6",
   "metadata": {},
   "source": [
    "**Example**: Calculate the **product** of all elements of sequemce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "031a2c66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "l = [1, 2, 3, 4] # 1 * 2 * 3 * 4 = 24\n",
    "reduce(lambda a, b: a*b, l)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aff08881",
   "metadata": {},
   "source": [
    "**Example**: Calculate the **n!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "34f589e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "n = 4\n",
    "l = range(1, n+1)\n",
    "reduce(lambda a, b: a*b, l)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b50bfaf",
   "metadata": {},
   "source": [
    "### The Reduce Initializer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d381078a",
   "metadata": {},
   "source": [
    "> The `reduce` function has a third (optional) parameter: **initializer**\n",
    "\n",
    "```python\n",
    "from functools import reduce\n",
    "reduce(function, iterable, initial=None) -> value\n",
    "```\n",
    "- If **`initial`** specified, it's essentially like adding it to the front of the iterable.\n",
    "\n",
    "- It's often used to procvide some kind of default in case the iterable is empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "8a1b6027",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "reduce() of empty iterable with no initial value",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[57], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m l \u001b[38;5;241m=\u001b[39m []\n\u001b[0;32m----> 3\u001b[0m reduce(\u001b[38;5;28;01mlambda\u001b[39;00m x, y: x\u001b[38;5;241m+\u001b[39my, l)\n",
      "\u001b[0;31mTypeError\u001b[0m: reduce() of empty iterable with no initial value"
     ]
    }
   ],
   "source": [
    "l = []\n",
    "\n",
    "reduce(lambda x, y: x+y, l) # TypeError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "c6875e25",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use initalizer\n",
    "l = []\n",
    "\n",
    "reduce(lambda x, y: x+y, l, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "9f8f71ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "7\n",
      "106\n"
     ]
    }
   ],
   "source": [
    "l = [1, 2, 3]\n",
    "\n",
    "print(reduce(lambda x, y: x+y, l)) # without inital -> 1 + 2 + 3 = 6\n",
    "print(reduce(lambda x, y: x+y, l, 1)) # with initial -> 1 + 1 + 2 + 3 = 7\n",
    "print(reduce(lambda x, y: x+y, l, 100)) # with initial -> 100 + 1 + 2 + 3 = 106"
   ]
  }
 ],
 "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"
  },
  "toc-autonumbering": false,
  "toc-showcode": false,
  "toc-showmarkdowntxt": false,
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}