Public_SafariOnline_Day1_Part2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Public-SafariOnline-Day1-Part2.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [
        "_kubx9jlEvOK",
        "o3LoKqH5FvBP",
        "bJJH_ybw-CkM",
        "KWDrBDOdN_77",
        "IdqC6jq5e4jd"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/noahgift/functional_intro_to_python/blob/master/Public_SafariOnline_Day1_Part2.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4J2lIggJLUMS",
        "colab_type": "text"
      },
      "source": [
        "# **Essential Machine Learning and Exploratory Data Analysis with Python and Jupyter Notebook**\n",
        "\n",
        "## Pragmatic AI Labs\n",
        "![alt text](https://paiml.com/images/logo_with_slogan_white_background.png)\n",
        "\n",
        "This notebook was produced by [Pragmatic AI Labs](https://paiml.com/).  You can continue learning about these topics by:\n",
        "\n",
        "*   Buying a copy of [Pragmatic AI: An Introduction to Cloud-Based Machine Learning](http://www.informit.com/store/pragmatic-ai-an-introduction-to-cloud-based-machine-9780134863917)\n",
        "*   Reading an online copy of [Pragmatic AI:Pragmatic AI: An Introduction to Cloud-Based Machine Learning](https://www.safaribooksonline.com/library/view/pragmatic-ai-an/9780134863924/)\n",
        "*  Watching video [Essential Machine Learning and AI with Python and Jupyter Notebook-Video-SafariOnline](https://www.safaribooksonline.com/videos/essential-machine-learning/9780135261118) on Safari Books Online.\n",
        "* Purchasing video [Essential Machine Learning and AI with Python and Jupyter Notebook- Purchase Video](http://www.informit.com/store/essential-machine-learning-and-ai-with-python-and-jupyter-9780135261095)\n",
        "*   Viewing more content at [noahgift.com](https://noahgift.com/)\n",
        "### Additional Related Topics from Noah Gift\n",
        "\n",
        "His most recent books are:\n",
        "\n",
        "*   [Pragmatic A.I.:   An introduction to Cloud-Based Machine Learning (Pearson, 2018)](https://www.amazon.com/Pragmatic-AI-Introduction-Cloud-Based-Analytics/dp/0134863860)\n",
        "*   [Python for DevOps (O'Reilly, 2020)](https://www.amazon.com/Python-DevOps-Ruthlessly-Effective-Automation/dp/149205769X). \n",
        "\n",
        "His most recent video courses are:\n",
        "\n",
        "*   [Essential Machine Learning and A.I. with Python and Jupyter Notebook LiveLessons (Pearson, 2018)](https://learning.oreilly.com/videos/essential-machine-learning/9780135261118)\n",
        "*   [AWS Certified Machine Learning-Specialty (ML-S) (Pearson, 2019)](https://learning.oreilly.com/videos/aws-certified-machine/9780135556597)\n",
        "*   [Python for Data Science Complete Video Course Video Training (Pearson, 2019)](https://learning.oreilly.com/videos/python-for-data/9780135687253)\n",
        "*   [AWS Certified Big Data - Specialty Complete Video Course and Practice Test Video Training (Pearson, 2019)](https://learning.oreilly.com/videos/aws-certified-big/9780135772324)\n",
        "*   [Building A.I. Applications on Google Cloud Platform (Pearson, 2019)](https://learning.oreilly.com/videos/building-ai-applications/9780135973462)\n",
        "*   [Pragmatic AI and Machine Learning Core Principles (Pearson, 2019)](https://learning.oreilly.com/videos/pragmatic-ai-and/9780136554714)\n",
        "*   [Data Engineering with Python and AWS Lambda (Pearson, 2019)](https://learning.oreilly.com/videos/data-engineering-with/9780135964330)\n",
        "\n",
        "His most recent online courses are:\n",
        "\n",
        "*   [Microservices with this Udacity DevOps Nanodegree (Udacity, 2019)](https://www.udacity.com/course/cloud-dev-ops-nanodegree--nd9991)\n",
        "*   [Command Line Automation in Python (DataCamp, 2019)](https://www.datacamp.com/instructors/ndgift)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o_M3Vd7KL1x5",
        "colab_type": "text"
      },
      "source": [
        "## Part 1.3: Understanding Libraries, Classes, Control Structures,  and Regular Expressions (45 minutes)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5zTvkFF5C-FT",
        "colab_type": "text"
      },
      "source": [
        "### Writing And Using Libraries In Python\n",
        "\n",
        "* *[Read related material covered in Chapter 7 of Pragmatic AI](https://www.safaribooksonline.com/library/view/pragmatic-ai-an/9780134863924/ch07.xhtml#ch07lev2)*\n",
        "\n",
        "* *[Watch Video Lesson 4:  Writing, Using and Deploying Libraries in Python](https://www.safaribooksonline.com/videos/essential-machine-learning/9780135261118/9780135261118-EMLA_01_04_00)*\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XusDa6zzGAEp",
        "colab_type": "text"
      },
      "source": [
        "#### Creating A Full Python Project\n",
        "\n",
        "* A more complete example can be found by walking through this Github project: https://github.com/noahgift/myrepo\n",
        "\n",
        "* An [article for CircleCI also talks more about this](https://circleci.com/blog/increase-reliability-in-data-science-and-machine-learning-projects-with-circleci/)\n",
        "\n",
        "* [Five Minute YouTube video](https://www.youtube.com/watch?v=xYX7n5bZw-w&t=62s) on building a repo from scratch\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kROp-yB4GANl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_kubx9jlEvOK",
        "colab_type": "text"
      },
      "source": [
        "#### Writing a library in Python\n",
        "It doesn't take long into a project before writing a library in python becomes important.  These are the basics\n",
        "In this repository there is a folder called ```funclib``` and inside is a ```__init__.py``` file.  To create a library, a module is needed in this directory with a function in it.\n",
        "\n",
        "Create a file:\n",
        "\n",
        "```\n",
        "touch funclib/funcmod.py\n",
        "\n",
        "```\n",
        "\n",
        "Inside this file, a function is created:\n",
        "\n",
        "\n",
        "```python\n",
        "\"\"\"This is a simple module\"\"\"\n",
        "\n",
        "def list_of_belts_in_bjj():\n",
        "    \"\"\"Returns a list of the belts in Brazilian Jiu Jitsu\"\"\"\n",
        "\n",
        "    belts = [\"white\", \"blue\", \"purple\", \"brown\", \"black\"]\n",
        "    return belts\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3hn85IdfFa9r",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tabQrkIXEyVg",
        "colab_type": "text"
      },
      "source": [
        "#### Using and Importing the library\n",
        "With Jupyter, if a library is directory above, sys.path.append can be added so it will be imported.\n",
        "Next, the module is imported using the namespace of the folder/filename/function name that was created earlier.\n",
        "\n",
        "```python\n",
        "import sys;sys.path.append(\"..\")\n",
        "from funclib import funcmod\n",
        "\n",
        "funcmod.list_of_belts_in_bjj()\n",
        "\n",
        "['white', 'blue', 'purple', 'brown', 'black']\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "60_2HtlPFDB-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mUiflyHRFdbR",
        "colab_type": "text"
      },
      "source": [
        "#### Installing other libraries using pip install\n",
        "\n",
        "Installing other libraries can be done with the ```pip install``` command\n",
        "\n",
        "To install the pandas package:\n",
        "\n",
        "```pip install pandas```\n",
        "\n",
        "Alternatively packages can be installed using a requirements.txt file\n",
        "\n",
        "```\n",
        "> cat requirements.txt \n",
        "pylint\n",
        "pytest\n",
        "pytest-cov\n",
        "click\n",
        "jupyter\n",
        "nbval\n",
        "\n",
        "> pip install -r requirements.txt\n",
        "\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YbHAlH7-PG_p",
        "colab_type": "code",
        "outputId": "b531f0bc-e92f-4c03-f2c0-5e1e22e43d43",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "%%writefile requirements.txt\n",
        "pylint\n",
        "pytest"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Writing requirements.txt\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mq9W5_cdPNLd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install -r requirements.txt"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eDwPrpbYunMU",
        "colab_type": "text"
      },
      "source": [
        "##### This is a great way to quiet colab installs"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jhEcA6_gFtrA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install -q pandas\n",
        "!pip install -q numpy"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o3LoKqH5FvBP",
        "colab_type": "text"
      },
      "source": [
        "##### To Use A 3rd Party Library in Python\n",
        "Import it in the library we created earlier\n",
        "\n",
        "```python\n",
        "\"\"\"This is a simple module\"\"\"\n",
        "\n",
        "import pandas as pd\n",
        "\n",
        "def list_of_belts_in_bjj():\n",
        "    \"\"\"Returns a list of the belts in Brazilian Jiu Jitsu\"\"\"\n",
        "\n",
        "    belts = [\"white\", \"blue\", \"purple\", \"brown\", \"black\"]\n",
        "    return belts\n",
        "\n",
        "def count_belts():\n",
        "    \"\"\"Uses Pandas to count number of belts\"\"\"\n",
        "\n",
        "    belts = list_of_belts_in_bjj()\n",
        "    df = pd.DataFrame(belts)\n",
        "    res = df.count()\n",
        "    count = res.values.tolist()[0]\n",
        "    return count \n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jA6vWH6AFvmv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import pandas as pd\n",
        "\n",
        "def list_of_belts_in_bjj():\n",
        "    \"\"\"Returns a list of the belts in Brazilian Jiu Jitsu\"\"\"\n",
        "\n",
        "    belts = [\"white\", \"blue\", \"purple\", \"brown\", \"black\"]\n",
        "    return belts\n",
        "\n",
        "def count_belts():\n",
        "    \"\"\"Uses Pandas to count number of belts\"\"\"\n",
        "\n",
        "    belts = list_of_belts_in_bjj()\n",
        "    df = pd.DataFrame(belts)\n",
        "    return df"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "krz_s5ZSfDnA",
        "colab_type": "code",
        "outputId": "18947db4-72c6-4699-ee49-e88ef76699ec",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 80
        }
      },
      "source": [
        "df = count_belts()\n",
        "df.tail(1)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>0</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>black</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "       0\n",
              "4  black"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wQIK5-fWGir3",
        "colab_type": "text"
      },
      "source": [
        "### Understanding Python Classes \n",
        "\n",
        "* *[Watch Video Lesson 5:  Understanding Python Classes](https://www.safaribooksonline.com/videos/essential-machine-learning/9780135261118/9780135261118-EMLA_01_05_00)*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rMA9KJbaG1T2",
        "colab_type": "text"
      },
      "source": [
        "#### Differences Between Classes and Functions\n",
        "The key differences between Classes and Functions are:\n",
        "\n",
        "* Functions are much easier to reason about\n",
        "* Functions (typically) have state inside the function only, where classes have state persists outside of the function\n",
        "* Classes can offer a more advanced level of abstraction at the cost of complexity"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CRj3o_0RHAxp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9DsnmUoyHGzx",
        "colab_type": "text"
      },
      "source": [
        "#### Creating an empty Class\n",
        "Using classes and interacting with them can be done iteratively in Jupyter Notebook.\n",
        "The simplest type of class is just a name as shown below:\n",
        "```\n",
        "class Competitor: pass\n",
        "```\n",
        "But, that class can be instantiated into multiple objects"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sNXweYZZHOhS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Competitor: pass"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7bNTtyGvHh7E",
        "colab_type": "text"
      },
      "source": [
        "#### Setting Attributes on an Object"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u6WPt43tHkji",
        "colab_type": "code",
        "outputId": "66723ff4-b028-46bb-a913-b2ccef88030b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "conor = Competitor()\n",
        "conor.name = \"Conor McGregor\"\n",
        "conor.age = 29\n",
        "conor.weight = 155\n",
        "\n",
        "conor.__dict__\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'age': 29, 'name': 'Conor McGregor', 'weight': 155}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AKMUUCnAHmM1",
        "colab_type": "code",
        "outputId": "9ea6015c-d18d-4488-f015-5c3b8e09ecc4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "nate = Competitor()\n",
        "nate.name = \"Nate Diaz\"\n",
        "nate.age = 30\n",
        "nate.weight = 170\n",
        "nate.__dict__"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'age': 30, 'name': 'Nate Diaz', 'weight': 170}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jzJzVnWDHo2A",
        "colab_type": "text"
      },
      "source": [
        "#### Interacting with Objects"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kB2B-OQ7IGZD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def print_competitor_age(object):\n",
        "    \"\"\"Print out age statistics about a competitor\"\"\"\n",
        "    \n",
        "    print(f\"{object.name} is {object.age} years old\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oQKDLcVGIGoh",
        "colab_type": "code",
        "outputId": "6ba58ec1-a5af-4a76-a604-d54e9b007f89",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print_competitor_age(nate)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Nate Diaz is 30 years old\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ka-LFYJ1IG0e",
        "colab_type": "code",
        "outputId": "7c17d3db-d594-49d5-e1d8-bec6e1008b63",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print_competitor_age(conor)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Conor McGregor is 29 years old\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yplytoRKI8pA",
        "colab_type": "text"
      },
      "source": [
        "#### Understanding Inheritance\n",
        "Classes can also inhert from other classes including methods.\n",
        "Often inheritance can be complex and a rule of thumb is to use discretion.\n",
        "\n",
        "In the example below, a UFC class was created that has a method (similar to a function), that can determine what weight class an athlete belongs to.  Then the Competitor class uses \"inheritance\", to inhert the code in the class."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "at28_-C7JC6m",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jJ2j1P-XJDVi",
        "colab_type": "text"
      },
      "source": [
        "##### Using Inheritance"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hIzHGW2SJI0-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class UFC:\n",
        "    def weight_class(self, weight):\n",
        "        \"\"\"Weight Class Finder\"\"\"\n",
        "        \n",
        "        classes = {155: \"Lightweight\", \n",
        "                    170: \"Welterweight\"}\n",
        "        return classes[weight]\n",
        "\n",
        "        "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YTuU3nhaJLZR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Competitor(UFC): pass"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MBqX0yAVJN_D",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "conor = Competitor()\n",
        "conor.name = \"Conor McGregor\"\n",
        "conor.age = 29\n",
        "conor.weight = 155\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ELf_GcPRJPWF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "nate = Competitor()\n",
        "nate.name = \"Nate Diaz\"\n",
        "nate.age = 30\n",
        "nate.weight = 170\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3g-obU6iR49h",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "conor.weight_class"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Uqkx_uN3JQxV",
        "colab_type": "text"
      },
      "source": [
        "##### Using inherited methods from Parent Class"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h4G1XdjkJW1v",
        "colab_type": "code",
        "outputId": "e34bc0d5-d67b-4511-a289-65e8e6bbca41",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print(conor.weight_class(conor.weight))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Lightweight\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KFgfFCMhJYYf",
        "colab_type": "code",
        "outputId": "694c7f9e-01d5-467d-f8b5-d966cc981817",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print(nate.weight_class(nate.weight))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Welterweight\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PEKWYhudJv_x",
        "colab_type": "text"
      },
      "source": [
        "#### Using Multiple Inheritance\n",
        "\n",
        "Multiple Inheritance is inheriting more than one class"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U34Ti24hJ7Sk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class MMA:\n",
        "  def org(self, org_name):\n",
        "      orgs = {\"UFC\": \"Ultimate Fighting Championship\",\n",
        "          \"Bellator\":  \"MMA promotion in Santa Monica, California.\"}\n",
        "      return orgs[org_name]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WELqXQNfJ86w",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class CompetitorAll(UFC, MMA):pass "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CZHnhEmIJ_Qr",
        "colab_type": "code",
        "outputId": "0aa2a4d1-29a1-4851-f68c-8ca3f999e044",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        "gsp = CompetitorAll()\n",
        "gsp.name = \"GSP\"\n",
        "gsp.age = 27\n",
        "gsp.weight = 170\n",
        "print(f'{gsp.name} is the G.O.A.T in the {gsp.weight_class(gsp.weight)} division of the {gsp.org(\"UFC\")}')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "GSP is the G.O.A.T in the Welterweight division of the Ultimate Fighting Championship\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "srx3voPVKPop",
        "colab_type": "text"
      },
      "source": [
        "#### Interacting with Special Class Methods and Other Class Techniques\n",
        "\n",
        "Class special methods have the signature ```__method__```:\n",
        "\n",
        "Examples include\n",
        "```\n",
        "__len__\n",
        "__call__\n",
        "__equal__\n",
        "\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Uzzr1EhLxUnP",
        "colab_type": "code",
        "outputId": "ad9218ce-b4a2-432d-feba-11e3f5fd16b9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "l = [1,2]\n",
        "len(l)\n",
        "#class Foo:pass\n",
        "#f = Foo()\n",
        "#len(f)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IJ48YIJUKoYz",
        "colab_type": "code",
        "outputId": "a63c8e38-fe41-4d56-809e-a13b3ed75f8d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "class JonJones:\n",
        "  \"\"\"Jon Jones class with customized length\"\"\"\n",
        "  \n",
        "  def __len__(self):\n",
        "    return 84\n",
        "\n",
        "jon_jones = JonJones()\n",
        "len(jon_jones)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "84"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bqGdWZB3UEos",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class foo():pass\n",
        "f = foo()\n",
        "f.red = \"red\"\n",
        "len(f)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tbTyE8mrKvcj",
        "colab_type": "text"
      },
      "source": [
        "@property decorator is a shortcut for creating a read only property"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QtQiqN9JKq_X",
        "colab_type": "code",
        "outputId": "d268e0e2-b61e-44d3-ff58-c548062cc384",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "class JonJones:\n",
        "  \"\"\"Jon Jones class with read only property\"\"\"\n",
        "  \n",
        "  @property\n",
        "  def reach(self):\n",
        "    return 84\n",
        "\n",
        "jon_jones = JonJones()\n",
        "jon_jones.reach\n",
        "#jon_jones.reach = 85 #cannot set\n",
        "jon_jones.length = 85\n",
        "jon_jones.length"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "85"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "grcojpMOKyao",
        "colab_type": "text"
      },
      "source": [
        "@staticmethod bolts a function onto a class"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vctQpjK-K0AE",
        "colab_type": "code",
        "outputId": "56af6d93-37a1-4af4-e3cd-93275c1f33bf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "class JonJones:\n",
        "  \"\"\"Jon Jones Class with 'bolt-on' reach method\n",
        "  self isn't needed\n",
        "  \"\"\"\n",
        "  \n",
        "  @staticmethod\n",
        "  def reach():\n",
        "    return 84\n",
        "\n",
        "jon_jones =JonJones()\n",
        "jon_jones.reach()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "84"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dhabI3o_dWd7",
        "colab_type": "text"
      },
      "source": [
        "#### Immutability concepts with Objects"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "faD4aYV2wmKi",
        "colab_type": "text"
      },
      "source": [
        "![Unbreakable concepts in Python](https://user-images.githubusercontent.com/58792/47947414-44e61900-ded9-11e8-9891-d357b65cfcf5.jpg)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8S3WDMvVdJaz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Foo:\n",
        "  \n",
        "  @property\n",
        "  def unbreakable(self):\n",
        "    return \"David\"\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xpR4L8XVdd1Q",
        "colab_type": "code",
        "outputId": "b179fe82-e8d2-45df-83cd-1fca13d932c5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "foo = Foo()\n",
        "foo.unbreakable "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'David'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GZwabNvndsCs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "foo.not_unbreakable = \"Elijah2\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VuSZ9Y49egiO",
        "colab_type": "text"
      },
      "source": [
        "@property acts like an read only attribute, but it isn't"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A4yseU7fecuW",
        "colab_type": "code",
        "outputId": "ffb18d66-c00b-45e0-9214-531cb5065c18",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "foo.__dict__"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'not_unbreakable': 'Elijah2'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DmLJWuUtfE2-",
        "colab_type": "text"
      },
      "source": [
        "You can change an attribute on the object, but not the read only property"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lQzn9BCoeeLu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "foo.not_unbreakable = \"Mr. Glass\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0iS_9Q0AfWtY",
        "colab_type": "code",
        "outputId": "e82a7b25-2307-466d-f7f4-541ee9ad42ed",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 166
        }
      },
      "source": [
        "foo.unbreakable = \"Bruce Willis\""
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-38-4bc1ea5ae699>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfoo\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munbreakable\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"Bruce Willis\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: can't set attribute"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vdXsz7m4fauR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6clKK6eovI89",
        "colab_type": "text"
      },
      "source": [
        "### Control Structures\n",
        "\n",
        "* *[Watch Video Lesson 3:  Using Python Control Structurers](https://www.safaribooksonline.com/videos/essential-machine-learning/9780135261118/9780135261118-EMLA_01_03_00)*\n",
        "\n",
        "\n",
        "**Material in Section**\n",
        "\n",
        "*  For loops\n",
        "*  While loops\n",
        "*  Using if/else/break/continue/pass statements \n",
        "*  Try/Except\n",
        "*  Generator expressions\n",
        "*  List Comprehensions\n",
        "*  Sorting\n",
        "*  Pattern Matching\n",
        "\n",
        "All programs eventually need a way to control the flow of execution.  This section describes techniques."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kkrALu_wvRMQ",
        "colab_type": "text"
      },
      "source": [
        "#### Using Loops\n",
        "\n",
        "The for loop is one of the most fundamental control structures in Python.\n",
        "One common pattern is to use the range function to generate a range of values, then to iterate on them.\n",
        "\n",
        "* *[Watch Video Lesson 3.1:  Create Loops](https://www.safaribooksonline.com/videos/essential-machine-learning/9780135261118/9780135261118-EMLA_01_03_01)*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w-jc1fbg9p9q",
        "colab_type": "text"
      },
      "source": [
        "##### Using a Simple For Loop\n",
        "\n",
        "built in range() function creates an iterable"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "abHaxRTlth7c",
        "colab_type": "code",
        "outputId": "a0821b79-2a59-45dd-a497-0e6eccdc286d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "res = range(3)\n",
        "print(list(res))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 2]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tnUuKBtlvWz5",
        "colab_type": "code",
        "outputId": "8b4eee5e-d436-42df-befa-1c421d189e5c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 122
        }
      },
      "source": [
        "for i in range(1,7):\n",
        "    print(i)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ANmx4hYRvdXF",
        "colab_type": "text"
      },
      "source": [
        "##### For loop over an iterable (list)\n",
        "\n",
        "Another common pattern is to iterate on a list (or any iterable)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K_XrmKB6vYHw",
        "colab_type": "code",
        "outputId": "024f288f-7237-4a0a-f07d-047257b7f672",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        }
      },
      "source": [
        "martial_arts = [\"Sambo\", \"Muay Thai\", \"BJJ\"]\n",
        "for martial_art in martial_arts:\n",
        "    print(f\"{martial_art} has influenced modern mixed martial arts\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Sambo has influenced modern mixed martial arts\n",
            "Muay Thai has influenced modern mixed martial arts\n",
            "BJJ has influenced modern mixed martial arts\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "McQsitwbvrIG",
        "colab_type": "text"
      },
      "source": [
        "##### While Loops\n",
        "\n",
        "A While Loop is often used as a way of looping until a condition is met. A very common use of a while loop is to create an infinite loop. In the example below a while loop is used to filter a function that returns 1 of 2 types of attacks."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XA-2E-uNvhUK",
        "colab_type": "code",
        "outputId": "e7ffb180-f9cc-42e3-90ac-5b74f11f60d8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 87
        }
      },
      "source": [
        "def attacks():\n",
        "    list_of_attacks = [\"lower_body\", \"lower_body\",\"upper_body\"]\n",
        "    print(f\"There are a total of {len(list_of_attacks)} attacks coming!\")\n",
        "    for attack in list_of_attacks:\n",
        "        yield attack\n",
        "attack = attacks()\n",
        "count = 0\n",
        "while next(attack) == \"lower_body\":\n",
        "    count +=1\n",
        "    print(f\"crossing legs to prevent attack #{count}\")\n",
        "else:\n",
        "    count +=1\n",
        "    print(f\"This is not a lower body attack, I will cross my arms for #{count}\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "There are a total of 3 attacks coming!\n",
            "crossing legs to prevent attack #1\n",
            "crossing legs to prevent attack #2\n",
            "This is not a lower body attack, I will cross my arms for #3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "88ORBTOPvyKy",
        "colab_type": "text"
      },
      "source": [
        "#### Using if/else/break/continue/pass statements \n",
        "\n",
        "* *[Watch Video Lesson 3.2:  if/else](https://www.safaribooksonline.com/videos/essential-machine-learning/9780135261118/9780135261118-EMLA_01_03_02)*\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e4RVlT2_-4Tj",
        "colab_type": "text"
      },
      "source": [
        "##### Using if/elif/else blocks\n",
        "If/Else statements are a common way to branch between decisions. In the example below if/elif are used to match a branch. If there are no matches, the last \"else\" statement is run."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4rPN8VYgvvsL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def recommended_attack(position):\n",
        "    \"\"\"Recommends an attack based on the position\"\"\"\n",
        "    \n",
        "    if position == \"full_guard\":\n",
        "        print(f\"Try an armbar attack\")\n",
        "    elif position == \"half_guard\":\n",
        "        print(f\"Try a kimura attack\")\n",
        "    elif position == \"full_mount\":\n",
        "        print(f\"Try an arm triangle\")\n",
        "    else:\n",
        "        print(f\"You're on your own, there is no suggestion for an attack\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "liJPIg7dv4kq",
        "colab_type": "code",
        "outputId": "794e046d-8649-452f-d78f-48f1a6a5cb51",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "recommended_attack(\"full_guard\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Try an armbar attack\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7d6qc-4yv_7F",
        "colab_type": "code",
        "outputId": "1ab35bd2-c505-49e0-c914-1e85a55d0e77",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "recommended_attack(\"z_guard\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "You're on your own, there is no suggestion for an attack\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jYEv2fd4_BRO",
        "colab_type": "text"
      },
      "source": [
        "##### Using break"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n6uxAIVc_B1F",
        "colab_type": "code",
        "outputId": "17c93dea-506b-4139-f04a-987674974879",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 104
        }
      },
      "source": [
        "submission_attacks = 0\n",
        "while True:\n",
        "  submission_attacks +=1\n",
        "  print(f\"Attempting Submission Attack Number {submission_attacks}\")\n",
        "  if submission_attacks > 3:\n",
        "    print(\"Attacker is tired...stopping attacks after 4th attack\")\n",
        "    break\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Attempting Submission Attack Number 1\n",
            "Attempting Submission Attack Number 2\n",
            "Attempting Submission Attack Number 3\n",
            "Attempting Submission Attack Number 4\n",
            "Attacker is tired...stopping attacks after 4th attack\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KB7SreVYAHsH",
        "colab_type": "text"
      },
      "source": [
        "##### Using continue"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a56Y60MpAH1t",
        "colab_type": "code",
        "outputId": "a0f28caa-ba57-4908-9339-0a4e4bdea744",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "martial_arts = [\"Sambo\", \"Muay Thai\", \"BJJ\"]\n",
        "for martial_art in martial_arts:\n",
        "  if not martial_art == \"BJJ\":\n",
        "    continue\n",
        "  print(f\"My favorite Martial Art is {martial_art}\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "My favorite Martial Art is BJJ\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PgcB-3dUB2I4",
        "colab_type": "text"
      },
      "source": [
        "##### Using pass\n",
        "\n",
        "The pass keyword is often a placeholder to define a class or function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SsucVX0JB2Pe",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def my_func(): pass\n",
        "class SomeClass: pass\n",
        "\n",
        "my_func()\n",
        "some_class = SomeClass()\n",
        "\n",
        "#Dark Patterns:  NO!\n",
        "#try:\n",
        "#  print(\"this\")\n",
        "#except:\n",
        "  #import sys;sys.exit(0)\n",
        "  #pass"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9wWsG9Cdwme0",
        "colab_type": "text"
      },
      "source": [
        "#### Try/Except\n",
        "\n",
        "There is an expression in sports, \"Always be prepared to do your best on your worst day\". Try/Except statements are similar. It is always a good idea to think about what happens when something goes wrong in code that is written. Try/Except blocks allow for this.\n",
        "\n",
        "* *[Watch Video Lesson 3.3:  Understand try/except](https://www.safaribooksonline.com/videos/essential-machine-learning/9780135261118/9780135261118-EMLA_01_03_03)*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1vlb0DVAHVHC",
        "colab_type": "text"
      },
      "source": [
        "##### Using try/except\n",
        "\n",
        "Catching a specific exception"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G94tPojywjkt",
        "colab_type": "code",
        "outputId": "46fdd76f-fcda-4620-f6bf-95a40aae7fe0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 87
        }
      },
      "source": [
        "tournaments = [\"NAGA\", \"IBJJF\", \"EBI\"]\n",
        "while True:\n",
        "    try:\n",
        "        tournament = tournaments.pop()\n",
        "        print(f\"I would like to compete in the {tournament} tournament.\")\n",
        "    except IndexError:\n",
        "        print(\"There are no more tournaments.  Popping an empty list\")\n",
        "        break"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "I would like to compete in the EBI tournament.\n",
            "I would like to compete in the IBJJF tournament.\n",
            "I would like to compete in the NAGA tournament.\n",
            "There are no more tournaments.  Popping an empty list\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YXDgzYG_H1Ke",
        "colab_type": "text"
      },
      "source": [
        "##### Logging exceptions\n",
        "\n",
        "It is a best practice to log exception blocks"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-KueP5USH1Ty",
        "colab_type": "code",
        "outputId": "2040ceda-6eec-4e96-b7d0-e7618f32fb22",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 157
        }
      },
      "source": [
        "import logging\n",
        "\n",
        "tournaments = [\"NAGA\", \"IBJJF\", \"EBI\"]\n",
        "while True:\n",
        "    try:\n",
        "        tournament = tournaments.pop()\n",
        "        print(f\"I would like to compete in the {tournament} tournament.\")\n",
        "    except IndexError:\n",
        "        logging.exception(f\"Exception Logged:  There are no more tournaments\")\n",
        "        break"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ERROR:root:Exception Logged:  There are no more tournaments\n",
            "Traceback (most recent call last):\n",
            "  File \"<ipython-input-55-c377a67d17fe>\", line 6, in <module>\n",
            "    tournament = tournaments.pop()\n",
            "IndexError: pop from empty list\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "I would like to compete in the EBI tournament.\n",
            "I would like to compete in the IBJJF tournament.\n",
            "I would like to compete in the NAGA tournament.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "22pQ51hdwE4w",
        "colab_type": "text"
      },
      "source": [
        "####Generator Expression\n",
        "\n",
        "Generator Expressions build further on the concept of yield by allowing for the lazy evaluation of a sequence. The benefit of generator expressions is that nothing is evaluated or brought into memory until it is actually evaluated.\n",
        "\n",
        "This is why the example below can be operating on an infi-nite sequence of random attacks that are generated. In the generator pipeline the lower-case attack, such as \"arm_triangle\" is converted to \"ARM_TRIANGLE\", next the underscore is remove \"ARM TRIANGLE\".\n",
        "\n",
        "* *[Watch Video Lesson 3.4:  Understand generator expressions](https://www.safaribooksonline.com/videos/essential-machine-learning/9780135261118/9780135261118-EMLA_01_03_04)*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iLd5wY06MHJP",
        "colab_type": "text"
      },
      "source": [
        "##### Creating Generator Expressions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5AIcGpUgwBR0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def lazy_return_random_attacks():\n",
        "    \"\"\"Yield attacks each time\"\"\"\n",
        "    import random\n",
        "    attacks = {\"kimura\": \"upper_body\",\n",
        "           \"straight_ankle_lock\":\"lower_body\", \n",
        "           \"arm_triangle\":\"upper_body\",\n",
        "            \"keylock\": \"upper_body\",\n",
        "            \"knee_bar\": \"lower_body\"}\n",
        "    while True:\n",
        "        random_attack = random.choices(list(attacks.keys()))\n",
        "        yield random_attack\n",
        "        \n",
        "#Make all attacks appear as Upper Case\n",
        "upper_case_attacks = (attack.pop().upper() for attack in lazy_return_random_attacks())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eaWWG7N8wNHd",
        "colab_type": "code",
        "outputId": "bfd3d3f3-b35d-4306-967e-11c0cd12c234",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "next(upper_case_attacks)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'STRAIGHT_ANKLE_LOCK'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nMYRCiTbMUCn",
        "colab_type": "text"
      },
      "source": [
        "##### Using Generator expressions\n",
        "\n",
        "Generator expressions can be used in a pipeline fashion"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NPKsH9dPwO89",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "## Generator Pipeline:  One expression chains into the next\n",
        "#Make all attacks appear as Upper Case\n",
        "upper_case_attacks = (attack.pop().upper() for attack in lazy_return_random_attacks())\n",
        "#Remove the underscore\n",
        "remove_underscore = (attack.split(\"_\") for attack in upper_case_attacks)\n",
        "#Create a new phrase \n",
        "new_attack_phrase = (\" \".join(phrase) for phrase in remove_underscore)\n",
        "#this is where you can call an AI API\n",
        "#my_api_call = comprehend(new_attack_phrase)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xb4vf2URwRnk",
        "colab_type": "code",
        "outputId": "58ebf2b0-ab1a-4ba8-cf50-90439bf72246",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "next(new_attack_phrase)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'STRAIGHT ANKLE LOCK'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OA9PLTTFwV00",
        "colab_type": "code",
        "outputId": "00afcccc-dd8a-470d-8b8a-711657997ed3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 192
        }
      },
      "source": [
        "for number in range(10):\n",
        "    print(next(new_attack_phrase))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "KEYLOCK\n",
            "KEYLOCK\n",
            "STRAIGHT ANKLE LOCK\n",
            "ARM TRIANGLE\n",
            "ARM TRIANGLE\n",
            "KNEE BAR\n",
            "ARM TRIANGLE\n",
            "KNEE BAR\n",
            "ARM TRIANGLE\n",
            "ARM TRIANGLE\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bBqchsBXwaiD",
        "colab_type": "text"
      },
      "source": [
        "#### List Comprehension\n",
        "\n",
        "A list comprehension is very similar to a generator expression, but it evaluated in memory. Additionally, it is optimized C code that be a substantial improvement over a traditional for loop.\n",
        "\n",
        "* *[Watch Video Lesson 3.5:  Understand list comprehensions](https://www.safaribooksonline.com/videos/essential-machine-learning/9780135261118/9780135261118-EMLA_01_03_05)*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e4v2SE7bOa_1",
        "colab_type": "text"
      },
      "source": [
        "##### Creating List Comprehensions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X_pm3eyqwXXM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "martial_arts = [\"Sambo\", \"Muay Thai\", \"BJJ\"]\n",
        "new_phrases = [\"\".join(f\"Mixed Martial Arts is influenced by {martial_art}\") for martial_art in martial_arts]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aPLuwa3TOzKp",
        "colab_type": "text"
      },
      "source": [
        "#####  Using List Comprehensions\n",
        "\n",
        "Unlike Generator expressions, list comprehensions are run in memory and evaluated immediately"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lVhLoAQ2wiHP",
        "colab_type": "code",
        "outputId": "0d1677a0-8e51-439f-d44c-ad9c6fcc4177",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        "print(new_phrases)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['Mixed Martial Arts is influenced by Sambo', 'Mixed Martial Arts is influenced by Muay Thai', 'Mixed Martial Arts is influenced by BJJ']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "quAhiuBw-sq9",
        "colab_type": "text"
      },
      "source": [
        "### Understanding Sorting\n",
        "\n",
        "Python has powerful built-in sorting\n",
        "\n",
        "* *[Watch Video Lesson 3.6:  Understand sorting](https://www.safaribooksonline.com/videos/essential-machine-learning/9780135261118/9780135261118-EMLA_01_03_06)*\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GC88vFkPQwLO",
        "colab_type": "text"
      },
      "source": [
        "##### Using built-in sorting\n",
        "\n",
        "sorted is a built-in function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-7lMsgk3Qz0m",
        "colab_type": "code",
        "outputId": "00ad057e-8069-4f2a-ccea-050a08ab1cf7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "martial_arts = [\"Sambo\", \"Muay Thai\", \"BJJ\"]\n",
        "sorted(martial_arts)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['BJJ', 'Muay Thai', 'Sambo']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0bSBsDWrSQfw",
        "colab_type": "text"
      },
      "source": [
        "Performance of sort can be easily benchmarked"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oe666a6iR35S",
        "colab_type": "code",
        "outputId": "d8e4367b-a223-4b89-9928-455b6143dbdf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        }
      },
      "source": [
        "%timeit sorted(martial_arts)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The slowest run took 12.01 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
            "1000000 loops, best of 3: 314 ns per loop\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i_Skh8l8S6re",
        "colab_type": "text"
      },
      "source": [
        "##### Customizing sorting"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GUsnX31VRxg4",
        "colab_type": "text"
      },
      "source": [
        "Sorting can be reversed"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VJsyTi9rRxsy",
        "colab_type": "code",
        "outputId": "28893600-5a08-4012-8388-3a785c0f3930",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "sorted(martial_arts, reverse=True)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Sambo', 'Muay Thai', 'BJJ']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 79
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OrWriGn-S_S6",
        "colab_type": "text"
      },
      "source": [
        "Sorting can use custom keys including a custom function.\n",
        "In this case I have \"rigged\" the sort to always unsure BJJ is the first choice and others have a length of characters"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IRoNvB9RS_fM",
        "colab_type": "code",
        "outputId": "5cacdd6f-bb2a-45fb-f4f1-d9e84877b4c3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "martial_arts = [\"Sambo\", \"Muay Thai\", \"BJJ\", \"AX\", \"Tire machèt\"]\n",
        "\n",
        "def best_martial_art(value):\n",
        "  if value == \"BJJ\":\n",
        "    return 1\n",
        "  return len(value) \n",
        "\n",
        "sorted(martial_arts, key=best_martial_art)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['BJJ', 'AX', 'Sambo', 'Muay Thai', 'Tire machèt']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 80
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FJOmSmkOo6pY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#To Do\n",
        "## Create a custom alphabetical sort with BJJ as top"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8PvJTX-u-3Hz",
        "colab_type": "text"
      },
      "source": [
        "### Python Regular Expressions\n",
        "\n",
        "It is very common to use regular expressions in Data work.  Explore these techniques in this sub-module.\n",
        "\n",
        "* [Watch Video Lesson 3.7:  Understand Python regular expressions](https://www.safaribooksonline.com/videos/essential-machine-learning/9780135261118/9780135261118-EMLA_01_03_07)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OHDcY-6IW3if",
        "colab_type": "text"
      },
      "source": [
        "##### Using re.search\n",
        "\n",
        "A very basic regular expression pattern"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IuqKpZUi-7Ie",
        "colab_type": "code",
        "outputId": "4bd7acac-ff15-4fa5-b158-2f3583cb6cdf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "import re\n",
        "phrase = \"I love the open-guard\"\n",
        "match = re.search(r'\\w+-guard', phrase)\n",
        "if match:\n",
        "  print(match.group())\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "open-guard\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YkeO2UUQW6-2",
        "colab_type": "text"
      },
      "source": [
        "##### Using re.findall\n",
        "\n",
        "to find many results findall is very useful"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GUHZy4gUW7PG",
        "colab_type": "code",
        "outputId": "e8fce298-0dc9-422f-b012-6ad79365cf40",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "phrase = \"I love the open-guard, closed-guard and deep-half-guard\"\n",
        "guards = re.findall(r'\\w+-guard', phrase)\n",
        "guards\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['open-guard', 'closed-guard', 'half-guard']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NKPx4S4GYd8f",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bJJH_ybw-CkM",
        "colab_type": "text"
      },
      "source": [
        "## Homework Day 1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fr1NnKv3-JbT",
        "colab_type": "text"
      },
      "source": [
        "### Watch Lesson 5:  Understand Python Classes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hlMLISAh-4wE",
        "colab_type": "text"
      },
      "source": [
        "Go through lesson and make sure you understand how classes work by extending the inheritance workflow with your own class and method.\n",
        "\n",
        "[Lesson 5: Understand Python Classes](https://www.safaribooksonline.com/videos/essential-machine-learning/9780135261118/9780135261118-EMLA_01_05_00)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KWDrBDOdN_77",
        "colab_type": "text"
      },
      "source": [
        "### Explore Learning Path:  Essential Machine Learning and Pragmatic AI\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CTHlCEd3OHWV",
        "colab_type": "text"
      },
      "source": [
        "Look through topics and explore items that interest you.\n",
        "\n",
        "[Learning Path:  Essential Machine Learning and Pragmatic AI](https://www.safaribooksonline.com/learning-paths/learning-path-essential/9780135747193/)\n",
        "\n",
        "![Learning Path](https://noahgift.com/img/live_lesson_essential_ml.jpg)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CTIFO2x8Oj7n",
        "colab_type": "text"
      },
      "source": [
        "### Register for Followup Course\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UrRZzEPtO6Lr",
        "colab_type": "text"
      },
      "source": [
        "[Managed Machine Learning Systems and Internet of Things](https://learning.oreilly.com/live-training/courses/managed-machine-learning-systems-and-internet-of-things/0636920224778/)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IdqC6jq5e4jd",
        "colab_type": "text"
      },
      "source": [
        "## FAQ"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AAYE0JnbZ79n",
        "colab_type": "text"
      },
      "source": [
        "How do I find basic functions in python\n",
        "\n",
        "\n",
        "\n",
        "*   go to [python documention](https://docs.python.org/3/search.html?q=built+in+functions&check_keywords=yes&area=default)\n",
        "*   go to [standard library](https://docs.python.org/3/library/)\n",
        "*  here is [link for 3rd party](https://pypi.org/)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JDCJXAQLae7s",
        "colab_type": "text"
      },
      "source": [
        "Given the Competitor class and the attributes set on the class's object at runtime, are those attributes publicly accessible or are getters/setters necessary?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I27fyW5Eah5d",
        "colab_type": "text"
      },
      "source": [
        "class Foo(): pass\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k-JPG7hKagL8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Foo(): pass\n",
        "\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sFJoLHcWao8Q",
        "colab_type": "code",
        "outputId": "90fa5bb2-f821-4ecd-d681-faaeefdd00d5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "f = Foo()\n",
        "f.__val = 1\n",
        "f.__dict__"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'__val': 1}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o2HhtJ5ga1n9",
        "colab_type": "text"
      },
      "source": [
        "Is it compulsory to define self in the arguments for multi class/inheritance ? def length(self): and def length():"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7zN_StSAa2pI",
        "colab_type": "text"
      },
      "source": [
        "self is  convention"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "US_Kl6JnbA-H",
        "colab_type": "text"
      },
      "source": [
        "Q:  this sorting - can it be used for air-bnb sort of situation, for example sort on various categories, like comfort, location, price, - 10 different keys . How complex with the sorting be ? "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Baxu2B7FbNqq",
        "colab_type": "text"
      },
      "source": [
        "Q:  How would a more customized sort function work with multiple attributes\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dbq6INsFe4xV",
        "colab_type": "text"
      },
      "source": [
        "### Question:  *Do \"pass\" and \"continue\" do the same thing in a loop?*\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "48dcE5GGfQje",
        "colab_type": "text"
      },
      "source": [
        "**Answer: ** In most cases no.  Continue will skip the iteration of the loop where it is called and not run code below it.  A pass will skip the line of code it is called in but will run the code below it."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N2igTxsEfcN3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_nJxgc5bb1qW",
        "colab_type": "text"
      },
      "source": [
        "Q:  Q: is there anything like nvm for Node.js and RVM for Ruby, which enables switching between different Python versions?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T3j4Yn-3b3aB",
        "colab_type": "text"
      },
      "source": [
        "* one is to use virtualenv\n",
        "* conda\n",
        "* pipenv"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vyG0qFOH4THF",
        "colab_type": "text"
      },
      "source": [
        "### CSV Regular Expression"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "emc5DnDdb2zx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import pandas as pd\n",
        "\n",
        "df = pd.read_csv(\"https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv\")\n",
        "\n",
        "#one way to do regex is built in pandas regex\n",
        "\n",
        "\n",
        "#second way is do an apply function\n",
        "#def custom_regex(x):\n",
        "#  if re.findall(r'\\w+-guard', phrase)\n",
        "#    return \"match\"\n",
        "#  return \"nomatch\"\n",
        "\n",
        "#df[\"does_match\"] = df[[\"species\"]].apply(custom_regex)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "la1ynodWyAVS",
        "colab_type": "text"
      },
      "source": [
        "### hidden methods"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bP-aWbhVyDkM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Foo():\n",
        "  def __foo(self):\n",
        "    return 1\n",
        "  def bar(self):\n",
        "    return self.__foo()*5"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NcHtXELZyNep",
        "colab_type": "code",
        "outputId": "c862b791-85e2-4ddf-96c7-34aeb112ad5a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "f = Foo()\n",
        "f.bar()\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 87
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3YFHof7DynBD",
        "colab_type": "text"
      },
      "source": [
        "## Constructor"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mNvb6tcvypFD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class FooBar():\n",
        "  def func(self):\n",
        "    return 7\n",
        "  def __init__(self, x):\n",
        "    print(self.func())\n",
        "    self.y = 10\n",
        "    self.x = x\n",
        "    "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SQbFj-LOyxLZ",
        "colab_type": "code",
        "outputId": "909166e2-78d9-4abe-f8b1-a620916782be",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "ff = FooBar(3)\n",
        "ff.x"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 96
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fQhEoJu1tNRe",
        "colab_type": "text"
      },
      "source": [
        "## References"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u6BaXDS7tQTD",
        "colab_type": "text"
      },
      "source": [
        "*   [Pragmatic AI: An Introduction to Cloud-Based Machine Learning-Physical Book](http://www.informit.com/store/pragmatic-ai-an-introduction-to-cloud-based-machine-9780134863917)\n",
        "*   [Pragmatic AI: Pragmatic AI: An Introduction to Cloud-Based Machine Learning-SafariOnline Book](https://www.safaribooksonline.com/library/view/pragmatic-ai-an/9780134863924/)\n",
        "*  [Essential Machine Learning and AI with Python and Jupyter Notebook-Video-SafariOnline](https://www.safaribooksonline.com/videos/essential-machine-learning/9780135261118)\n",
        "* [Essential Machine Learning and AI with Python and Jupyter Notebook- Purchase Video](http://www.informit.com/store/essential-machine-learning-and-ai-with-python-and-jupyter-9780135261095)\n",
        "*   [noahgift.com](https://noahgift.com/)\n",
        "*   [paiml.com](https://paiml.com/)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RlBGPRHznwmh",
        "colab_type": "code",
        "outputId": "04ec5ff7-2eb4-41de-84e3-2d8d037351c5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "class Foo():pass\n",
        "\n",
        "f = Foo()\n",
        "\n",
        "for i in range(2):\n",
        "  f.i = 1\n",
        "  \n",
        "f.__dict__"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'i': 1}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 105
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HoHOkXbwogyv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class A(object):\n",
        "    def __init__(self):\n",
        "        self.x = 'Hello'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GDS_S8OMpEzJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Neighbourhood():\n",
        "  def __init__(self, number, street, city):\n",
        "    self.number = number\n",
        "    self.street = street\n",
        "    self.city = city"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RQTLqSDnpNKY",
        "colab_type": "code",
        "outputId": "1a8fcb59-ce97-4630-e10e-02712e47aaec",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "n = Neighbourhood(345, \"mystreet\", \"san francisco\")\n",
        "n.city\n",
        "n.number\n",
        "n.__dict__"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'city': 'san francisco', 'number': 345, 'street': 'mystreet'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 114
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7jtTQ3LhpUK6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import json\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZYNoOkMwpqoU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "mydict=json.loads(\"\")\n",
        "import pandas as pd\n",
        "pd.to_csv(mydict)\n",
        "\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}