Chapter1_Minimal_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Chapter1-Minimal-Python.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "yh19-aXLq7Q1"
      ],
      "authorship_tag": "ABX9TyMlTNiTqBW5TSL5JLSj6bmW",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/paiml/minimal-python/blob/master/Chapter1_Minimal_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GMOTYzPfqcIE",
        "colab_type": "text"
      },
      "source": [
        "# Chapter One: The Basics"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mf3JE8qSqYI2",
        "colab_type": "text"
      },
      "source": [
        "**This is a chapter in the book Minimal Python**\n",
        "\n",
        "* [Buy a copy on LeanPub](https://leanpub.com/minimalpython)\n",
        "* [Buy a copy from Amazon](https://www.amazon.com/Minimal-Python-efficient-programmer-onemillion2021-ebook/dp/B0855NSRR7)\n",
        "\n",
        "[*Licensed Under Attribution-NonCommercial-ShareAlike 4.0*](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n",
        "\n",
        "![Minimal Python Book](https://d2sofvawe08yqg.cloudfront.net/minimalpython/hero?1582640276)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yh19-aXLq7Q1",
        "colab_type": "text"
      },
      "source": [
        "## Execute Commands in Colab Notebook"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "knRQcVkxqw2u",
        "colab_type": "code",
        "outputId": "62ebb9cf-bf7f-4232-de79-585b0d4f86ef",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print(\"hi\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hi\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R5kUcEe0uRnf",
        "colab_type": "code",
        "outputId": "28d89638-2f36-4331-c10a-f0f8806e7cb3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "1+1"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6hHdlLwlumHJ",
        "colab_type": "text"
      },
      "source": [
        "*Challenge:  Do another calculation using addition or subtraction in the cell below (remember shift+return executes the cell)*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D1F7tXsfu-u3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qqAIvhP5N4iu",
        "colab_type": "text"
      },
      "source": [
        "## Write procedural code"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BwmnQEziVQ9k",
        "colab_type": "text"
      },
      "source": [
        " ### Procedural Statements\n",
        " Procedural statements are literally statements that  can be issued one line at a time.  Below are types of procedural statements.  These statements can be run in:\n",
        " * Jupyter Notebook\n",
        " * IPython shell\n",
        " * Python interpreter\n",
        " * Python scripts"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_jaxjKtPTeBx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "three_type_of_energy = [\"protein\", \"carbohydrates\", \"fat\"]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H004n8R-WDGF",
        "colab_type": "text"
      },
      "source": [
        "### **Multiple procedural statements**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xrZWZEFmV_bN",
        "colab_type": "code",
        "outputId": "4e179bd6-cad9-4165-f582-2c5c3a4c6351",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "protein, carbohydrate, fat = three_type_of_energy\n",
        "print(f\"{carbohydrate} sure taste good\")\n",
        "print(f\"{fat} isn't bad for you anymore?\")\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "carbohydrates sure taste good\n",
            "fat isn't bad for you anymore?\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6IiZ6RnLWKsq",
        "colab_type": "text"
      },
      "source": [
        "### Adding Numbers"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h049FhlhWPRm",
        "colab_type": "code",
        "outputId": "85c2b05e-9649-435e-bbb4-61f666a55ca5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "protein = 4\n",
        "fat = 9\n",
        "carbohydrate = 4\n",
        "carbohydrate + protein"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mlszsN87WmcO",
        "colab_type": "text"
      },
      "source": [
        "**Adding Phrases**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FaE5GnCaWgbI",
        "colab_type": "code",
        "outputId": "40730303-1b6b-4c6a-bdd0-45f3c5d16852",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "\"a carbohydrate \" + \"has \" + str(carbohydrate) + \" calories\" "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'a carbohydrate has 4 calories'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WSrfrIO1XYts",
        "colab_type": "text"
      },
      "source": [
        "**Complex statements**\n",
        "\n",
        "More complex statements can be created that use data structures like the belts variable, which is a list."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0nf0W0e3XSQS",
        "colab_type": "code",
        "outputId": "7250d000-5442-4e43-ea51-9516e9f6d0ed",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "source": [
        "for energy_type in three_type_of_energy:\n",
        "  print(energy_type)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "protein\n",
            "carbohydrates\n",
            "fat\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yHdWIarsN850",
        "colab_type": "text"
      },
      "source": [
        "## Use simple expressions and variables"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jYjzO6a4N88q",
        "colab_type": "text"
      },
      "source": [
        "### assert"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xXnbhsNjWTiu",
        "colab_type": "code",
        "outputId": "fd781d57-5d1b-4a56-9f25-7b88530c3491",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 181
        }
      },
      "source": [
        "assert carbohydrate == 9\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AssertionError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-65-448b002ebeaf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mcarbohydrate\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m9\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mAssertionError\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N0jWM3RIWdEC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "assert carbohydrate == 4"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dJhCYS9gWhE7",
        "colab_type": "text"
      },
      "source": [
        "### pass"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5JTGSrVLXC56",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Calorie: pass\n",
        "kcal = Calorie()\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IQ6SXQ1hJo31",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "kcal.value = \"9\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-ZupZ1esXMXN",
        "colab_type": "text"
      },
      "source": [
        "### del\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YSl9e1O6XQVo",
        "colab_type": "code",
        "outputId": "1bb7a93a-5d44-4127-b150-01496cdb3094",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 357
        }
      },
      "source": [
        "class Calorie: pass\n",
        "kcal = Calorie()\n",
        "%who_ls"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Calorie',\n",
              " 'breakfast',\n",
              " 'calories',\n",
              " 'carb',\n",
              " 'carbohydrate',\n",
              " 'carbs',\n",
              " 'egg_set',\n",
              " 'energy',\n",
              " 'energy_type',\n",
              " 'fat',\n",
              " 'food',\n",
              " 'ingredients',\n",
              " 'kcal',\n",
              " 'omelette',\n",
              " 'protein',\n",
              " 'snacks',\n",
              " 'this',\n",
              " 'three_type_of_energy',\n",
              " 'too_much_food',\n",
              " 'variable']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sa1YcirqJ0J7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "kcal.value = 9"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q1Kfx2kQXbES",
        "colab_type": "code",
        "outputId": "2b14803e-1867-4d3d-b1a6-6218c40f5e4b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 340
        }
      },
      "source": [
        "del kcal\n",
        "%who_ls"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Calorie',\n",
              " 'breakfast',\n",
              " 'calories',\n",
              " 'carb',\n",
              " 'carbohydrate',\n",
              " 'carbs',\n",
              " 'egg_set',\n",
              " 'energy',\n",
              " 'energy_type',\n",
              " 'fat',\n",
              " 'food',\n",
              " 'ingredients',\n",
              " 'omelette',\n",
              " 'protein',\n",
              " 'snacks',\n",
              " 'this',\n",
              " 'three_type_of_energy',\n",
              " 'too_much_food',\n",
              " 'variable']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7sHqDgRiXlYS",
        "colab_type": "text"
      },
      "source": [
        "### return"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cS3zelFyXoXX",
        "colab_type": "code",
        "outputId": "4c08a16f-fe44-4c1b-b6a1-64428c5222d6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "def food():\n",
        "  return \"whey\"\n",
        "\n",
        "print(f\"Make {food()} while the sun shines\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Make whey while the sun shines\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qFVa9v6FYOi0",
        "colab_type": "text"
      },
      "source": [
        "### yield"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AHJMMYqfYR47",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def too_much_food():\n",
        "  meal = [\"orange\", \"apple\", \"turkey\", \"ham\"]\n",
        "  for snack in meal:\n",
        "    yield snack\n",
        "    "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Uiu8dH3IYoaX",
        "colab_type": "code",
        "outputId": "d54843d4-0b5f-437c-e4c8-0c81dddec746",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "snacks = too_much_food()\n",
        "print(next(snacks))\n",
        "print(next(snacks))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "orange\n",
            "apple\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6xXJnKUnKNqp",
        "colab_type": "code",
        "outputId": "6854502c-6548-46ae-98fe-b72368bb51b9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "next(snacks)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'turkey'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 76
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3vvXvpmwKQ08",
        "colab_type": "code",
        "outputId": "1a0fc4af-0bb1-4dea-8947-0a26e7b329e9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "next(snacks)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'ham'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PTL1xoBdKT45",
        "colab_type": "code",
        "outputId": "c1ae5143-d784-4fc9-c55a-95ccd20867dc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        }
      },
      "source": [
        "next(snacks)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "StopIteration",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-78-4cb0aa5aecce>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msnacks\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mStopIteration\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4ZDzW5MqZ1RU",
        "colab_type": "text"
      },
      "source": [
        "### break\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0kjVX0pnZ3D6",
        "colab_type": "code",
        "outputId": "5894a0be-74a0-4340-eebd-a049682bbcf0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        }
      },
      "source": [
        "carbohydrate = 4\n",
        "calories = 0\n",
        "while True:\n",
        "  calories += carbohydrate\n",
        "  print(f\"Eating more carbohydrates {calories}\")\n",
        "  if calories > 8:\n",
        "    print(\"This is all I can eat\")\n",
        "    break"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Eating more carbohydrates 4\n",
            "Eating more carbohydrates 8\n",
            "Eating more carbohydrates 12\n",
            "This is all I can eat\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tfcD9G_TKTDp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6VpcRvywahUF",
        "colab_type": "text"
      },
      "source": [
        "### continue"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "quS_WfM8alY-",
        "colab_type": "code",
        "outputId": "4fae0a60-0ba2-4da8-fa34-8febc0f2b763",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "source": [
        "three_type_of_energy = [\"protein\", \"sugar\", \"fat\"]\n",
        "for energy in three_type_of_energy:\n",
        "  if energy == \"sugar\":\n",
        "    print(f\"skipping {energy} for my health\")\n",
        "    continue\n",
        "  print(f\"eating {energy}\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "eating protein\n",
            "skipping sugar for my health\n",
            "eating fat\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I2e-GRTObNek",
        "colab_type": "text"
      },
      "source": [
        "### import\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D1XcQeQ8bQCJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import this"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "p8t4I8eiM9kO"
      },
      "source": [
        "## Work with the built-in types"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "jDqDV20zM9kP"
      },
      "source": [
        "### dict"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4XJ5TAyycHbH",
        "colab_type": "code",
        "outputId": "d9e94016-cc6e-4acc-96b2-66c28f0e86c5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "omelette = {\"egg\": 3, \"ham\": \"yes\"}\n",
        "type(omelette)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 87
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dVGDHgzScHyB",
        "colab_type": "text"
      },
      "source": [
        "### list"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v2kHfbALcJGK",
        "colab_type": "code",
        "outputId": "400be13e-62e7-46f2-f5ac-4bbb977d34df",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "ingredients = [\"egg\", \"ham\", \"bacon\"]\n",
        "type(ingredients)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 88
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tBSUPJEmcJhf",
        "colab_type": "text"
      },
      "source": [
        "### set\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eOdfWOr8cNHH",
        "colab_type": "code",
        "outputId": "18c390c3-4c9e-4bcf-bba9-90a3c32edc2e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "egg_set = set([\"egg\", \"egg\"])\n",
        "type(egg_set)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "set"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LzKIr5mZLn9S",
        "colab_type": "code",
        "outputId": "b7abb843-470c-4ebe-b62f-e10a88265bd7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "egg_set"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'egg'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 91
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z2eOUv5AHSZL",
        "colab_type": "text"
      },
      "source": [
        "### tuple"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xEyAvrjdHUE1",
        "colab_type": "code",
        "outputId": "1e983865-ec67-4d7c-91bb-afde45b4bbb8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 181
        }
      },
      "source": [
        "breakfast = (\"egg\",\"soup\")\n",
        "breakfast[0] = \"turkey\""
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-96-5737173ae030>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mbreakfast\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"egg\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"soup\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mbreakfast\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"turkey\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mB5Mcx3GLy0b",
        "colab_type": "code",
        "outputId": "fd89789f-b6ad-4df9-c065-dea941b6d549",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "breakfast[1]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'soup'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 95
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5E7X1a9QLK0H",
        "colab_type": "text"
      },
      "source": [
        "## Printing"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "G7VMVJY9HNjQ"
      },
      "source": [
        "### Printing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n1r0n2V3Vs70",
        "colab_type": "code",
        "outputId": "3b1554a1-33d6-4c7a-f2df-60e14d50432d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print(\"omelets are tasty\")\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "omelets are tasty\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oWl-6bpTMJnr",
        "colab_type": "code",
        "outputId": "7d44db3e-0733-4aa9-ad50-415167482214",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "variable = \"ham\"\n",
        "print(f\"I like {variable}\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "I like ham\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8nUjNnApV6cC",
        "colab_type": "text"
      },
      "source": [
        "### Create Variable and Use Variable"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mhjO2LpSVx9V",
        "colab_type": "code",
        "outputId": "7802f366-5d2b-440b-81dd-4fde62e71174",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "variable = \"omelets\";print(variable)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "omelets\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YtGLHh1mdTGA",
        "colab_type": "text"
      },
      "source": [
        "### Use print as a function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "id03bYS2dX2u",
        "colab_type": "code",
        "outputId": "e56ccfb5-d93e-4312-a5c7-3a35e6d6cf46",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print(\"kombucha\", \"manuka honey\", sep=\"+\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "kombucha+manuka honey\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "O_mIki5Virkk"
      },
      "source": [
        "## Perform basic math operations\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eRmipgSocZ9i",
        "colab_type": "text"
      },
      "source": [
        "#### Numbers and Arithmetic Operations\n",
        "\n",
        "Python is also a built-in calculator. Without installing any additional libraries it can do many simple and complex arithmetic operations."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xd6LxgEXcgP8",
        "colab_type": "text"
      },
      "source": [
        "**Adding and Subtracting Numbers**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mKwZGBoMb6_A",
        "colab_type": "code",
        "outputId": "012deab5-6e37-4c3e-e938-66b502b14978",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "steps = (1+1)-1\n",
        "print(f\"Two Steps Forward:  One Step Back = {steps}\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Two Steps Forward:  One Step Back = 1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nMKS0ZYkdjvp",
        "colab_type": "text"
      },
      "source": [
        "**Multiplication with Decimals**\n",
        "\n",
        "Can use float type to solve decimal problems"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xgrw0LDucinh",
        "colab_type": "code",
        "outputId": "c01e6e27-1b28-43cf-8fa8-f69bcd362d9a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "body_fat_percentage = 0.10\n",
        "weight = 200\n",
        "fat_total = body_fat_percentage * weight\n",
        "print(f\"I weight 200lbs, and {fat_total}lbs of that is fat\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "I weight 200lbs, and 20.0lbs of that is fat\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gjMkBnuxiCQW",
        "colab_type": "text"
      },
      "source": [
        "Can also use Decimal Library to set precision and deal with repeating decimal\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GN_PYDuDiBHg",
        "colab_type": "code",
        "outputId": "4a32c96d-3d86-4105-bbf8-51ed00273cda",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "from decimal import (Decimal, getcontext)\n",
        "\n",
        "getcontext().prec = 2\n",
        "Decimal(1)/Decimal(3)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Decimal('0.33')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 107
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f1_B6OUrdxlU",
        "colab_type": "text"
      },
      "source": [
        "**Using Exponents**\n",
        "\n",
        "Using the Python math library it is straightforward to call 2 to the 3rd power"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q2oC1HVhdmB9",
        "colab_type": "code",
        "outputId": "cf76c6ed-e0f0-4207-d07e-5eaf94bb9d0e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "import math\n",
        "math.pow(2,3)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 108
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nkPcDry7jWt-",
        "colab_type": "text"
      },
      "source": [
        "Can also use built in exponent operator to accomplish same thing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9aV-R-DljXEj",
        "colab_type": "code",
        "outputId": "45484ec4-1e15-48e7-ea2c-a62e8ff4b57b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "2**3"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 109
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9cejMs6nNhKQ",
        "colab_type": "text"
      },
      "source": [
        "multiply"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2w0o6EAjNfNg",
        "colab_type": "code",
        "outputId": "5935736e-78e1-4e03-87d8-5e77549127ec",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "2*3"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 110
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aYA_mApaI-Y7",
        "colab_type": "text"
      },
      "source": [
        "this is regular multiplication"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6A_Vdvl_I8lg",
        "colab_type": "code",
        "outputId": "937270a6-1ae6-4d79-915d-4f06ba68ce02",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "2*3"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P6gOf9qtd6Nt",
        "colab_type": "text"
      },
      "source": [
        "**Converting Between different numerical types**\n",
        "\n",
        "There are many numerical forms to be aware of in Python.\n",
        "A couple of the most common are:\n",
        "\n",
        "* Integers\n",
        "* Floats"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XCWg7yX-d210",
        "colab_type": "code",
        "outputId": "c4a0aed3-7394-4ab7-85f2-430bd4a7cfae",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "number = 100\n",
        "num_type = type(number).__name__\n",
        "print(f\"{number} is type [{num_type}]\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100 is type [int]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iW2f1Ik7eAzd",
        "colab_type": "code",
        "outputId": "2a7317ca-e4f2-4b4e-fe01-4e880c5b439e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "number = float(100)\n",
        "num_type = type(number).__name__\n",
        "print(f\"{number} is type [{num_type}]\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100.0 is type [float]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5dnSfoXZFQuP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Foo:pass\n",
        "f = Foo()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "44v5W-HdFU4J",
        "colab_type": "code",
        "outputId": "ee42e20f-d270-435f-e7cc-a5aa320f6257",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "type(f)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "__main__.Foo"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 114
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MrrFXb99gQ1Z",
        "colab_type": "text"
      },
      "source": [
        "**Numbers can also be rounded**\n",
        "\n",
        "Python Built in round "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wjtnfol2iZDL",
        "colab_type": "code",
        "outputId": "ea6bed82-1fc6-4825-e97d-eac500f2de07",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "too_many_decimals = 1.912345897\n",
        "round(too_many_decimals, 3)\n",
        "#get more info\n",
        "#round?"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.912"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 115
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SuJDUTLFWUJz",
        "colab_type": "text"
      },
      "source": [
        "Numpy round"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PEabuAGGWXIF",
        "colab_type": "code",
        "outputId": "0f75132f-fe28-4e31-8f02-0e4994f552ef",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "import numpy as np\n",
        "np.round(too_many_decimals, 3)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.912"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 116
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X3aHIe6qW8ab",
        "colab_type": "text"
      },
      "source": [
        "Pandas round"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J-x_sjiZW-gB",
        "colab_type": "code",
        "outputId": "c40516d8-6cd7-4c1d-a82e-c153ee878d78",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 80
        }
      },
      "source": [
        "import pandas as pd\n",
        "df = pd.DataFrame([too_many_decimals], columns=[\"A\"], index=[\"first\"])\n",
        "df.round(2)\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>A</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>first</th>\n",
              "      <td>1.91</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "          A\n",
              "first  1.91"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 117
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "elnncfa0XtOt",
        "colab_type": "text"
      },
      "source": [
        "Simple benchmark of all three (**Python**, **numpy** and **Pandas** round):   using **%timeit**\n",
        "\n",
        "*Depending on what is getting rounded (i.e. a very large DataFrame, performance may very, so knowing how to benchmark performance is important with round) *\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Yr1SXcF5Xw-L",
        "colab_type": "code",
        "outputId": "d18d8e94-68fc-4251-aca0-3aa8d99d640c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 153
        }
      },
      "source": [
        "print(\"built in Python Round\")\n",
        "%timeit round(too_many_decimals, 2)\n",
        "\n",
        "print(\"numpy round\")\n",
        "%timeit np.round(too_many_decimals, 2)\n",
        "\n",
        "print(\"Pandas DataFrame round\")\n",
        "%timeit df.round(2)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "built in Python Round\n",
            "The slowest run took 21.00 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
            "1000000 loops, best of 3: 486 ns per loop\n",
            "numpy round\n",
            "The slowest run took 9.26 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
            "100000 loops, best of 3: 7.62 µs per loop\n",
            "Pandas DataFrame round\n",
            "1000 loops, best of 3: 951 µs per loop\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "X6TKBogIisNT"
      },
      "source": [
        "## Use classes and objects with dot notation\n",
        "\n"
      ]
    },
    {
      "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": "74f9253c-a3bd-44e8-98de-f6977b284a9c",
        "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": 121
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IJ48YIJUKoYz",
        "colab_type": "code",
        "outputId": "d54236e3-c70e-4b0e-d745-99a8e6d9885d",
        "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": 122
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bqGdWZB3UEos",
        "colab_type": "code",
        "outputId": "cdbf49a0-59f5-4202-8f5e-1b35b6cb065b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 198
        }
      },
      "source": [
        "class foo():pass\n",
        "f = foo()\n",
        "f.red = \"red\"\n",
        "len(f)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-123-f0f0529fb27b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfoo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mred\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"red\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: object of type 'foo' has no len()"
          ]
        }
      ]
    },
    {
      "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": "8a7373da-2b8d-4d4f-e183-465f61553dbb",
        "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": 125
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WURULjSfO7sc",
        "colab_type": "code",
        "outputId": "e447db71-a08a-4ecb-89d2-5aea3a98e741",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 181
        }
      },
      "source": [
        "jon_jones.reach\n",
        "jon_jones.reach = 85"
      ],
      "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-127-c873d37e7994>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mjon_jones\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreach\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mjon_jones\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreach\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m85\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": "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": "c8378034-ede1-46ca-d568-83aa6128c4fd",
        "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": 130
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dhabI3o_dWd7",
        "colab_type": "text"
      },
      "source": [
        "#### Immutability concepts with Objects"
      ]
    },
    {
      "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": "6b9ce786-52c1-49ee-e1bb-61bb1cd4a7f7",
        "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": 133
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GZwabNvndsCs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "foo.not_unbreakable = \"Elijah\""
      ],
      "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": "cd344e59-5c5c-401d-e77d-4321c8703375",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "foo.__dict__"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'not_unbreakable': 'Elijah'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 135
        }
      ]
    },
    {
      "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": "f6518647-88d8-45e0-f626-0df7f66f94e0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        }
      },
      "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-137-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": "pBTeTbnRKG_k",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "pA8QZjLiaFqL"
      },
      "source": [
        "## Learn to loop with for loops"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "kkrALu_wvRMQ"
      },
      "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."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "w-jc1fbg9p9q"
      },
      "source": [
        "#### Using a Simple For Loop\n",
        "\n",
        "built in range() function creates an iterable"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "abHaxRTlth7c",
        "outputId": "82c8779b-8a91-428f-903f-97f2022a05a2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "res = range(3)\n",
        "res"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "range(0, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "tnUuKBtlvWz5",
        "outputId": "32f9f15f-2f04-4aa5-9913-4bf2a692bf4a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        }
      },
      "source": [
        "for i in range(1,6):\n",
        "    print(i)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ANmx4hYRvdXF"
      },
      "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": {
        "colab_type": "code",
        "id": "K_XrmKB6vYHw",
        "outputId": "fb9ec401-2f76-4e22-8168-994b76f292aa",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "source": [
        "friends = [\"Moby\", \"Ahab\", \"Stubb\"]\n",
        "for friend in friends:\n",
        "  print(f\"With friends like {friend} who needs a Yelp review?\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "With friends like Moby who needs a Yelp review?\n",
            "With friends like Ahab who needs a Yelp review?\n",
            "With friends like Stubb who needs a Yelp review?\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "bBzfSYvQaLUk"
      },
      "source": [
        "## Repeat with while loops"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "UMsckwkIivgc"
      },
      "source": [
        "### While Loops\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "XA-2E-uNvhUK",
        "outputId": "eeab10d9-78f7-452f-ea6c-6b411acf15ee",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        }
      },
      "source": [
        "def sea_life():\n",
        "    animals = [\"whale\", \"orca\",\"porpoise\", \"moby_dick\"]\n",
        "    print(f\"There are many creatures in the sea: {len(animals)}\")\n",
        "    for animal in animals:\n",
        "        yield animal\n",
        "\n",
        "animals = sea_life()\n",
        "count = 0\n",
        "\n",
        "while next(animals) != \"moby_dick\":\n",
        "    count +=1\n",
        "    print(f\"hold your fire #{count}, it is just a common sea creature\")\n",
        "else:\n",
        "    count +=1\n",
        "    print(f\"Fire the harpoon, we spotted Moby Dick #{count}\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "There are many creatures in the sea: 4\n",
            "hold your fire #1, it is just a common sea creature\n",
            "hold your fire #2, it is just a common sea creature\n",
            "hold your fire #3, it is just a common sea creature\n",
            "Fire the harpoon, we spotted Moby Dick #4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "O4LapCrFbex3"
      },
      "source": [
        "## Learn to handle exceptions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "9wWsG9Cdwme0"
      },
      "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."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "1vlb0DVAHVHC"
      },
      "source": [
        "#### Using try/except\n",
        "\n",
        "Catching a specific exception"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "G94tPojywjkt",
        "outputId": "497be1ae-13cf-413a-c810-36678758289a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        }
      },
      "source": [
        "whales = [\"Keiko\", \"Shamu\", \"Moby Dick\"]\n",
        "while True:\n",
        "    try:\n",
        "        whale = whales.pop()\n",
        "        print(f\"I want this whale {whale}!\")\n",
        "    except IndexError:\n",
        "        print(\"There are no more whales to be had\")\n",
        "        break"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "I want this whale Moby Dick!\n",
            "I want this whale Shamu!\n",
            "I want this whale Keiko!\n",
            "There are no more whales to be had\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "YXDgzYG_H1Ke"
      },
      "source": [
        "#### Logging exceptions\n",
        "\n",
        "It is a best practice to log exception blocks"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O9mOcKsU5EAU",
        "colab_type": "code",
        "outputId": "30bba4f9-e692-40a6-de1c-a76a3ca7415b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        }
      },
      "source": [
        "import logging\n",
        "\n",
        "whales = [\"Keiko\", \"Shamu\", \"Moby Dick\"]\n",
        "while True:\n",
        "    try:\n",
        "        whale = whales.pop()\n",
        "        print(f\"I want this whale {whale}!\")\n",
        "    except IndexError:\n",
        "        logging.exception(f\"Exception Logged:  There are no more tournaments\")\n",
        "        print(\"There are no more whales to be had\")\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-17-6e00ea1cd041>\", line 6, in <module>\n",
            "    whale = whales.pop()\n",
            "IndexError: pop from empty list\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "I want this whale Moby Dick!\n",
            "I want this whale Shamu!\n",
            "I want this whale Keiko!\n",
            "There are no more whales to be had\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "EXsL-XdRhiQ4"
      },
      "source": [
        "## Use conditionals"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "88ORBTOPvyKy"
      },
      "source": [
        "### Using if/else/break/continue/pass statements \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "e4RVlT2_-4Tj"
      },
      "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": {
        "colab_type": "code",
        "id": "4rPN8VYgvvsL",
        "colab": {}
      },
      "source": [
        "def recommended_whale(emotion):\n",
        "    \"\"\"Recommends a whale based on emotion\"\"\"\n",
        "    \n",
        "    if emotion == \"angry\":\n",
        "        print(f\"You seem very {emotion}, I have just the whale for you:  Moby Dick!\")\n",
        "    elif emotion == \"happy\":\n",
        "        print(f\"You seem very {emotion}, I have just the whale for you:  Shamu!\")\n",
        "    else:\n",
        "        print(f\"You seem very {emotion}, I have no whale to recommend: How about a Crocodile instead?\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "liJPIg7dv4kq",
        "outputId": "e3bd7464-0e5c-4fcd-d770-8abb5f66d6e3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "recommended_whale(\"sad\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "You seem very sad, I have no whale to recommend: How about a Crocodile instead?\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cex2V7WFN9dz",
        "colab_type": "text"
      },
      "source": [
        "#### Single line conditional asssigment"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pN0BSWFyOFNA",
        "colab_type": "code",
        "outputId": "61240197-9be2-4e41-e3cd-851cf232b8c2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "happy = False\n",
        "cloudy = False\n",
        "\n",
        "happy = False if cloudy else True\n",
        "  \n",
        "happy"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "jYEv2fd4_BRO"
      },
      "source": [
        "#### Using break"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "n6uxAIVc_B1F",
        "outputId": "9cb686c2-7a98-4587-f3b2-56f0ee4cf3b5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        }
      },
      "source": [
        "crew_members = 0\n",
        "while True:\n",
        "  crew_members +=1\n",
        "  print(f\"Moby Dick is attempting to eat crew member {crew_members}\")\n",
        "  if crew_members > 3:\n",
        "    print(f\"Moby Dick is very full, he ate {crew_members} and couldn't possibly eat any more\")\n",
        "    break\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Moby Dick is attempting to eat crew member 1\n",
            "Moby Dick is attempting to eat crew member 2\n",
            "Moby Dick is attempting to eat crew member 3\n",
            "Moby Dick is attempting to eat crew member 4\n",
            "Moby Dick is very full, he ate 4 and couldn't possibly eat any more\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "KB7SreVYAHsH"
      },
      "source": [
        "#### Using continue"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "a56Y60MpAH1t",
        "outputId": "44c9934e-6b49-4c26-8331-395782d2cf4a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "whales = [\"Keiko\", \"Shamu\", \"Moby Dick\"]\n",
        "for whale in whales:\n",
        "  if not whale == \"Moby Dick\":\n",
        "    continue\n",
        "  print(f\"My favorite whale is {whale}\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "My favorite whale is Moby Dick\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "PgcB-3dUB2I4"
      },
      "source": [
        "#### Using pass\n",
        "\n",
        "The pass keyword is often a placeholder to define a class or function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "SsucVX0JB2Pe",
        "outputId": "72578bae-e1d6-4935-befb-aa9580f102b9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 130
        }
      },
      "source": [
        "def my_func(): pass\n",
        "\n",
        "\n",
        "my_func()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndentationError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-10-e2f9698e90a7>\"\u001b[0;36m, line \u001b[0;32m4\u001b[0m\n\u001b[0;31m    my_func()\u001b[0m\n\u001b[0m          ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nRn_iPJqNrFu",
        "colab_type": "code",
        "outputId": "bc55f73d-15de-4c50-c4a2-25c8b39d4d21",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "class SomeClass: pass\n",
        "\n",
        "some_class = SomeClass()\n",
        "\n",
        "some_class"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<__main__.SomeClass at 0x7fbdeb4e2a90>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    }
  ]
}