Python Cheatsheet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Cheatsheet "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hello World"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    " print(\"Hello, World!\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Five is greater than two!\n"
     ]
    }
   ],
   "source": [
    "if 5 > 2:\n",
    "  print(\"Five is greater than two!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "#This is a comment\n",
    "print(\"Hello, World!\")\n",
    "\n",
    "\"\"\"\n",
    "This is a comment\n",
    "written in\n",
    "more than just one line\n",
    "\"\"\"\n",
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "John\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "y = \"John\"\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(type(x))\n",
    "print(type(y)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String Quotes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"John\"\n",
    "# is the same as\n",
    "x = 'John'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Case sensitive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    " a = 4\n",
    "A = \"Sally\"\n",
    "#A will not overwrite a "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Illegal variable names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-155-0e82719f22b4>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-155-0e82719f22b4>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    2myvar = \"John\"\u001b[0m\n\u001b[0m     ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "2myvar = \"John\"\n",
    "my-var = \"John\"\n",
    "my var = \"John\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Many to many"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " x, y, z = \"Orange\", \"Banana\", \"Cherry\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### One to many"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = y = z = \"Orange\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "x, y, z = fruits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"awesome\"\n",
    "print(\"Python is \" + x)\n",
    "print(\"Python is \" + x + \" \" + \"Yay!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Globals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"out\"\n",
    "\n",
    "def myfunc():\n",
    "  x = \"in\"\n",
    "  print(x)\n",
    "\n",
    "myfunc()\n",
    "\n",
    "print(x) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"out\"\n",
    "\n",
    "def myfunc():\n",
    "  global x\n",
    "  x = \"in\"\n",
    "\n",
    "myfunc()\n",
    "\n",
    "print(x) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = \"Hello World\" # str\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Numeric"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Int, or integer, is a whole number, positive or negative, without decimals, of unlimited length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = 20 # int\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Float, or \"floating point number\" is a number, positive or negative, containing one or more decimals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = 20.5 # float\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Complex numbers are written with a \"j\" as the imaginary part:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = 1j # complex\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Type Conversion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "x = 1    # int\n",
    "y = 2.8  # float\n",
    "z = 1j   # complex\n",
    "\n",
    "#convert from int to float:\n",
    "a = float(x)\n",
    "\n",
    "#convert from float to int:\n",
    "b = int(y)\n",
    "\n",
    "#convert from int to complex:\n",
    "c = complex(x)\n",
    "\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "\n",
    "print(type(a))\n",
    "print(type(b))\n",
    "print(type(c)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Random Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "print(random.randrange(1, 42)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "x = [\"apple\", \"banana\", \"cherry\"] # list\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "x = (\"apple\", \"banana\", \"cherry\") # tuple\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'range'>\n"
     ]
    }
   ],
   "source": [
    "x = range(6) # range\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "x = {\"name\" : \"John\", \"age\" : 36} # dict\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "x = {\"apple\", \"banana\", \"cherry\"} # set\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'frozenset'>\n"
     ]
    }
   ],
   "source": [
    "x = frozenset({\"apple\", \"banana\", \"cherry\"}) # frozenset\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Boolean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "x = True # bool\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Binary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bytes'>\n"
     ]
    }
   ],
   "source": [
    "x = b\"Hello\" # bytes\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bytearray'>\n"
     ]
    }
   ],
   "source": [
    "x = bytearray(5) # bytearray\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'memoryview'>\n"
     ]
    }
   ],
   "source": [
    "x = memoryview(bytes(5)) # memoryview\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Casting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "int() - constructs an integer number from an integer literal, a float literal (by rounding down to the previous whole number), or a string literal (providing the string represents a whole number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = int(1)   # x will be 1\n",
    "y = int(2.8) # y will be 2\n",
    "z = int(\"3\") # z will be 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "float() - constructs a float number from an integer literal, a float literal or a string literal (providing the string represents a float or an integer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = float(1)     # x will be 1.0\n",
    "y = float(2.8)   # y will be 2.8\n",
    "z = float(\"3\")   # z will be 3.0\n",
    "w = float(\"4.2\") # w will be 4.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "str() - constructs a string from a wide variety of data types, including strings, integer literals and float literals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = str(\"s1\") # x will be 's1'\n",
    "y = str(2)    # y will be '2'\n",
    "z = str(3.0)  # z will be '3.0' "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Multiline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lorem ipsum dolor sit amet,\n",
      "consectetur adipiscing elit,\n",
      "sed do eiusmod tempor incididunt\n",
      "ut labore et dolore magna aliqua.\n"
     ]
    }
   ],
   "source": [
    "a = '''Lorem ipsum dolor sit amet,\n",
    "consectetur adipiscing elit,\n",
    "sed do eiusmod tempor incididunt\n",
    "ut labore et dolore magna aliqua.'''\n",
    "print(a) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Strings are Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e\n"
     ]
    }
   ],
   "source": [
    "a = \"Hello, World!\"\n",
    "print(a[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Iterating over characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b\n",
      "a\n",
      "n\n",
      "a\n",
      "n\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "for x in \"banana\":\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### String Length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "a = \"Hello, World!\"\n",
    "print(len(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Contains"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "hidden": true,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "txt = \"The best things in life are free!\"\n",
    "print(\"free\" in txt)\n",
    "print(\"expensive\" not in txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "llo\n",
      "Hello\n",
      "llo, World!\n",
      "orl\n"
     ]
    }
   ],
   "source": [
    "b = \"Hello, World!\"\n",
    "\n",
    "# get characters 2 to 5 (not included)\n",
    "print(b[2:5])\n",
    "\n",
    "# get characters start to 5 (not included)\n",
    "print(b[:5])\n",
    "\n",
    "# get characters 2 to end\n",
    "print(b[2:]) \n",
    "\n",
    "# get characters -5 to -2 (negative indexes start from the end of the string)\n",
    "print(b[-5:-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Manipulating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO, WORLD!\n",
      "hello, world!\n",
      "Hello, World!\n",
      "Jello, World!\n",
      "['Hello', ' World!']\n"
     ]
    }
   ],
   "source": [
    "a = \"Hello, World!\"\n",
    "print(a.upper()) # upper-case\n",
    "print(a.lower()) # lower-case\n",
    "print(\" Hello, World! \".strip()) # Remove whitespace from beginning or end\n",
    "print(a.replace(\"H\", \"J\")) # Replace H with J\n",
    "print(a.split(\",\")) # Split comma separated string into substrings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I want 3 pieces of item 567 for 49.95 dollars.\n",
      "I want 49.95 pieces of item 567 for 3 dollars.\n"
     ]
    }
   ],
   "source": [
    "quantity = 3\n",
    "itemno = 567\n",
    "price = 49.95\n",
    "myorder = \"I want {} pieces of item {} for {} dollars.\"\n",
    "print(myorder.format(quantity, itemno, price))\n",
    "myorder = \"I want {2} pieces of item {1} for {0} dollars.\" # place arguments based on index\n",
    "print(myorder.format(quantity, itemno, price))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Escape Characters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "\\' \t    Single Quote \t\n",
    "\\\\ \t    Backslash \t\n",
    "\\n \t    New Line \t\n",
    "\\r \t    Carriage Return \t\n",
    "\\t \t    Tab \t\n",
    "\\b \t    Backspace \t\n",
    "\\f \t    Form Feed \t\n",
    "\\ooo \tOctal value \t\n",
    "\\xhh \tHex value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"Double Quotes\"\n",
      "'Single Quotes'\n",
      "Backslash\\\n"
     ]
    }
   ],
   "source": [
    "txt = \"\\\"Double Quotes\\\"\"\n",
    "print(txt)\n",
    "txt = \"\\'Single Quotes\\'\"\n",
    "print(txt)\n",
    "txt = \"Backslash\\\\\"\n",
    "print(txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### String Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'capitalize' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-178-3b0ec19efffe>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcapitalize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Converts the first character to upper case\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mcasefold\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Converts string into lower case\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mcenter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Returns a centered string\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mcount\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Returns the number of times a specified value occurs in a string\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mencode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Returns an encoded version of the string\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'capitalize' is not defined"
     ]
    }
   ],
   "source": [
    "capitalize() # Converts the first character to upper case\n",
    "casefold() # Converts string into lower case\n",
    "center() # Returns a centered string\n",
    "count() # Returns the number of times a specified value occurs in a string\n",
    "encode() # Returns an encoded version of the string\n",
    "endswith() # Returns true if the string ends with the specified value\n",
    "expandtabs() # Sets the tab size of the string\n",
    "find() # Searches the string for a specified value and returns the position of where it was found\n",
    "format() # Formats specified values in a string\n",
    "format_map() # Formats specified values in a string\n",
    "index() # Searches the string for a specified value and returns the position of where it was found\n",
    "isalnum() # Returns True if all characters in the string are alphanumeric\n",
    "isalpha() # Returns True if all characters in the string are in the alphabet\n",
    "isdecimal() # Returns True if all characters in the string are decimals\n",
    "isdigit() # Returns True if all characters in the string are digits\n",
    "isidentifier() # Returns True if the string is an identifier\n",
    "islower() # Returns True if all characters in the string are lower case\n",
    "isnumeric() # Returns True if all characters in the string are numeric\n",
    "isprintable() # Returns True if all characters in the string are printable\n",
    "isspace() # Returns True if all characters in the string are whitespaces\n",
    "istitle() # Returns True if the string follows the rules of a title\n",
    "isupper() # Returns True if all characters in the string are upper case\n",
    "join() # Joins the elements of an iterable to the end of the string\n",
    "ljust() # Returns a left justified version of the string\n",
    "lower() # Converts a string into lower case\n",
    "lstrip() # Returns a left trim version of the string\n",
    "maketrans() # Returns a translation table to be used in translations\n",
    "partition() # Returns a tuple where the string is parted into three parts\n",
    "replace() # Returns a string where a specified value is replaced with a specified value\n",
    "rfind() # Searches the string for a specified value and returns the last position of where it was found\n",
    "rindex() # Searches the string for a specified value and returns the last position of where it was found\n",
    "rjust() # Returns a right justified version of the string\n",
    "rpartition() # Returns a tuple where the string is parted into three parts\n",
    "rsplit() # Splits the string at the specified separator, and returns a list\n",
    "rstrip() # Returns a right trim version of the string\n",
    "split() # Splits the string at the specified separator, and returns a list\n",
    "splitlines() # Splits the string at line breaks and returns a list\n",
    "startswith() # Returns true if the string starts with the specified value\n",
    "strip() # Returns a trimmed version of the string\n",
    "swapcase() # Swaps cases, lower case becomes upper case and vice versa\n",
    "title() # Converts the first character of each word to upper case\n",
    "translate() # Returns a translated string\n",
    "upper() # Converts a string into upper case\n",
    "zfill() # Fills the string with a specified number of 0 values at the beginning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### Booleans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "print(10 > 9)\n",
    "print(10 == 9)\n",
    "print(10 < 9) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### True Values\n",
    "* Any string is True, except empty strings.\n",
    "* Any number is True, except 0.\n",
    "* Any list, tuple, set, and dictionary are True, except empty ones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(bool(\"Hello\"))\n",
    "print(bool(15))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### False Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "print(bool(False))\n",
    "print(bool(None))\n",
    "print(bool(0))\n",
    "print(bool(\"\"))\n",
    "print(bool(()))\n",
    "print(bool([]))\n",
    "print(bool({}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Arithmetic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "print(\"1 + 2 -> {}\".format(1 + 2)) # Addition\n",
    "print(\"1 - 2 -> {}\".format(1 - 2)) # Subtraction\n",
    "print(\"1 * 2 -> {}\".format(1 * 2)) # Multiplication\n",
    "print(\"1 / 2 -> {}\".format(1 / 2)) # Division\n",
    "print(\"1 % 2 -> {}\".format(1 % 2)) # Modulus\n",
    "print(\"1 ** 2 -> {}\".format(1 ** 2)) # Exponentiation\n",
    "print(\"1 // 2 -> {}\".format(1 // 2)) # Floor division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "print(\"x += 3  -> x = x + 3\")  # +=\n",
    "print(\"x -= 3  -> x = x - 3\")  # -=\n",
    "print(\"x *= 3  -> x = x * 3\")  # *=\n",
    "print(\"x /= 3  -> x = x / 3\")  # /=\n",
    "print(\"x %= 3  -> x = x % 3\")  # %=\n",
    "print(\"x //= 3 -> x = x // 3\") # //=\n",
    "print(\"x **= 3 -> x = x ** 3\") # **=\n",
    "print(\"x &= 3  -> x = x & 3\")  # &=\n",
    "print(\"x |= 3  -> x = x | 3\")  # |=\n",
    "print(\"x ^= 3  -> x = x ^ 3\")  # ^=\n",
    "print(\"x >>= 3 -> x = x >> 3\") # >>=\n",
    "print(\"x <<= 3 -> x = x << 3\") # <<="
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = 1\n",
    "y = 2\n",
    "x == y # Equal\n",
    "x != y # Not equal\n",
    "x > y  # Greater than\n",
    "x < y  # Less than\n",
    "x >= y # Greater than or equal to\n",
    "x <= y # Less than or equal to"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Logical"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = 1\n",
    "x < 5 and  x < 10     # and - true if both are true\n",
    "x < 5 or x < 4        # or - true if one is true\n",
    "not(x < 5 and x < 10) # not - reverse result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Identity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = 1\n",
    "y = x\n",
    "print(x is y)     # True if both are the same object\n",
    "print(x is not y) # True if both are not the same object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Membership"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = 1\n",
    "y = [x, \"something\"]\n",
    "print(x in y)     # True if a sequence with the value is present in the object\n",
    "print(x not in y) # True if a sequence with the value is not present in the object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Bitwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "x = 42\n",
    "y = 35\n",
    "\n",
    "print(str(x) + \": \" + bin(x))\n",
    "print(str(y) + \": \" + bin(y))\n",
    "\n",
    "print(\"101010 &  100011  -> \" + bin(x & y))  # AND Sets each bit to 1 if both bits are 1\n",
    "print(\"101010 |  100011  -> \" + bin(x | y))  # OR Sets each bit to 1 if one of two bits is 1\n",
    "print(\"101010 ^  100011  -> \" + bin(x ^ y))  # XOR Sets each bit to 1 if only one of two bits is 1\n",
    "print(\"~101010          -> \" + bin(~x))     # NOT Inverts all the bits\n",
    "print(\"101010 << 100011 -> \" + bin(x << y)) # Shift left by pushing zeros in from the right and let the leftmost bits fall off\n",
    "print(\"101010 >> 100011 -> \" + bin(x >> y)) # Shift right by pushing copies of the leftmost bit in from the left, and let the rightmost bits fall off\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# List creation\n",
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "print(thislist)\n",
    "\n",
    "# Can have duplicates\n",
    "thislist = [\"apple\", \"banana\", \"cherry\", \"apple\", \"cherry\"]\n",
    "print(thislist)\n",
    "\n",
    "# List Length\n",
    "print(len(thislist))\n",
    "\n",
    "# Can contain any data types\n",
    "list1 = [\"abc\", 34, True, 40, \"male\"] \n",
    "\n",
    "# List Constructor\n",
    "thislist = list()\n",
    "print(thislist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Access List Items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "print(thislist[1]) # Print the second item of the list\n",
    "print(thislist[-1]) # Negative indexing means start from the end (-1 refers to the last item)\n",
    "print(thislist[1:3]) # Range of Indexes\n",
    "print(thislist[:3]) # By leaving out the start value, the range will start at the first item\n",
    "print(thislist[2:]) # By leaving out the end value, the range will go on to the end of the list\n",
    "print(thislist[-2:-1]) # Start the search from the end of the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Change List Items\n",
    "* If you insert more items than you replace, the new items will be inserted where you specified, and the remaining items will move accordingly.\n",
    "* If you insert less items than you replace, the new items will be inserted where you specified, and the remaining items will move accordingly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "thislist[1] = \"blackcurrant\" # Change by index\n",
    "print(thislist)\n",
    "\n",
    "thislist = [\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"mango\"]\n",
    "thislist[1:3] = [\"blackcurrant\", \"watermelon\"] # Change a range of values\n",
    "print(thislist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Add List Items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "thislist.append(\"orange\")\n",
    "print(thislist)\n",
    "\n",
    "thislist.insert(1, \"orange\") # Insert a new list item, without replacing any of the existing values\n",
    "print(thislist)\n",
    "\n",
    "tropical = [\"mango\", \"pineapple\", \"papaya\"]\n",
    "thislist.extend(tropical) # Append elements from another iterable object to the current list \n",
    "thislist.extend((\"kiwi\", \"orange\"))\n",
    "print(thislist)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Remove List Items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "thislist.remove(\"banana\") # remove specified item\n",
    "print(thislist)\n",
    "\n",
    "thislist.pop(1) # remove by index, without index it removes the last item\n",
    "print(thislist)\n",
    "\n",
    "del thislist[0] # remove by index\n",
    "print(thislist)\n",
    "\n",
    "thislist.clear() # empties the list\n",
    "\n",
    "del thislist # deletes the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iterate Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "# for x in list\n",
    "for x in thislist:\n",
    "  print(x)\n",
    "\n",
    "# for loop\n",
    "for i in range(len(thislist)):\n",
    "  print(thislist[i])\n",
    "\n",
    "# while loop\n",
    "i = 0\n",
    "while i < len(thislist):\n",
    "  print(thislist[i])\n",
    "  i = i + 1\n",
    "\n",
    "# list comprehension loop\n",
    "[print(x) for x in thislist] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\", \"kiwi\", \"mango\"]\n",
    "# Create a new list based on the values of an existing list\n",
    "# ..using a for loop\n",
    "newlist = []\n",
    "\n",
    "for x in fruits:\n",
    "  if \"a\" in x:\n",
    "    newlist.append(x)\n",
    "\n",
    "# ..using list comprehension\n",
    "newlist = [x for x in fruits if \"a\" in x]\n",
    "\n",
    "print(newlist) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Syntax\n",
    "newlist = [***expression*** for ***item*** in ***iterable*** if ***condition*** == True] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Iterable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "newlist = [x for x in range(10)] # List with values from 0-10 (not including 10)\n",
    "print(newlist)\n",
    "\n",
    "newlist = [x for x in range(10) if x < 5] # List with values \n",
    "print(newlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "\n",
    "newlist = [x.upper() for x in fruits]\n",
    "print(newlist)\n",
    "\n",
    "newlist = ['hello' for x in fruits] \n",
    "print(newlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "thislist = [\"orange\", \"mango\", \"kiwi\", \"pineapple\", \"banana\"]\n",
    "\n",
    "thislist.sort() # Sort the list alphabetically (case sensitive) / numerically\n",
    "thislist.sort(key = str.lower) # Sort the list alphabetically (case insensitive)\n",
    "print(thislist)\n",
    "\n",
    "thislist.sort(reverse = True) # Sort descending\n",
    "print(thislist)\n",
    "\n",
    "thislist.reverse() # Reverse the list\n",
    "print(thislist)\n",
    "\n",
    "# Custom Sorting\n",
    "def myfunc(n):\n",
    "  return abs(n - 50)\n",
    "\n",
    "thatlist = [100, 50, 65, 82, 23]\n",
    "thatlist.sort(key = myfunc)\n",
    "print(thatlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Copy Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "mylist = thislist.copy() # Copy the list\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Join Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Using + operator\n",
    "list1 = [\"a\", \"b\", \"c\"]\n",
    "list2 = [1, 2, 3]\n",
    "\n",
    "list3 = list1 + list2\n",
    "print(list3)\n",
    "\n",
    "# Appending one by one\n",
    "list1 = [\"a\", \"b\" , \"c\"]\n",
    "list2 = [1, 2, 3]\n",
    "\n",
    "for x in list2:\n",
    "  list1.append(x)\n",
    "\n",
    "print(list1) \n",
    "\n",
    "# Using extend()\n",
    "list1 = [\"a\", \"b\" , \"c\"]\n",
    "list2 = [1, 2, 3]\n",
    "\n",
    "list1.extend(list2)\n",
    "print(list1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "append() # Adds an element at the end of the list\n",
    "clear() # Removes all the elements from the list\n",
    "copy() # Returns a copy of the list\n",
    "count() # Returns the number of elements with the specified value\n",
    "extend() # Add the elements of a list (or any iterable), to the end of the current list\n",
    "index() # Returns the index of the first element with the specified value\n",
    "insert() # Adds an element at the specified position\n",
    "pop() # Removes the element at the specified position\n",
    "remove() # Removes the item with the specified value\n",
    "reverse() # Reverses the order of the list\n",
    "sort() # Sorts the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "Tuple items are ordered, unchangeable, and allow duplicate values. It's not possible to change, add or remove items after the tuple has been created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
    "print(thistuple)\n",
    "print(len(thistuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thistuple = (\"apple\",) # Tuple\n",
    "thistuple = (\"apple\")  # NOT a tuple\n",
    "thistuple = tuple((\"apple\", \"banana\")) # double round-brackets\n",
    "thattuple = (\"abc\", 34, True, 40, \"male\")\n",
    "print(type(thattuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Access"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
    "print(thistuple[1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Update\n",
    "Once a tuple is created, you cannot add items to it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-179-5cdfb278adae>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mthistuple\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"apple\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"banana\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"cherry\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mthistuple\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"orange\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
    "thistuple.append(\"orange\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
    "y = list(thistuple)\n",
    "y.append(\"orange\")\n",
    "thistuple = tuple(y)\n",
    "print(thistuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
    "y = list(thistuple)\n",
    "y.remove(\"apple\")\n",
    "thistuple = tuple(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
    "del thistuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Unpack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = (\"apple\", \"banana\", \"cherry\")\n",
    "(green, yellow, red) = fruits\n",
    "print(green)\n",
    "print(yellow)\n",
    "print(red)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Using Asterix *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = (\"apple\", \"banana\", \"cherry\", \"strawberry\", \"raspberry\")\n",
    "\n",
    "(green, yellow, *red) = fruits\n",
    "\n",
    "print(green)\n",
    "print(yellow)\n",
    "print(red)\n",
    "print(\"\\n\")\n",
    "\n",
    "(green, *tropic, red) = fruits\n",
    "print(green)\n",
    "print(tropic)\n",
    "print(red)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
    "for x in thistuple:\n",
    "  print(x) \n",
    "\n",
    "for i in range(len(thistuple)):\n",
    "  print(thistuple[i]) \n",
    "\n",
    "i = 0\n",
    "while i < len(thistuple):\n",
    "  print(thistuple[i])\n",
    "  i = i + 1 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Join Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple1 = (\"a\", \"b\" , \"c\")\n",
    "tuple2 = (1, 2, 3)\n",
    "\n",
    "tuple3 = tuple1 + tuple2\n",
    "print(tuple3)\n",
    "\n",
    "tuple4 = tuple1 * 2\n",
    "print(tuple4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuple Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "count() # Returns the number of times a specified value occurs in a tuple\n",
    "index() # Searches the tuple for a specified value and returns the position of where it was found"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets\n",
    "A set is a collection which is unchangable, unordered and unindexed. Sets are unordered, so you cannot be sure in which order the items will appear. Once a set is created, you cannot change its items, but you can add new items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
    "set1 = {\"abc\", 34, True, 40, \"male\"}\n",
    "set2 = set((\"apple\", \"banana\", \"cherry\")) # double round-brackets\n",
    "print(type(set1))\n",
    "print(thisset)\n",
    "print(len(thisset)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Duplicates Not Allowed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thisset = {\"apple\", \"banana\", \"cherry\", \"apple\"}\n",
    "print(thisset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Access Items\n",
    "You cannot access items in a set by referring to an index or a key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
    "\n",
    "for x in thisset:\n",
    "  print(x) \n",
    "\n",
    "print(\"banana\" in thisset) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Add / Remove Items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
    "thisset.add(\"orange\")\n",
    "print(thisset) \n",
    "\n",
    "thisset.update({\"pineapple\"})\n",
    "thisset.update([\"mango\"])\n",
    "print(thisset) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the item to remove does not exist, remove() will raise an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
    "thisset.remove(\"banana\")\n",
    "print(thisset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the item to remove does not exist, discard() will NOT raise an error. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
    "thisset.discard(\"banana\")\n",
    "thisset.discard(\"42\")\n",
    "print(thisset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sets are unordered, so when using the pop() method, you do not know which item that gets removed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
    "thisset.pop() # removes last item\n",
    "print(thisset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The clear() method empties the set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
    "thisset.clear()\n",
    "print(thisset) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loop Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
    "\n",
    "for x in thisset:\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Join Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1 = {\"a\", \"b\" , \"c\"}\n",
    "set2 = {1, 2, 3}\n",
    "\n",
    "set3 = set1.union(set2)\n",
    "print(set3) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1 = {\"a\", \"b\" , \"c\"}\n",
    "set2 = {1, 2, 3}\n",
    "\n",
    "set1.update(set2)\n",
    "print(set1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The intersection_update() method will keep only the items that are present in both sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = {\"apple\", \"banana\", \"cherry\"}\n",
    "y = {\"google\", \"microsoft\", \"apple\"}\n",
    "\n",
    "x.intersection_update(y)\n",
    "\n",
    "print(x) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The intersection() method will return a new set, that only contains the items that are present in both sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = {\"apple\", \"banana\", \"cherry\"}\n",
    "y = {\"google\", \"microsoft\", \"apple\"}\n",
    "\n",
    "z = x.intersection(y)\n",
    "\n",
    "print(z) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The symmetric_difference_update() method will keep only the elements that are NOT present in both sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = {\"apple\", \"banana\", \"cherry\"}\n",
    "y = {\"google\", \"microsoft\", \"apple\"}\n",
    "\n",
    "x.symmetric_difference_update(y)\n",
    "\n",
    "print(x) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The symmetric_difference() method will return a new set, that contains only the elements that are NOT present in both sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = {\"apple\", \"banana\", \"cherry\"}\n",
    "y = {\"google\", \"microsoft\", \"apple\"}\n",
    "\n",
    "z = x.symmetric_difference(y)\n",
    "\n",
    "print(z) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'add' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-180-b3258674a9c4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Adds an element to the set\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mclear\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Removes all the elements from the set\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Returns a copy of the set\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mdifference\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Returns a set containing the difference between two or more sets\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mdifference_update\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Removes the items in this set that are also included in another, specified set\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'add' is not defined"
     ]
    }
   ],
   "source": [
    "add() # Adds an element to the set\n",
    "clear() # Removes all the elements from the set\n",
    "copy() # Returns a copy of the set\n",
    "difference() # Returns a set containing the difference between two or more sets\n",
    "difference_update() # Removes the items in this set that are also included in another, specified set\n",
    "discard() # Remove the specified item\n",
    "intersection() # Returns a set, that is the intersection of two other sets\n",
    "intersection_update() # Removes the items in this set that are not present in other, specified set(s)\n",
    "isdisjoint() # Returns whether two sets have a intersection or not\n",
    "issubset() # Returns whether another set contains this set or not\n",
    "issuperset() # Returns whether this set contains another set or not\n",
    "pop() # Removes an element from the set\n",
    "remove() # Removes the specified element\n",
    "symmetric_difference() # Returns a set with the symmetric differences of two sets\n",
    "symmetric_difference_update() # inserts the symmetric differences from this set and another\n",
    "union() # Return a set containing the union of sets\n",
    "update() # Update the set with the union of this set and others"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "A dictionary is a collection which is unordered, changeable and does not allow duplicates. Dictionary items are unordered, changeable, and does not allow duplicates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thisdict =\t{\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "print(type(thisdict))\n",
    "print(thisdict)\n",
    "print(thisdict[\"brand\"])\n",
    "print(len(thisdict)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Access Items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thisdict =\t{\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "x = thisdict[\"model\"]\n",
    "x = thisdict.get(\"model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "car = {\n",
    "\"brand\": \"Ford\",\n",
    "\"model\": \"Mustang\",\n",
    "\"year\": 1964\n",
    "}\n",
    "\n",
    "print(car.keys())\n",
    "print(car.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The items() method will return each item in a dictionary, as tuples in a list. The returned list is a view of the items of the dictionary, meaning that any changes done to the dictionary will be reflected in the items list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(car.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Change Items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thisdict =\t{\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "thisdict[\"year\"] = 2018\n",
    "thisdict.update({\"model\": \"Bronco\"}) \n",
    "print(thisdict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Add / Remove Items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thisdict =\t{\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "thisdict[\"color\"] = \"red\"\n",
    "thisdict.update({\"condition\": \"new\"}) \n",
    "print(thisdict)\n",
    "\n",
    "thisdict.pop(\"model\")\n",
    "print(thisdict)\n",
    "\n",
    "thisdict.clear()\n",
    "del thisdict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loop Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "thisdict =\t{\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "\n",
    "print(\"Print all key names\")\n",
    "for x in thisdict:\n",
    "  print(x) \n",
    "\n",
    "print(\"\\nPrint all key names\")\n",
    "for x in thisdict.keys():\n",
    "  print(x) \n",
    "\n",
    "print(\"\\nPrint all values\")\n",
    "for x in thisdict:\n",
    "  print(thisdict[x]) \n",
    "\n",
    "print(\"\\nPrint all values\")\n",
    "for x in thisdict.values():\n",
    "  print(x) \n",
    "\n",
    "print(\"\\nPrint keys and values\")\n",
    "for x, y in thisdict.items():\n",
    "  print(x, y) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Copy Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thisdict =\t{\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "dict1 = thisdict.copy()\n",
    "dict2 = dict(thisdict)\n",
    "print(dict1)\n",
    "print(dict2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Nested Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "child1 = {\n",
    "  \"name\" : \"Emil\",\n",
    "  \"year\" : 2004\n",
    "}\n",
    "\n",
    "myfamily = {\n",
    "  \"child1\" : child1,\n",
    "  \"child2\" : {\n",
    "    \"name\" : \"Tobias\",\n",
    "    \"year\" : 2007\n",
    "  }\n",
    "}\n",
    "\n",
    "print(myfamily)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionary Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clear() # Removes all the elements from the dictionary\n",
    "copy() # Returns a copy of the dictionary\n",
    "fromkeys() # Returns a dictionary with the specified keys and value\n",
    "get() # Returns the value of the specified key\n",
    "items() # Returns a list containing a tuple for each key value pair\n",
    "keys() # Returns a list containing the dictionary's keys\n",
    "pop() # Removes the element with the specified key\n",
    "popitem() # Removes the last inserted key-value pair\n",
    "setdefault() # Returns the value of the specified key. If the key does not exist: insert the key, with the specified value\n",
    "update() # Updates the dictionary with the specified key-value pairs\n",
    "values() # Returns a list of all the values in the dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If..Else"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 33\n",
    "b = 200\n",
    "if b > a:\n",
    "  print(\"b is greater than a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 200\n",
    "b = 33\n",
    "if b > a:\n",
    "  print(\"b is greater than a\")\n",
    "elif a == b:\n",
    "  print(\"a and b are equal\")\n",
    "else:\n",
    "  print(\"a is greater than b\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if a > b: print(\"a is greater than b\") \n",
    "print(\"A\") if a > b else print(\"B\") \n",
    "print(\"A\") if a > b else print(\"=\") if a == b else print(\"B\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 200 > 33 and 500 > 100:\n",
    "  print(\"Both conditions are True\")\n",
    "if 200 > 33 or 100 > 100:\n",
    "  print(\"At least one of the conditions is True\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 2 > 1:\n",
    "  pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    " i = 1\n",
    "while i < 6:\n",
    "  print(i)\n",
    "  i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`break` stop the loop even if the while condition is true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1\n",
    "while i < 6:\n",
    "  print(i)\n",
    "  if i == 3:\n",
    "    break\n",
    "  i += 1 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`continue` stops the current iteration, and continue with the next"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i < 6:\n",
    "  i += 1\n",
    "  if i == 3:\n",
    "    continue\n",
    "  print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`else` runs a block of code once when the condition no longer is true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1\n",
    "while i < 6:\n",
    "  print(i)\n",
    "  i += 1\n",
    "else:\n",
    "  print(\"i is no longer less than 6\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for x in range(6):\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`break` stop the loop even if the while condition is true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "banana\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "for x in fruits:\n",
    "  print(x)\n",
    "  if x == \"banana\":\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`continue` stops the current iteration, and continue with the next"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "cherry\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "for x in fruits:\n",
    "  if x == \"banana\":\n",
    "    continue\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`else` runs a block of code once when the condition no longer is true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "Finally finished!\n"
     ]
    }
   ],
   "source": [
    "for x in range(6):\n",
    "  print(x)\n",
    "else:\n",
    "  print(\"Finally finished!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello from a function\n"
     ]
    }
   ],
   "source": [
    "def my_function():\n",
    "  print(\"Hello from a function\")\n",
    "\n",
    "my_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Emil Refsnes\n"
     ]
    }
   ],
   "source": [
    "def my_function(fname):\n",
    "  print(fname + \" Refsnes\")\n",
    "\n",
    "my_function(\"Emil\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Arbitrary Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'kids' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-187-001b18479b34>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"The youngest child is \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mkids\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mmy_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Emil\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Tobias\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Linus\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-187-001b18479b34>\u001b[0m in \u001b[0;36mmy_function\u001b[0;34m(*args)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mmy_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"The youngest child is \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mkids\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mmy_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Emil\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Tobias\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Linus\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'kids' is not defined"
     ]
    }
   ],
   "source": [
    "def my_function(*args):\n",
    "  print(\"The youngest child is \" + kids[2])\n",
    "\n",
    "my_function(\"Emil\", \"Tobias\", \"Linus\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Keyword Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def my_function(child3, child2, child1):\n",
    "  print(\"The youngest child is \" + child3)\n",
    "\n",
    "my_function(child1 = \"Emil\", child2 = \"Tobias\", child3 = \"Linus\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Arbitrary Keyword Arguments **kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function(**kwargs):\n",
    "  print(\"His last name is \" + kwargs[\"lname\"])\n",
    "\n",
    "my_function(fname = \"A\", lname = \"B\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Default Parameter Value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function(country = \"Norway\"):\n",
    "  print(\"I am from \" + country)\n",
    "\n",
    "my_function(\"Sweden\")\n",
    "my_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List Argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function(food):\n",
    "  for x in food:\n",
    "    print(x)\n",
    "\n",
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "\n",
    "my_function(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Recursion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(n):\n",
    "    if n == 0:\n",
    "        return 0\n",
    "    if n == 1:\n",
    "        return 1\n",
    "    return fib(n - 1) + fib(n - 2)\n",
    "\n",
    "print(fib(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda Functions\n",
    "A lambda function is a small anonymous function. It can take any number of arguments, but can only have one expression.\n",
    "\n",
    "$ lambda \\ arguments : expression $ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add 10 to a and return\n",
    "x = lambda a : a + 10\n",
    "print(x(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiply a with b and return\n",
    "x = lambda a, b : a * b\n",
    "print(x(5, 6)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunc(n):\n",
    "  return lambda a : a * n\n",
    "\n",
    "mytripler = myfunc(3)\n",
    "\n",
    "print(mytripler(11))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sequences and Series"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A sequence is a functions whose domain is $ \\mathbb{N} $ which in the following it is written as $ f(n)_{n\\in \\mathbb{N}^+} $ or shorter $(a_n)$ or even shorter just $a_n$.\n",
    "\n",
    "A (infinite) series is defined as \n",
    "$ \n",
    "\\sum\\limits_{n=1}^\\infty a_n \n",
    "= a_0 + a_1 + a_2 + a_3 + ... \n",
    ": a_n \n",
    "\\in \\mathbb{R} \\ or \\  \\mathbb{C} \n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fractions import Fraction\n",
    "\n",
    "def viewGen(gen, n): # return first n results of generator\n",
    "    c = 1 # counter\n",
    "    L = [] # empty list to collect results\n",
    "    for x in gen:\n",
    "        if c > n: # return if counter is higher than n\n",
    "            return L\n",
    "        c += 1 # increase counter\n",
    "        L.append(x) # append n-tht result to the list\n",
    "        \n",
    "def someValues(seq, L = [10 ** k for k in range(10)]):\n",
    "    for n in L:\n",
    "        print(\"{:>15}: {}\".format(n, seq(n)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ (3^n) $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def seq1():\n",
    "    val = 1\n",
    "    while True:\n",
    "        yield val\n",
    "        val *= 3\n",
    "\n",
    "viewGen(seq1(), 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Graphic Representation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(range(1,11), viewGen(seq1(), 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plt.scatter(viewGen(seq1(), 10), [0] * 10 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Monotone and bounded "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **monotonically increasing**:  \n",
    "$ a_n \\leq a_{n+1} $\n",
    "* **monotonically decreasing**:  \n",
    "$ a_n \\geq a_{n+1} $\n",
    "* **strictly monotonically increasing**  \n",
    "$ a_n < a_{n+1} $ and $ a_n > a_{n+1} $\n",
    "* **bounded below**: \n",
    "$ a_n \\leq K : K \\in \\mathbb{R} $\n",
    "* **bounded above**: \n",
    "$ a_n \\geq k : k \\in \\mathbb{R} $\n",
    "* **bounded**: $ k \\leq a_n \\leq K $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Convergence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The sequence $ (a_n) $ converges against $a$ is written as\n",
    "\n",
    "$ \n",
    "\\lim \\limits_{n \\to \\infty}(a_n) = a $ or\n",
    "$ (a_n) \\xrightarrow[n \\rightarrow\\infty]{} a $ or simply $ (a_n) \\xrightarrow{} a $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ (\\frac{n}{n+1}) \\xrightarrow{} 1 $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              0: 0.0\n",
      "              1: 0.5\n",
      "              2: 0.6666666666666666\n",
      "              3: 0.75\n",
      "              4: 0.8\n",
      "              5: 0.8333333333333334\n",
      "              6: 0.8571428571428571\n",
      "              7: 0.875\n",
      "              8: 0.8888888888888888\n",
      "              9: 0.9\n"
     ]
    }
   ],
   "source": [
    "someValues(lambda n : n / (n+1), range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              1: 0.5\n",
      "             10: 0.9090909090909091\n",
      "            100: 0.9900990099009901\n",
      "           1000: 0.999000999000999\n",
      "          10000: 0.9999000099990001\n",
      "         100000: 0.999990000099999\n",
      "        1000000: 0.999999000001\n",
      "       10000000: 0.99999990000001\n",
      "      100000000: 0.9999999900000001\n",
      "     1000000000: 0.999999999\n"
     ]
    }
   ],
   "source": [
    "# The sequence converges to 1\n",
    "# But this is not a mathematical proof!\n",
    "someValues(lambda n : n / (n+1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Math rules for converging sequences\n",
    "\n",
    "* $ \\lim \\limits_{n \\to \\infty}(c * a_n) \n",
    "= c * a : c \\in \\mathbb{R}$\n",
    "* $ \\lim \\limits_{n \\to \\infty}(a_n \\pm b_n) \n",
    "= a \\pm b$\n",
    "* $ \\lim \\limits_{n \\to \\infty}(a_n * b_n) \n",
    "= a * b$\n",
    "* $ \\lim \\limits_{n \\to \\infty}(\\frac{a_n}{b_n}) = \\frac{a}{b} : b \\neq 0 $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Divergent Sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If most elements $a_n > 0 $ the sequence is called **definite divergent to $\\infty$** and written as  \n",
    "\n",
    "$ \\lim \\limits_{n \\to \\infty} a_n = \\infty $\n",
    "if $\\frac{1}{a_n} \\xrightarrow{} 0 $\n",
    "\n",
    "If most elements $a_n < 0 $ the sequence is called **definite divergent to $-\\infty$** and written as  \n",
    "\n",
    "$ \\lim \\limits_{n \\to \\infty} a_n = -\\infty $\n",
    "if $\\frac{1}{a_n} \\xrightarrow{} 0 $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ (2^n) \\xrightarrow{} \\infty $\n",
    "\n",
    "$ (-n^2) \\xrightarrow{} -\\infty  $\n",
    "\n",
    "$ (n+(-1)^n) \\xrightarrow{} \\infty  $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Harmonic Sequence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ (\\frac{1}{n}) = \\sum\\limits_{n=1}^\\infty \\frac{1}{n} = \\frac{1}{1} + \\frac{1}{2} + \\frac{1}{3} + \\frac{1}{4} + ...$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Fraction(1, 1),\n",
       " Fraction(1, 2),\n",
       " Fraction(1, 3),\n",
       " Fraction(1, 4),\n",
       " Fraction(1, 5),\n",
       " Fraction(1, 6),\n",
       " Fraction(1, 7),\n",
       " Fraction(1, 8),\n",
       " Fraction(1, 9),\n",
       " Fraction(1, 10)]"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def harmonic():\n",
    "    n = 1 # Counter\n",
    "    while True: # Infinite loop\n",
    "        yield Fraction(1,n) # yield 1/n\n",
    "        n += 1 # Increase counter\n",
    "\n",
    "viewGen(harmonic(), 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Alternating Sequence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ \\frac{1}{(-2)^n} = (-1)^n*\\frac{1}{2^n} $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Fraction(1, 1),\n",
       " Fraction(-1, 2),\n",
       " Fraction(1, 4),\n",
       " Fraction(-1, 8),\n",
       " Fraction(1, 16),\n",
       " Fraction(-1, 32),\n",
       " Fraction(1, 64),\n",
       " Fraction(-1, 128),\n",
       " Fraction(1, 256),\n",
       " Fraction(-1, 512)]"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def alternating():\n",
    "    val = Fraction(1)\n",
    "    while True:\n",
    "        yield val\n",
    "        val *= -Fraction(1,2)\n",
    "\n",
    "viewGen(alternating(), 10) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Geometric"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ (q^n) \\longrightarrow 0 $ for $ |q| < 1 $\n",
    "\n",
    "$ |q| > 1 $ diverges"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ (\\frac{2}{3}^n) \\longrightarrow 0 $\n",
    "\n",
    "$ \\lim \\limits_{n \\to \\infty}(\\frac{2}{3}^n) = 0 $ but $ \\lim \\limits_{n \\to \\infty}(\\frac{3}{2}^n) = \\infty $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              1: 0.6666666666666666\n",
      "             10: 0.017341529915832606\n",
      "            100: 2.4596544265798157e-18\n",
      "           1000: 8.104774656527117e-177\n",
      "          10000: 0.0\n",
      "         100000: 0.0\n",
      "        1000000: 0.0\n",
      "       10000000: 0.0\n",
      "      100000000: 0.0\n",
      "     1000000000: 0.0\n"
     ]
    }
   ],
   "source": [
    "# The sequence converges to 0\n",
    "# The values 0.0 are math errors (numbers get too small)\n",
    "someValues(lambda n : (2/3)**n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ \\lim \\limits_{n \\to \\infty}(\\sqrt[n]{a}) = 1 $ for $a>0$, the same for $ (\\sqrt[n]{n}) $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ (\\sqrt[n]{42}) \\longrightarrow 1 $\n",
    "\n",
    "Note: $ \\sqrt[n]{a} = a^{1/n} $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              1: 42.0\n",
      "             10: 1.4531984602822678\n",
      "            100: 1.0380839894716327\n",
      "           1000: 1.0037446634161584\n",
      "          10000: 1.0003738368214026\n",
      "         100000: 1.0000373773947002\n",
      "        1000000: 1.0000037376766033\n",
      "       10000000: 1.0000003737670318\n",
      "      100000000: 1.0000000373766968\n",
      "     1000000000: 1.0000000037376697\n"
     ]
    }
   ],
   "source": [
    "someValues(lambda n : 42 ** (1/n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fractions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ \\lim \\limits_{n \\to \\infty}(\\frac{n^p}{b^n}) = 0 : p\\in\\mathbb{N}, |b|>1$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              1: 0.5\n",
      "             10: 0.9765625\n",
      "            100: 7.888609052210118e-25\n",
      "           1000: 9.332636185032189e-293\n",
      "          10000: 0.0\n",
      "         100000: 0.0\n",
      "        1000000: 0.0\n",
      "       10000000: 0.0\n",
      "      100000000: 0.0\n",
      "     1000000000: 0.0\n"
     ]
    }
   ],
   "source": [
    "someValues(lambda n : (n ** 3)/(2 ** n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ \\lim \\limits_{n \\to \\infty}(\\frac{b^n}{n!}) = 0 : b\\in\\mathbb{R}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              1: 5.0\n",
      "              2: 12.5\n",
      "             10: 2.6911444554673722\n",
      "             20: 3.919904349624791e-05\n",
      "            100: 8.45272575844283e-89\n"
     ]
    }
   ],
   "source": [
    "from math import factorial\n",
    "someValues(lambda n : (5 ** n) / factorial(n), [1, 2, 10, 20, 100])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exponential"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ ((1+\\frac{1}{n})^n) \\xrightarrow[n \\rightarrow\\infty]{} \\newcommand*\\euler{\\mathrm{e}}\\approx 2.7 $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              1: 2.0\n",
      "             10: 2.5937424601000023\n",
      "            100: 2.7048138294215285\n",
      "           1000: 2.7169239322355936\n",
      "          10000: 2.7181459268249255\n",
      "         100000: 2.7182682371922975\n",
      "        1000000: 2.7182804690957534\n",
      "       10000000: 2.7182816941320818\n",
      "      100000000: 2.7182817983473577\n",
      "     1000000000: 2.7182820520115603\n"
     ]
    }
   ],
   "source": [
    "someValues(lambda n : (1 + 1/n)**n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Recursively-defined Sequence\n",
    "\n",
    "Elements are described via their previous element."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ a_1 = 1 $,  \n",
    "$ a_2 = 2a_1 $,  \n",
    "$ a_3 = 3a_2 $,  \n",
    "...\n",
    "\n",
    "$ 1,2,6,26,120... $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def rec1(s, n):\n",
    "    yield s*n\n",
    "    yield from rec1(s*n, n + 1)\n",
    "\n",
    "viewGen(rec1(1, 1), 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ a_1 = 1 $,  \n",
    "$ a_2 = a_1 + 1 $,  \n",
    "$ a_3 = a_2 + 1 $,  \n",
    "...\n",
    "\n",
    "$ 1,2,3,4,5... $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def rec2(n):\n",
    "    yield n\n",
    "    yield from rec2(n + 1)\n",
    "\n",
    "viewGen(rec2(1), 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fibonacci\n",
    "\n",
    "The Fibonacci sequence is defined as \n",
    "\n",
    "1. $ f(0) = f(1) = 1 $\n",
    "\n",
    "2. $ f(n) = f(n-1) + f(n-2) $\n",
    "\n",
    "$ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, … $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144]"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fib():\n",
    "    a, b = 0, 1\n",
    "    while True:\n",
    "        yield a\n",
    "        a, b = b, a + b\n",
    "\n",
    "viewGen(fib(), 13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144]"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fib_rec(s = 0, n = 1):\n",
    "    if s == 0:\n",
    "        yield 0\n",
    "    if s == 0 and n == 1:\n",
    "        yield 1\n",
    "    yield s + n\n",
    "    yield from fib_rec(n, s + n)\n",
    "\n",
    "viewGen(fib_rec(), 13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "305px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}