python_cheat_sheet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# About [![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/wilfredinni/python-cheatsheet/master)\n",
    "\n",
    "Basic cheatsheet for Python mostly based on the book written by Al Sweigart, [Automate the Boring Stuff with Python](https://automatetheboringstuff.com/) under the [Creative Commons license](https://creativecommons.org/licenses/by-nc-sa/3.0/) and many other sources.\n",
    "\n",
    "## Contribute\n",
    "\n",
    "All contributions are welcome:\n",
    "\n",
    "- Read the issues, Fork the project and do a Pull Request.\n",
    "- Request a new topic creating a `New issue` with the  `enhancement` tag.\n",
    "- Find any kind of errors in the cheat sheet and create a `New issue` with the details or fork the project and do a Pull Request.\n",
    "- Suggest a better or more pythonic way for existing examples.\n",
    "\n",
    "## Read It\n",
    "\n",
    "- [Online](https://wilfredinni.github.io/python-cheatsheet/)\n",
    "- [Github](https://github.com/wilfredinni/python-cheatsheet)\n",
    "- [PDF](https://github.com/wilfredinni/Python-cheatsheet/raw/master/python_cheat_sheet.pdf)\n",
    "- [Jupyter Notebook](https://mybinder.org/v2/gh/wilfredinni/python-cheatsheet/master?filepath=python_cheat_sheet.ipynb)\n",
    "\n",
    "## Python Cheatsheet\n",
    "\n",
    "- [Python Basics](#python-basics)\n",
    "    - [Math Operators](#math-operators)\n",
    "    - [Data Types](#data-types)\n",
    "    - [String Concatenation and Replication](#string-concatenation-and-replication)\n",
    "    - [Variables](#variables)\n",
    "    - [Comments](#comments)\n",
    "    - [The print() Function](#the-print-function)\n",
    "    - [The input() Function](#the-input-function)\n",
    "    - [The len() Function](#the-len-function)\n",
    "    - [The str(), int(), and float() Functions](#the-str-int-and-float-functions)\n",
    "- [Flow Control](#flow-control)\n",
    "    - [Comparison Operators](#comparison-operators)\n",
    "    - [Boolean evaluation](#boolean-evaluation)\n",
    "    - [Boolean Operators](#boolean-operators)\n",
    "    - [Mixing Boolean and Comparison Operators](#mixing-boolean-and-comparison-operators)\n",
    "    - [if Statements](#if-statements)\n",
    "    - [else Statements](#else-statements)\n",
    "    - [elif Statements](#elif-statements)\n",
    "    - [while Loop Statements](#while-loop-statements)\n",
    "    - [break Statements](#break-statements)\n",
    "    - [continue Statements](#continue-statements)\n",
    "    - [for Loops and the range() Function](#for-loops-and-the-range-function)\n",
    "    - [For else statement](#for-else-statement)\n",
    "    - [Importing Modules](#importing-modules)\n",
    "    - [Ending a Program Early with sys.exit()](#ending-a-program-early-with-sysexit)\n",
    "- [Functions](#functions)\n",
    "    - [Return Values and return Statements](#return-values-and-return-statements)\n",
    "    - [The None Value](#the-none-value)\n",
    "    - [Keyword Arguments and print()](#keyword-arguments-and-print)\n",
    "    - [Local and Global Scope](#local-and-global-scope)\n",
    "    - [The global Statement](#the-global-statement)\n",
    "- [Exception Handling](#exception-handling)\n",
    "    - [Basic exception handling](#basic-exception-handling)\n",
    "    - [Final code in exception handling](#final-code-in-exception-handling)\n",
    "- [Lists](#lists)\n",
    "    - [Getting Individual Values in a List with Indexes](#getting-individual-values-in-a-list-with-indexes)\n",
    "    - [Negative Indexes](#negative-indexes)\n",
    "    - [Getting Sublists with Slices](#getting-sublists-with-slices)\n",
    "    - [Getting a List’s Length with len()](#getting-a-list%E2%80%99s-length-with-len)\n",
    "    - [Changing Values in a List with Indexes](#changing-values-in-a-list-with-indexes)\n",
    "    - [List Concatenation and List Replication](#list-concatenation-and-list-replication)\n",
    "    - [Removing Values from Lists with del Statements](#removing-values-from-lists-with-del-statements)\n",
    "    - [Using for Loops with Lists](#using-for-loops-with-lists)\n",
    "    - [Looping Through Multiple Lists with zip()](#looping-through-multiple-lists-with-zip)\n",
    "    - [The in and not in Operators](#the-in-and-not-in-operators)\n",
    "    - [The Multiple Assignment Trick](#the-multiple-assignment-trick)\n",
    "    - [Augmented Assignment Operators](#augmented-assignment-operators)\n",
    "    - [Finding a Value in a List with the index() Method](#finding-a-value-in-a-list-with-the-index-method)\n",
    "    - [Adding Values to Lists with the append() and insert() Methods](#adding-values-to-lists-with-the-append-and-insert-methods)\n",
    "    - [Removing Values from Lists with remove()](#removing-values-from-lists-with-remove)\n",
    "    - [Sorting the Values in a List with the sort() Method](#sorting-the-values-in-a-list-with-the-sort-method)\n",
    "    - [Tuple Data Type](#tuple-data-type)\n",
    "    - [Converting Types with the list() and tuple() Functions](#converting-types-with-the-list-and-tuple-functions)\n",
    "- [Dictionaries and Structuring Data](#dictionaries-and-structuring-data)\n",
    "    - [The keys(), values(), and items() Methods](#the-keys-values-and-items-methods)\n",
    "    - [Checking Whether a Key or Value Exists in a Dictionary](#checking-whether-a-key-or-value-exists-in-a-dictionary)\n",
    "    - [The get() Method](#the-get-method)\n",
    "    - [The setdefault() Method](#the-setdefault-method)\n",
    "    - [Pretty Printing](#pretty-printing)\n",
    "- [itertools Module](#itertools-module)\n",
    "    - [accumulate()](#accumulate)\n",
    "    - [combinations()](#combinations)\n",
    "    - [combinations_with_replacement()](#combinationswithreplacement)\n",
    "    - [count()](#count)\n",
    "    - [cycle()](#cycle)\n",
    "    - [chain()](#chain)\n",
    "    - [compress()](#compress)\n",
    "    - [dropwhile()](#dropwhile)\n",
    "    - [filterfalse()](#filterfalse)\n",
    "    - [groupby()](#groupby)\n",
    "    - [islice()](#islice)\n",
    "    - [permutations()](#permutations)\n",
    "    - [product()](#product)\n",
    "    - [repeat()](#repeat)\n",
    "    - [starmap()](#starmap)\n",
    "    - [takewhile()](#takewhile)\n",
    "    - [tee()](#tee)\n",
    "    - [zip_longest()](#ziplongest)\n",
    "- [Comprehensions](#comprehensions)\n",
    "    - [List comprehension](#list-comprehension)\n",
    "    - [Set comprehension](#set-comprehension)\n",
    "    - [Dict comprehension](#dict-comprehension)\n",
    "- [Manipulating Strings](#manipulating-strings)\n",
    "    - [Escape Characters](#escape-characters)\n",
    "    - [Raw Strings](#raw-strings)\n",
    "    - [Multiline Strings with Triple Quotes](#multiline-strings-with-triple-quotes)\n",
    "    - [Indexing and Slicing Strings](#indexing-and-slicing-strings)\n",
    "    - [The in and not in Operators with Strings](#the-in-and-not-in-operators-with-strings)\n",
    "    - [The in and not in Operators with list](#the-in-and-not-in-operators-with-list)\n",
    "    - [The upper(), lower(), isupper(), and islower() String Methods](#the-upper-lower-isupper-and-islower-string-methods)\n",
    "    - [The isX String Methods](#the-isx-string-methods)\n",
    "    - [The startswith() and endswith() String Methods](#the-startswith-and-endswith-string-methods)\n",
    "    - [The join() and split() String Methods](#the-join-and-split-string-methods)\n",
    "    - [Justifying Text with rjust(), ljust(), and center()](#justifying-text-with-rjust-ljust-and-center)\n",
    "    - [Removing Whitespace with strip(), rstrip(), and lstrip()](#removing-whitespace-with-strip-rstrip-and-lstrip)\n",
    "    - [Copying and Pasting Strings with the pyperclip Module (need pip install)](#copying-and-pasting-strings-with-the-pyperclip-module-need-pip-install)\n",
    "- [String Formatting](#string-formatting)\n",
    "    - [% operator](#operator)\n",
    "    - [String Formatting (str.format)](#string-formatting-strformat)\n",
    "    - [Lazy string formatting](#lazy-string-formatting)\n",
    "    - [Formatted String Literals (Python 3.6+)](#formatted-string-literals-python-36)\n",
    "    - [Template Strings](#template-strings)\n",
    "- [Regular Expressions](#regular-expressions)\n",
    "    - [Matching Regex Objects](#matching-regex-objects)\n",
    "    - [Grouping with Parentheses](#grouping-with-parentheses)\n",
    "    - [Matching Multiple Groups with the Pipe](#matching-multiple-groups-with-the-pipe)\n",
    "    - [Optional Matching with the Question Mark](#optional-matching-with-the-question-mark)\n",
    "    - [Matching Zero or More with the Star](#matching-zero-or-more-with-the-star)\n",
    "    - [Matching One or More with the Plus](#matching-one-or-more-with-the-plus)\n",
    "    - [Matching Specific Repetitions with Curly Brackets](#matching-specific-repetitions-with-curly-brackets)\n",
    "    - [Greedy and Nongreedy Matching](#greedy-and-nongreedy-matching)\n",
    "    - [The findall() Method](#the-findall-method)\n",
    "    - [Making Your Own Character Classes](#making-your-own-character-classes)\n",
    "    - [The Caret and Dollar Sign Characters](#the-caret-and-dollar-sign-characters)\n",
    "    - [The Wildcard Character](#the-wildcard-character)\n",
    "    - [Matching Everything with Dot-Star](#matching-everything-with-dot-star)\n",
    "    - [Matching Newlines with the Dot Character](#matching-newlines-with-the-dot-character)\n",
    "    - [Review of Regex Symbols](#review-of-regex-symbols)\n",
    "    - [Case-Insensitive Matching](#case-insensitive-matching)\n",
    "    - [Substituting Strings with the sub() Method](#substituting-strings-with-the-sub-method)\n",
    "    - [Managing Complex Regexes](#managing-complex-regexes)\n",
    "- [Handling File and Directory Paths](#handling-file-and-directory-paths)\n",
    "    - [Backslash on Windows and Forward Slash on OS X and Linux](#backslash-on-windows-and-forward-slash-on-os-x-and-linux)\n",
    "    - [The Current Working Directory](#the-current-working-directory)\n",
    "    - [Creating New Folders](#creating-new-folders)\n",
    "    - [Absolute vs. Relative Paths](#absolute-vs-relative-paths)\n",
    "    - [Handling Absolute and Relative Paths](#handling-absolute-and-relative-paths)\n",
    "    - [Checking Path Validity](#checking-path-validity)\n",
    "    - [Finding File Sizes and Folder Contents](#finding-file-sizes-and-folder-contents)\n",
    "    - [Copying Files and Folders](#copying-files-and-folders)\n",
    "    - [Moving and Renaming Files and Folders](#moving-and-renaming-files-and-folders)\n",
    "    - [Permanently Deleting Files and Folders](#permanently-deleting-files-and-folders)\n",
    "    - [Safe Deletes with the send2trash Module](#safe-deletes-with-the-send2trash-module)\n",
    "    - [Walking a Directory Tree](#walking-a-directory-tree)\n",
    "- [Reading and Writing Files](#reading-and-writing-files)\n",
    "    - [The File Reading/Writing Process](#the-file-readingwriting-process)\n",
    "    - [Opening and reading files with the open() function](#opening-and-reading-files-with-the-open-function)\n",
    "    - [Writing to Files](#writing-to-files)\n",
    "    - [Saving Variables with the shelve Module](#saving-variables-with-the-shelve-module)\n",
    "    - [Saving Variables with the pprint.pformat() Function](#saving-variables-with-the-pprintpformat-function)\n",
    "    - [Reading ZIP Files](#reading-zip-files)\n",
    "    - [Extracting from ZIP Files](#extracting-from-zip-files)\n",
    "    - [Creating and Adding to ZIP Files](#creating-and-adding-to-zip-files)\n",
    "- [JSON, YAML and configuration files](#json-yaml-and-configuration-files)\n",
    "    - [JSON](#json)\n",
    "    - [YAML](#yaml)\n",
    "    - [Anyconfig](#anyconfig)\n",
    "- [Debugging](#debugging)\n",
    "    - [Raising Exceptions](#raising-exceptions)\n",
    "    - [Getting the Traceback as a String](#getting-the-traceback-as-a-string)\n",
    "    - [Assertions](#assertions)\n",
    "    - [Logging](#logging)\n",
    "    - [Logging Levels](#logging-levels)\n",
    "    - [Disabling Logging](#disabling-logging)\n",
    "    - [Logging to a File](#logging-to-a-file)\n",
    "- [Lambda Functions](#lambda-functions)\n",
    "- [Ternary Conditional Operator](#ternary-conditional-operator)\n",
    "- [Virtual Environment](#virtual-environment)\n",
    "    - [virtualenv](#virtualenv)\n",
    "    - [pipenv](#pipenv)\n",
    "\n",
    "## Python Basics\n",
    "\n",
    "### Math Operators\n",
    "\n",
    "From **Highest** to **Lowest** precedence:\n",
    "\n",
    "| Operators | Operation        | Example         |\n",
    "| --------- | ---------------- | --------------- |\n",
    "| **        | Exponent         | `2 ** 3 = 8`    |\n",
    "| %         | Modulus/Remaider | `22 % 8 = 6`    |\n",
    "| //        | Integer division | `22 // 8 = 2`   |\n",
    "| /         | Division         | `22 / 8 = 2.75` |\n",
    "| *         | Multiplication   | `3 * 3 = 9`     |\n",
    "| -         | Subtraction      | `5 - 2 = 3`     |\n",
    "| +         | Addition         | `2 + 2 = 4`     |\n",
    "\n",
    "Examples of expressions in the interactive shell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 2 + 3 * 6\n",
    "20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> (2 + 3) * 6\n",
    "30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 2 ** 8\n",
    "256"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 23 // 7\n",
    "3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 23 % 7\n",
    "2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> (5 - 1) * ((7 + 1) / (3 - 1))\n",
    "16.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Data Types\n",
    "\n",
    "| Data Type              | Examples                                  |\n",
    "| ---------------------- | ----------------------------------------- |\n",
    "| Integers               | `-2, -1, 0, 1, 2, 3, 4, 5`                |\n",
    "| Floating-point numbers | `-1.25, -1.0, --0.5, 0.0, 0.5, 1.0, 1.25` |\n",
    "| Strings                | `'a', 'aa', 'aaa', 'Hello!', '11 cats'`   |\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### String Concatenation and Replication\n",
    "\n",
    "String concatenation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Alice' 'Bob'\n",
    "'AliceBob'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: Avoid `+` operator for string concatenation. Prefer string formatting.\n",
    "\n",
    "String Replication:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Alice' * 5\n",
    "'AliceAliceAliceAliceAlice'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Variables\n",
    "\n",
    "You can name a variable anything as long as it obeys the following three rules:\n",
    "\n",
    "1. It can be only one word.\n",
    "1. It can use only letters, numbers, and the underscore (`_`) character.\n",
    "1. It can’t begin with a number.\n",
    "1. Variable name starting with an underscore (`_`) are considered as \"unuseful`.\n",
    "\n",
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = 'Hello'\n",
    ">>> spam\n",
    "'Hello'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> _spam = 'Hello'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`_spam` should not be used again in the code.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Comments\n",
    "\n",
    "Inline comment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a comment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiline comment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    "# This is a\n",
    "# multiline comment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Code with a comment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1  # initialization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please note the two spaces in front of the comment.\n",
    "\n",
    "Function docstring:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo():\n",
    "    \"\"\"\n",
    "    This is a function docstring\n",
    "    You can also use:\n",
    "    ''' Function Docstring '''\n",
    "    \"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The print() Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> print('Hello world!')\n",
    "Hello world!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> a = 1\n",
    ">>> print('Hello world!', a)\n",
    "Hello world! 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The input() Function\n",
    "\n",
    "Example Code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> print('What is your name?')   # ask for their name\n",
    ">>> myName = input()\n",
    ">>> print('It is good to meet you, {}'.format(myName))\n",
    "What is your name?\n",
    "Al\n",
    "It is good to meet you, Al"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The len() Function\n",
    "\n",
    "Evaluates to the integer value of the number of characters in a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> len('hello')\n",
    "5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: test of emptiness of strings, lists, dictionary, etc, should **not** use len, but prefer direct\n",
    "boolean evaluation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> a = [1, 2, 3]\n",
    ">>> if a:\n",
    ">>>     print(\"the list is not empty!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The str(), int(), and float() Functions\n",
    "\n",
    "Integer to String or Float:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> str(29)\n",
    "'29'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> print('I am ' + str(29) + ' years old.')\n",
    "I am 29 years old."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> str(-3.14)\n",
    "'-3.14'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Float to Integer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> int(7.7)\n",
    "7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> int(7.7) + 1\n",
    "8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "## Flow Control\n",
    "\n",
    "### Comparison Operators\n",
    "\n",
    "| Operator | Meaning                  |\n",
    "| -------- | ------------------------ |\n",
    "| `==`     | Equal to                 |\n",
    "| `!=`     | Not equal to             |\n",
    "| `<`      | Less than                |\n",
    "| `>`      | Greater Than             |\n",
    "| `<=`     | Less than or Equal to    |\n",
    "| `>=`     | Greater than or Equal to |\n",
    "\n",
    "These operators evaluate to True or False depending on the values you give them.\n",
    "\n",
    "Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 42 == 42\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 40 == 42\n",
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'hello' == 'hello'\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'hello' == 'Hello'\n",
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'dog' != 'cat'\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 42 == 42.0\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 42 == '42'\n",
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean evaluation\n",
    "\n",
    "Never use `==` or `!=` operator to evaluate boolean operation. Use the `is` or `is not` operators,\n",
    "or use implicit boolean evaluation.\n",
    "\n",
    "NO (even if they are valid Python):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> True == True\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> True != False\n",
    "True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "YES (even if they are valid Python):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> True is True\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> True is not False\n",
    "True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These statements are equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    ">>> if a is True:\n",
    ">>>    pass\n",
    ">>> if a is not False:\n",
    ">>>    pass\n",
    ">>> if a:\n",
    ">>>    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And these as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    ">>> if a is False:\n",
    ">>>    pass\n",
    ">>> if a is not True:\n",
    ">>>    pass\n",
    ">>> if not a:\n",
    ">>>    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Boolean Operators\n",
    "\n",
    "There are three Boolean operators: and, or, and not.\n",
    "\n",
    "The *and* Operator’s *Truth* Table:\n",
    "\n",
    "| Expression        | Evaluates to |\n",
    "| ----------------- | ------------ |\n",
    "| `True and True`   | `True`      |\n",
    "| `True and False`  | `False`     |\n",
    "| `False and True`  | `False`     |\n",
    "| `False and False` | `False`     |\n",
    "\n",
    "The *or* Operator’s *Truth* Table:\n",
    "\n",
    "| Expression       | Evaluates to   |\n",
    "| ---------------- | -------------- |\n",
    "| `True or True`   | `True`         |\n",
    "| `True or False`  | `True`         |\n",
    "| `False or True`  | `True`         |\n",
    "| `False or False` | `False`        |\n",
    "\n",
    "The *not* Operator’s *Truth* Table:\n",
    "\n",
    "| Expression   | Evaluates to  |\n",
    "| ------------ | ------------- |\n",
    "| `not True`   | `False`       |\n",
    "| `not False`  | `True`        |\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Mixing Boolean and Comparison Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> (4 < 5) and (5 < 6)\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> (4 < 5) and (9 < 6)\n",
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> (1 == 2) or (2 == 2)\n",
    "True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use multiple Boolean operators in an expression, along with the comparison operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 2 + 2 == 4 and not 2 + 2 == 5 and 2 * 2 == 2 + 2\n",
    "True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### if Statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if name == 'Alice':\n",
    "    print('Hi, Alice.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### else Statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'Bob'\n",
    "if name == 'Alice':\n",
    "    print('Hi, Alice.')\n",
    "else:\n",
    "    print('Hello, stranger.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### elif Statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'Bob'\n",
    "age = 5\n",
    "if name == 'Alice':\n",
    "    print('Hi, Alice.')\n",
    "elif age < 12:\n",
    "    print('You are not Alice, kiddo.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'Bob'\n",
    "age = 30\n",
    "if name == 'Alice':\n",
    "    print('Hi, Alice.')\n",
    "elif age < 12:\n",
    "    print('You are not Alice, kiddo.')\n",
    "else:\n",
    "    print('You are neither Alice nor a little kid.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### while Loop Statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spam = 0\n",
    "while spam < 5:\n",
    "    print('Hello, world.')\n",
    "    spam = spam + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### break Statements\n",
    "\n",
    " If the execution reaches a break statement, it immediately exits the while loop’s clause:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    print('Please type your name.')\n",
    "    name = input()\n",
    "    if name == 'your name':\n",
    "        break\n",
    "print('Thank you!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### continue Statements\n",
    "\n",
    "When the program execution reaches a continue statement, the program execution immediately jumps back to the start of the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    print('Who are you?')\n",
    "    name = input()\n",
    "    if name != 'Joe':\n",
    "        continue\n",
    "    print('Hello, Joe. What is the password? (It is a fish.)')\n",
    "    password = input()\n",
    "    if password == 'swordfish':\n",
    "        break\n",
    "print('Access granted.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### for Loops and the range() Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> print('My name is')\n",
    ">>> for i in range(5):\n",
    ">>>     print('Jimmy Five Times (' + str(i) + ')')\n",
    "My name is\n",
    "Jimmy Five Times (0)\n",
    "Jimmy Five Times (1)\n",
    "Jimmy Five Times (2)\n",
    "Jimmy Five Times (3)\n",
    "Jimmy Five Times (4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The *range()* function can also be called with three arguments. The first two arguments will be the start and stop values, and the third will be the step argument. The step is the amount that the variable is increased by after each iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> for i in range(0, 10, 2):\n",
    ">>>    print(i)\n",
    "0\n",
    "2\n",
    "4\n",
    "6\n",
    "8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can even use a negative number for the step argument to make the for loop count down instead of up."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> for i in range(5, -1, -1):\n",
    ">>>     print(i)\n",
    "5\n",
    "4\n",
    "3\n",
    "2\n",
    "1\n",
    "0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For else statement\n",
    "\n",
    "This allows to specify a statement to execute in case of the full loop has been executed. Only\n",
    "useful when a `break` condition can occur in the loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> for i in [1, 2, 3, 4, 5]:\n",
    ">>>    if i == 3:\n",
    ">>>        break\n",
    ">>> else:\n",
    ">>>    print(\"only executed when no item of the list is equal to 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Importing Modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "for i in range(5):\n",
    "    print(random.randint(1, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random, sys, os, math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import *."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Ending a Program Early with sys.exit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "while True:\n",
    "    print('Type exit to exit.')\n",
    "    response = input()\n",
    "    if response == 'exit':\n",
    "        sys.exit()\n",
    "    print('You typed ' + response + '.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "## Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> def hello(name):\n",
    ">>>     print('Hello ' + name)\n",
    ">>>\n",
    ">>> hello('Alice')\n",
    ">>> hello('Bob')\n",
    "Hello Alice\n",
    "Hello Bob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Return Values and return Statements\n",
    "\n",
    "When creating a function using the def statement, you can specify what the return value should be with a return statement. A return statement consists of the following:\n",
    "\n",
    "- The return keyword.\n",
    "\n",
    "- The value or expression that the function should return."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "def getAnswer(answerNumber):\n",
    "    if answerNumber == 1:\n",
    "        return 'It is certain'\n",
    "    elif answerNumber == 2:\n",
    "        return 'It is decidedly so'\n",
    "    elif answerNumber == 3:\n",
    "        return 'Yes'\n",
    "    elif answerNumber == 4:\n",
    "        return 'Reply hazy try again'\n",
    "    elif answerNumber == 5:\n",
    "        return 'Ask again later'\n",
    "    elif answerNumber == 6:\n",
    "        return 'Concentrate and ask again'\n",
    "    elif answerNumber == 7:\n",
    "        return 'My reply is no'\n",
    "    elif answerNumber == 8:\n",
    "        return 'Outlook not so good'\n",
    "    elif answerNumber == 9:\n",
    "        return 'Very doubtful'\n",
    "\n",
    "r = random.randint(1, 9)\n",
    "fortune = getAnswer(r)\n",
    "print(fortune)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The None Value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = print('Hello!')\n",
    "Hello!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam is None\n",
    "True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: never compare to `None` with the `==` operator. Always use `is`.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Keyword Arguments and print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> print('Hello', end='')\n",
    ">>> print('World')\n",
    "HelloWorld"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> print('cats', 'dogs', 'mice')\n",
    "cats dogs mice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> print('cats', 'dogs', 'mice', sep=',')\n",
    "cats,dogs,mice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Local and Global Scope\n",
    "\n",
    "- Code in the global scope cannot use any local variables.\n",
    "\n",
    "- However, a local scope can access global variables.\n",
    "\n",
    "- Code in a function’s local scope cannot use variables in any other local scope.\n",
    "\n",
    "- You can use the same name for different variables if they are in different scopes. That is, there can be a local variable named spam and a global variable also named spam.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The global Statement\n",
    "\n",
    "If you need to modify a global variable from within a function, use the global statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> def spam():\n",
    ">>>     global eggs\n",
    ">>>     eggs = 'spam'\n",
    ">>>\n",
    ">>> eggs = 'global'\n",
    ">>> spam()\n",
    ">>> print(eggs)\n",
    "spam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are four rules to tell whether a variable is in a local scope or global scope:\n",
    "\n",
    "1. If a variable is being used in the global scope (that is, outside of all functions), then it is always a global variable.\n",
    "\n",
    "1. If there is a global statement for that variable in a function, it is a global variable.\n",
    "\n",
    "1. Otherwise, if the variable is used in an assignment statement in the function, it is a local variable.\n",
    "\n",
    "1. But if the variable is not used in an assignment statement, it is a global variable.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "## Exception Handling\n",
    "\n",
    "### Basic exception handling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> def spam(divideBy):\n",
    ">>>     try:\n",
    ">>>         return 42 / divideBy\n",
    ">>>     except ZeroDivisionError as e:\n",
    ">>>         print('Error: Invalid argument: {}'.format(e))\n",
    ">>>\n",
    ">>> print(spam(2))\n",
    ">>> print(spam(12))\n",
    ">>> print(spam(0))\n",
    ">>> print(spam(1))\n",
    "21.0\n",
    "3.5\n",
    "Error: Invalid argument: division by zero\n",
    "None\n",
    "42.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Final code in exception handling\n",
    "\n",
    "Code inside the `finally` section is always executed, no matter if an exception has been raised or\n",
    "not, and even if an exception is not caught."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> def spam(divideBy):\n",
    ">>>     try:\n",
    ">>>         return 42 / divideBy\n",
    ">>>     except ZeroDivisionError as e:\n",
    ">>>         print('Error: Invalid argument: {}'.format(e))\n",
    ">>>     finally:\n",
    ">>>         print(\"-- division finished --\")\n",
    ">>> print(spam(12))\n",
    ">>> print(spam(0))\n",
    "21.0\n",
    "-- division finished --\n",
    "3.5\n",
    "-- division finished --\n",
    "Error: Invalid argument: division by zero\n",
    "-- division finished --\n",
    "None\n",
    "-- division finished --\n",
    "42.0\n",
    "-- division finished --"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "## Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = ['cat', 'bat', 'rat', 'elephant']\n",
    "\n",
    ">>> spam\n",
    "['cat', 'bat', 'rat', 'elephant']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Getting Individual Values in a List with Indexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = ['cat', 'bat', 'rat', 'elephant']\n",
    ">>> spam[0]\n",
    "'cat'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam[1]\n",
    "'bat'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam[2]\n",
    "'rat'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam[3]\n",
    "'elephant'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Negative Indexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = ['cat', 'bat', 'rat', 'elephant']\n",
    ">>> spam[-1]\n",
    "'elephant'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam[-3]\n",
    "'bat'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'The ' + spam[-1] + ' is afraid of the ' + spam[-3] + '.'\n",
    "'The elephant is afraid of the bat.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Getting Sublists with Slices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = ['cat', 'bat', 'rat', 'elephant']\n",
    ">>> spam[0:4]\n",
    "['cat', 'bat', 'rat', 'elephant']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam[1:3]\n",
    "['bat', 'rat']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam[0:-1]\n",
    "['cat', 'bat', 'rat']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = ['cat', 'bat', 'rat', 'elephant']\n",
    ">>> spam[:2]\n",
    "['cat', 'bat']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam[1:]\n",
    "['bat', 'rat', 'elephant']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam[:]\n",
    "['cat', 'bat', 'rat', 'elephant']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Getting a List’s Length with len()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = ['cat', 'dog', 'moose']\n",
    ">>> len(spam)\n",
    "3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Changing Values in a List with Indexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = ['cat', 'bat', 'rat', 'elephant']\n",
    ">>> spam[1] = 'aardvark'\n",
    "\n",
    ">>> spam\n",
    "['cat', 'aardvark', 'rat', 'elephant']\n",
    "\n",
    ">>> spam[2] = spam[1]\n",
    "\n",
    ">>> spam\n",
    "['cat', 'aardvark', 'aardvark', 'elephant']\n",
    "\n",
    ">>> spam[-1] = 12345\n",
    "\n",
    ">>> spam\n",
    "['cat', 'aardvark', 'aardvark', 12345]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### List Concatenation and List Replication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> [1, 2, 3] + ['A', 'B', 'C']\n",
    "[1, 2, 3, 'A', 'B', 'C']\n",
    "\n",
    ">>> ['X', 'Y', 'Z'] * 3\n",
    "['X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z']\n",
    "\n",
    ">>> spam = [1, 2, 3]\n",
    "\n",
    ">>> spam = spam + ['A', 'B', 'C']\n",
    "\n",
    ">>> spam\n",
    "[1, 2, 3, 'A', 'B', 'C']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Removing Values from Lists with del Statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = ['cat', 'bat', 'rat', 'elephant']\n",
    ">>> del spam[2]\n",
    ">>> spam\n",
    "['cat', 'bat', 'elephant']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> del spam[2]\n",
    ">>> spam\n",
    "['cat', 'bat']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Using for Loops with Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> supplies = ['pens', 'staplers', 'flame-throwers', 'binders']\n",
    ">>> for i, supply in enumerate(supplies):\n",
    ">>>     print('Index ' + str(i) + ' in supplies is: ' + supply)\n",
    "Index 0 in supplies is: pens\n",
    "Index 1 in supplies is: staplers\n",
    "Index 2 in supplies is: flame-throwers\n",
    "Index 3 in supplies is: binders"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Looping Through Multiple Lists with zip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> name = ['Pete', 'John', 'Elizabeth']\n",
    ">>> age = [6, 23, 44]\n",
    ">>> for n, a in zip(name, age):\n",
    ">>>     print('{} is {} years old'.format(n, a))\n",
    "Pete is 6 years old\n",
    "John is 23 years old\n",
    "Alice is 44 years old"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The in and not in Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'howdy' in ['hello', 'hi', 'howdy', 'heyas']\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = ['hello', 'hi', 'howdy', 'heyas']\n",
    ">>> 'cat' in spam\n",
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'howdy' not in spam\n",
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'cat' not in spam\n",
    "True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The Multiple Assignment Trick\n",
    "\n",
    "The multiple assignment trick is a shortcut that lets you assign multiple variables with the values in a list in one line of code. So instead of doing this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> cat = ['fat', 'orange', 'loud']\n",
    "\n",
    ">>> size = cat[0]\n",
    "\n",
    ">>> color = cat[1]\n",
    "\n",
    ">>> disposition = cat[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You could type this line of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> cat = ['fat', 'orange', 'loud']\n",
    "\n",
    ">>> size, color, disposition = cat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The multiple assignment trick can also be used to swap the values in two variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> a, b = 'Alice', 'Bob'\n",
    ">>> a, b = b, a\n",
    ">>> print(a)\n",
    "'Bob'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> print(b)\n",
    "'Alice'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Augmented Assignment Operators\n",
    "\n",
    "| Operator    | Equivalent        |\n",
    "| ----------- | ----------------- |\n",
    "| `spam += 1` | `spam = spam + 1` |\n",
    "| `spam -= 1` | `spam = spam - 1` |\n",
    "| `spam *= 1` | `spam = spam * 1` |\n",
    "| `spam /= 1` | `spam = spam / 1` |\n",
    "| `spam %= 1` | `spam = spam % 1` |\n",
    "\n",
    "Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = 'Hello'\n",
    ">>> spam += ' world!'\n",
    ">>> spam\n",
    "'Hello world!'\n",
    "\n",
    ">>> bacon = ['Zophie']\n",
    ">>> bacon *= 3\n",
    ">>> bacon\n",
    "['Zophie', 'Zophie', 'Zophie']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Finding a Value in a List with the index() Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = ['Zophie', 'Pooka', 'Fat-tail', 'Pooka']\n",
    "\n",
    ">>> spam.index('Pooka')\n",
    "1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Adding Values to Lists with the append() and insert() Methods\n",
    "\n",
    "**append()**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = ['cat', 'dog', 'bat']\n",
    "\n",
    ">>> spam.append('moose')\n",
    "\n",
    ">>> spam\n",
    "['cat', 'dog', 'bat', 'moose']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**insert()**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = ['cat', 'dog', 'bat']\n",
    "\n",
    ">>> spam.insert(1, 'chicken')\n",
    "\n",
    ">>> spam\n",
    "['cat', 'chicken', 'dog', 'bat']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Removing Values from Lists with remove()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = ['cat', 'bat', 'rat', 'elephant']\n",
    "\n",
    ">>> spam.remove('bat')\n",
    "\n",
    ">>> spam\n",
    "['cat', 'rat', 'elephant']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the value appears multiple times in the list, only the first instance of the value will be removed.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Sorting the Values in a List with the sort() Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = [2, 5, 3.14, 1, -7]\n",
    ">>> spam.sort()\n",
    ">>> spam\n",
    "[-7, 1, 2, 3.14, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = ['ants', 'cats', 'dogs', 'badgers', 'elephants']\n",
    ">>> spam.sort()\n",
    ">>> spam\n",
    "['ants', 'badgers', 'cats', 'dogs', 'elephants']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also pass True for the reverse keyword argument to have sort() sort the values in reverse order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam.sort(reverse=True)\n",
    ">>> spam\n",
    "['elephants', 'dogs', 'cats', 'badgers', 'ants']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you need to sort the values in regular alphabetical order, pass str. lower for the key keyword argument in the sort() method call:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = ['a', 'z', 'A', 'Z']\n",
    ">>> spam.sort(key=str.lower)\n",
    ">>> spam\n",
    "['a', 'A', 'z', 'Z']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use the built-in function `sorted` to return a new list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = ['ants', 'cats', 'dogs', 'badgers', 'elephants']\n",
    ">>> sorted(spam)\n",
    "['ants', 'badgers', 'cats', 'dogs', 'elephants']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Tuple Data Type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> eggs = ('hello', 42, 0.5)\n",
    ">>> eggs[0]\n",
    "'hello'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> eggs[1:3]\n",
    "(42, 0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> len(eggs)\n",
    "3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The main way that tuples are different from lists is that tuples, like strings, are immutable.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Converting Types with the list() and tuple() Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> tuple(['cat', 'dog', 5])\n",
    "('cat', 'dog', 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> list(('cat', 'dog', 5))\n",
    "['cat', 'dog', 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> list('hello')\n",
    "['h', 'e', 'l', 'l', 'o']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "## Dictionaries and Structuring Data\n",
    "\n",
    "Example Dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myCat = {'size': 'fat', 'color': 'gray', 'disposition': 'loud'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The keys(), values(), and items() Methods\n",
    "\n",
    "values():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = {'color': 'red', 'age': 42}\n",
    ">>> for v in spam.values():\n",
    ">>>     print(v)\n",
    "red\n",
    "42"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "keys():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> for k in spam.keys():\n",
    ">>>     print(k)\n",
    "color\n",
    "age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "items():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> for i in spam.items():\n",
    ">>>     print(i)\n",
    "('color', 'red')\n",
    "('age', 42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the keys(), values(), and items() methods, a for loop can iterate over the keys, values, or key-value pairs in a dictionary, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    ">>> spam = {'color': 'red', 'age': 42}\n",
    ">>>\n",
    ">>> for k, v in spam.items():\n",
    ">>>     print('Key: ' + k + ' Value: ' + str(v))\n",
    "Key: age Value: 42\n",
    "Key: color Value: red"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Checking Whether a Key or Value Exists in a Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = {'name': 'Zophie', 'age': 7}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'name' in spam.keys()\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Zophie' in spam.values()\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> # You can omit the call to keys() when checking for a key\n",
    ">>> 'color' in spam\n",
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'color' not in spam\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'color' in spam\n",
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The get() Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> picnic_items = {'apples': 5, 'cups': 2}\n",
    "\n",
    ">>> 'I am bringing ' + str(picnic_items.get('cups', 0)) + ' cups.'\n",
    "'I am bringing 2 cups.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'I am bringing ' + str(picnic_items.get('eggs', 0)) + ' eggs.'\n",
    "'I am bringing 0 eggs.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The setdefault() Method\n",
    "\n",
    "Let's consider this code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spam = {'name': 'Pooka', 'age': 5}\n",
    "\n",
    "if 'color' not in spam:\n",
    "    spam['color'] = 'black'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `setdefault` we could make the same code more shortly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = {'name': 'Pooka', 'age': 5}\n",
    ">>> spam.setdefault('color', 'black')\n",
    "'black'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam\n",
    "{'color': 'black', 'age': 5, 'name': 'Pooka'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam.setdefault('color', 'white')\n",
    "'black'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam\n",
    "{'color': 'black', 'age': 5, 'name': 'Pooka'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Pretty Printing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import pprint\n",
    ">>>\n",
    ">>> message = 'It was a bright cold day in April, and the clocks were striking\n",
    ">>> thirteen.'\n",
    ">>> count = {}\n",
    ">>>\n",
    ">>> for character in message:\n",
    ">>>     count.setdefault(character, 0)\n",
    ">>>     count[character] = count[character] + 1\n",
    ">>>\n",
    ">>> pprint.pprint(count)\n",
    "{' ': 13,\n",
    " ',': 1,\n",
    " '.': 1,\n",
    " 'A': 1,\n",
    " 'I': 1,\n",
    " 'a': 4,\n",
    " 'b': 1,\n",
    " 'c': 3,\n",
    " 'd': 3,\n",
    " 'e': 5,\n",
    " 'g': 2,\n",
    " 'h': 3,\n",
    " 'i': 6,\n",
    " 'k': 2,\n",
    " 'l': 3,\n",
    " 'n': 4,\n",
    " 'o': 2,\n",
    " 'p': 1,\n",
    " 'r': 5,\n",
    " 's': 3,\n",
    " 't': 6,\n",
    " 'w': 2,\n",
    " 'y': 1}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "## itertools Module\n",
    "\n",
    "The *itertools* module is a colection of tools intented to be fast and use memory efficiently when handling iterators (like [lists](#lists) or [dictionaries](#dictionaries-and-structuring-data)).\n",
    "\n",
    "From the official [Python 3.x documentation](https://docs.python.org/3/library/itertools.html):\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",
    "The *itertools* module comes in the standard library and must be imported.\n",
    "\n",
    "The [operator](https://docs.python.org/3/library/operator.html) module will also be used. This module is not necessary when using itertools, but needed for some of the examples below.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### accumulate()\n",
    "\n",
    "Makes an iterator that returns the results of a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "itertools.accumulate(iterable[, func])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> data = [1, 2, 3, 4, 5]\n",
    ">>> result = itertools.accumulate(data, operator.mul)\n",
    ">>> for each in result:\n",
    ">>>    print(each)\n",
    "1\n",
    "2\n",
    "6\n",
    "24\n",
    "120"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The operator.mul takes two numbers and multiplies them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "operator.mul(1, 2)\n",
    "2\n",
    "operator.mul(2, 3)\n",
    "6\n",
    "operator.mul(6, 4)\n",
    "24\n",
    "operator.mul(24, 5)\n",
    "120"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Passing a function is optional:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> data = [5, 2, 6, 4, 5, 9, 1]\n",
    ">>> result = itertools.accumulate(data)\n",
    ">>> for each in result:\n",
    ">>>    print(each)\n",
    "5\n",
    "7\n",
    "13\n",
    "17\n",
    "22\n",
    "31\n",
    "32"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If no function is designated the items will be summed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5\n",
    "5 + 2 = 7\n",
    "7 + 6 = 13\n",
    "13 + 4 = 17\n",
    "17 + 5 = 22\n",
    "22 + 9 = 31\n",
    "31 + 1 = 32"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### combinations()\n",
    "\n",
    "Takes an iterable and a integer. This will create all the unique combination that have r members."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "itertools.combinations(iterable, r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> shapes = ['circle', 'triangle', 'square',]\n",
    ">>> result = itertools.combinations(shapes, 2)\n",
    ">>> for each in result:\n",
    ">>>    print(each)\n",
    "('circle', 'triangle')\n",
    "('circle', 'square')\n",
    "('triangle', 'square')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### combinations_with_replacement()\n",
    "\n",
    "Just like combinations(), but allows individual elements to be repeated more than once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "itertools.combinations_with_replacement(iterable, r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> shapes = ['circle', 'triangle', 'square']\n",
    ">>> result = itertools.combinations_with_replacement(shapes, 2)\n",
    ">>> for each in result:\n",
    ">>>    print(each)\n",
    "('circle', 'circle')\n",
    "('circle', 'triangle')\n",
    "('circle', 'square')\n",
    "('triangle', 'triangle')\n",
    "('triangle', 'square')\n",
    "('square', 'square')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### count()\n",
    "\n",
    "Makes an iterator that returns evenly spaced values starting with number start."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "itertools.count(start=0, step=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> for i in itertools.count(10,3):\n",
    ">>>    print(i)\n",
    ">>>    if i > 20:\n",
    ">>>        break\n",
    "10\n",
    "13\n",
    "16\n",
    "19\n",
    "22"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### cycle()\n",
    "\n",
    "This function cycles through an iterator endlessly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "itertools.cycle(iterable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> colors = ['red', 'orange', 'yellow', 'green', 'blue', 'violet']\n",
    ">>> for color in itertools.cycle(colors):\n",
    ">>>    print(color)\n",
    "red\n",
    "orange\n",
    "yellow\n",
    "green\n",
    "blue\n",
    "violet\n",
    "red\n",
    "orange"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When reached the end of the iterable it start over again from the beginning.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### chain()\n",
    "\n",
    "Take a series of iterables and return them as one long iterable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "itertools.chain(*iterables)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> colors = ['red', 'orange', 'yellow', 'green', 'blue']\n",
    ">>> shapes = ['circle', 'triangle', 'square', 'pentagon']\n",
    ">>> result = itertools.chain(colors, shapes)\n",
    ">>> for each in result:\n",
    ">>>    print(each)\n",
    "red\n",
    "orange\n",
    "yellow\n",
    "green\n",
    "blue\n",
    "circle\n",
    "triangle\n",
    "square\n",
    "pentagon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### compress()\n",
    "\n",
    "Filters one iterable with another."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "itertools.compress(data, selectors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> shapes = ['circle', 'triangle', 'square', 'pentagon']\n",
    ">>> selections = [True, False, True, False]\n",
    ">>> result = itertools.compress(shapes, selections)\n",
    ">>> for each in result:\n",
    ">>>    print(each)\n",
    "circle\n",
    "square"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### dropwhile()\n",
    "\n",
    "Make an iterator that drops elements from the iterable as long as the predicate is true; afterwards, returns every element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "itertools.dropwhile(predicate, iterable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1]\n",
    ">>> result = itertools.dropwhile(lambda x: x<5, data)\n",
    ">>> for each in result:\n",
    ">>>    print(each)\n",
    "5\n",
    "6\n",
    "7\n",
    "8\n",
    "9\n",
    "10\n",
    "1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### filterfalse()\n",
    "\n",
    "Makes an iterator that filters elements from iterable returning only those for which the predicate is False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "itertools.filterfalse(predicate, iterable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    ">>> result = itertools.filterfalse(lambda x: x<5, data)\n",
    ">>> for each in result:\n",
    ">>>    print(each)\n",
    "5\n",
    "6\n",
    "7\n",
    "8\n",
    "9\n",
    "10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### groupby()\n",
    "\n",
    "Simply put, this function groups things together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "itertools.groupby(iterable, key=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> robots = [{\n",
    "    'name': 'blaster',\n",
    "    'faction': 'autobot'\n",
    "}, {\n",
    "    'name': 'galvatron',\n",
    "    'faction': 'decepticon'\n",
    "}, {\n",
    "    'name': 'jazz',\n",
    "    'faction': 'autobot'\n",
    "}, {\n",
    "    'name': 'metroplex',\n",
    "    'faction': 'autobot'\n",
    "}, {\n",
    "    'name': 'megatron',\n",
    "    'faction': 'decepticon'\n",
    "}, {\n",
    "    'name': 'starcream',\n",
    "    'faction': 'decepticon'\n",
    "}]\n",
    ">>> for key, group in itertools.groupby(robots, key=lambda x: x['faction']):\n",
    ">>>    print(key)\n",
    ">>>    print(list(group))\n",
    "autobot\n",
    "[{'name': 'blaster', 'faction': 'autobot'}]\n",
    "decepticon\n",
    "[{'name': 'galvatron', 'faction': 'decepticon'}]\n",
    "autobot\n",
    "[{'name': 'jazz', 'faction': 'autobot'}, {'name': 'metroplex', 'faction': 'autobot'}]\n",
    "decepticon\n",
    "[{'name': 'megatron', 'faction': 'decepticon'}, {'name': 'starcream', 'faction': 'decepticon'}]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### islice()\n",
    "\n",
    "This function is very much like slices. This allows you to cut out a piece of an iterable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "itertools.islice(iterable, start, stop[, step])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> colors = ['red', 'orange', 'yellow', 'green', 'blue',]\n",
    ">>> few_colors = itertools.islice(colors, 2)\n",
    ">>> for each in few_colors:\n",
    ">>>    print(each)\n",
    "red\n",
    "orange"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### permutations()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "itertools.permutations(iterable, r=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> alpha_data = ['a', 'b', 'c']\n",
    ">>> result = itertools.permutations(alpha_data)\n",
    ">>> for each in result:\n",
    ">>>    print(each)\n",
    "('a', 'b', 'c')\n",
    "('a', 'c', 'b')\n",
    "('b', 'a', 'c')\n",
    "('b', 'c', 'a')\n",
    "('c', 'a', 'b')\n",
    "('c', 'b', 'a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### product()\n",
    "\n",
    "Creates the cartesian products from a series of iterables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> num_data = [1, 2, 3]\n",
    ">>> alpha_data = ['a', 'b', 'c']\n",
    ">>> result = itertools.product(num_data, alpha_data)\n",
    ">>> for each in result:\n",
    "    print(each)\n",
    "(1, 'a')\n",
    "(1, 'b')\n",
    "(1, 'c')\n",
    "(2, 'a')\n",
    "(2, 'b')\n",
    "(2, 'c')\n",
    "(3, 'a')\n",
    "(3, 'b')\n",
    "(3, 'c')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### repeat()\n",
    "\n",
    "This function will repeat an object over and over again. Unless, there is a times argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "itertools.repeat(object[, times])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> for i in itertools.repeat(\"spam\", 3):\n",
    "    print(i)\n",
    "spam\n",
    "spam\n",
    "spam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### starmap()\n",
    "\n",
    "Makes an iterator that computes the function using arguments obtained from the iterable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "itertools.starmap(function, iterable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> data = [(2, 6), (8, 4), (7, 3)]\n",
    ">>> result = itertools.starmap(operator.mul, data)\n",
    ">>> for each in result:\n",
    ">>>    print(each)\n",
    "12\n",
    "32\n",
    "21"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### takewhile()\n",
    "\n",
    "The opposite of dropwhile(). Makes an iterator and returns elements from the iterable as long as the predicate is true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "itertools.takwwhile(predicate, iterable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1]\n",
    ">>> result = itertools.takewhile(lambda x: x<5, data)\n",
    ">>> for each in result:\n",
    ">>>    print(each)\n",
    "1\n",
    "2\n",
    "3\n",
    "4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### tee()\n",
    "\n",
    "Return n independent iterators from a single iterable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "itertools.tee(iterable, n=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> colors = ['red', 'orange', 'yellow', 'green', 'blue']\n",
    ">>> alpha_colors, beta_colors = itertools.tee(colors)\n",
    ">>> for each in alpha_colors:\n",
    ">>>    print(each)\n",
    "red\n",
    "orange\n",
    "yellow\n",
    "green\n",
    "blue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> colors = ['red', 'orange', 'yellow', 'green', 'blue']\n",
    ">>> alpha_colors, beta_colors = itertools.tee(colors)\n",
    ">>> for each in beta_colors:\n",
    ">>>    print(each)\n",
    "red\n",
    "orange\n",
    "yellow\n",
    "green\n",
    "blue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### zip_longest()\n",
    "\n",
    "Makes an iterator that aggregates elements from each of the iterables. If the iterables are of uneven length, missing values are filled-in with fillvalue. Iteration continues until the longest iterable is exhausted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "itertools.zip_longest(*iterables, fillvalue=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> colors = ['red', 'orange', 'yellow', 'green', 'blue',]\n",
    ">>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,]\n",
    ">>> for each in itertools.zip_longest(colors, data, fillvalue=None):\n",
    ">>>    print(each)\n",
    "('red', 1)\n",
    "('orange', 2)\n",
    "('yellow', 3)\n",
    "('green', 4)\n",
    "('blue', 5)\n",
    "(None, 6)\n",
    "(None, 7)\n",
    "(None, 8)\n",
    "(None, 9)\n",
    "(None, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "## Comprehensions\n",
    "\n",
    "### List comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> a = [1, 3, 5, 7, 9, 11]\n",
    "\n",
    ">>> [i - 1 for i in a]\n",
    "[0, 2, 4, 6, 8, 10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> b = {\"abc\", \"def\"}\n",
    ">>> {s.upper() for s in b}\n",
    "{\"ABC\", \"DEF}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dict comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> c = {'name': 'Pooka', 'age': 5}\n",
    ">>> {v, k for k, v in c.items()}\n",
    "{'Pooka': 'name', 5: 'age'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A List comprehension can be generated from a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> c = {'name': 'Pooka', 'first_name': 'Oooka'}\n",
    ">>> [\"{}:{}\".format(k.upper(), v.upper()) for k, v in c.items()]\n",
    "['NAME:POOKA', 'FIRST_NAME:OOOKA']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manipulating Strings\n",
    "\n",
    "### Escape Characters\n",
    "\n",
    "| Escape character   | Prints as            |\n",
    "| ------------------ | -------------------- |\n",
    "| `\\'`               | Single quote         |\n",
    "| `\\\"`               | Double quote         |\n",
    "| `\\t`               | Tab                  |\n",
    "| `\\n`               | Newline (line break) |\n",
    "| `\\\\`               | Backslash            |\n",
    "\n",
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> print(\"Hello there!\\nHow are you?\\nI\\'m doing fine.\")\n",
    "Hello there!\n",
    "How are you?\n",
    "I'm doing fine."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Raw Strings\n",
    "\n",
    "A raw string completely ignores all escape characters and prints any backslash that appears in the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> print(r'That is Carol\\'s cat.')\n",
    "That is Carol\\'s cat."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "Note: mostly used for regular expression definition (see `re` package)\n",
    "\n",
    "### Multiline Strings with Triple Quotes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> print('''Dear Alice,\n",
    ">>>\n",
    ">>> Eve's cat has been arrested for catnapping, cat burglary, and extortion.\n",
    ">>>\n",
    ">>> Sincerely,\n",
    ">>> Bob''')\n",
    "Dear Alice,\n",
    "\n",
    "Eve's cat has been arrested for catnapping, cat burglary, and extortion.\n",
    "\n",
    "Sincerely,\n",
    "Bob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To keep a nicer flow in your code, you can use the `dedent` function from the `textwrap` standard package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> from textwrap import dedent\n",
    ">>>\n",
    ">>> def my_function():\n",
    ">>>     print('''\n",
    ">>>         Dear Alice,\n",
    ">>>\n",
    ">>>         Eve's cat has been arrested for catnapping, cat burglary, and extortion.\n",
    ">>>\n",
    ">>>         Sincerely,\n",
    ">>>         Bob\n",
    ">>>         ''').strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This generates the same string than before.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Indexing and Slicing Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H   e   l   l   o       w   o   r   l   d    !\n",
    "0   1   2   3   4   5   6   7   8   9   10   11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = 'Hello world!'\n",
    "\n",
    ">>> spam[0]\n",
    "'H'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam[4]\n",
    "'o'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam[-1]\n",
    "'!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    ">>> spam[0:5]\n",
    "'Hello'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam[:5]\n",
    "'Hello'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam[6:]\n",
    "'world!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam[6:-1]\n",
    "'world'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam[:-1]\n",
    "'Hello world'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam[::-1]\n",
    "'!dlrow olleH'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = 'Hello world!'\n",
    ">>> fizz = spam[0:5]\n",
    ">>> fizz\n",
    "'Hello'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The in and not in Operators with Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Hello' in 'Hello World'\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Hello' in 'Hello'\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'HELLO' in 'Hello World'\n",
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> '' in 'spam'\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'cats' not in 'cats and dogs'\n",
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The in and not in Operators with list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> a = [1, 2, 3, 4]\n",
    ">>> 5 in a\n",
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 2 in a\n",
    "True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The upper(), lower(), isupper(), and islower() String Methods\n",
    "\n",
    "`upper()` and `lower()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = 'Hello world!'\n",
    ">>> spam = spam.upper()\n",
    ">>> spam\n",
    "'HELLO WORLD!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = spam.lower()\n",
    ">>> spam\n",
    "'hello world!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "isupper() and islower():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = 'Hello world!'\n",
    ">>> spam.islower()\n",
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam.isupper()\n",
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'HELLO'.isupper()\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'abc12345'.islower()\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> '12345'.islower()\n",
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> '12345'.isupper()\n",
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The isX String Methods\n",
    "\n",
    "- **isalpha()** returns True if the string consists only of letters and is not blank.\n",
    "- **isalnum()** returns True if the string consists only of lettersand numbers and is not blank.\n",
    "- **isdecimal()** returns True if the string consists only ofnumeric characters and is not blank.\n",
    "- **isspace()** returns True if the string consists only of spaces,tabs, and new-lines and is not blank.\n",
    "- **istitle()** returns True if the string consists only of wordsthat begin with an uppercase letter followed by onlylowercase letters.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The startswith() and endswith() String Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Hello world!'.startswith('Hello')\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Hello world!'.endswith('world!')\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'abc123'.startswith('abcdef')\n",
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'abc123'.endswith('12')\n",
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Hello world!'.startswith('Hello world!')\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Hello world!'.endswith('Hello world!')\n",
    "True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The join() and split() String Methods\n",
    "\n",
    "join():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> ', '.join(['cats', 'rats', 'bats'])\n",
    "'cats, rats, bats'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> ' '.join(['My', 'name', 'is', 'Simon'])\n",
    "'My name is Simon'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'ABC'.join(['My', 'name', 'is', 'Simon'])\n",
    "'MyABCnameABCisABCSimon'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "split():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'My name is Simon'.split()\n",
    "['My', 'name', 'is', 'Simon']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'MyABCnameABCisABCSimon'.split('ABC')\n",
    "['My', 'name', 'is', 'Simon']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'My name is Simon'.split('m')\n",
    "['My na', 'e is Si', 'on']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Justifying Text with rjust(), ljust(), and center()\n",
    "\n",
    "rjust() and ljust():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Hello'.rjust(10)\n",
    "'     Hello'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Hello'.rjust(20)\n",
    "'               Hello'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Hello World'.rjust(20)\n",
    "'         Hello World'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Hello'.ljust(10)\n",
    "'Hello     '"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An optional second argument to rjust() and ljust() will specify a fill character other than a space character. Enter the following into the interactive shell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Hello'.rjust(20, '*')\n",
    "'***************Hello'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Hello'.ljust(20, '-')\n",
    "'Hello---------------'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "center():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Hello'.center(20)\n",
    "'       Hello       '"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Hello'.center(20, '=')\n",
    "'=======Hello========'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Removing Whitespace with strip(), rstrip(), and lstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = '    Hello World     '\n",
    ">>> spam.strip()\n",
    "'Hello World'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam.lstrip()\n",
    "'Hello World '"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam.rstrip()\n",
    "'    Hello World'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spam = 'SpamSpamBaconSpamEggsSpamSpam'\n",
    ">>> spam.strip('ampS')\n",
    "'BaconSpamEggs'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Copying and Pasting Strings with the pyperclip Module (need pip install)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import pyperclip\n",
    "\n",
    ">>> pyperclip.copy('Hello world!')\n",
    "\n",
    ">>> pyperclip.paste()\n",
    "'Hello world!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "## String Formatting\n",
    "\n",
    "### % operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> name = 'Pete'\n",
    ">>> 'Hello %s' % name\n",
    "\"Hello Pete\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the `%x` format specifier to convert an int value to a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> num = 5\n",
    ">>> 'I have %x apples' % num\n",
    "\"I have 5 apples\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: For new code prefere using str.format over the `%` operator.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### String Formatting (str.format)\n",
    "\n",
    "Python 3 introduced a new way to do string formatting that was later back-ported to Python 2.7. This makes the syntax for string formatting more regular."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> name = 'John'\n",
    ">>> age = 20'\n",
    "\n",
    ">>> \"Hello I'm {}, my age is {}\".format(name, age)\n",
    "\"Hello I'm John, my age is 20\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> \"Hello I'm {0}, my age is {1}\".format(name, age)\n",
    "\"Hello I'm John, my age is 20\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The official [Python 3.x documentation](https://docs.python.org/3/library/stdtypes.html?highlight=sprintf#printf-style-string-formatting) recommend `str.format` over the `%` operator:\n",
    "\n",
    "> The formatting operations described here exhibit a variety of quirks that lead to a number of common errors (such as failing to display tuples and dictionaries correctly). Using the newer formatted string literals or the str.format() interface helps avoid these errors. These alternatives also provide more powerful, flexible and extensible approaches to formatting text.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Lazy string formatting\n",
    "\n",
    "You would only use `%s` string formatting on functions that can do lazy parameters evaluation,\n",
    "the most common being logging:\n",
    "\n",
    "Prefer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> name = \"alice\"\n",
    ">>> logging.debug(\"User name: %s\", name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Over:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> logging.debug(\"User name: {}\".format(name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> logging.debug(\"User name: \" + name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Formatted String Literals (Python 3.6+)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> name = 'Elizabeth'\n",
    ">>> f'Hello {name}!'\n",
    "'Hello Elizabeth!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is even possible to do inline arithmetic with it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> a = 5\n",
    ">>> b = 10\n",
    ">>> f'Five plus ten is {a + b} and not {2 * (a + b)}.'\n",
    "'Five plus ten is 15 and not 30.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Template Strings\n",
    "\n",
    " A simpler and less powerful mechanism, but it is recommended when handling format strings generated by users. Due to their reduced complexity template strings are a safer choice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> from string import Template\n",
    ">>> name = 'Elizabeth'\n",
    ">>> t = Template('Hey $name!')\n",
    ">>> t.substitute(name=name)\n",
    "'Hey Elizabeth!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "## Regular Expressions\n",
    "\n",
    "1. Import the regex module with `import re`.\n",
    "1. Create a Regex object with the `re.compile()` function. (Remember to use a raw string.)\n",
    "1. Pass the string you want to search into the Regex object’s `search()` method. This returns a `Match` object.\n",
    "1. Call the Match object’s `group()` method to return a string of the actual matched text.\n",
    "\n",
    "All the regex functions in Python are in the re module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import re"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Matching Regex Objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> phone_num_regex = re.compile(r'\\d\\d\\d-\\d\\d\\d-\\d\\d\\d\\d')\n",
    "\n",
    ">>> mo = phone_num_regex.search('My number is 415-555-4242.')\n",
    "\n",
    ">>> print('Phone number found: ' + mo.group())\n",
    "Phone number found: 415-555-4242"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Grouping with Parentheses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> phone_num_regex = re.compile(r'(\\d\\d\\d)-(\\d\\d\\d-\\d\\d\\d\\d)')\n",
    "\n",
    ">>> mo = phone_num_regex.search('My number is 415-555-4242.')\n",
    "\n",
    ">>> mo.group(1)\n",
    "'415'\n",
    "\n",
    ">>> mo.group(2)\n",
    "'555-4242'\n",
    "\n",
    ">>> mo.group(0)\n",
    "'415-555-4242'\n",
    "\n",
    ">>> mo.group()\n",
    "'415-555-4242'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To retrieve all the groups at once: use the groups() method—note the plural form for the name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> mo.groups()\n",
    "('415', '555-4242')\n",
    "\n",
    ">>> area_code, main_number = mo.groups()\n",
    "\n",
    ">>> print(area_code)\n",
    "415\n",
    "\n",
    ">>> print(main_number)\n",
    "555-4242"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Matching Multiple Groups with the Pipe\n",
    "\n",
    "The | character is called a pipe. You can use it anywhere you want to match one of many expressions. For example, the regular expression r'Batman|Tina Fey' will match either 'Batman' or 'Tina Fey'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> hero_regex = re.compile (r'Batman|Tina Fey')\n",
    "\n",
    ">>> mo1 = hero_regex.search('Batman and Tina Fey.')\n",
    "\n",
    ">>> mo1.group()\n",
    "'Batman'\n",
    "\n",
    ">>> mo2 = hero_regex.search('Tina Fey and Batman.')\n",
    "\n",
    ">>> mo2.group()\n",
    "'Tina Fey'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use the pipe to match one of several patterns as part of your regex:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> bat_regex = re.compile(r'Bat(man|mobile|copter|bat)')\n",
    "\n",
    ">>> mo = bat_regex.search('Batmobile lost a wheel')\n",
    "\n",
    ">>> mo.group()\n",
    "'Batmobile'\n",
    "\n",
    ">>> mo.group(1)\n",
    "'mobile'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Optional Matching with the Question Mark\n",
    "\n",
    "The ? character flags the group that precedes it as an optional part of the pattern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> bat_regex = re.compile(r'Bat(wo)?man')\n",
    ">>> mo1 = bat_regex.search('The Adventures of Batman')\n",
    ">>> mo1.group()\n",
    "'Batman'\n",
    "\n",
    ">>> mo2 = bat_regex.search('The Adventures of Batwoman')\n",
    ">>> mo2.group()\n",
    "'Batwoman'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Matching Zero or More with the Star\n",
    "\n",
    "The * (called the star or asterisk) means “match zero or more”—the group that precedes the star can occur any number of times in the text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> bat_regex = re.compile(r'Bat(wo)*man')\n",
    ">>> mo1 = bat_regex.search('The Adventures of Batman')\n",
    ">>> mo1.group()\n",
    "'Batman'\n",
    "\n",
    ">>> mo2 = bat_regex.search('The Adventures of Batwoman')\n",
    ">>> mo2.group()\n",
    "'Batwoman'\n",
    "\n",
    ">>> mo3 = bat_regex.search('The Adventures of Batwowowowoman')\n",
    ">>> mo3.group()\n",
    "'Batwowowowoman'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Matching One or More with the Plus\n",
    "\n",
    "While * means “match zero or more,” the + (or plus) means “match one or more”. The group preceding a plus must appear at least once. It is not optional:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> bat_regex = re.compile(r'Bat(wo)+man')\n",
    ">>> mo1 = bat_regex.search('The Adventures of Batwoman')\n",
    ">>> mo1.group()\n",
    "'Batwoman'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> mo2 = bat_regex.search('The Adventures of Batwowowowoman')\n",
    ">>> mo2.group()\n",
    "'Batwowowowoman'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> mo3 = bat_regex.search('The Adventures of Batman')\n",
    ">>> mo3 is None\n",
    "True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Matching Specific Repetitions with Curly Brackets\n",
    "\n",
    "If you have a group that you want to repeat a specific number of times, follow the group in your regex with a number in curly brackets. For example, the regex (Ha){3} will match the string 'HaHaHa', but it will not match 'HaHa', since the latter has only two repeats of the (Ha) group.\n",
    "\n",
    "Instead of one number, you can specify a range by writing a minimum, a comma, and a maximum in between the curly brackets. For example, the regex (Ha){3,5} will match 'HaHaHa', 'HaHaHaHa', and 'HaHaHaHaHa'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> ha_regex = re.compile(r'(Ha){3}')\n",
    ">>> mo1 = ha_regex.search('HaHaHa')\n",
    ">>> mo1.group()\n",
    "'HaHaHa'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> mo2 = ha_regex.search('Ha')\n",
    ">>> mo2 is None\n",
    "True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Greedy and Nongreedy Matching\n",
    "\n",
    "Python’s regular expressions are greedy by default, which means that in ambiguous situations they will match the longest string possible. The non-greedy version of the curly brackets, which matches the shortest string possible, has the closing curly bracket followed by a question mark."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> greedy_ha_regex = re.compile(r'(Ha){3,5}')\n",
    ">>> mo1 = greedy_ha_regex.search('HaHaHaHaHa')\n",
    ">>> mo1.group()\n",
    "'HaHaHaHaHa'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> nongreedy_ha_regex = re.compile(r'(Ha){3,5}?')\n",
    ">>> mo2 = nongreedy_ha_regex.search('HaHaHaHaHa')\n",
    ">>> mo2.group()\n",
    "'HaHaHa'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The findall() Method\n",
    "\n",
    "In addition to the search() method, Regex objects also have a findall() method. While search() will return a Match object of the first matched text in the searched string, the findall() method will return the strings of every match in the searched string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> phone_num_regex = re.compile(r'\\d\\d\\d-\\d\\d\\d-\\d\\d\\d\\d') # has no groups\n",
    "\n",
    ">>> phone_num_regex.findall('Cell: 415-555-9999 Work: 212-555-0000')\n",
    "['415-555-9999', '212-555-0000']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To summarize what the findall() method returns, remember the following:\n",
    "\n",
    "- When called on a regex with no groups, such as \\d-\\d\\d\\d-\\d\\d\\d\\d, the method findall() returns a list of ng matches, such as ['415-555-9999', '212-555-0000'].\n",
    "\n",
    "- When called on a regex that has groups, such as (\\d\\d\\d)-d\\d)-(\\d\\ d\\d\\d), the method findall() returns a list of es of strings (one string for each group), such as [('415', ', '9999'), ('212', '555', '0000')].\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Making Your Own Character Classes\n",
    "\n",
    "There are times when you want to match a set of characters but the shorthand character classes (\\d, \\w, \\s, and so on) are too broad. You can define your own character class using square brackets. For example, the character class [aeiouAEIOU] will match any vowel, both lowercase and uppercase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> vowel_regex = re.compile(r'[aeiouAEIOU]')\n",
    "\n",
    ">>> vowel_regex.findall('Robocop eats baby food. BABY FOOD.')\n",
    "['o', 'o', 'o', 'e', 'a', 'a', 'o', 'o', 'A', 'O', 'O']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also include ranges of letters or numbers by using a hyphen. For example, the character class [a-zA-Z0-9] will match all lowercase letters, uppercase letters, and numbers.\n",
    "\n",
    "By placing a caret character (^) just after the character class’s opening bracket, you can make a negative character class. A negative character class will match all the characters that are not in the character class. For example, enter the following into the interactive shell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> consonant_regex = re.compile(r'[^aeiouAEIOU]')\n",
    "\n",
    ">>> consonant_regex.findall('Robocop eats baby food. BABY FOOD.')\n",
    "['R', 'b', 'c', 'p', ' ', 't', 's', ' ', 'b', 'b', 'y', ' ', 'f', 'd', '.', '\n",
    "', 'B', 'B', 'Y', ' ', 'F', 'D', '.']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The Caret and Dollar Sign Characters\n",
    "\n",
    "- You can also use the caret symbol (^) at the start of a regex to indicate that a match must occur at the beginning of the searched text.\n",
    "\n",
    "- Likewise, you can put a dollar sign ($) at the end of the regex to indicate the string must end with this regex pattern.\n",
    "\n",
    "- And you can use the ^ and $ together to indicate that the entire string must match the regex—that is, it’s not enough for a match to be made on some subset of the string.\n",
    "\n",
    "The r'^Hello' regular expression string matches strings that begin with 'Hello':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> begins_with_hello = re.compile(r'^Hello')\n",
    "\n",
    ">>> begins_with_hello.search('Hello world!')\n",
    "<_sre.SRE_Match object; span=(0, 5), match='Hello'>\n",
    "\n",
    ">>> begins_with_hello.search('He said hello.') is None\n",
    "True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The r'\\d$' regular expression string matches strings that end with a numeric character from 0 to 9:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> whole_string_is_num = re.compile(r'^\\d+$')\n",
    "\n",
    ">>> whole_string_is_num.search('1234567890')\n",
    "<_sre.SRE_Match object; span=(0, 10), match='1234567890'>\n",
    "\n",
    ">>> whole_string_is_num.search('12345xyz67890') is None\n",
    "True\n",
    "\n",
    ">>> whole_string_is_num.search('12 34567890') is None\n",
    "True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The Wildcard Character\n",
    "\n",
    "The . (or dot) character in a regular expression is called a wildcard and will match any character except for a newline:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> at_regex = re.compile(r'.at')\n",
    "\n",
    ">>> at_regex.findall('The cat in the hat sat on the flat mat.')\n",
    "['cat', 'hat', 'sat', 'lat', 'mat']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Matching Everything with Dot-Star"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> name_regex = re.compile(r'First Name: (.*) Last Name: (.*)')\n",
    "\n",
    ">>> mo = name_regex.search('First Name: Al Last Name: Sweigart')\n",
    "\n",
    ">>> mo.group(1)\n",
    "'Al'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> mo.group(2)\n",
    "'Sweigart'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dot-star uses greedy mode: It will always try to match as much text as possible. To match any and all text in a nongreedy fashion, use the dot, star, and question mark (.*?). The question mark tells Python to match in a nongreedy way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> nongreedy_regex = re.compile(r'<.*?>')\n",
    ">>> mo = nongreedy_regex.search('<To serve man> for dinner.>')\n",
    ">>> mo.group()\n",
    "'<To serve man>'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> greedy_regex = re.compile(r'<.*>')\n",
    ">>> mo = greedy_regex.search('<To serve man> for dinner.>')\n",
    ">>> mo.group()\n",
    "'<To serve man> for dinner.>'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Matching Newlines with the Dot Character\n",
    "\n",
    "The dot-star will match everything except a newline. By passing re.DOTALL as the second argument to re.compile(), you can make the dot character match all characters, including the newline character:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> no_newline_regex = re.compile('.*')\n",
    ">>> no_newline_regex.search('Serve the public trust.\\nProtect the innocent.\\nUphold the law.').group()\n",
    "'Serve the public trust.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> newline_regex = re.compile('.*', re.DOTALL)\n",
    ">>> newline_regex.search('Serve the public trust.\\nProtect the innocent.\\nUphold the law.').group()\n",
    "'Serve the public trust.\\nProtect the innocent.\\nUphold the law.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Review of Regex Symbols\n",
    "\n",
    "| Symbol                   | Matches                                                      |\n",
    "| ------------------------ | ------------------------------------------------------------ |\n",
    "| `?`                      | zero or one of the preceding group.                          |\n",
    "| `*`                      | zero or more of the preceding group.                         |\n",
    "| `+`                      | one or more of the preceding group.                          |\n",
    "| `{n}`                    | exactly n of the preceding group.                            |\n",
    "| `{n,}`                   | n or more of the preceding group.                            |\n",
    "| `{,m}`                   | 0 to m of the preceding group.                               |\n",
    "| `{n,m}`                  | at least n and at most m of the preceding p.                 |\n",
    "| `{n,m}?` or `*?` or `+?` | performs a nongreedy match of the preceding p.               |\n",
    "| `^spam`                  | means the string must begin with spam.                       |\n",
    "| `spam$`                  | means the string must end with spam.                         |\n",
    "| `.`                      | any character, except newline characters.                    |\n",
    "| `\\d`, `\\w`, and `\\s`     | a digit, word, or space character, ectively.                 |\n",
    "| `\\D`, `\\W`, and `\\S`     | anything except a digit, word, or space acter, respectively. |\n",
    "| `[abc]`                  | any character between the brackets (such as a, b, ).         |\n",
    "| `[^abc]`                 | any character that isn’t between the brackets.               |\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Case-Insensitive Matching\n",
    "\n",
    "To make your regex case-insensitive, you can pass re.IGNORECASE or re.I as a second argument to re.compile():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> robocop = re.compile(r'robocop', re.I)\n",
    "\n",
    ">>> robocop.search('Robocop is part man, part machine, all cop.').group()\n",
    "'Robocop'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> robocop.search('ROBOCOP protects the innocent.').group()\n",
    "'ROBOCOP'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> robocop.search('Al, why does your programming book talk about robocop so much?').group()\n",
    "'robocop'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Substituting Strings with the sub() Method\n",
    "\n",
    "The sub() method for Regex objects is passed two arguments:\n",
    "\n",
    "1. The first argument is a string to replace any matches.\n",
    "1. The second is the string for the regular expression.\n",
    "\n",
    "The sub() method returns a string with the substitutions applied:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> names_regex = re.compile(r'Agent \\w+')\n",
    "\n",
    ">>> names_regex.sub('CENSORED', 'Agent Alice gave the secret documents to Agent Bob.')\n",
    "'CENSORED gave the secret documents to CENSORED.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> agent_names_regex = re.compile(r'Agent (\\w)\\w*')\n",
    "\n",
    ">>> agent_names_regex.sub(r'\\1****', 'Agent Alice told Agent Carol that Agent Eve knew Agent Bob was a double agent.')\n",
    "A**** told C**** that E**** knew B**** was a double agent.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Managing Complex Regexes\n",
    "\n",
    "To tell the re.compile() function to ignore whitespace and comments inside the regular expression string, “verbose mode” can be enabled by passing the variable re.VERBOSE as the second argument to re.compile().\n",
    "\n",
    "Now instead of a hard-to-read regular expression like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "phone_regex = re.compile(r'((\\d{3}|\\(\\d{3}\\))?(\\s|-|\\.)?\\d{3}(\\s|-|\\.)\\d{4}(\\s*(ext|x|ext.)\\s*\\d{2,5})?)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "you can spread the regular expression over multiple lines with comments like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "phone_regex = re.compile(r'''(\n",
    "    (\\d{3}|\\(\\d{3}\\))?            # area code\n",
    "    (\\s|-|\\.)?                    # separator\n",
    "    \\d{3}                         # first 3 digits\n",
    "    (\\s|-|\\.)                     # separator\n",
    "    \\d{4}                         # last 4 digits\n",
    "    (\\s*(ext|x|ext.)\\s*\\d{2,5})?  # extension\n",
    "    )''', re.VERBOSE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "## Handling File and Directory Paths\n",
    "\n",
    "There are two main modules in Python that deals with path manipulation.\n",
    "One is the `os.path` module and the other is the `pathlib` module.\n",
    "The `pathlib` module was added in Python 3.4, offering an object-oriented way\n",
    "to handle file system paths.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Backslash on Windows and Forward Slash on OS X and Linux\n",
    "\n",
    "On Windows, paths are written using backslashes (\\) as the separator between\n",
    "folder names. On Unix based operating system such as macOS, Linux, and BSDs,\n",
    "the forward slash (/) is used as the path separator. Joining paths can be\n",
    "a headache if your code needs to work on different platforms.\n",
    "\n",
    "Fortunately, Python provides easy ways to handle this. We will showcase\n",
    "how to deal with this with both `os.path.join` and `pathlib.Path.joinpath`\n",
    "\n",
    "Using `os.path.join` on Windows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import os\n",
    "\n",
    ">>> os.path.join('usr', 'bin', 'spam')\n",
    "'usr\\\\bin\\\\spam'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And using `pathlib` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> from pathlib import Path\n",
    "\n",
    ">>> print(Path('usr').joinpath('bin').joinpath('spam')\n",
    "usr/bin/spam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`pathlib` also provides a shortcut to joinpath using the `/` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> from pathlib import Path\n",
    "\n",
    ">>> print(Path('usr') / 'bin' / 'spam')\n",
    "usr/bin/spam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the path separator is different between Windows and Unix based operating\n",
    "system, that's why you want to use one of the above methods instead of\n",
    "adding strings together to join paths together.\n",
    "\n",
    "Joining paths is helpful if you need to create different file paths under\n",
    "the same directory.\n",
    "\n",
    "Using `os.path.join` on Windows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> my_files = ['accounts.txt', 'details.csv', 'invite.docx']\n",
    "\n",
    ">>> for filename in my_files:\n",
    ">>>     print(os.path.join('C:\\\\Users\\\\asweigart', filename))\n",
    "C:\\Users\\asweigart\\accounts.txt\n",
    "C:\\Users\\asweigart\\details.csv\n",
    "C:\\Users\\asweigart\\invite.docx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `pathlib` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> my_files = ['accounts.txt', 'details.csv', 'invite.docx']\n",
    ">>> home = Path.home()\n",
    ">>> for filename in my_files:\n",
    ">>>     print(home / filename)\n",
    "/home/asweigart/accounts.txt\n",
    "/home/asweigart/details.csv\n",
    "/home/asweigart/invite.docx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### The Current Working Directory\n",
    "\n",
    "Using `os` on Windows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import os\n",
    "\n",
    ">>> os.getcwd()\n",
    "'C:\\\\Python34'\n",
    ">>> os.chdir('C:\\\\Windows\\\\System32')\n",
    "\n",
    ">>> os.getcwd()\n",
    "'C:\\\\Windows\\\\System32'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `pathlib` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> from pathlib import Path\n",
    ">>> from os import chdir\n",
    "\n",
    ">>> print(Path.cwd())\n",
    "/home/asweigart\n",
    "\n",
    ">>> chdir('/usr/lib/python3.6')\n",
    ">>> print(Path.cwd())\n",
    "/usr/lib/python3.6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Creating New Folders\n",
    "\n",
    "Using `os` on Windows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import os\n",
    ">>> os.makedirs('C:\\\\delicious\\\\walnut\\\\waffles')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `pathlib` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> from pathlib import Path\n",
    ">>> cwd = Path.cwd()\n",
    ">>> (cwd / 'delicious' / 'walnut' / 'waffles').mkdir()\n",
    "Traceback (most recent call last):\n",
    "  File \"<stdin>\", line 1, in <module>\n",
    "  File \"/usr/lib/python3.6/pathlib.py\", line 1226, in mkdir\n",
    "    self._accessor.mkdir(self, mode)\n",
    "  File \"/usr/lib/python3.6/pathlib.py\", line 387, in wrapped\n",
    "    return strfunc(str(pathobj), *args)\n",
    "FileNotFoundError: [Errno 2] No such file or directory: '/home/asweigart/delicious/walnut/waffles'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oh no, we got a nasty error! The reason is that the 'delicious' directory does\n",
    "not exist, so we cannot make the 'walnut' and the 'waffles' directories under\n",
    "it. To fix this, do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> from pathlib import Path\n",
    ">>> cwd = Path.cwd()\n",
    ">>> (cwd / 'delicious' / 'walnut' / 'waffles').mkdir(parents=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And all is good :)\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Absolute vs. Relative Paths\n",
    "\n",
    "There are two ways to specify a file path.\n",
    "\n",
    "- An absolute path, which always begins with the root folder\n",
    "- A relative path, which is relative to the program’s current working directory\n",
    "\n",
    "There are also the dot (.) and dot-dot (..) folders. These are not real folders but special names that can be used in a path. A single period (“dot”) for a folder name is shorthand for “this directory.” Two periods (“dot-dot”) means “the parent folder.”\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Handling Absolute and Relative Paths\n",
    "\n",
    "To see if a path is an absolute path:\n",
    "\n",
    "Using `os.path` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import os\n",
    ">>> os.path.isabs('/')\n",
    "True\n",
    ">>> os.path.isabs('..')\n",
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `pathlib` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> from pathlib import Path\n",
    ">>> Path('/').is_absolute()\n",
    "True\n",
    ">>> Path('..').is_absolute()\n",
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can extract an absolute path with both `os.path` and `pathlib`\n",
    "\n",
    "Using `os.path` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import os\n",
    ">>> os.getcwd()\n",
    "'/home/asweigart'\n",
    ">>> os.path.abspath('..')\n",
    "'/home'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `pathlib` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "print(Path.cwd())\n",
    "/home/asweigart\n",
    "print(Path('..').resolve())\n",
    "/home"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can get a relative path from a starting path to another path.\n",
    "\n",
    "Using `os.path` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import os\n",
    ">>> os.path.relpath('/etc/passwd', '/')\n",
    "'etc/passwd'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `pathlib` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> from pathlib import Path\n",
    ">>> print(Path('/etc/passwd').relative_to('/'))\n",
    "etc/passwd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Checking Path Validity\n",
    "\n",
    "Checking if a file/directory exists:\n",
    "\n",
    "Using `os.path` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    ">>> os.path.exists('.')\n",
    "True\n",
    ">>> os.path.exists('setup.py')\n",
    "True\n",
    ">>> os.path.exists('/etc')\n",
    "True\n",
    ">>> os.path.exists('nonexistentfile')\n",
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `pathlib` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    ">>> Path('.').exists()\n",
    "True\n",
    ">>> Path('setup.py').exists()\n",
    "True\n",
    ">>> Path('/etc').exists()\n",
    "True\n",
    ">>> Path('nonexistentfile').exists()\n",
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Checking if a path is a file:\n",
    "\n",
    "Using `os.path` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import os\n",
    ">>> os.path.isfile('setup.py')\n",
    "True\n",
    ">>> os.path.isfile('/home')\n",
    "False\n",
    ">>> os.path.isfile('nonexistentfile')\n",
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `pathlib` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> from pathlib import Path\n",
    ">>> Path('setup.py').is_file()\n",
    "True\n",
    ">>> Path('/home').is_file()\n",
    "False\n",
    ">>> Path('nonexistentfile').is_file()\n",
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Checking if a path is a directory:\n",
    "\n",
    "Using `os.path` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import os\n",
    ">>> os.path.isdir('/')\n",
    "True\n",
    ">>> os.path.isdir('setup.py')\n",
    "False\n",
    ">>> os.path.isdir('/spam')\n",
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `pathlib` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> from pathlib import Path\n",
    ">>> Path('/').is_dir()\n",
    "True\n",
    ">>> Path('setup.py').is_dir()\n",
    "False\n",
    ">>> Path('/spam').is_dir()\n",
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Finding File Sizes and Folder Contents\n",
    "\n",
    "Getting a file's size in bytes:\n",
    "\n",
    "Using `os.path` on Windows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import os\n",
    ">>> os.path.getsize('C:\\\\Windows\\\\System32\\\\calc.exe')\n",
    "776192"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `pathlib` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> from pathlib import Path\n",
    ">>> stat = Path('/bin/python3.6').stat()\n",
    ">>> print(stat) # stat contains some other information about the file as well\n",
    "os.stat_result(st_mode=33261, st_ino=141087, st_dev=2051, st_nlink=2, st_uid=0,\n",
    "--snip--\n",
    "st_gid=0, st_size=10024, st_atime=1517725562, st_mtime=1515119809, st_ctime=1517261276)\n",
    ">>> print(stat.st_size) # size in bytes\n",
    "10024"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listing directory contents using `os.listdir` on Windows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import os\n",
    ">>> os.listdir('C:\\\\Windows\\\\System32')\n",
    "['0409', '12520437.cpx', '12520850.cpx', '5U877.ax', 'aaclient.dll',\n",
    "--snip--\n",
    "'xwtpdui.dll', 'xwtpw32.dll', 'zh-CN', 'zh-HK', 'zh-TW', 'zipfldr.dll']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listing directory contents using `pathlib` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> from pathlib import Path\n",
    ">>> for f in Path('/usr/bin').iterdir():\n",
    ">>>     print(f)\n",
    "...\n",
    "/usr/bin/tiff2rgba\n",
    "/usr/bin/iconv\n",
    "/usr/bin/ldd\n",
    "/usr/bin/cache_restore\n",
    "/usr/bin/udiskie\n",
    "/usr/bin/unix2dos\n",
    "/usr/bin/t1reencode\n",
    "/usr/bin/epstopdf\n",
    "/usr/bin/idle3\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To find the total size of all the files in this directory:\n",
    "\n",
    "**WARNING**: Directories themselves also have a size! So you might want to\n",
    "check for whether a path is a file or directory using the methods in the methods discussed in the above section!\n",
    "\n",
    "Using `os.path.getsize()` and `os.listdir()` together on Windows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import os\n",
    ">>> total_size = 0\n",
    "\n",
    ">>> for filename in os.listdir('C:\\\\Windows\\\\System32'):\n",
    "      total_size = total_size + os.path.getsize(os.path.join('C:\\\\Windows\\\\System32', filename))\n",
    "\n",
    ">>> print(total_size)\n",
    "1117846456"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `pathlib` on \\*nix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> from pathlib import Path\n",
    ">>> total_size = 0\n",
    "\n",
    ">>> for sub_path in Path('/usr/bin').iterdir():\n",
    "...     total_size += sub_path.stat().st_size\n",
    ">>>\n",
    ">>> print(total_size)\n",
    "1903178911"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Copying Files and Folders\n",
    "\n",
    "The shutil module provides functions for copying files, as well as entire folders."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import shutil, os\n",
    "\n",
    ">>> os.chdir('C:\\\\')\n",
    "\n",
    ">>> shutil.copy('C:\\\\spam.txt', 'C:\\\\delicious')\n",
    "   'C:\\\\delicious\\\\spam.txt'\n",
    "\n",
    ">>> shutil.copy('eggs.txt', 'C:\\\\delicious\\\\eggs2.txt')\n",
    "   'C:\\\\delicious\\\\eggs2.txt'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While shutil.copy() will copy a single file, shutil.copytree() will copy an entire folder and every folder and file contained in it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import shutil, os\n",
    "\n",
    ">>> os.chdir('C:\\\\')\n",
    "\n",
    ">>> shutil.copytree('C:\\\\bacon', 'C:\\\\bacon_backup')\n",
    "'C:\\\\bacon_backup'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Moving and Renaming Files and Folders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import shutil\n",
    ">>> shutil.move('C:\\\\bacon.txt', 'C:\\\\eggs')\n",
    "'C:\\\\eggs\\\\bacon.txt'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The destination path can also specify a filename. In the following example, the source file is moved and renamed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> shutil.move('C:\\\\bacon.txt', 'C:\\\\eggs\\\\new_bacon.txt')\n",
    "'C:\\\\eggs\\\\new_bacon.txt'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If there is no eggs folder, then move() will rename bacon.txt to a file named eggs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> shutil.move('C:\\\\bacon.txt', 'C:\\\\eggs')\n",
    "'C:\\\\eggs'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Permanently Deleting Files and Folders\n",
    "\n",
    "- Calling os.unlink(path) or Path.unlink() will delete the file at path.\n",
    "\n",
    "- Calling os.rmdir(path) or Path.rmdir() will delete the folder at path. This folder must be empty of any files or folders.\n",
    "\n",
    "- Calling shutil.rmtree(path) will remove the folder at path, and all files and folders it contains will also be deleted.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Safe Deletes with the send2trash Module\n",
    "\n",
    " You can install this module by running pip install send2trash from a Terminal window."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import send2trash\n",
    "\n",
    ">>> with open('bacon.txt', 'a') as bacon_file: # creates the file\n",
    "...     bacon_file.write('Bacon is not a vegetable.')\n",
    "25\n",
    "\n",
    ">>> send2trash.send2trash('bacon.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Walking a Directory Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import os\n",
    ">>>\n",
    ">>> for folder_name, subfolders, filenames in os.walk('C:\\\\delicious'):\n",
    ">>>     print('The current folder is ' + folder_name)\n",
    ">>>\n",
    ">>>     for subfolder in subfolders:\n",
    ">>>         print('SUBFOLDER OF ' + folder_name + ': ' + subfolder)\n",
    ">>>     for filename in filenames:\n",
    ">>>         print('FILE INSIDE ' + folder_name + ': '+ filename)\n",
    ">>>\n",
    ">>>     print('')\n",
    "The current folder is C:\\delicious\n",
    "SUBFOLDER OF C:\\delicious: cats\n",
    "SUBFOLDER OF C:\\delicious: walnut\n",
    "FILE INSIDE C:\\delicious: spam.txt\n",
    "\n",
    "The current folder is C:\\delicious\\cats\n",
    "FILE INSIDE C:\\delicious\\cats: catnames.txt\n",
    "FILE INSIDE C:\\delicious\\cats: zophie.jpg\n",
    "\n",
    "The current folder is C:\\delicious\\walnut\n",
    "SUBFOLDER OF C:\\delicious\\walnut: waffles\n",
    "\n",
    "The current folder is C:\\delicious\\walnut\\waffles\n",
    "FILE INSIDE C:\\delicious\\walnut\\waffles: butter.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "`pathlib` provides a lot more functionality than the ones listed above,\n",
    "like getting file name, getting file extension, reading/writing a file without\n",
    "manually opening it, etc. Check out the\n",
    "[official documentation](https://docs.python.org/3/library/pathlib.html)\n",
    "if you want to know more!\n",
    "\n",
    "## Reading and Writing Files\n",
    "\n",
    "### The File Reading/Writing Process\n",
    "\n",
    "To read/write to a file in Python, you will want to use the `with`\n",
    "statement, which will close the file for you after you are done.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Opening and reading files with the open() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> with open('C:\\\\Users\\\\your_home_folder\\\\hello.txt') as hello_file:\n",
    "...     hello_content = hello_file.read()\n",
    ">>> hello_content\n",
    "'Hello World!'\n",
    "\n",
    ">>> # Alternatively, you can use the *readlines()* method to get a list of string values from the file, one string for each line of text:\n",
    "\n",
    ">>> with open('sonnet29.txt') as sonnet_file:\n",
    "...     sonnet_file.readlines()\n",
    "[When, in disgrace with fortune and men's eyes,\\n', ' I all alone beweep my\n",
    "outcast state,\\n', And trouble deaf heaven with my bootless cries,\\n', And\n",
    "look upon myself and curse my fate,']\n",
    "\n",
    ">>> # You can also iterate through the file line by line:\n",
    ">>> with open('sonnet29.txt') as sonnet_file:\n",
    "...     for line in sonnet_file: # note the new line character will be included in the line\n",
    "...         print(line, end='')\n",
    "\n",
    "When, in disgrace with fortune and men's eyes,\n",
    "I all alone beweep my outcast state,\n",
    "And trouble deaf heaven with my bootless cries,\n",
    "And look upon myself and curse my fate,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Writing to Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> with open('bacon.txt', 'w') as bacon_file:\n",
    "...     bacon_file.write('Hello world!\\n')\n",
    "13\n",
    "\n",
    ">>> with open('bacon.txt', 'a') as bacon_file:\n",
    "...     bacon_file.write('Bacon is not a vegetable.')\n",
    "25\n",
    "\n",
    ">>> with open('bacon.txt') as bacon_file:\n",
    "...     content = bacon_file.read()\n",
    "\n",
    ">>> print(content)\n",
    "Hello world!\n",
    "Bacon is not a vegetable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Saving Variables with the shelve Module\n",
    "\n",
    "To save variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import shelve\n",
    "\n",
    ">>> cats = ['Zophie', 'Pooka', 'Simon']\n",
    ">>> with shelve.open('mydata') as shelf_file:\n",
    "...     shelf_file['cats'] = cats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To open and read variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> with shelve.open('mydata') as shelf_file:\n",
    "...     print(type(shelf_file))\n",
    "...     print(shelf_file['cats'])\n",
    "<class 'shelve.DbfilenameShelf'>\n",
    "['Zophie', 'Pooka', 'Simon']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like dictionaries, shelf values have keys() and values() methods that will return list-like values of the keys and values in the shelf. Since these methods return list-like values instead of true lists, you should pass them to the list() function to get them in list form."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> with shelve.open('mydata') as shelf_file:\n",
    "...     print(list(shelf_file.keys()))\n",
    "...     print(list(shelf_file.values()))\n",
    "['cats']\n",
    "[['Zophie', 'Pooka', 'Simon']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Saving Variables with the pprint.pformat() Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import pprint\n",
    "\n",
    ">>> cats = [{'name': 'Zophie', 'desc': 'chubby'}, {'name': 'Pooka', 'desc': 'fluffy'}]\n",
    "\n",
    ">>> pprint.pformat(cats)\n",
    "\"[{'desc': 'chubby', 'name': 'Zophie'}, {'desc': 'fluffy', 'name': 'Pooka'}]\"\n",
    "\n",
    ">>> with open('myCats.py', 'w') as file_obj:\n",
    "...     file_obj.write('cats = ' + pprint.pformat(cats) + '\\n')\n",
    "83"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Reading ZIP Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import zipfile, os\n",
    "\n",
    ">>> os.chdir('C:\\\\')    # move to the folder with example.zip\n",
    ">>> with zipfile.ZipFile('example.zip') as example_zip:\n",
    "...     print(example_zip.namelist())\n",
    "...     spam_info = example_zip.getinfo('spam.txt')\n",
    "...     print(spam_info.file_size)\n",
    "...     print(spam_info.compress_size)\n",
    "...     print('Compressed file is %sx smaller!' % (round(spam_info.file_size / spam_info.compress_size, 2)))\n",
    "\n",
    "['spam.txt', 'cats/', 'cats/catnames.txt', 'cats/zophie.jpg']\n",
    "13908\n",
    "3828\n",
    "'Compressed file is 3.63x smaller!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Extracting from ZIP Files\n",
    "\n",
    "The extractall() method for ZipFile objects extracts all the files and folders from a ZIP file into the current working directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import zipfile, os\n",
    "\n",
    ">>> os.chdir('C:\\\\')    # move to the folder with example.zip\n",
    "\n",
    ">>> with zipfile.ZipFile('example.zip') as example_zip:\n",
    "...     example_zip.extractall()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The extract() method for ZipFile objects will extract a single file from the ZIP file. Continue the interactive shell example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> with zipfile.ZipFile('example.zip') as example_zip:\n",
    "...     print(example_zip.extract('spam.txt'))\n",
    "...     print(example_zip.extract('spam.txt', 'C:\\\\some\\\\new\\\\folders'))\n",
    "'C:\\\\spam.txt'\n",
    "'C:\\\\some\\\\new\\\\folders\\\\spam.txt'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Creating and Adding to ZIP Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import zipfile\n",
    "\n",
    ">>> with zipfile.ZipFile('new.zip', 'w') as new_zip:\n",
    "...     new_zip.write('spam.txt', compress_type=zipfile.ZIP_DEFLATED)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code will create a new ZIP file named new.zip that has the compressed contents of spam.txt.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "## JSON, YAML and configuration files\n",
    "\n",
    "### JSON\n",
    "\n",
    "Open a JSON file with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "with open(\"filename.json\", \"r\") as f:\n",
    "    content = json.loads(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a JSON file with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "content = {\"name\": \"Joe\", \"age\": 20}\n",
    "with open(\"filename.json\", \"w\") as f:\n",
    "    f.write(json.dumps(content, indent=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### YAML\n",
    "\n",
    "Compared to JSON, YAML allows a much better humain maintainance and gives ability to add comments.\n",
    "It is a convinient choice for configuration files where human will have to edit.\n",
    "\n",
    "There are two main librairies allowing to access to YAML files:\n",
    "\n",
    "- [PyYaml](https://pypi.python.org/pypi/PyYAML)\n",
    "- [Ruamel.yaml](https://pypi.python.org/pypi/ruamel.yaml)\n",
    "\n",
    "Install them using `pip install` in your virtual environment.\n",
    "\n",
    "The first one it easier to use but the second one, Ruamel, implements much better the YAML\n",
    "specification, and allow for example to modify a YAML content without altering comments.\n",
    "\n",
    "Open a YAML file with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ruamel.yaml import YAML\n",
    "\n",
    "with open(\"filename.yaml\") as f:\n",
    "    yaml=YAML()\n",
    "    yaml.load(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Anyconfig\n",
    "\n",
    "[Anyconfig](https://pypi.python.org/pypi/anyconfig) is a very handy package allowing to abstract completly the underlying configuration file format. It allows to load a Python dictionary from JSON, YAML, TOML, and so on.\n",
    "\n",
    "Install it with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "pip install anyconfig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usage:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import anyconfig\n",
    "\n",
    "conf1 = anyconfig.load(\"/path/to/foo/conf.d/a.yml\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "## Debugging\n",
    "\n",
    "### Raising Exceptions\n",
    "\n",
    "Exceptions are raised with a raise statement. In code, a raise statement consists of the following:\n",
    "\n",
    "- The raise keyword\n",
    "- A call to the Exception() function\n",
    "- A string with a helpful error message passed to the Exception() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> raise Exception('This is the error message.')\n",
    "Traceback (most recent call last):\n",
    "  File \"<pyshell#191>\", line 1, in <module>\n",
    "    raise Exception('This is the error message.')\n",
    "Exception: This is the error message."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often it’s the code that calls the function, not the function itself, that knows how to handle an expection. So you will commonly see a raise statement inside a function and the try and except statements in the code calling the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def box_print(symbol, width, height):\n",
    "    if len(symbol) != 1:\n",
    "      raise Exception('Symbol must be a single character string.')\n",
    "    if width <= 2:\n",
    "      raise Exception('Width must be greater than 2.')\n",
    "    if height <= 2:\n",
    "      raise Exception('Height must be greater than 2.')\n",
    "    print(symbol * width)\n",
    "    for i in range(height - 2):\n",
    "        print(symbol + (' ' * (width - 2)) + symbol)\n",
    "    print(symbol * width)\n",
    "for sym, w, h in (('*', 4, 4), ('O', 20, 5), ('x', 1, 3), ('ZZ', 3, 3)):\n",
    "    try:\n",
    "        box_print(sym, w, h)\n",
    "  except Exception as err:\n",
    "      print('An exception happened: ' + str(err))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Getting the Traceback as a String\n",
    "\n",
    "The traceback is displayed by Python whenever a raised exception goes unhandled. But can also obtain it as a string by calling traceback.format_exc(). This function is useful if you want the information from an exception’s traceback but also want an except statement to gracefully handle the exception. You will need to import Python’s traceback module before calling this function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import traceback\n",
    "\n",
    ">>> try:\n",
    ">>>      raise Exception('This is the error message.')\n",
    ">>> except:\n",
    ">>>      with open('errorInfo.txt', 'w') as error_file:\n",
    ">>>          error_file.write(traceback.format_exc())\n",
    ">>>      print('The traceback info was written to errorInfo.txt.')\n",
    "116\n",
    "The traceback info was written to errorInfo.txt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The 116 is the return value from the write() method, since 116 characters were written to the file. The traceback text was written to errorInfo.txt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Traceback (most recent call last):\n",
    "  File \"<pyshell#28>\", line 2, in <module>\n",
    "Exception: This is the error message."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Assertions\n",
    "\n",
    "An assertion is a sanity check to make sure your code isn’t doing something obviously wrong. These sanity checks are performed by assert statements. If the sanity check fails, then an AssertionError exception is raised. In code, an assert statement consists of the following:\n",
    "\n",
    "- The assert keyword\n",
    "- A condition (that is, an expression that evaluates to True or False)\n",
    "- A comma\n",
    "- A string to display when the condition is False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> pod_bay_door_status = 'open'\n",
    "\n",
    ">>> assert pod_bay_door_status == 'open', 'The pod bay doors need to be \"open\".'\n",
    "\n",
    ">>> pod_bay_door_status = 'I\\'m sorry, Dave. I\\'m afraid I can\\'t do that.'\n",
    "\n",
    ">>> assert pod_bay_door_status == 'open', 'The pod bay doors need to be \"open\".'\n",
    "\n",
    "Traceback (most recent call last):\n",
    "  File \"<pyshell#10>\", line 1, in <module>\n",
    "    assert pod_bay_door_status == 'open', 'The pod bay doors need to be \"open\".'\n",
    "AssertionError: The pod bay doors need to be \"open\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In plain English, an assert statement says, “I assert that this condition holds true, and if not, there is a bug somewhere in the program.” Unlike exceptions, your code should not handle assert statements with try and except; if an assert fails, your program should crash. By failing fast like this, you shorten the time between the original cause of the bug and when you first notice the bug. This will reduce the amount of code you will have to check before finding the code that’s causing the bug.\n",
    "\n",
    "Disabling Assertions\n",
    "\n",
    "Assertions can be disabled by passing the -O option when running Python.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Logging\n",
    "\n",
    "To enable the logging module to display log messages on your screen as your program runs, copy the following to the top of your program (but under the #! python shebang line):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "\n",
    "logging.basicConfig(level=logging.DEBUG, format=' %(asctime)s - %(levelname)s- %(message)s')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Say you wrote a function to calculate the factorial of a number. In mathematics, factorial 4 is 1 × 2 × 3 × 4, or 24. Factorial 7 is 1 × 2 × 3 × 4 × 5 × 6 × 7, or 5,040. Open a new file editor window and enter the following code. It has a bug in it, but you will also enter several log messages to help yourself figure out what is going wrong. Save the program as factorialLog.py."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import logging\n",
    ">>>\n",
    ">>> logging.basicConfig(level=logging.DEBUG, format=' %(asctime)s - %(levelname)s- %(message)s')\n",
    ">>>\n",
    ">>> logging.debug('Start of program')\n",
    ">>>\n",
    ">>> def factorial(n):\n",
    ">>>\n",
    ">>>     logging.debug('Start of factorial(%s)' % (n))\n",
    ">>>     total = 1\n",
    ">>>\n",
    ">>>     for i in range(1, n + 1):\n",
    ">>>         total *= i\n",
    ">>>         logging.debug('i is ' + str(i) + ', total is ' + str(total))\n",
    ">>>\n",
    ">>>     logging.debug('End of factorial(%s)' % (n))\n",
    ">>>\n",
    ">>>     return total\n",
    ">>>\n",
    ">>> print(factorial(5))\n",
    ">>> logging.debug('End of program')\n",
    "2015-05-23 16:20:12,664 - DEBUG - Start of program\n",
    "2015-05-23 16:20:12,664 - DEBUG - Start of factorial(5)\n",
    "2015-05-23 16:20:12,665 - DEBUG - i is 0, total is 0\n",
    "2015-05-23 16:20:12,668 - DEBUG - i is 1, total is 0\n",
    "2015-05-23 16:20:12,670 - DEBUG - i is 2, total is 0\n",
    "2015-05-23 16:20:12,673 - DEBUG - i is 3, total is 0\n",
    "2015-05-23 16:20:12,675 - DEBUG - i is 4, total is 0\n",
    "2015-05-23 16:20:12,678 - DEBUG - i is 5, total is 0\n",
    "2015-05-23 16:20:12,680 - DEBUG - End of factorial(5)\n",
    "0\n",
    "2015-05-23 16:20:12,684 - DEBUG - End of program"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Logging Levels\n",
    "\n",
    "Logging levels provide a way to categorize your log messages by importance. There are five logging levels, described in Table 10-1 from least to most important. Messages can be logged at each level using a different logging function.\n",
    "\n",
    "| Level      | Logging Function     | Description                                                                                                                    |\n",
    "| ---------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------ |\n",
    "| `DEBUG`    | `logging.debug()`    | The lowest level. Used for small details. Usually you care about these messages only when diagnosing problems.                 |\n",
    "| `INFO`     | `logging.info()`     | Used to record information on general events in your program or confirm that things are working at their point in the program. |\n",
    "| `WARNING`  | `logging.warning()`  | Used to indicate a potential problem that doesn’t prevent the program from working but might do so in the future.              |\n",
    "| `ERROR`    | `logging.error()`    | Used to record an error that caused the program to fail to do something.                                                       |\n",
    "| `CRITICAL` | `logging.critical()` | The highest level. Used to indicate a fatal error that has caused or is about to cause the program to stop running entirely.   |\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Disabling Logging\n",
    "\n",
    "After you’ve debugged your program, you probably don’t want all these log messages cluttering the screen. The logging.disable() function disables these so that you don’t have to go into your program and remove all the logging calls by hand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import logging\n",
    "\n",
    ">>> logging.basicConfig(level=logging.INFO, format=' %(asctime)s -%(levelname)s - %(message)s')\n",
    "\n",
    ">>> logging.critical('Critical error! Critical error!')\n",
    "2015-05-22 11:10:48,054 - CRITICAL - Critical error! Critical error!\n",
    "\n",
    ">>> logging.disable(logging.CRITICAL)\n",
    "\n",
    ">>> logging.critical('Critical error! Critical error!')\n",
    "\n",
    ">>> logging.error('Error! Error!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### Logging to a File\n",
    "\n",
    "Instead of displaying the log messages to the screen, you can write them to a text file. The logging.basicConfig() function takes a filename keyword argument, like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "\n",
    "logging.basicConfig(filename='myProgramLog.txt', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "## Lambda Functions\n",
    "\n",
    "This function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> def add(x, y):\n",
    "        return x + y\n",
    "\n",
    ">>> add(5, 3)\n",
    "8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Is equivalent to the *lambda* function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> add = lambda x, y: x + y\n",
    ">>> add(5, 3)\n",
    "8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's not even need to bind it to a name like add before:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> (lambda x, y: x + y)(5, 3)\n",
    "8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like regular nested functions, lambdas also work as lexical closures:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> def make_adder(n):\n",
    "        return lambda x: x + n\n",
    "\n",
    ">>> plus_3 = make_adder(3)\n",
    ">>> plus_5 = make_adder(5)\n",
    "\n",
    ">>> plus_3(4)\n",
    "7\n",
    ">>> plus_5(4)\n",
    "9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: lambda can only evaluate an expression, like a single line of code.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "## Ternary Conditional Operator\n",
    "\n",
    "Many programming languages have a ternary operator, which define a conditional expression. The most common usage is to make a terse simple conditional assignment statement. In other words, it offers one-line code to evaluate the first expression if the condition is true, otherwise it evaluates the second expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "<expression1> if <condition> else <expression2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> age = 15\n",
    "\n",
    ">>> print('kid' if age < 18 else 'adult')\n",
    "kid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ternary operators can be changed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> age = 15\n",
    "\n",
    ">>> print('kid' if age < 13 else 'teenager' if age < 18 else 'adult')\n",
    "teenager"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code above is equivalent to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if age < 18:\n",
    "    if age < 12:\n",
    "        print('kid')\n",
    "    else:\n",
    "        print('teenager')\n",
    "else:\n",
    "    print('adult')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "## Virtual Environment\n",
    "\n",
    "The use of a Virtual Environment is to test python code in encapsulated environments and to also avoid filling the base Python installation with libraries we might use for only one project.\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### virtualenv\n",
    "\n",
    "1. Install virtualenv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pip install virtualenv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Install virtualenvwrapper-win (Windows)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pip install virtualenvwrapper-win"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usage:\n",
    "\n",
    "1. Make a Virtual Environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mkvirtualenv HelloWold"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anything we install now will be specific to this project. And available to the projects we connect to this environment.\n",
    "\n",
    "1. Set Project Directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "To bind our virtualenv with our current working directory we simply enter:\n",
    "\n",
    "    setprojectdir ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Deactivate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "To move onto something else in the command line type ‘deactivate’ to deactivate your environment.\n",
    "\n",
    "    deactivate\n",
    "\n",
    "Notice how the parenthesis disappear."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Workon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Open up the command prompt and type ‘workon HelloWold’ to activate the environment and move into your root project folder\n",
    "\n",
    "    workon HelloWold"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Return to the Top*](#python-cheatsheet)\n",
    "\n",
    "### pipenv\n",
    "\n",
    "> Pipenv — the officially recommended Python packaging tool from Python.org, free (as in freedom).\n",
    "\n",
    "1. Install pipenv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pip install pipenv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Enter your Project directory and install the Packages for your project"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cd my_project\n",
    "pipenv install <package>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pipenv will install your package and create a Pipfile for you in your project’s directory. The Pipfile is used to track which dependencies your project needs in case you need to re-install them.\n",
    "\n",
    "1. Uninstall Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipenv uninstall <package>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Activate the Virtual Environment associated with your Python project"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipenv shell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Exit the Virtual Environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find more information and a video in [docs.pipenv.org](https://docs.pipenv.org/).\n",
    "\n",
    "[*Return to the Top*](#python-cheatsheet)"
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 2
}