Python - Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Basics Notes\n",
    "-----------------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Definitions\n",
    "\n",
    "**Compiling** - Translates readable code into machine instructions and also reading over code and looking for errors *(aka compilers)*\n",
    "    \n",
    "**GUI** - Graphical User Interface. Complex so it has more than just text.   \n",
    "* *ex) Chrome, MS Words, Snapchat, MAC OS*\n",
    "        \n",
    "**Console Interface** - Similar to command line interfaces so exclusively plain text and NO GRAPHICS!\n",
    "\n",
    "**Development Enviornment** - Where you code such as PYCHARM\n",
    "\n",
    "**Python** - *High Level Language* known for being *Dynamic* and *Interperted*\n",
    "* *High Level* - Easier than low level, not focused on inner workings of the machine\n",
    "* *Dynamic* - It will run the code line by line without trying to compile it\n",
    "* *Interperted* - Will not compile before execution so we want to see errors until we actually run the program\n",
    "\n",
    "**Function** - Segment of code that performs a specific task and sometimes takes input an dproduces and output\n",
    "\n",
    "**Method** - A function that is a part of a class in object oriented proramming. \n",
    "\n",
    "**Object Oriented Programming** - Lets us createe new concepts and teach them to the computer *(preloaded)*\n",
    "\n",
    "**Event-Driven Programming** - Program waits an dreacts to events rather than running code linearly. \n",
    "* *ex) search engine*\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Errors and Debugging\n",
    "\n",
    "**Types of Errors**\n",
    "1. NameError - Using a variable name that doesn't exist\n",
    "2. TypeError - Performing incorrect operation on object\n",
    "3. AttributeError - Asking information about a variable that doesn't make sense\n",
    "4. SyntaxError - Line of code can't be read by machine\n",
    "5. RuntimeError - Divide by zero, null error, or memory issue\n",
    "\n",
    "**Basic Debugging**\n",
    "1. Print Debugging/Tracing\"- Adding print statements to determine which line of code is not executing\n",
    "2. Scope Debugging - Adding print statements to check variables at different stages\n",
    "3. Rubber Duck Debugging - Programmer explains code to a ducky outloud\n",
    "\n",
    "**Advanced Debugging**\n",
    "1. Step by Step Execution - running code line by line using **Breaks** (similar to matlab)\n",
    "2. Variable Visualization - Window that displayes variables and it's contents at all times\n",
    "3. Inline Debugging - While writing code, it will show you it you've done something wrong"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print Statements\n",
    "\n",
    "The **print** statement can be used in the following different ways :\n",
    "\n",
    "* print(\"Hello World\")\n",
    "* print(\"Hello\", [Variable Containing the String])\n",
    "* print(\"Hello\" + [Variable Containing the String])\n",
    "* print(\"Hello %s\" % [Variable containing the string])\n",
    "  \n",
    "**This can be used for conversions inside the print statement itself.**\n",
    "  \n",
    "| Symbol | Task Performed |\n",
    "|----|---|\n",
    "| %s | string |\n",
    "| %d | Integer |\n",
    "| %f | Float |\n",
    "| %o | Octal |\n",
    "| %x | Hexadecimal |\n",
    "| %e | exponential |\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world!\n"
     ]
    }
   ],
   "source": [
    "print(\"hello world!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual Number = 18\n",
      "Float of the number = 18.000000\n",
      "Octal equivalent of the number = 22\n",
      "Hexadecimal equivalent of the number = 12\n",
      "Exponential equivalent of the number = 1.800000e+01\n"
     ]
    }
   ],
   "source": [
    "print(\"Actual Number = %d\" %18)\n",
    "print(\"Float of the number = %f\" %18)\n",
    "print(\"Octal equivalent of the number = %o\" %18)\n",
    "print(\"Hexadecimal equivalent of the number = %x\" %18)\n",
    "print(\"Exponential equivalent of the number = %e\" %18)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jan\n",
      "Feb\n",
      "Mar\n",
      "Apr\n",
      "May\n",
      "Jun\n",
      "Jul\n",
      "Aug\n"
     ]
    }
   ],
   "source": [
    "print(\"Jan\\nFeb\\nMar\\nApr\\nMay\\nJun\\nJul\\nAug\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Routine:\n",
      "\t- Eat\n",
      "\t- Sleep\n",
      "\t- Repeat\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"\"\"\n",
    "Routine:\n",
    "\\t- Eat\n",
    "\\t- Sleep\\n\\t- Repeat\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "**String Indexing** - `variable_name [ index ] ` will return string at that index\n",
    "\n",
    "**String Slicing** - `variable_name [ index : ]` will return everything including and after that string in the selected index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original string is: Taj Mahal is beautiful\n",
      "Indexed is: M\n",
      "Sliced is: Mahal is beautiful\n"
     ]
    }
   ],
   "source": [
    "String0 = 'Taj Mahal is beautiful'\n",
    "print(\"Original string is: %s\" %String0)\n",
    "print(\"Indexed is: %s\" %String0[4])\n",
    "print(\"Sliced is: %s\" %String0[4:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Built-In Functions Used with Strings:**\n",
    "\n",
    "| **Functions** |\n",
    "|:----:|\n",
    "| find()  |\n",
    "| capitalize()  |\n",
    "| center()  |\n",
    "| zfill()  |\n",
    "| index()  |\n",
    "| count()  |\n",
    "| .join()  |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'                        Taj Mahal is beautiful                        '"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String0 = 'Taj Mahal is beautiful'\n",
    "print(String0.find('al')) #String\n",
    "print(String0.find('j',1,3)) #Index\n",
    "String0.center(70)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Observe the first letter in this sentence.\n"
     ]
    }
   ],
   "source": [
    "String3 = 'observe the first letter in this sentence.'\n",
    "print(String3.capitalize())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "String0 = 'Taj Mahal is beautiful'\n",
    "print(String0.index('Taj'))\n",
    "print(String0.index('Mahal',0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Slices.** Let $0 \\leq a < b$. Then $a:b$ is a _slice_ that specifies the right-open interval, $[a, b)$.\n",
    "\n",
    "If $a$ (or $b$) is negative, then it is replaced with $n+a$ (or $n+b$), where $n$ is the length of the string. In other words, negative positions are interpreted as \"counting from the end.\"\n",
    "\n",
    "A slice may have a third parameter, $a:b:s$, where $s$ denotes the _step size_. Again, assume $0 \\leq a < b$ and suppose $s > 0$. Then the 3-parameter slice $a:b:s$ expands into the sequence, $a, a+s, a+2s, \\ldots, a+(k-1)s$, where $k = \\left\\lfloor\\frac{b-a}{s}\\right\\rfloor$.\n",
    "\n",
    "_Defaults._ Omitting `a`, `b`, or `s` yields the defaults of `a=0`, `b=len(x)`, and `s=1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'sa'\n",
      "''\n",
      "sae\n",
      "sae\n"
     ]
    }
   ],
   "source": [
    "bottle = \"message\"\n",
    "\n",
    "print(\"'{}'\".format(bottle[3:5]))\n",
    "print(\"'{}'\".format(bottle[5:3])) # Empty, since a >= b\n",
    "\n",
    "print(bottle[2:7:2])\n",
    "print(bottle[2::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Negative steps** ($s < 0$) reverse the direction. That is, if $s < 0$ then one cannot have a non-empty sequence unless $a > b$. The defaults for omitted $a$ and $b$ values change to $a=n-1$ and $b=-1$ (recall that the intervals are right-open)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "egassem\n",
      "easm easm\n",
      "'message'\n",
      "'m'\n"
     ]
    }
   ],
   "source": [
    "print(bottle[::-1])\n",
    "print(bottle[::-2], bottle[6::-2])\n",
    "print(\"'{}'\".format(bottle[0::1]))\n",
    "print(\"'{}'\".format(bottle[0::-1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Aside:_ **Slices are objects!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "easm easm\n"
     ]
    }
   ],
   "source": [
    "ind = slice(6, None, -2)\n",
    "print(bottle[6::-2], bottle[ind])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators\n",
    "### Arithmetic Operators\n",
    "\n",
    "| Symbol | Task Performed |\n",
    "|----|---|\n",
    "| +  | Addition |\n",
    "| -  | Subtraction |\n",
    "| /  | division |\n",
    "| %  | quotient / mod |\n",
    "| *  | multiplication |\n",
    "| //  | floor division |\n",
    "| **  | to the power of |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Relational Operators\n",
    "| Symbol | Task Performed |\n",
    "|----|---|\n",
    "| == | True, if it is equal |\n",
    "| !=  | True, if not equal to |\n",
    "| < | less than |\n",
    "| > | greater than |\n",
    "| <=  | less than or equal to |\n",
    "| >=  | greater than or equal to |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean Operators\n",
    "| Symbol | Task Performed |\n",
    "|----|---|\n",
    "| &  | Logical And |\n",
    "| l  | Logical OR |\n",
    "| ^  | XOR |\n",
    "| ~  | Negate |\n",
    "| >>  | Right shift |\n",
    "| <<  | Left shift |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type Conversions\n",
    "\n",
    "| Symbol | Task Performed |\n",
    "|----|---|\n",
    "| str()  | Convert anything to string |\n",
    "| int()  | Convert to int |\n",
    "| bool()  | Convert to F-0 T-1 |\n",
    "| float()  | Convert to float decimal |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simplified Operations\n",
    "\n",
    "| Symbol | Task Performed |\n",
    "|----|---|\n",
    "| round()  | Round value |\n",
    "| abs()  | Absolute value |\n",
    "| complex()  | Define complex value  |\n",
    "| input()  | Accepts int and str|\n",
    "| type()  | Type of variable |\n",
    "| range()  | Range |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "4.56\n"
     ]
    }
   ],
   "source": [
    "print(round(5.6231)) \n",
    "print(round(4.55892, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.385164807134504\n"
     ]
    }
   ],
   "source": [
    "c =complex('5+2j')\n",
    "print(abs(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**range( )** function outputs the integers of the specified range. Generally add a value to the last number as it does not include it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 3)\n",
      "range(2, 9)\n",
      "range(2, 27, 8)\n"
     ]
    }
   ],
   "source": [
    "print(range(3))\n",
    "print(range(2,9))\n",
    "print(range(2,27,8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Booleans and bit manipulation\n",
    "\n",
    "Boolean variables can take on the values of `True` or `False`. The built-in boolean operations are `and`, `or`, and `not`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(True and False)\n",
    "print(True or True)\n",
    "print(not True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to booleans, you can also perform bit-level manipulations on integers. The following operators perform logical operations bitwise between the corresponding bits of the operands.\n",
    "\n",
    "\n",
    "| Operator     | Name            | Description                                 |\n",
    "|--------------|-----------------|---------------------------------------------|\n",
    "| ``a & b``    | Bitwise AND     | Bits defined in both ``a`` and ``b``        |\n",
    "| <code>a &#124; b</code>| Bitwise OR      | Bits defined in ``a`` or ``b`` or both      |\n",
    "| ``a ^ b``    | Bitwise XOR     | Bits defined in ``a`` or ``b`` but not both |\n",
    "| ``a << b``   | Bit shift left  | Shift bits of ``a`` left by ``b`` units     |\n",
    "| ``a >> b``   | Bit shift right | Shift bits of ``a`` right by ``b`` units    |\n",
    "| ``~a``       | Bitwise NOT     | Bitwise negation of ``a``                          |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0b101\n",
      "0b101\n",
      "101\n",
      "0b101 101\n",
      "0000101\n",
      "          \n",
      "000101\n",
      "001101\n",
      "000101\n"
     ]
    }
   ],
   "source": [
    "print(bin(5))\n",
    "print(format(5, '#b'))\n",
    "print(format(5, 'b')) # no prefix\n",
    "print(f'{5:#b}', f'{5:b}')\n",
    "print('{:07b}'.format(5)) # 7 bits with leading zeros\n",
    "\n",
    "print('          ')\n",
    "\n",
    "print('{:06b}'.format(5)) # or use '{:#06b}' for a 6-bit string prefixed by '0b'\n",
    "print('{:06b}'.format(13))\n",
    "print('{:06b}'.format(5 & 13))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Structures\n",
    "**The collection or group of data in a structure**\n",
    "\n",
    "### Lists\n",
    "Lists are the most commonly used data structure: `parentlist=[ item1, item2 ]`\n",
    "\n",
    "You can combine int and str in lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 8]\n"
     ]
    }
   ],
   "source": [
    "a = ['apple', 8]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Concat lists: [1, 2, 3] + [4, 'xo', 6.7, True] = [1, 2, 3, 4, 'xo', 6.7, True] (total length is 7)\n",
      "3 xo True\n",
      "[3, 'xo', True]\n",
      "[True, 6.7, 'xo', 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "y = [4, \"xo\", 6.7, True]\n",
    "z = x + y\n",
    "print(\"Concat lists: {} + {} = {} (total length is {})\".format(x, y, z, len(z)))\n",
    "print(z[2], z[4], z[6])\n",
    "print(z[2::2]) # slice (and later, dice)\n",
    "print(z[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**List constructor.** The list type, denoted by `list` in Python, can also be used to construct an empty list or a list object from another collection type. A pair of empty square brackets is synonymous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "[]\n",
      "['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
     ]
    }
   ],
   "source": [
    "empty_list = []\n",
    "print(empty_list)\n",
    "\n",
    "another_empty_list = list()\n",
    "print(another_empty_list)\n",
    "\n",
    "list_from_string = list('abcdefg')\n",
    "print(list_from_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Modifying lists:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 'xo', 6.7, True, 'one more value...']\n",
      "[1, 2, -7, 4, 'xo', 6.7, True, 'one more value...']\n",
      "[1, 2, 3, 4, 'xo', 6.7, True, 'one more value...']\n",
      "[1, 2, 3, 4, 'xo', 6.7, True, 'one more value...', 'one more value...']\n",
      "[1, 2, 3, 4, 'xo', 6.7, True, 'one more value...', 'one more value...']\n",
      "['one more value...', 'one more value...', True, 6.7, 'xo', 4, 3, 2, 1]\n",
      "[1, 2, 3, 4, 'xo', 6.7, True, 'one more value...', 'one more value...']\n"
     ]
    }
   ],
   "source": [
    "# Make a change\n",
    "print(z)\n",
    "z[2] = -(z[2] + z[3])\n",
    "print(z)\n",
    "\n",
    "# Undo the change\n",
    "z[2] *= -1\n",
    "z[2] -= z[3]\n",
    "print(z)\n",
    "\n",
    "z.append(\"one more value...\")  # Methods, some of which involve in-place modifications\n",
    "print(z)\n",
    "\n",
    "print(z)\n",
    "z.reverse()\n",
    "print(z)\n",
    "z.reverse() # Undo\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**List comprehensions.** Use this compact construct to build up lists of values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 'xoxo', 13.4, 2]\n"
     ]
    }
   ],
   "source": [
    "c = [2*xi for xi in x+y] # \"double\" every element\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Conditional Clause:** For filtering comprehension values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "g = [4, 6, 0, 2, 7, 8, 1, 3, 9, 5]\n",
      "h = even(g) = [4, 6, 0, 2, 8]\n"
     ]
    }
   ],
   "source": [
    "g = [i for i in range(10)] # 0 .. 9\n",
    "\n",
    "from random import shuffle\n",
    "shuffle(g) # permute randomly\n",
    "\n",
    "print('g =', g)\n",
    "\n",
    "# Select only even values\n",
    "h = [i for i in g if (i % 2) == 0]\n",
    "print('h = even(g) =', h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indexing a List: \n",
    "Lists can be indexed in the reverse order: `parentlist[ index ] `\n",
    "\n",
    "**Note that lists always start indexing at 0**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'apple'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = ['apple', 8]\n",
    "a[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Nested Lists\n",
    "This list inside a list is called as nested lists and is how an array would be declared."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['apple', 'orange'], ['carrot', 'potato']]\n"
     ]
    }
   ],
   "source": [
    "x = ['apple', 'orange']\n",
    "y = ['carrot','potato']\n",
    "z  = [x,y]\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Indexing a Nested List:**\n",
    "\n",
    "Access a list inside a list: `parentlist[index]`\n",
    "\n",
    "Access value inside specific list in nested list: `parentlist[index1][index2] `"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['apple', 'orange'], ['carrot', 'potato']]\n",
      "['apple', 'orange']\n",
      "apple\n"
     ]
    }
   ],
   "source": [
    "x = ['apple', 'orange']\n",
    "y = ['carrot','potato']\n",
    "z  = [x,y]\n",
    "print(z)\n",
    "print(z[0])\n",
    "print(z[0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Slicing\n",
    "This is accessing a sequence of data inside the list.\n",
    "Slicing is done by defining the index values of the first element and the last element from the parent list that is required in the sliced list. It is written as `parentlist[ a : b ]` where a,b are the index values from the parent list. If a or b is not defined then the index value is considered to be the first value for a if a is not defined and the last value for b when b is not defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[0, 1, 2, 3]\n",
      "[4, 5, 6, 7, 8, 9]\n",
      "[0, 3, 6]\n"
     ]
    }
   ],
   "source": [
    "num = [0,1,2,3,4,5,6,7,8,9]\n",
    "print(num)\n",
    "print(num[0:4])\n",
    "print(num[4:])\n",
    "print(num[:9:3]) #fixed step"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Built in List Functions\n",
    "\n",
    "| Function | \n",
    "|:----:|\n",
    "| len()  |\n",
    "| min()  |\n",
    "| max()  |\n",
    "| lst.append()  |\n",
    "| lst.count()  |\n",
    "| lst.index()  |\n",
    "| lst.insert()  |\n",
    "| lst.pop()  |\n",
    "| lst.reverse()  |\n",
    "| lst.sort()  |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control Structures\n",
    " ### IF Conditions\n",
    " \n",
    " #### `if some_condition: `\n",
    " \n",
    "     algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "x = 12\n",
    "if x >10:\n",
    "    print(\"Hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `if some_condition: `\n",
    " \n",
    "     algorithm\n",
    "\n",
    "#### `else some_condition: `\n",
    "\n",
    "     algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "x = 12\n",
    "if x > 10:\n",
    "    print(\"hello\")\n",
    "else:\n",
    "    print(\"world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `if some_condition: `\n",
    " \n",
    "     algorithm\n",
    "\n",
    "#### `elif some_condition: `\n",
    "\n",
    "     algorithm\n",
    "\n",
    "#### `else some_condition: `\n",
    "\n",
    "     algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x<y\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = 12\n",
    "if x > y:\n",
    "    print(\"x>y\")\n",
    "elif x < y:\n",
    "    print(\"x<y\")\n",
    "else:\n",
    "    print(\"x=y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For Loops\n",
    "#### `for variable in something:`\n",
    "    \n",
    "    algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First loop:\n",
      "1\n",
      "2\n",
      "3\n",
      "Second loop:\n",
      "-3\n",
      "-2\n",
      "-1\n",
      "0\n",
      "Third loop:\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "print(\"First loop:\")\n",
    "for i in range(1, 4, 1):\n",
    "    print(i)\n",
    "\n",
    "print(\"Second loop:\")\n",
    "for i in range(-3,1,1):\n",
    "    print(i)\n",
    "\n",
    "print(\"Third loop:\")\n",
    "for i in range(2,11,2):\n",
    "    print(i)\n",
    "    \n",
    "## OR\n",
    "#for i in range(1, 11):\n",
    "    #if i % 2 == 0: ## checks if it's even\n",
    "        #print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[4, 5, 6]\n",
      "[7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "for list1 in list_of_lists:\n",
    "        print(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "6\n",
      "7\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "list_of_lists = [[1, 2], [4, 6], [7, 8]]\n",
    "for list1 in list_of_lists:\n",
    "    for x in list1:\n",
    "        print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While Loops\n",
    "#### `while some_condition: `\n",
    "\n",
    "    algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "yellow\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i < 3:\n",
    "    print(i ** 2)\n",
    "    i = i+1\n",
    "print('yellow')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Break and Continue\n",
    "\n",
    "**This is used to break out of a loop when a condition becomes true during execution. Afterwards you can continue the loop**\n",
    "\n",
    "`break` and `continue`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "for i in range(100):\n",
    "    print(i)\n",
    "    if i>=7:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "The end.\n",
      "The end.\n",
      "The end.\n",
      "The end.\n",
      "The end.\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    if i>4:\n",
    "        print(\"The end.\")\n",
    "        continue\n",
    "    elif i<7:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Comprehensions\n",
    "\n",
    "**Generate a required list with a single line of code using list comprehensions:**\n",
    "\n",
    "*For example If i need to generate multiples of say 27 I write the code using for loop as:*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[27, 54, 81, 108, 135, 162, 189, 216, 243, 270]\n"
     ]
    }
   ],
   "source": [
    "res = []\n",
    "for i in range(1,11):\n",
    "    x = 27*i\n",
    "    res.append(x)\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since you are generating another list altogether and that is what is required, List comprehensions is a more efficient way to solve this problem. \n",
    "\n",
    "**Remember to enclose it in square brackets**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[27, 54, 81, 108, 135, 162, 189, 216, 243, 270]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[27*x for x in range(1,11)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "Most of the times, In a algorithm the statements keep repeating and it will be a tedious job to execute the same statements again and again and will consume a lot of memory and is not efficient. Enter Functions.\n",
    "\n",
    "**This is the basic syntax of a function:**\n",
    "\n",
    "`def funcname(arg1, arg2,... argN):`\n",
    "\n",
    "`''' Document String'''`\n",
    "\n",
    "`statements`\n",
    "\n",
    "`return <value>`\n",
    "\n",
    "Read the above syntax as, A function by name \"funcname\" is defined, which accepts arguements \"arg1,arg2,....argN\". The function is documented and it is '''Document String'''. The function after executing the statements returns a \"value\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter your name :mom\n",
      "Hey mom!\n",
      "mom, How do you do?\n"
     ]
    }
   ],
   "source": [
    "## Define the Function ##\n",
    "def firstfunc(username):\n",
    "    print(\"Hey\", username + '!')\n",
    "    print(username + ',' ,\"How do you do?\")\n",
    "    \n",
    "## Take Input ##    \n",
    "name1 = input('Please enter your name :')\n",
    "\n",
    "## Call the Function ##\n",
    "firstfunc(name1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simplify this even further by defining another function secondfunc() which accepts the name and stores it inside a variable and then calls the firstfunc() from inside the function itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter your name : mom\n",
      "Hey mom!\n",
      "mom, How do you do?\n"
     ]
    }
   ],
   "source": [
    "def firstfunc(username):\n",
    "    print(\"Hey\", username + '!')\n",
    "    print(username + ',' ,\"How do you do?\")\n",
    "def secondfunc():\n",
    "    name = input(\"Please enter your name : \")\n",
    "    firstfunc(name)\n",
    "    \n",
    "secondfunc()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Return Statements\n",
    "\n",
    "When the function results in some value and that value has to be stored in a variable or needs to be sent back or returned for further operation to the main algorithm, a return statement is used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "def times(x,y):\n",
    "    z = x*y\n",
    "    return z\n",
    "\n",
    "c = times(4,5)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we defined times( ) function accepts two arguements and return the variable z which contains the result of the product of the two arguements. The z value is stored in variable c and can be used for further operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Global and Local Variables\n",
    "\n",
    "Whatever variable is declared inside a function is local variable and outside the function in global variable.\n",
    "\n",
    "In the function below we are appending a element to the declared list inside the function. eg2 variable declared inside the function is a local variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes\n",
    "\n",
    "Variables, Lists, Dictionaries etc in python is a object (Object Oriented Programming)\n",
    "\n",
    "A class is a structure in Python that can be used as a blueprint to create objects that have\n",
    "\n",
    "1. prototyped features, \"attributes\" that are variable\n",
    "\n",
    "2. \"methods\" which are functions that can be applied to the object that is created, or rather, an instance of that class.\n",
    "\n",
    "\n",
    "**A class is declared as follows:**\n",
    "\n",
    "   `class class_name:`\n",
    "\n",
    "        Functions\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FirstClass:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note that** `pass` **means do nothing** "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining a class\n",
    "\n",
    "We want to define a class called *Client* in which a new instance stores a client's name, balance, and account level.\n",
    "It will take the format of:\n",
    "    \n",
    "    class Client(object):\n",
    "        def __init__(self, args[, ...])\n",
    "            #more code\n",
    "            \n",
    "\"def `__init__`\" is what we use when creating classes to define how we can create a new instance of this class. \n",
    "\n",
    "The arguments of `__init__` are required input when creating a new instance of this class, except for 'self'. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create the Client class below\n",
    "class Client(object):\n",
    "    def __init__(self, name, balance):\n",
    "        self.name = name\n",
    "        self.balance = balance + 100\n",
    "        \n",
    "        #define account level\n",
    "        if self.balance < 5000:\n",
    "            self.level = \"Basic\"\n",
    "        elif self.balance < 15000:\n",
    "            self.level = \"Intermediate\"\n",
    "        else:\n",
    "            self.level = \"Advanced\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **attributes** in *Client* are *name, balance* and *level*. \n",
    "\n",
    "**Note**: \"self.name\" and \"name\" are different variables. Here they represent the same values, but in other cases, this may lead to problems. For example, here the bank has decided to update \"self.balance\" by giving all new members a bonus $100 on top of what they're putting in the bank. Calling \"balance\" for other calculations will not have the correct value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating an Instance of a Class\n",
    "\n",
    "Now, lets try creating some new clients named John_Doe, and Jane_Defoe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "John_Doe = Client(\"John Doe\", 500)\n",
    "Jane_Defoe = Client(\"Jane Defoe\", 150000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see the attributes of John_Doe, or Jane_Defoe by calling them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "150100"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "John_Doe.name\n",
    "Jane_Defoe.level\n",
    "Jane_Defoe.balance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also add, remove or modify attributes as we like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "John_Doe.email = \"jdoe23@gmail.com\"\n",
    "John_Doe.email = \"johndoe23@gmail.com\"\n",
    "del John_Doe.email"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'jdoe23@gmail.com'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getattr(John_Doe, 'name')\n",
    "setattr(John_Doe, 'email', 'jdoe23@gmail.com')\n",
    "John_Doe.email"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use the following instead of the normal statements:\n",
    "\n",
    "- The `getattr(obj, name[, default])` : to access the attribute of object.\n",
    "\n",
    "- The `hasattr(obj,name)` : to check if an attribute exists or not.\n",
    "\n",
    "- The `setattr(obj,name,value)` : to set an attribute. If attribute does not exist, then it would be created.\n",
    "\n",
    "- The `delattr(obj, name)` : to delete an attribute."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Attributes vs. Normal Attributes\n",
    "\n",
    "A class attribute is an attribute set at the class-level rather than the instance-level, such that the value of this attribute will be the same across all instances.\n",
    "\n",
    "For our *Client* class, we might want to set the name of the bank, and the location, which would not change from instance to instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "Client.bank = \"TD\"\n",
    "Client.location = \"Toronto, ON\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'TD'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# try calling these attributes at the class and instance level\n",
    "Client.bank\n",
    "Jane_Defoe.bank"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Methods\n",
    "\n",
    "A class method is a type of method that will receive the class rather than the instance as the first parameter. It is also identified similarly to a static method, with `@classmethod`.\n",
    "\n",
    "Create a class method called bank_location() that will print both the bank name and location when called upon the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add a class method called bank_location()\n",
    "# create the Client class below\n",
    "class Client(object):\n",
    "    bank = \"TD\"\n",
    "    location = \"Toronto, ON\"\n",
    "    \n",
    "    def __init__(self, name, balance):\n",
    "        self.name = name\n",
    "        self.balance = balance + 100\n",
    "        \n",
    "        #define account level\n",
    "        if self.balance < 5000:\n",
    "            self.level = \"Basic\"\n",
    "        elif self.balance < 15000:\n",
    "            self.level = \"Intermediate\"\n",
    "        else:\n",
    "            self.level = \"Advanced\"\n",
    "            \n",
    "    @classmethod\n",
    "    def bank_location(cls):\n",
    "        return str(cls.bank + \" \" + cls.location)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'TD Toronto, ON'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Client.bank_location()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Key Concept: Inheritance\n",
    "\n",
    "A 'child' class can be created from a 'parent' class, whereby the child will bring over attributes and methods that its parent has, but where new features can be created as well. \n",
    "\n",
    "This would be useful if you want to create multiple classes that would have some features that are kept the same between them. You would simply create a parent class of these children classes that have those maintained features.\n",
    "\n",
    "Imagine we want to create different types of clients but still have all the base attributes and methods found in client currently. \n",
    "\n",
    "For example, let's create a class called *Savings* that inherits from the *Client* class. In doing so, we do not need to write another `__init__` method as it will inherit this from its parent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create the Savings class below\n",
    "class Savings(Client):\n",
    "    interest_rate = 0.005\n",
    "    \n",
    "    def update_balance(self):\n",
    "        self.balance += self.balance*self.interest_rate\n",
    "        return self.balance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create an instance the same way as a Client but this time by calling Savings instead\n",
    "Lina_Tran = Savings(\"Lina Tran\", 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lina Tran\n",
      "150\n",
      "0.005\n"
     ]
    }
   ],
   "source": [
    "# it now has access to the new attributes and methods in Savings...\n",
    "print(Lina_Tran.name)\n",
    "print(Lina_Tran.balance)\n",
    "print(Lina_Tran.interest_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "150.75"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ...as well as access to attributes and methods from the Client class as well\n",
    "Lina_Tran.update_balance()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "#defining a method outside the class definition\n",
    "def check_balance(self):\n",
    "    return self.balance\n",
    "\n",
    "Client.check_balance = check_balance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Client' object has no attribute 'check_balance'",
     "output_type": "error",
     "traceback": [
      "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[1;31mAttributeError\u001B[0m                            Traceback (most recent call last)",
      "\u001B[1;32m<ipython-input-46-865726cb3b7d>\u001B[0m in \u001B[0;36m<module>\u001B[1;34m\u001B[0m\n\u001B[1;32m----> 1\u001B[1;33m \u001B[0mJohn_Doe\u001B[0m\u001B[1;33m.\u001B[0m\u001B[0mcheck_balance\u001B[0m\u001B[1;33m(\u001B[0m\u001B[1;33m)\u001B[0m\u001B[1;33m\u001B[0m\u001B[1;33m\u001B[0m\u001B[0m\n\u001B[0m",
      "\u001B[1;31mAttributeError\u001B[0m: 'Client' object has no attribute 'check_balance'"
     ]
    }
   ],
   "source": [
    "John_Doe.check_balance()"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}