built_in_functions_and_libraries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TABLE OF CONTENTS: <a id='toc'></a>\n",
    "\n",
    "These tips focus largely on built-in functions and libraries that I think are good to know.\n",
    "\n",
    "I may not cover everything in each library.<br>\n",
    "Please go through official documentation if you want more thorough examples.\n",
    "\n",
    "All functions are operating under their default parameters.\n",
    "\n",
    "<b>Topics:</b>\n",
    "\n",
    "- <b>[Functions](#functions)\n",
    "     - [Map](#map)\n",
    "     - [Filter](#filter)\n",
    "     - [Zip](#zip)\n",
    "     - [Print Formatting](#print)\n",
    "         - [Multiline comments](#multi)\n",
    "         - [Formatting](#format)\n",
    "     - [Str and Repr](#strrepr)\n",
    "- <b>[Libraries](#libraries)<b>\n",
    "     - [Itertools](#itertools)\n",
    "         - [Infinite Itorators](#infinite)\n",
    "         - [Iterators Terminating On The Shortest Input Sequence](#itotsis)\n",
    "         - [Combinatoric Iterators](#combinatoric)\n",
    "     - [Collections](#collections)\n",
    "     - [Functools](#functools)\n",
    "     - [Datetime](#dt)\n",
    "     - [OS](#os)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Uncomment if you want to use inline pythontutor\n",
    "\n",
    "# from IPython.display import IFrame\n",
    "\n",
    "# IFrame('http://www.pythontutor.com/visualize.html#mode=display', height=1500, width=750)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions<a id=functions></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Map<a id=\"map\"></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "Use map to quickly apply a function across a list(array), can be used in conjuncture with lambda to be done even quicker."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "list_2 = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n",
    "\n",
    "def addition(x, y):\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[12, 14, 16, 18, 20, 22, 24, 26, 28, 30]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using a standard function.\n",
    "\n",
    "list(map(addition, list_1, list_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[12, 14, 16, 18, 20, 22, 24, 26, 28, 30]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using a lambda function.\n",
    "\n",
    "list(map(lambda x, y: x + y, list_1, list_2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filter<a id=\"filter\"></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "As its name suggests its used to filter things like a list(array), uses lambda functions as well. They're really good to know."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Filter for elements greater than 5\n",
    "\n",
    "list(filter(lambda x : x > 5, list_1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zip<a id=\"zip\"></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "Easy way to take two lists and put them together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Tim': 'dog', 'Steve': 'cat', 'Matt': 'sheep'}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Very useful when making a dictionary\n",
    "\n",
    "animals = [\"dog\", \"cat\", \"sheep\"]\n",
    "animal_names = [\"Tim\", \"Steve\", \"Matt\"]\n",
    "\n",
    "dict(zip(animal_names, animals))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Tim', 'dog'), ('Steve', 'cat'), ('Matt', 'sheep')]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Will make a tuple by default\n",
    "\n",
    "list(zip(animal_names, animals))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<zip at 0x7fa3184bf680>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# It will return as an object so you need a list() or dict() call to return anything\n",
    "zip(animal_names, animals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 2, 'c': 3, 'd': 4}\n"
     ]
    }
   ],
   "source": [
    "# Quick way to zip dictionaries\n",
    "\n",
    "dict_1 = {\"a\":1, \"b\":2}\n",
    "dict_2 = {\"c\":3, \"d\":4}\n",
    "\n",
    "dict_3 = {**dict_1, **dict_2}\n",
    "print(dict_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Print formatting<a id=\"print\"></a>\n",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# Standard for loop print:\n",
    "for i in list_1:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 "
     ]
    }
   ],
   "source": [
    "# For loop printing on the same line\n",
    "\n",
    "for i in list_1:  # defaults are sep=' ', end='\\n'\n",
    "    print(i, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10\n"
     ]
    }
   ],
   "source": [
    "# Quickest way of unpacking of a list, although it prints on the same line.\n",
    "print(*list_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# Quicker way than a for loop with a new line.\n",
    "print(*list_1, sep=\"\\n\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Multiline comments</b><a id='multi'></a>\n",
    "\n",
    "With Python you can use both double and single quotation marks, I highly suggest you use double quotation marks because if you want to use an apostrophe you will not have to change your outer quotation marks. This is up to you, either work.\n",
    "\n",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm using an apostrophe\n"
     ]
    }
   ],
   "source": [
    "print(\"I'm using an apostrophe\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Use triple quotes for these\n",
      "Or these\n"
     ]
    }
   ],
   "source": [
    "print('''Use triple quotes for these''')\n",
    "\n",
    "print(\"\"\"Or these\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "These are very useful you can use .format on this too.\n",
      "These will keep the formatting within the string\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print('''These are very useful you can use {} on this too.\n",
    "These will keep the formatting within the string\n",
    "'''.format('.format'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "These are very useful you can use f-strings on this too.\n",
      "These will keep the formatting within the string\n",
      "\n",
      "name='tyler'\n"
     ]
    }
   ],
   "source": [
    "# f-strings work with triple quotes too.\n",
    "\n",
    "string = \"f-strings\"\n",
    "\n",
    "print(f\"\"\"These are very useful you can use {string} on this too.\n",
    "These will keep the formatting within the string\n",
    "\"\"\")\n",
    "\n",
    "#You can also print the value and variable name together like this:\n",
    "\n",
    "name = \"tyler\"\n",
    "print(f\"{name=}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# These are use in documentation, specifically within in functions or class methods\n",
    "\n",
    "def documentation(x, y):\n",
    "    \"\"\"This function takes two parameters\n",
    "    It will then sum x and y\n",
    "    \"\"\"\n",
    "    return(x+y)\n",
    "\n",
    "# OR\n",
    "\n",
    "def documentation(x, y):  # I typically push the first line down, I've seen it either way\n",
    "    \"\"\"\n",
    "    This function takes two parameters\n",
    "    It will then sum x and y\n",
    "    \"\"\"\n",
    "    return(x+y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is a really long string I need extended.'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Extending multilined strings\n",
    "\n",
    "long_string_1 = \"this is a really long string \" \\\n",
    "                \"I need extended.\"\n",
    "\n",
    "long_string_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I could also do this instead.'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "long_string_2 = (\"I could also do \"\n",
    "                 \"this instead.\"\n",
    "                 )\n",
    "\n",
    "long_string_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Formatting</b><a id ='format'></a>\n",
    "\n",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "# Format a print statement in a few ways\n",
    "\n",
    "print(\"hello {}\".format(\"world\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello %s' % 'world\n"
     ]
    }
   ],
   "source": [
    "print(\"hello %s' % 'world\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "chips, candy, peanuts\n"
     ]
    }
   ],
   "source": [
    "# You can unpack a list to format they will align numerically\n",
    "\n",
    "snacks = [\"chips\", \"candy\", \"peanuts\"]\n",
    "\n",
    "print(\"{}, {}, {}\".format(*snacks))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "candy, candy, candy\n",
      "peanuts, candy, chips\n"
     ]
    }
   ],
   "source": [
    "# You can also force indexes\n",
    "snacks = [\"chips\", \"candy\", \"peanuts\"]\n",
    "\n",
    "print(\"{1}, {1}, {1}\".format(*snacks))\n",
    "print(\"{2}, {1}, {0}\".format(*snacks))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat dog is a show\n"
     ]
    }
   ],
   "source": [
    "# F strings allow you to put a variable by its name within a string. > Python 3.6\n",
    "\n",
    "var1 = \"cat\"\n",
    "var2 = \"dog\"\n",
    "\n",
    "print(f\"{var1} {var2} is a show\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "\n",
      "hello\\n\n"
     ]
    }
   ],
   "source": [
    "# Raw strings will print out exactly what is in the string. \n",
    "# This is used in regex or regular expressions... import re\n",
    "\n",
    "print(\"hello\\n\")\n",
    "\n",
    "print(r\"hello\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'$1,234.54'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Formatting money, this one is really useful!\n",
    "\n",
    "\"${:,.2f}\".format(1234.54)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34.0%\n"
     ]
    }
   ],
   "source": [
    "# Formatting percents\n",
    "\n",
    "print(\"%.1f%%\" % 34)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000000\n",
      "1000\n"
     ]
    }
   ],
   "source": [
    "# Format numbers for readability\n",
    "\n",
    "one_million = 1_000_000 # easily read as 1,000,000\n",
    "\n",
    "one_thousand = 1_000 # easily read as 1,000\n",
    "\n",
    "print(one_million) \n",
    "\n",
    "print(one_thousand) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <b>Str and Repr</b><a id ='strrepr'></a>\n",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'repr() shows it is a string by returning quotes'\n"
     ]
    }
   ],
   "source": [
    "\"\"\"repr() computes the “official” string representation of an object.\n",
    "\n",
    "The goal of repr is to be unambiguous.\n",
    "\n",
    "A representation that has all information about the object\n",
    "Use !r to shorthand repr in a format string.\"\"\"\n",
    "\n",
    "print(\"{!r}\".format(\"repr() shows it is a string by returning quotes\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str() doesn't return the quotes, we don't need know it's a string\n"
     ]
    }
   ],
   "source": [
    "\"\"\"str() computes the “informal” string representation of an object\n",
    "\n",
    "The goal of str is to be readable.\n",
    "\n",
    "A representation that is useful for printing the object.\n",
    "Use !s to shorthand str in a format string.\"\"\"\n",
    "\n",
    "print(\"{!s}\".format(\"str() doesn't return the quotes, we don't need know it's a string\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2022-08-23 15:19:10.314056'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Another example\n",
    "\n",
    "import datetime\n",
    "\n",
    "str(datetime.datetime.now())  # str gives us readability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'datetime.datetime(2022, 8, 23, 15, 19, 10, 329810)'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repr(datetime.datetime.now())  # repr shows where the object came from."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Libraries<a id=libraries></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Itertools <a id=\"itertools\"></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "<b>Please learn about generators first.</b>\n",
    "\n",
    "This module implements a number of iterator building blocks inspired by constructs from APL, Haskell, and SML. Each has been recast in a form suitable for Python.\n",
    "\n",
    "The module standardizes a core set of fast, memory efficient tools that are useful by themselves or in combination. Together, they form an “iterator algebra” making it possible to construct specialized tools succinctly and efficiently in pure Python.\n",
    "\n",
    "https://docs.python.org/3/library/itertools.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import * #does not work"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Infinite itorators</b><br><a id=\"infinite\"></a>\n",
    "\n",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Count</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "5\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "\"\"\"count(start=0, step=1)\n",
    "\n",
    "This creates an iterable object that goes up by the step you specify.\n",
    "This will continuously yield increments of 5 i.e. 0, 5, 10, 15, 20...\n",
    "\n",
    "Remember: Each time your generator is called upon using next, it will only then yield the result. \n",
    "This will continue until your generator is exhausted.\n",
    "\n",
    "Do not use as a list.\n",
    "\"\"\"\n",
    "\n",
    "count_object = count(0, 5) # (start, step)\n",
    "\n",
    "print(next(count_object))\n",
    "print(next(count_object))\n",
    "print(next(count_object))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Cycle</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "B\n",
      "C\n",
      "D\n",
      "A\n"
     ]
    }
   ],
   "source": [
    "\"\"\"cycle(iterable)\n",
    "\n",
    "This creates an iterable object of what you pass in in an endless cycle.\n",
    "This will continuously yield, A B C D A B C D A B C D ...\n",
    "\n",
    "Do not use as a list.\n",
    "\"\"\"\n",
    "\n",
    "cycle_object = cycle(\"ABCD\")\n",
    "\n",
    "print(next(cycle_object))\n",
    "print(next(cycle_object))\n",
    "print(next(cycle_object))\n",
    "print(next(cycle_object))\n",
    "print(next(cycle_object))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Repeat</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 10, 10]\n",
      "['hello', 'hello', 'hello', 'hello']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"repeat(object, times=None)\n",
    "\n",
    "Used to repeat an element up to n times.\n",
    "\n",
    "\n",
    "Works as a generator.\n",
    "\"\"\"\n",
    "\n",
    "print(list(repeat(10, 3)))\n",
    "print(list(repeat(\"hello\", 4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "repeat_obj = repeat(10, 3)\n",
    "\n",
    "print(next(repeat_obj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Iterators terminating on the shortest input sequence</b><a id=\"itotsis\"></a>\n",
    "\n",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Accumulate</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 6, 10, 15]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"accumulate(iterable, func=operator.add)\n",
    "\n",
    "Accumulate makes an iterator that returns accumulated sums.\n",
    "Works similar to itertools.reduce() although only with addition\n",
    "\"\"\"\n",
    "\n",
    "list(accumulate([1, 2, 3, 4, 5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "# Generator\n",
    "\n",
    "accu_onj = accumulate([1, 2, 3, 4, 5])\n",
    "\n",
    "print(next(accu_onj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Chain</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'e', 'd', 'f', 'g', 'h', 'i', 'j', 'k', 'l']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"chain(*iterables)\n",
    "\n",
    "Chain makes an iterator that returns elements from the first iterable until it is exhausted,\n",
    "then proceeds to the next iterable, until all of the iterables are exhausted.\n",
    "Used for treating consecutive sequences as a single sequence.\n",
    "\n",
    "You can chain together lists, tuples, sets and strings\n",
    "\"\"\"\n",
    "\n",
    "print(list(chain((\"a\", \"b\", \"c\"), {\"d\", \"e\", \"f\"}, [\"g\", \"h\", \"i\"], \"jkl\"))) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n"
     ]
    }
   ],
   "source": [
    "# Generator\n",
    "\n",
    "chain_obj = chain((\"a\", \"b\", \"c\"), {\"d\", \"e\", \"f\"}, [\"g\", \"h\", \"i\"], \"jkl\")\n",
    "\n",
    "print(next(chain_obj))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'e', 'd', 'f', 'g', 'h', 'i', 'j', 'k', 'l']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"chain.from_interable(iterables)\n",
    "\n",
    "Alternate constructor for chain(). Gets chained inputs from a single \n",
    "iterable argument that is evaluated.\n",
    "\n",
    "Works as a generator\n",
    "\"\"\"\n",
    "\n",
    "# Now with a single argument.\n",
    "\n",
    "print(list(chain.from_iterable([(\"a\", \"b\", \"c\"), {\"d\", \"e\", \"f\"}, [\"g\", \"h\", \"i\"], \"jkl\"]))) # Now as a single argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will raise a TypeError uncomment to run.\n",
    "\n",
    "# print(list(chain.from_iterable(\n",
    "#     (\"a\", \"b\", \"c\"), {\"d\", \"e\", \"f\"}, [\"g\", \"h\", \"i\"], \"jkl\")\n",
    "# ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Compress</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'C', 'E', 'F']"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"compress(data, selectors)\n",
    "\n",
    "Compress makes an iterator that filters elements from data returning\n",
    "only those that have a corresponding element in selectors that\n",
    "evaluates to True. \n",
    "\n",
    "Stops when either the data or selectors iterables have been exhausted.\n",
    "\"\"\"\n",
    "\n",
    "# A, C, E and F correspond to 1 or True to they will return\n",
    "list(compress(\"ABCDEF\", [1, 0, 1, 0, 1, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n"
     ]
    }
   ],
   "source": [
    "# Generator\n",
    "\n",
    "#Remember: Each time your generator is called upon using next, it will only then yield the result. \n",
    "#This will continue until your generator is exhausted.\n",
    "\n",
    "compress_obj = compress(\"ABCDEF\", [1, 0, 1, 0, 1, 1])\n",
    "\n",
    "print(next(compress_obj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Dropwhile</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"dropwhile(predicate, iterable)\n",
    "\n",
    "Dropwhile makes an iterator that drops elements from the iterable\n",
    "as long as the predicate is true; afterwards, returns every element.\n",
    "\n",
    "Works as a generator.\n",
    "\n",
    "1 < 5 True won't return\n",
    "2 < 5 True won't return\n",
    "3 < 5 True won't return\n",
    "4 < 5 True won't return\n",
    "5 !< 5 False will return \n",
    "\n",
    "Now will return 5 and everything after.\n",
    "\"\"\"\n",
    "\n",
    "list(dropwhile(lambda x: x<5, [1, 2, 3, 4, 5, 6, 7, 8, 9]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# Generator\n",
    "\n",
    "dropwhile_obj = dropwhile(lambda x: x<5, [1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
    "\n",
    "print(next(dropwhile_obj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Filterfalse</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"filterfalse(predicate, iterable)\n",
    "\n",
    "Makes an iterator that filters elements from an iterable \n",
    "returning only those for which the predicate is False (0)\n",
    "\n",
    "Works as a generator.\n",
    "\n",
    "0 % 2 = 0 False will return\n",
    "1 % 2 = 1 True won't return\n",
    "2 % 2 = 0 False will return\n",
    "3 % 2 = 1 True won't return\n",
    "etc...\n",
    "\"\"\"\n",
    "\n",
    "list(filterfalse(lambda x: x%2, range(10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "# Generator\n",
    "\n",
    "filterfalse_obj = filterfalse(lambda x: x%2, range(10))\n",
    "\n",
    "print(next(filterfalse_obj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Groupby</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B', 'C', 'D', 'A', 'B']"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"groupby(iterable, key=None)\n",
    "\n",
    "Makes an iterator that returns consecutive keys\n",
    "and groups from the iterable.\n",
    "\n",
    "The operation of groupby() is similar to the uniq filter in Unix.\n",
    "It generates a break or new group every time the value of the key\n",
    "function changes.\n",
    "\n",
    "Generally, the iterable needs to already be sorted on the same key function.\n",
    "\"\"\"\n",
    "\n",
    "# Only returns the individual elements\n",
    "\n",
    "[k for k, g in groupby(\"AAAABBBCCDAABBB\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['A', 'A', 'A', 'A'],\n",
       " ['B', 'B', 'B'],\n",
       " ['C', 'C'],\n",
       " ['D'],\n",
       " ['A', 'A'],\n",
       " ['B', 'B', 'B']]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using groupby like this will return the groups\n",
    "\n",
    "[list(g) for k, g in groupby(\"AAAABBBCCDAABBB\")]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Islice</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'B']\n",
      "['A', 'B']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"islice(iterable, *args)\n",
    "\n",
    "Very similar to calling the index in a string\n",
    "\"\"\"\n",
    "\n",
    "print(list(islice(\"ABCDEFG\", 2)))\n",
    "\n",
    "# similar to\n",
    "\n",
    "print(list(\"ABCDEFG\"[0:2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['C', 'D']\n",
      "['C', 'D']\n"
     ]
    }
   ],
   "source": [
    "print(list(islice(\"ABCDEFG\", 2, 4)))\n",
    "\n",
    "# similar to\n",
    "\n",
    "print(list(\"ABCDEFG\"[2:4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['C', 'D', 'E', 'F', 'G']\n",
      "['C', 'D', 'E', 'F', 'G']\n"
     ]
    }
   ],
   "source": [
    "print(list(islice(\"ABCDEFG\", 2, None)))\n",
    "\n",
    "# similar to\n",
    "\n",
    "print(list(\"ABCDEFG\"[2:]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'C', 'E', 'G']\n",
      "['A', 'C', 'E', 'G']\n"
     ]
    }
   ],
   "source": [
    "print(list(islice(\"ABCDEFG\", 0, None, 2)))\n",
    "\n",
    "# similar to\n",
    "\n",
    "print(list(\"ABCDEFG\"[::2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Starmap</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[32, 9, 1000]\n",
      "[32, 9, 1000]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"starmap(function, iterable)\n",
    "\n",
    "Makes an iterator that computes the function\n",
    "using arguments obtained from the iterable.\n",
    "\n",
    "Works as a generator.\n",
    "\"\"\"\n",
    "\n",
    "print(list(starmap(pow, [(2, 5), (3, 2), (10, 3)])))\n",
    "\n",
    "# similar to\n",
    "\n",
    "starmap_equivalent = [2**5, 3**2, 10**3]\n",
    "print(starmap_equivalent)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32\n"
     ]
    }
   ],
   "source": [
    "starmap_obj = starmap(pow, [(2,5), (3,2), (10,3)])\n",
    "\n",
    "print(next(starmap_obj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Takewhile</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"takewhile(predicate, iterable)\n",
    "\n",
    "Makes an iterator that returns elements \n",
    "from the iterable as long as the predicate is true.\n",
    "\"\"\"\n",
    "\n",
    "list(takewhile(lambda x: x<5, [1, 4, 6, 4, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "takewhile_obj = takewhile(lambda x: x<5, [1, 4, 6, 4, 1])\n",
    "\n",
    "print(next(takewhile_obj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Tee</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<itertools._tee object at 0x7fa3183be840>, <itertools._tee object at 0x7fa3183bed40>, <itertools._tee object at 0x7fa3183be540>)\n"
     ]
    }
   ],
   "source": [
    "\"\"\"tee(iterable, n=2)\n",
    "\n",
    "Tee will take the iterable that you give it \n",
    "and return a tuple of n iterables, which you can then iterate through. \n",
    "\"\"\"\n",
    "b = tee((1,2,3,4), 3)\n",
    "print(b) #outputs ([1,2,3,4], [1,2,3,4], [1,2,3,4])\n",
    "\n",
    "# b = itertools.tee((1,2,3,4), 3) outputs the same thing as above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[1, 2, 3, 4]\n",
      "[1, 2, 3, 4]\n",
      "[]\n",
      "[]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "# Created 3 iterable object with the same elements\n",
    "for i in range(0,3):\n",
    "    print(list(b[i]))\n",
    "for i in range(0,3): #Remember they are iterators so they're designed to generate data exactly one time. \n",
    "    print(list(b[i]))#If you want to get data out of it a second time, you either have to save \n",
    "                     #all the iterated data to another list, or initiate the iterator again."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Zip Longest</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('A', 'x'), ('B', 'y'), ('C', '-'), ('D', '-')]\n",
      "[('A', 'x'), ('B', 'y'), ('C', 'z'), ('D', '-')]\n",
      "[('A', 'x'), ('B', 'y'), ('C', 'z'), ('D', 'a'), ('-', 'b')]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"zip_longest(*iterables, fillvalue=None)\n",
    "\n",
    "Makes an iterator that aggregates elements from each of the iterables.\n",
    "If the iterables are of uneven length, missing values are filled-in \n",
    "with the fillvalue.\n",
    "\n",
    "Iteration continues until the longest iterable is exhausted.\n",
    "\"\"\"\n",
    "\n",
    "print(list(zip_longest(\"ABCD\", \"xy\", fillvalue=\"-\")))\n",
    "\n",
    "print(list(zip_longest(\"ABCD\", \"xyz\", fillvalue=\"-\")))\n",
    "\n",
    "print(list(zip_longest(\"ABCD\", \"xyzab\", fillvalue=\"-\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('A', 'x')\n"
     ]
    }
   ],
   "source": [
    "zip_longest_obj = zip_longest(\"ABCD\", \"xy\", fillvalue=\"-\")\n",
    "\n",
    "#Remember: Each time your generator is called upon using next, it will only then yield the result. \n",
    "#This will continue until your generator is exhausted.\n",
    "\n",
    "print(next(zip_longest_obj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Combinatoric iterators</b><a id=\"combinatoric\"></a>\n",
    "\n",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Product</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A',), ('B',), ('C',), ('D',)]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Product (*iterables, repeat=1)\n",
    "\n",
    "Product is equivalent to for loops. \n",
    "Repeat lets you choose how many times to nest.\n",
    "\n",
    "Works as a generator.\n",
    "\"\"\"\n",
    "\n",
    "# Single for loop\n",
    "list(product(\"ABCD\", repeat=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A', 'A'),\n",
       " ('A', 'B'),\n",
       " ('A', 'C'),\n",
       " ('A', 'D'),\n",
       " ('B', 'A'),\n",
       " ('B', 'B'),\n",
       " ('B', 'C'),\n",
       " ('B', 'D'),\n",
       " ('C', 'A'),\n",
       " ('C', 'B'),\n",
       " ('C', 'C'),\n",
       " ('C', 'D'),\n",
       " ('D', 'A'),\n",
       " ('D', 'B'),\n",
       " ('D', 'C'),\n",
       " ('D', 'D')]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(product(\"ABCD\", repeat=2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('A',)\n"
     ]
    }
   ],
   "source": [
    "product_object = product(\"ABCD\", repeat=1)\n",
    "\n",
    "print(next(product_object))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Permuations</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A', 'B'),\n",
       " ('A', 'C'),\n",
       " ('A', 'D'),\n",
       " ('B', 'A'),\n",
       " ('B', 'C'),\n",
       " ('B', 'D'),\n",
       " ('C', 'A'),\n",
       " ('C', 'B'),\n",
       " ('C', 'D'),\n",
       " ('D', 'A'),\n",
       " ('D', 'B'),\n",
       " ('D', 'C')]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"permutations(iterable, r=None_\n",
    "\n",
    "Returns all permutations, no repeated elements\n",
    "\n",
    "Works as a generator.\n",
    "\"\"\"\n",
    "\n",
    "list(permutations(\"ABCD\", 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('A', 'B')\n"
     ]
    }
   ],
   "source": [
    "permutation_obj = permutations(\"ABCD\", 2)\n",
    "\n",
    "print(next(permutation_obj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Combinations</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'C'), ('B', 'D'), ('C', 'D')]"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"combinations(iterable, r)\n",
    "\n",
    "Returns all combinations results in sorted order,\n",
    "no repeated elements.\n",
    "\n",
    "Works as a generator.\n",
    "\"\"\"\n",
    "\n",
    "list(combinations(\"ABCD\", 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('A', 'B')\n"
     ]
    }
   ],
   "source": [
    "combinations_obj = combinations(\"ABCD\", 2)\n",
    "\n",
    "print(next(combinations_obj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Combinations With Replacement</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A', 'A'),\n",
       " ('A', 'B'),\n",
       " ('A', 'C'),\n",
       " ('A', 'D'),\n",
       " ('B', 'B'),\n",
       " ('B', 'C'),\n",
       " ('B', 'D'),\n",
       " ('C', 'C'),\n",
       " ('C', 'D'),\n",
       " ('D', 'D')]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"combinations_with_replacement(iterable, r)\n",
    "\n",
    "Returns all combinations with replacements,\n",
    "Results in sorted order\n",
    "r represents the size/length of different combinations that are possible\n",
    "\n",
    "The list should return with these additional elements:\n",
    "[(\"A\", \"A\"), (\"B\", \"B\"), (\"C\", \"C\"), (\"D\", \"D\")]\n",
    "\n",
    "Works as a generator.\n",
    "\"\"\"\n",
    "\n",
    "list(combinations_with_replacement(\"ABCD\", 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('A', 'A')\n"
     ]
    }
   ],
   "source": [
    "combinations_replace_obj = combinations_with_replacement(\"ABCD\", 2)\n",
    "\n",
    "print(next(combinations_replace_obj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Collections<a id=\"collections\"></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "This module implements specialized container datatypes providing alternatives to Python’s general purpose built-in containers, dict, list, set, and tuple.\n",
    "\n",
    "NOTES:<br>\n",
    "user(dict|list|string) have lost value moving from Python2 -> Python3.\n",
    "I won't be covering them.\n",
    "\n",
    "https://docs.python.org/3/library/collections.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Namedtuple</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Color(red=255, green=255, blue=224)\n"
     ]
    }
   ],
   "source": [
    "\"\"\"namedtuple(typename, field_names, rename=False) # verbose=False argument was removed in Python 3.7\n",
    "\n",
    "A factory function used to create tuple-like IMMUTABLE objects that act like lists\n",
    "dictionaries. Use named tuples instead of tuples anywhere \n",
    "you think object notation will make your code more easily readable.\n",
    "Note that the the VALUES they store don’t have to be immutable\n",
    "but attributes in named tuples are immutable.\n",
    "\n",
    "\n",
    "required arguments:\n",
    "\n",
    "typename    - the class name represented as a string\n",
    "field_names - the field names you'll use to access the tuple values\n",
    "                - can be an iterable of strings\n",
    "                - can be a string with values separated by white space\n",
    "                - can be a string with values separated by commas\n",
    "\n",
    "optional arguments:\n",
    "\n",
    "rename   - if set to true, all invalid field names are replaced with positional names\n",
    "defaults - defaulted to None, which means field names won't have default values. Can \n",
    "           be set to an iterable of values\n",
    "module   - the .__module__ attribute of the resulting namedtuple is set to this given value\n",
    "           \n",
    "\n",
    "named tuple methods:\n",
    "._make          creates list like tuple\n",
    "\n",
    "._asdict()      creates dict like tuple\n",
    "\n",
    "._replace       Return a new instance of the named tuple \n",
    "                replacing specified fields with new values.\n",
    "\n",
    "._fields        Tuple of strings listing the field names. \n",
    "\"\"\"\n",
    "\n",
    "# Real world application\n",
    "\n",
    "Color = namedtuple(\"Color\", [\"red\", \"green\", \"blue\"])\n",
    "banana = Color(red=255, green=255, blue=224)\n",
    "\n",
    "print(banana)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Functionality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "255"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indexable\n",
    "\n",
    "banana[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "255"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Key accessable\n",
    "\n",
    "# ._asdict()\n",
    "\n",
    "banana_dict = banana._asdict()\n",
    "\n",
    "banana_dict[\"red\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "descriptor(x=11, y=22)\n",
      "descriptor(x=11, y=22)\n"
     ]
    }
   ],
   "source": [
    "# These create list like objects, iterable and indexable.\n",
    "\n",
    "# ._make\n",
    "\n",
    "something = namedtuple(\"descriptor\", [\"x\", \"y\"])\n",
    "\n",
    "print(something(11,22))\n",
    "\n",
    "# Similar to\n",
    "\n",
    "values = [11,22]\n",
    "print(something._make(values))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "descriptor(x=33, y=22)"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ._replace \n",
    "\n",
    "p = something(x=11, y=22)\n",
    "p._replace(x=33)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('x', 'y')"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ._fields\n",
    "\n",
    "something._fields"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Deque</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque([1, 2, 3])\n"
     ]
    }
   ],
   "source": [
    "\"\"\"deque([iterable[, maxlen]])\n",
    "\n",
    "Deques are a generalization of stacks and queues\n",
    "\n",
    "The name is pronounced “deck” and is short for\n",
    "“double-ended queue.\n",
    "\n",
    "Think of a deque as a list like container with \n",
    "fast appends and pops on either end.\n",
    "\n",
    "\n",
    "append(x)                 Add x to the right side of the deque.\n",
    "\n",
    "appendleft(x)             Add x to the left side of the deque.\n",
    "\n",
    "clear()                   Remove all elements from the deque \n",
    "                          leaving it with length 0.\n",
    "\n",
    "count(x)                  Count the number of deque elements equal to x.\n",
    "\n",
    "extend(iterable)          Extend the right side of the deque \n",
    "                          by appending elements from the iterable argument.\n",
    "\n",
    "extendleft(iterable)      Extend the left side of the deque by appending\n",
    "                          elements from iterable. Note, the series of \n",
    "                          left appends results in reversing the order \n",
    "                          of elements in the iterable argument.\n",
    "\n",
    "pop()                     Remove and return an element from the right \n",
    "                          side of the deque. If no elements are present, \n",
    "                          raises an IndexError.\n",
    "\n",
    "popleft()                 Remove and return an element from the left \n",
    "                          side of the deque. If no elements are present,\n",
    "                          raises an IndexError.\n",
    "\n",
    "remove(value)             Removed the first occurrence of value.\n",
    "                          If not found, raises a ValueError.\n",
    "\n",
    "reverse()                 Reverse the elements of the deque in-place\n",
    "                          and then return None.\n",
    "\n",
    "rotate(n)                 Rotate the deque n steps to the right.\n",
    "                          If n is negative, rotate to the left.\n",
    "                          Rotating one step to the right is equivalent to:\n",
    "                          d.appendleft(d.pop()).\n",
    "\"\"\"\n",
    "\n",
    "d = deque([1, 2, 3])\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque([1, 2, 3, 4])\n"
     ]
    }
   ],
   "source": [
    "# append()\n",
    "\n",
    "d.append(4)\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque([0, 1, 2, 3, 4])\n"
     ]
    }
   ],
   "source": [
    "# appendleft()\n",
    "\n",
    "d.appendleft(0) \n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque([])\n"
     ]
    }
   ],
   "source": [
    "# clear()\n",
    "\n",
    "d.clear()\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque([1, 2, 3])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# count()\n",
    "d = deque([1, 2, 3])\n",
    "\n",
    "print(d)\n",
    "\n",
    "d.count(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque([1, 2, 3, 4, 5, 6])\n"
     ]
    }
   ],
   "source": [
    "# entend()\n",
    "\n",
    "d.extend([4, 5, 6])\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque([-2, -1, 0, 1, 2, 3, 4, 5, 6])\n"
     ]
    }
   ],
   "source": [
    "# extendleft()\n",
    "\n",
    "d.extendleft([0, -1, -2])\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "deque([-2, -1, 0, 1, 2, 3, 4, 5])\n"
     ]
    }
   ],
   "source": [
    "# pop()\n",
    "\n",
    "print(d.pop())\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-2\n",
      "deque([-1, 0, 1, 2, 3, 4, 5])\n"
     ]
    }
   ],
   "source": [
    "# popleft()\n",
    "\n",
    "print(d.popleft())\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque([-1, 0, 1, 2, 3, 4, 5])\n",
      "deque([-1, 0, 1, 2, 3, 4])\n"
     ]
    }
   ],
   "source": [
    "# remove()\n",
    "\n",
    "print(d)\n",
    "\n",
    "d.remove(5)\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque([-1, 0, 1, 2, 3, 4])\n",
      "deque([4, 3, 2, 1, 0, -1])\n"
     ]
    }
   ],
   "source": [
    "# reverse()\n",
    "\n",
    "print(d)\n",
    "\n",
    "d.reverse()\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque([4, 3, 2, 1, 0, -1])\n",
      "deque([-1, 4, 3, 2, 1, 0])\n",
      "deque([4, 3, 2, 1, 0, -1])\n"
     ]
    }
   ],
   "source": [
    "# rotate(n) # You can adjust n\n",
    "\n",
    "print(d)\n",
    "\n",
    "d.rotate()  # Pushed the right most element to become the left most element.\n",
    "\n",
    "print(d)\n",
    "\n",
    "d.rotate(-1)  # Pushed the left most element to become the right most element.\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>ChainMap</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'a': 1, 'b': 2, 'c': 3}, {'c': 4, 'd': 5, 'e': 6}]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"ChainMap(*maps)\n",
    "\n",
    "A ChainMap class is provided for quickly linking\n",
    "a number of mappings so they can be treated as a single unit.\n",
    "\n",
    "Identical keys within the ChainMap object will all have\n",
    "the value of the first instance of that key.\n",
    "\"\"\"\n",
    "\n",
    "dict1 = {\"a\":1, \"b\":2, \"c\":3}\n",
    "dict2 = {\"c\":4, \"d\":5, \"e\":6}\n",
    "\n",
    "chained = ChainMap(dict1,dict2)\n",
    "print(chained.maps) #maps operation displays keys and values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['c', 'd', 'e', 'a', 'b']\n"
     ]
    }
   ],
   "source": [
    "print(list(chained.keys())) #keys operation displays keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 6, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "print (list(chained.values())) #values operation displays values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Counter</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({1: 3, 2: 3, 3: 3, 5: 3, 7: 3, 4: 3, 9: 3})"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Counter([iterable-or-mapping])\n",
    "\n",
    "It is an unordered collection where elements\n",
    "are stored as dictionary keys and their counts\n",
    "are stored as dictionary values.\n",
    "\n",
    "Keys are the elements in the list and \n",
    "the values are the number of occurences\n",
    "\"\"\"\n",
    "\n",
    "example_list = [1, 1, 1, 2, 2, 2, 3, 3, 3, 5, 5, 5, 7, 7, 7, 4, 4, 4, 9, 9, 9]\n",
    "\n",
    "Counter(example_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>OrderedDict</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"OrderedDict([items])\n",
    "\n",
    "An OrderedDict is a dict that remembers\n",
    "the order that keys were first inserted.\n",
    "If a new entry overwrites an existing entry,\n",
    "the order is left unchanged.\n",
    "\"\"\"\n",
    "\n",
    "ordered_dict = OrderedDict({\"a\":1, \"b\":2, \"c\":3, \"d\":4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 4)])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ordered_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 1\n",
      "b 2\n",
      "c 3\n",
      "d 4\n"
     ]
    }
   ],
   "source": [
    "# Supports all dictionary functions.\n",
    "\n",
    "for k,v in ordered_dict.items():\n",
    "    print(k,v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Defaultdict</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'m': 1, 'i': 4, 's': 4, 'p': 2}\n",
      "[('m', 1), ('i', 4), ('s', 4), ('p', 2)]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"defaultdict([default_factory[, ...]])\n",
    "\n",
    "When a key is encountered for the first time it is assigned\n",
    "the default_factory value you assign.\n",
    "\n",
    "Great to use when you need to count individual elements within a collection\n",
    "Similar to count, but with the ability to set that default_factory.\n",
    "\"\"\"\n",
    "\n",
    "string = \"mississippi\"\n",
    "\n",
    "d = {}\n",
    "\n",
    "for letter in string:\n",
    "    if letter not in d:\n",
    "        d[letter] = 1  # For every new key we give it a default value of 1\n",
    "    else:\n",
    "        d[letter] += 1\n",
    "        \n",
    "print(d) \n",
    "        \n",
    "# Similar to\n",
    "\n",
    "default_dict2 = defaultdict(int)\n",
    "for k in string:\n",
    "    default_dict2[k] += 1\n",
    "\n",
    "print(list(default_dict2.items()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('yellow', [1, 3]), ('blue', [2, 4]), ('red', [1])]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Setting the default to a list.\n",
    "\n",
    "colors = [(\"yellow\", 1), (\"blue\", 2), (\"yellow\", 3), (\"blue\", 4), (\"red\", 1)]\n",
    "\n",
    "colors_default_dict = defaultdict(list)\n",
    "\n",
    "for k, v in colors:\n",
    "    colors_default_dict[k].append(v)\n",
    "\n",
    "list(colors_default_dict.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functools<a id='functools'></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "The functools module is for higher-order functions: functions that act on or return other functions. In general, any callable object can be treated as a function for the purposes of this module. Functools has a lot of wrapper tools and functionality. Partial and reduce are very good to know. I may add more to this section later.\n",
    "\n",
    "https://docs.python.org/3/library/functools.html#functools.partial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from functools import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Partial</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Partial(func, *args, **keywords)\n",
    "\n",
    "Partial makes a new version of a function with one or more arguments already filled in. Used for quick access.\n",
    "\n",
    "Good resource https://www.pydanny.com/python-partials-are-fun.html\n",
    "\"\"\"\n",
    "\n",
    "# Initial function\n",
    "def student(first, last, grade):\n",
    "    print(first, last, grade)\n",
    "\n",
    "# Partial function\n",
    "freshman = partial(student, grade=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Joe Smith 10\n"
     ]
    }
   ],
   "source": [
    "freshman(\"Joe\", \"Smith\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Partialmethod</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "\"\"\"partialmethod(func, *args, **keywords)\n",
    "\n",
    "Return a new partialmethod descriptor \n",
    "which behaves like partial except that \n",
    "it is designed to be used as a method \n",
    "definition rather than being directly callable.\n",
    "\"\"\"\n",
    "\n",
    "class Cell(object):\n",
    "    def __init__(self):\n",
    "        self._alive = False\n",
    "    @property\n",
    "    def alive(self):\n",
    "        return self._alive\n",
    "    def set_state(self, state):\n",
    "        self._alive = bool(state)\n",
    "    set_alive = partialmethod(set_state, True)\n",
    "    set_dead = partialmethod(set_state, False)\n",
    "\n",
    "c = Cell()\n",
    "print(c.alive)  # Calls `self._alive = False` via @property\n",
    "\n",
    "c.set_alive()   # Partial method is callable and sets the state True\n",
    "print(c.alive)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Reduce</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"reduce(function, iterable, initializer=None)\n",
    "\n",
    "Reduce needs to be imported in Python3.x\n",
    "\n",
    "Reduce is a useful function for performing some computation on a list and returning the result.\n",
    "It applies a rolling computation to sequential pairs of values in a list. This one is tricky.\n",
    "\n",
    "Easiest example to understand is trying to multiply a whole list together like shown below \n",
    "i.e 1*2*3*4*5*6*7*8*9*10\n",
    "\"\"\"\n",
    "\n",
    "list_1 = list(range(1,11))\n",
    "\n",
    "reduce((lambda x, y: x * y), list_1) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Another great example is using reduce to compare elements in a list against each other.\n",
    "\n",
    "reduce(lambda x, y: y if y > x else x, list_1) # Finding the largest number in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce(lambda x, y: y if y < x else x, list_1) # Finding the smallest number in the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Lru_cache</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'lru_cache(maxsize=128, typed=False)\\n\\nDecorator to wrap a function with a memoizing callable that saves up to the maxsize most recent calls.\\n'"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"lru_cache(maxsize=128, typed=False)\n",
    "\n",
    "Decorator to wrap a function with a memoizing callable that saves up to the maxsize most recent calls.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Without memoization.\n",
    "\n",
    "def fib(n):\n",
    "    if n == 1 or n == 2:\n",
    "        return 1\n",
    "    else:\n",
    "        return fib(n-2) + fib(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "# With memoization.\n",
    "\n",
    "cache = {}\n",
    "\n",
    "def fib(n):\n",
    "    try:\n",
    "        if n in cache:\n",
    "            return cache[n]\n",
    "        elif n == 1 or n == 2:\n",
    "            value = 1\n",
    "        elif n > 2:\n",
    "            value = fib(n-2) + fib(n-1)\n",
    "        cache[n] = value\n",
    "        return value\n",
    "    except (UnboundLocalError, ) as e:\n",
    "        print(f\"Don't use 0 | {e}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "# With @lru_cache()\n",
    "\n",
    "from functools import lru_cache\n",
    "\n",
    "@lru_cache()\n",
    "def fib(n):\n",
    "    if n == 1 or n == 2:\n",
    "        return 1\n",
    "    else:\n",
    "        return fib(n-2) + fib(n-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Datetime<a id='dt'></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "The datetime module helps when manipulating time and date in Python with ease. \n",
    "\n",
    "https://docs.python.org/3/library/datetime.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2022, 8, 23, 15, 19, 11, 519484)"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"datetime()\n",
    "\n",
    "Display the current time and date of your machine.\n",
    "A datetime object will return following attributes:\n",
    "year, month, day, hour, minute, seconds, micro-seconds.\n",
    "\"\"\"\n",
    "\n",
    "datetime.now()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today is the 23 day of month 8, and the year is 2022!\n"
     ]
    }
   ],
   "source": [
    "now = datetime.now()\n",
    "\n",
    "# We can also extract only certain data as desired.\n",
    "\n",
    "now_year = now.year\n",
    "now_month = now.month\n",
    "now_day = now.day\n",
    "\n",
    "print(f\"Today is the {now_day} day of month {now_month}, and the year is {now_year}!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Strftime</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The current month is August.\n"
     ]
    }
   ],
   "source": [
    "\"\"\"strftime() \n",
    "\n",
    "Strftime formats datetime objects into readable strings\n",
    "\n",
    "The %B is how strftime knows to return the \n",
    "string of the current month in full.\n",
    "\n",
    "Useful cheatsheet for how to use strftime:\n",
    "https://devhints.io/strftime.\n",
    "\"\"\"\n",
    "\n",
    "print(f\"The current month is {now.strftime('%B')}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today's date is 23-08-2022. Be careful; It's not a datetimeobject anymore it is a <class 'str'>!\n"
     ]
    }
   ],
   "source": [
    "# strftime() can generally be used to format datetime objects.\n",
    "\n",
    "formatted = now.strftime(\"%d-%m-%Y\")\n",
    "\n",
    "print(f\"Today's date is {formatted}. Be careful; It's not a datetimeobject anymore it is a {type(formatted)}!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Timedelta</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I started studying in university back in 21-10-2015\n",
      "and I'll finish in 17-10-2018\n"
     ]
    }
   ],
   "source": [
    "\"\"\"timedelta()\n",
    "Used to get a date X days\\months\\etc from now.\n",
    "\n",
    "\"\"\"\n",
    "from datetime import timedelta\n",
    "\n",
    "\"\"\"School lasts about three years, \n",
    "so we calculate the time difference between\n",
    "starting university time and three years \n",
    "(or 3 * 52 weeks) from this time\"\"\"\n",
    "\n",
    "start_uni_time = datetime(2015, 10, 21)\n",
    "end_uni_time = start_uni_time + timedelta(weeks=52 * 3)\n",
    "\n",
    "print(f\"\"\"I started studying in university back in {start_uni_time.strftime(\"%d-%m-%Y\")}\n",
    "and I'll finish in {end_uni_time.strftime(\"%d-%m-%Y\")}\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### OS<a id='os'></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "This module provides a portable way of using operating system dependent functionality.\n",
    "\n",
    "I used macOS so I will be giving equivalents in that/bash.\n",
    "\n",
    "Please uncomment these yourself. I did not want to show my paths here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Shows your cwd. Equivalent to: pwd\n",
    "\n",
    "# os.getcwd() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Change your cwd to whatever path you'd like, this goes up one directory. Equivalent to: cd ..\n",
    "\n",
    "# os.chdir('..')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['LICENSE.md',\n",
       " 'random_tips.ipynb',\n",
       " 'functions_and_classes.ipynb',\n",
       " 'built_in_functions_and_libraries.ipynb',\n",
       " '.gitignore',\n",
       " '.ipynb_checkpoints',\n",
       " 'general_tips.ipynb',\n",
       " 'README.rst',\n",
       " '.git']"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.listdir() # Shows what files are in your directory. Equivalent to: ls -a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Use these to make a directory or directories(recursively)\n",
    "\n",
    "# os.mkdir('DIRECTORY')\n",
    "\n",
    "# os.mkdirs('DIRECTORY/SUBDIRECTORY')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #  Use these to remove a directory or directories(recursively)\n",
    "\n",
    "# os.rmdir('DIRECTORY')\n",
    "\n",
    "# os.removedirs('DIRECTORY/SUBDIRECTORY'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Used to reanme files.\n",
    "\n",
    "# os.reanme('OLD', 'NEW')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Grab your environment variables.\n",
    "\n",
    "Within your shell you can add environment variables using export.\n",
    "\"\"\"\n",
    "\n",
    "os.environ.get(\"ENV_VARIABLE_KEY\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>os.path</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Use this to join two paths together. This example joins one directory up from your current directory and the another subdirectory\n",
    "\n",
    "# os.path.join(os.getcwed(), '..', 'NAME_OF_SUBDIRECTORY')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'python_tips'"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This should remove everything except the name of the directory this file is located.\n",
    "\n",
    "os.path.basename(os.getcwd())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # This should remove the name of the directory this file is located. Opposite of the example above.\n",
    "\n",
    "# os.path.dirname(os.getcwd())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # This will give you the effect of using the two previous example in one. It gives the basename and the dirname in a tuple.\n",
    "\n",
    "# os.path.split(os.getcwd())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Used to check if a path exists.\n",
    "\n",
    "os.path.exists(os.getcwd())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Used to check if something is a dir.\n",
    "\n",
    "os.path.isdir(os.getcwd())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Used to check if something is a file.\n",
    "\n",
    "os.path.isfile(os.getcwd())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('file', '.txt')"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# # Useful for handling extensions.\n",
    "\n",
    "os.path.splitext(\"file.txt\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}