Ch08-2-Lists-Advanced.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Comprehensions & Higher order functions\n",
    "<a href=\"https://colab.research.google.com/github/rambasnet/FDSPython-Notebooks/blob/master/Ch08-2-Lists-Advanced.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
    "\n",
    "## Topics\n",
    "- list shortcuts\n",
    "- lambda functions applications\n",
    "- built-in higher order functions\n",
    "\n",
    "## List comprehension\n",
    "- list is a very powerful and commonly used container\n",
    "- list shortcuts can make you an efficient programmer\n",
    "- E.g., an arithmetic set $S = \\{x^2 : x \\in \\{0 ... 9\\}\\}$\n",
    "    - is equivalent to: \n",
    "    ```python\n",
    "    S = [x**2 for x in range(10)]\n",
    "    ```\n",
    "- consists of brackets containing an expression followed by a for clause, then zero or more for or if clauses\n",
    "    - the expressions can be anything\n",
    "    - always results a new list from evaluating expression\n",
    "- syntax:\n",
    "```python\n",
    "someList = [expression for item in list if conditional] # one-way selector\n",
    "someList = [expression if conditionl else expression for item in list] # two-way selector\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Typical way to create a list of squared values of list 0 to 9?\n",
    "sq = []\n",
    "for i in range(10):\n",
    "    sq.append(i**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "print(sq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# List comprehension -- handy technique:\n",
    "S = [x**2 for x in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Math: $V = \\{2^0, 2^1, 2^2, 2^3, ... 2^{12}\\}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096]\n"
     ]
    }
   ],
   "source": [
    "# In Python:\n",
    "V = [2**x for x in range(13)]\n",
    "print(V)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "In Math: $M = \\{x | x \\in S \\ and \\ x \\ even\\}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simple approach in Python\n",
    "M = []\n",
    "for x in S: \n",
    "    if x%2 == 0: \n",
    "        M.append(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 16, 36, 64]\n"
     ]
    }
   ],
   "source": [
    "print(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# List comprehension\n",
    "M1 = [x for x in S if x%2==0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 16, 36, 64]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert M == M1, 'M and M1 are not equal!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "M2 = [True if x%2==0 else False for x in range(1, 21)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentence = \"The quick brown fox jumps over the lazy dog\"\n",
    "# words = sentence.split()\n",
    "# can make a list of tuples or list of lists\n",
    "wlist = [(w.upper(), w.lower(), len(w)) for w in sentence.split()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('THE', 'the', 3),\n",
       " ('QUICK', 'quick', 5),\n",
       " ('BROWN', 'brown', 5),\n",
       " ('FOX', 'fox', 3),\n",
       " ('JUMPS', 'jumps', 5),\n",
       " ('OVER', 'over', 4),\n",
       " ('THE', 'the', 3),\n",
       " ('LAZY', 'lazy', 4),\n",
       " ('DOG', 'dog', 3)]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wlist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested list comprehension\n",
    "- syntax to handle the nested loop for nested lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's create a nestedList of [[1, 2, 3, 4]*4]\n",
    "nestedList = [list(range(1, 5))]*5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nestedList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's just keep the even values from each nested lists\n",
    "even = [x for lst in nestedList for x in lst if x%2==0 ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 2, 4, 2, 4, 2, 4, 2, 4]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "even"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's create boolen single list of True/False\n",
    "evenOdd = [True if x%2 == 0 else False for lst in nestedList for x in lst]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evenOdd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's create boolen nested list of True/False\n",
    "evenOdd1 = [[True if x%2 == 0 else False for x in lst] for lst in nestedList]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[False, True, False, True],\n",
       " [False, True, False, True],\n",
       " [False, True, False, True],\n",
       " [False, True, False, True],\n",
       " [False, True, False, True]]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evenOdd1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## higher order functions and lambda applications\n",
    "- map, reduce, filter, sorted functions take function and iterable such as list as arguments\n",
    "- lambda expression can be used as a parameter for higher order functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sorted( )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = ['Apple', 'apple', 'ball', 'Ball', 'cat']\n",
    "list2 = sorted(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Ball', 'apple', 'ball', 'cat']\n"
     ]
    }
   ],
   "source": [
    "print(list2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sorting the list of tuples with different element (other than the first) as key\n",
    "list3 = [('cat', 10), ('ball', 20), ('apple', 3)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('apple', 3), ('ball', 20), ('cat', 10)]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# by default uses the first element as the key\n",
    "sorted(list3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('cat', 10), ('ball', 20), ('apple', 3)]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check the original list\n",
    "list3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sorting the list of tuples with different element (other than the first) as key\n",
    "# using itemgetter function\n",
    "from operator import itemgetter\n",
    "list5 = sorted(list3, key=itemgetter(1), reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('ball', 20), ('cat', 10), ('apple', 3)]\n"
     ]
    }
   ],
   "source": [
    "print(list5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# directly using list item\n",
    "list6 = sorted(list3, key=lambda x: x[1], reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('ball', 20), ('cat', 10), ('apple', 3)]\n"
     ]
    }
   ],
   "source": [
    "print(list6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### filter( )\n",
    "- filter elemets in the list by returning a new list for each element the function returns True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class filter in module builtins:\n",
      "\n",
      "class filter(object)\n",
      " |  filter(function or None, iterable) --> filter object\n",
      " |  \n",
      " |  Return an iterator yielding those items of iterable for which function(item)\n",
      " |  is true. If function is None, return the items that are true.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __next__(self, /)\n",
      " |      Implement next(self).\n",
      " |  \n",
      " |  __reduce__(...)\n",
      " |      Return state information for pickling.\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"
     ]
    }
   ],
   "source": [
    "help(filter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "list7 = [2, 18, 9, 22, 17, 24, 8, 12, 27]\n",
    "list8 = list(filter(lambda x: x%3==0, list7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[18, 9, 24, 12, 27]\n"
     ]
    }
   ],
   "source": [
    "print(list8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### map( )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class map in module builtins:\n",
      "\n",
      "class map(object)\n",
      " |  map(func, *iterables) --> map object\n",
      " |  \n",
      " |  Make an iterator that computes the function using arguments from\n",
      " |  each of the iterables.  Stops when the shortest iterable is exhausted.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __next__(self, /)\n",
      " |      Implement next(self).\n",
      " |  \n",
      " |  __reduce__(...)\n",
      " |      Return state information for pickling.\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"
     ]
    }
   ],
   "source": [
    "help(map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "items = list(range(1, 11))\n",
    "squared = list(map(lambda x: x**2, items))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "print(squared)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# map each words with its length\n",
    "sentence = \"The quick brown fox jumps over the lazy dog\"\n",
    "words = [word.lower() for word in sentence.split()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['the', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog']\n"
     ]
    }
   ],
   "source": [
    "print(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "w_len = list(map(lambda w: (w, w.upper(), len(w)), words))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('the', 'THE', 3), ('quick', 'QUICK', 5), ('brown', 'BROWN', 5), ('fox', 'FOX', 3), ('jumps', 'JUMPS', 5), ('over', 'OVER', 4), ('the', 'THE', 3), ('lazy', 'LAZY', 4), ('dog', 'DOG', 3)]\n"
     ]
    }
   ],
   "source": [
    "print(w_len)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### mapping one type to another"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter numbers separated by space: 1 2 100 99 50\n"
     ]
    }
   ],
   "source": [
    "# Example: map string to integers; common operation while reading list of numbers\n",
    "data = input('Enter numbers separated by space: ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1 2 100 99 50'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 99 45 454 454 4545 455\n"
     ]
    }
   ],
   "source": [
    "nums = list(map(int, input().split()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[100, 99, 45, 454, 454, 4545, 455]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nums"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### reduce( )\n",
    "- used to reduce a list of values to a single output\n",
    "- `reduce()` is defined in `functools` module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module functools:\n",
      "\n",
      "NAME\n",
      "    functools - functools.py - Tools for working with functions and callable objects\n",
      "\n",
      "MODULE REFERENCE\n",
      "    https://docs.python.org/3.9/library/functools\n",
      "    \n",
      "    The following documentation is automatically generated from the Python\n",
      "    source files.  It may be incomplete, incorrect or include features that\n",
      "    are considered implementation detail and may vary between Python\n",
      "    implementations.  When in doubt, consult the module reference at the\n",
      "    location listed above.\n",
      "\n",
      "CLASSES\n",
      "    builtins.object\n",
      "        cached_property\n",
      "        partial\n",
      "        partialmethod\n",
      "        singledispatchmethod\n",
      "    \n",
      "    class cached_property(builtins.object)\n",
      "     |  cached_property(func)\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __get__(self, instance, owner=None)\n",
      "     |  \n",
      "     |  __init__(self, func)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  __set_name__(self, owner, name)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Class methods defined here:\n",
      "     |  \n",
      "     |  __class_getitem__ = GenericAlias(...) from builtins.type\n",
      "     |      Represent a PEP 585 generic type\n",
      "     |      \n",
      "     |      E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "    \n",
      "    class partial(builtins.object)\n",
      "     |  partial(func, *args, **keywords) - new function with partial application\n",
      "     |  of the given arguments and keywords.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __call__(self, /, *args, **kwargs)\n",
      "     |      Call self as a function.\n",
      "     |  \n",
      "     |  __delattr__(self, name, /)\n",
      "     |      Implement delattr(self, name).\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  __setattr__(self, name, value, /)\n",
      "     |      Implement setattr(self, name, value).\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Class methods defined here:\n",
      "     |  \n",
      "     |  __class_getitem__(...) from builtins.type\n",
      "     |      See PEP 585\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",
      "     |  __dict__\n",
      "     |  \n",
      "     |  args\n",
      "     |      tuple of arguments to future partial calls\n",
      "     |  \n",
      "     |  func\n",
      "     |      function object to use in future partial calls\n",
      "     |  \n",
      "     |  keywords\n",
      "     |      dictionary of keyword arguments to future partial calls\n",
      "    \n",
      "    class partialmethod(builtins.object)\n",
      "     |  partialmethod(func, /, *args, **keywords)\n",
      "     |  \n",
      "     |  Method descriptor with partial application of the given arguments\n",
      "     |  and keywords.\n",
      "     |  \n",
      "     |  Supports wrapping existing descriptors and handles non-descriptor\n",
      "     |  callables as instance methods.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __get__(self, obj, cls=None)\n",
      "     |  \n",
      "     |  __init__(self, func, /, *args, **keywords)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  __repr__(self)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Class methods defined here:\n",
      "     |  \n",
      "     |  __class_getitem__ = GenericAlias(...) from builtins.type\n",
      "     |      Represent a PEP 585 generic type\n",
      "     |      \n",
      "     |      E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Readonly properties defined here:\n",
      "     |  \n",
      "     |  __isabstractmethod__\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "    \n",
      "    class singledispatchmethod(builtins.object)\n",
      "     |  singledispatchmethod(func)\n",
      "     |  \n",
      "     |  Single-dispatch generic method descriptor.\n",
      "     |  \n",
      "     |  Supports wrapping existing descriptors and handles non-descriptor\n",
      "     |  callables as instance methods.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __get__(self, obj, cls=None)\n",
      "     |  \n",
      "     |  __init__(self, func)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  register(self, cls, method=None)\n",
      "     |      generic_method.register(cls, func) -> func\n",
      "     |      \n",
      "     |      Registers a new implementation for the given *cls* on a *generic_method*.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Readonly properties defined here:\n",
      "     |  \n",
      "     |  __isabstractmethod__\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "\n",
      "FUNCTIONS\n",
      "    cache(user_function, /)\n",
      "        Simple lightweight unbounded cache.  Sometimes called \"memoize\".\n",
      "    \n",
      "    cmp_to_key(...)\n",
      "        Convert a cmp= function into a key= function.\n",
      "    \n",
      "    lru_cache(maxsize=128, typed=False)\n",
      "        Least-recently-used cache decorator.\n",
      "        \n",
      "        If *maxsize* is set to None, the LRU features are disabled and the cache\n",
      "        can grow without bound.\n",
      "        \n",
      "        If *typed* is True, arguments of different types will be cached separately.\n",
      "        For example, f(3.0) and f(3) will be treated as distinct calls with\n",
      "        distinct results.\n",
      "        \n",
      "        Arguments to the cached function must be hashable.\n",
      "        \n",
      "        View the cache statistics named tuple (hits, misses, maxsize, currsize)\n",
      "        with f.cache_info().  Clear the cache and statistics with f.cache_clear().\n",
      "        Access the underlying function with f.__wrapped__.\n",
      "        \n",
      "        See:  https://en.wikipedia.org/wiki/Cache_replacement_policies#Least_recently_used_(LRU)\n",
      "    \n",
      "    reduce(...)\n",
      "        reduce(function, sequence[, initial]) -> value\n",
      "        \n",
      "        Apply a function of two arguments cumulatively to the items of a sequence,\n",
      "        from left to right, so as to reduce the sequence to a single value.\n",
      "        For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates\n",
      "        ((((1+2)+3)+4)+5).  If initial is present, it is placed before the items\n",
      "        of the sequence in the calculation, and serves as a default when the\n",
      "        sequence is empty.\n",
      "    \n",
      "    singledispatch(func)\n",
      "        Single-dispatch generic function decorator.\n",
      "        \n",
      "        Transforms a function into a generic function, which can have different\n",
      "        behaviours depending upon the type of its first argument. The decorated\n",
      "        function acts as the default implementation, and additional\n",
      "        implementations can be registered using the register() attribute of the\n",
      "        generic function.\n",
      "    \n",
      "    total_ordering(cls)\n",
      "        Class decorator that fills in missing ordering methods\n",
      "    \n",
      "    update_wrapper(wrapper, wrapped, assigned=('__module__', '__name__', '__qualname__', '__doc__', '__annotations__'), updated=('__dict__',))\n",
      "        Update a wrapper function to look like the wrapped function\n",
      "        \n",
      "        wrapper is the function to be updated\n",
      "        wrapped is the original function\n",
      "        assigned is a tuple naming the attributes assigned directly\n",
      "        from the wrapped function to the wrapper function (defaults to\n",
      "        functools.WRAPPER_ASSIGNMENTS)\n",
      "        updated is a tuple naming the attributes of the wrapper that\n",
      "        are updated with the corresponding attribute from the wrapped\n",
      "        function (defaults to functools.WRAPPER_UPDATES)\n",
      "    \n",
      "    wraps(wrapped, assigned=('__module__', '__name__', '__qualname__', '__doc__', '__annotations__'), updated=('__dict__',))\n",
      "        Decorator factory to apply update_wrapper() to a wrapper function\n",
      "        \n",
      "        Returns a decorator that invokes update_wrapper() with the decorated\n",
      "        function as the wrapper argument and the arguments to wraps() as the\n",
      "        remaining arguments. Default arguments are as for update_wrapper().\n",
      "        This is a convenience function to simplify applying partial() to\n",
      "        update_wrapper().\n",
      "\n",
      "DATA\n",
      "    WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__qualname__', '__do...\n",
      "    WRAPPER_UPDATES = ('__dict__',)\n",
      "    __all__ = ['update_wrapper', 'wraps', 'WRAPPER_ASSIGNMENTS', 'WRAPPER_...\n",
      "\n",
      "FILE\n",
      "    /Users/rbasnet/miniconda3/envs/py/lib/python3.9/functools.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import functools\n",
    "help(functools)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### reduce applications\n",
    "\n",
    "### find sum of first n positive integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = functools.reduce(lambda x,y:x+y, range(1, 11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test the result!\n",
    "assert sum(range(1, 11)) == s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### find factorial (or product) of first n positive integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "fact = functools.reduce(lambda x,y:x*y, range(1, 11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test the result using math.factorial function\n",
    "import math\n",
    "assert math.factorial(10) == fact"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kattis problems\n",
    "\n",
    "1. Connect-N - https://open.kattis.com/problems/connectn\n",
    "    - Hint: 2-D Array - simply check 4 winning ways from each B or R char - just like in tic-tac-toe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}