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 0x10a9b3248>"
      ]
     },
     "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",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Use triple quotes for these\n"
     ]
    }
   ],
   "source": [
    "print('''Use triple quotes for these''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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": 17,
   "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": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is a really long string I need extended.'"
      ]
     },
     "execution_count": 18,
     "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": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I could also do this instead.'"
      ]
     },
     "execution_count": 19,
     "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": 20,
   "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": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "print('hello %s' % 'world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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": 23,
   "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": 24,
   "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": 25,
   "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": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'$1,234.54'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Formatting money, this one is really useful!\n",
    "\n",
    "'${:,.2f}'.format(1234.54)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34.0%\n"
     ]
    }
   ],
   "source": [
    "# Formatting percents\n",
    "\n",
    "print('%.1f%%' % 34)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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": 29,
   "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": 30,
   "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": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2020-02-01 02:17:06.311716'"
      ]
     },
     "execution_count": 31,
     "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": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'datetime.datetime(2020, 2, 1, 2, 17, 6, 330357)'"
      ]
     },
     "execution_count": 32,
     "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": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import *"
   ]
  },
  {
   "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": 34,
   "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",
    "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": 35,
   "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": 36,
   "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",
    "Works as a generator.\n",
    "'''\n",
    "\n",
    "print(list(repeat(10, 3)))\n",
    "print(list(repeat('hello', 4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "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": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 6, 10, 15]"
      ]
     },
     "execution_count": 38,
     "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": 39,
   "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": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'e', 'f', 'd', '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": 41,
   "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": 42,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'e', 'f', 'd', '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": 43,
   "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": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'C', 'E', 'F']"
      ]
     },
     "execution_count": 44,
     "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": 45,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n"
     ]
    }
   ],
   "source": [
    "# Generator\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": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 46,
     "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": 47,
   "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": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8]"
      ]
     },
     "execution_count": 48,
     "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": 49,
   "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": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B', 'C', 'D', 'A', 'B']"
      ]
     },
     "execution_count": 50,
     "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": 51,
   "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": 51,
     "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": 52,
   "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": 53,
   "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": 54,
   "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": 55,
   "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": 56,
   "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": 57,
   "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": 58,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4]"
      ]
     },
     "execution_count": 58,
     "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": 59,
   "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": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<itertools._tee object at 0x10a9db908>, <itertools._tee object at 0x10a9db9c8>, <itertools._tee object at 0x10a9dbb88>)\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)  # Created 3 iterable object with the same elements\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for first in b[0]:\n",
    "    print(first)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for second in b[1]:\n",
    "    print(second)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for third in b[2]:\n",
    "    print(third)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Will raise IndexError uncomment to run.\n",
    "\n",
    "# for third in b[3]:\n",
    "#     print(third)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Zip Longest</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "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": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('A', 'x')\n"
     ]
    }
   ],
   "source": [
    "zip_longest_obj = zip_longest('ABCD', 'xy', fillvalue='-')\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": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A',), ('B',), ('C',), ('D',)]"
      ]
     },
     "execution_count": 67,
     "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": 68,
   "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": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(product('ABCD', repeat=2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "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": 70,
   "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": 70,
     "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": 71,
   "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": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'C'), ('B', 'D'), ('C', 'D')]"
      ]
     },
     "execution_count": 72,
     "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": 73,
   "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": 74,
   "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": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''combinations_with_replacement(iterable, r)\n",
    "\n",
    "Returns all combinations with replacements,\n",
    "Results in sorted order\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": 75,
   "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": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Namedtuple</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Color(red=255, green=255, blue=224)\n"
     ]
    }
   ],
   "source": [
    "'''namedtuple(typename, field_names, verbose=False, rename=False)\n",
    "\n",
    "Used to create tuple-like objects that act like lists\n",
    "dictionaries. Very good at being descriptive check.\n",
    "\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": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Functionality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "255"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indexable\n",
    "\n",
    "banana[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "255"
      ]
     },
     "execution_count": 80,
     "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": 81,
   "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": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "descriptor(x=33, y=22)"
      ]
     },
     "execution_count": 82,
     "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": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('x', 'y')"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ._fields\n",
    "\n",
    "something._fields"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Deque</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "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": 85,
   "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": 86,
   "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": 87,
   "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": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque([1, 2, 3])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 88,
     "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": 89,
   "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": 90,
   "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": 91,
   "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": 92,
   "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": 93,
   "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": 94,
   "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": 95,
   "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": 96,
   "metadata": {},
   "outputs": [],
   "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",
    "If there a key that is the same within the ChainMap object, \n",
    "it will assign the value to 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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chained['b']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assigned 3 not 4 because dict1 was paased first.\n",
    "\n",
    "chained['c']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Counter</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({1: 3, 2: 3, 3: 3, 5: 3, 7: 3, 4: 3, 9: 3})"
      ]
     },
     "execution_count": 99,
     "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": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''OrderedDict([items])\n",
    "\n",
    "An OrderedDict is a dict that remembers\n",
    "the order that keys were first inserted.\n",
    "'''\n",
    "\n",
    "ordered_dict = OrderedDict({'a':1, 'b':2, 'c':3, 'd':4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 4)])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ordered_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "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": 103,
   "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": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('yellow', [1, 3]), ('blue', [2, 4]), ('red', [1])]"
      ]
     },
     "execution_count": 104,
     "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.\n",
    "\n",
    "https://docs.python.org/3/library/functools.html#functools.partial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Functools has a lot of wrapper tools and functionality. \\nI may go over them at some point. For now I think partial and reduce\\nare very good to know.\\n'"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import *\n",
    "\n",
    "'''Functools has a lot of wrapper tools and functionality. \n",
    "I may go over them at some point. For now I think partial and reduce\n",
    "are very good to know.\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Partial</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "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": 107,
   "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": 108,
   "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": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 109,
     "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 really 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 understnad is trying to multiply a whole list together 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": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 110,
     "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": 111,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 111,
     "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": 112,
   "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": 112,
     "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": 113,
   "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": 114,
   "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": 115,
   "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": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2020, 2, 1, 2, 17, 7, 539280)"
      ]
     },
     "execution_count": 117,
     "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": 118,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today is the 1 day of month 2, and the year is 2020!\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('Today is the {} day of month {}, and the year is {}!'\n",
    "      .format(now_day, now_month, now_year))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Strftime</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The current month is February.\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('The current month is {}.'.format(now.strftime('%B')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today's date is 01-02-2020. Be careful;\n",
      "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",
    "print('''Today's date is {}. Be careful;\n",
    "It's not a datetimeobject anymore it is a {}!'''\n",
    "      .format(formatted, type(formatted)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Timedelta</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I started studying in university back in 21-10-2015,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('''I started studying in university back in {},and I'll finish in {}'''\n",
    "      .format(start_uni_time.strftime('%d-%m-%Y'), 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": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Shows your cwd. Equivalent to: pwd\n",
    "\n",
    "# os.getcwd() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "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": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['LICENSE.md',\n",
       " '.DS_Store',\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": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.listdir() # Shows what files are in your directory. Equivalent to: ls -a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "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": 127,
   "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": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Used to reanme files.\n",
    "\n",
    "# os.reanme('OLD', 'NEW')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "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": 130,
   "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": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'python_tips'"
      ]
     },
     "execution_count": 131,
     "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": 132,
   "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": 133,
   "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": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 134,
     "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": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 135,
     "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": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 136,
     "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": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('file', '.txt')"
      ]
     },
     "execution_count": 137,
     "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}