A Python Crash Course - Part 1 - Fundamentals.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Python Crash Course - Part 1 - Fundamentals\n",
        "![Python](https://img.shields.io/badge/python-3670A0?style=for-the-badge&logo=python&logoColor=ffdd54) \n",
        "\n",
        "[![author](https://shields.io/badge/author-Jing%20Nghik_(TeachJing)-blueviolet?style=plastic)](https://www.youtube.com/c/teachjing)\n",
        "\n",
        "**Requires** ![version](https://img.shields.io/badge/python-%3E%3D%203.6-blue)\n",
        "\n",
        "# Introduction\n",
        "\n",
        "This 📔 notebook takes you through the 👨‍🎓 learning the basic fundamentals of Python. Its an 👩‍💻 interactive self-paced  tutorial within notebook. This course will have you learning variables, data types, loops in no time. 😋\n",
        "\n",
        "## Table of Contents\n",
        "- Getting Started\n",
        "- Variables\n",
        "- Data Types\n",
        "- Collections\n",
        "- Block Indentation\n",
        "\n",
        "![Note](https://img.shields.io/badge/Note-blue) \n",
        "Be sure to click the table of contents under Menu -> View -> TOC to easily navigate the notebook.\n",
        "\n",
        "![Additional Resources](https://img.shields.io/badge/Additional_Learning_Resources-grey?style=for-the-badge&logo=appveyor) \n",
        "- [Microsoft Learn - Python learning modules] (https://docs.microsoft.com/en-us/learn/browse/?terms=python)\n",
        "- [Python.org - The Python Standard Library] (https://docs.python.org/3/library/index.html)\n",
        "- [Jupyter Notebooks Crash Course] (https://tacc.github.io/CSC2017Institute/docs/day1/jupyter.html)\n",
        "\n"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Getting Started\n",
        "\n",
        "If you haven't already, you may want to understand how to use Jupyter notebooks and more specifically Azure Notebooks by using this guide \"Getting Started with Azure ML Notebooks and Microsoft Sentinel\"\n",
        "\n",
        "[![docs](https://img.shields.io/badge/docs.microsoft.com_-_Getting_Started_with_Azure_notebooks-lightgrey?logo=microsoft&style=social)](https://docs.microsoft.com/en-us/azure/sentinel/notebook-get-started)\n",
        "<br><br>\n",
        "![Note](https://img.shields.io/badge/Please_Note-informational)\n",
        "The order on when you run the each cells are important. Some cells will have a dependency on another cell in order to work.<br>\n",
        "Make sure you identify if the cell requires other cells to run, otherwise you may run into errors."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Navigation\n",
        "\n",
        "<center><b>Keyboard Shortcuts</b></center>\n",
        "\n",
        "| key | description\n",
        "|---|---|\n",
        "|🔼🔽|Up/Down keys will navigate cell blocks|\n",
        "| `a` | Add a cell above highlighted cell |\n",
        "| `b` | Add a cell below highlighted cell |\n",
        "| `d` `d` | Delete a cell |\n",
        "| `c` | Copy a cell into clipboard |\n",
        "| `x` | Cut a cell into clipboard |\n",
        "| `v` | Paste a cell below selected cell |\n",
        "| `z` | Undo your boo boo|\n",
        "| `Enter`| Edit a cell |\n",
        "| `Escape` | Escape current cell in order to navigate|\n",
        "| `Ctrl` + `Enter` | Runs current cell and stays on the current cell. | \n",
        "| `Shift` + `Enter` | Runs current cell and moves once cell down after running | \n",
        "| `m` | Convert current cell to `markdown` cell format |\n",
        "| `y` | Convert current cell to `code` cell format |"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Use your table contents to quickly browse to certain topics or areas of interest. \n",
        "\n",
        "Lets get 😎fancy by showing you how to quickly navigate a notebook. You will notice that in whatever cell your working in, it is `highlighted` indicating its your current or selected cell. \n",
        "\n",
        "![Try](https://img.shields.io/badge/Try_The_Following-blue)\n",
        "- 🗺 Navigating - So lets press the `escape` key and navigate up and down by using our arrows 🔼 🔽\n",
        "- ➕ Adding Cells - Now, lets hit the `a` or `b` key. This will either add a cell above/below your currently selected cell when navigating.\n",
        "- ❌ Deleting - Highlight any cell when you are navigating and then press `d` `d`. (Make sure you aren't editing a cell `escape`)\n",
        "- 📝 Editing - To edit a cell, just navigate to the cell and press `enter` which puts you in edit mode.\n",
        "- ✂ Cutting/Pasting - Highlight a cell and press `c` or `x` to copy/cut a cell. Then navigate to where you want to paste it and press `v` which will paste the cell below your selected/currentEditing - To edit a cell, just navigate to the cell and press `enter` which puts you in edit mode.\n",
        "- Undo - Oops, you made a mistake? 😓 Press z to undo that boo boo 💩.\n",
        "\n",
        "☝ Above is a helpful reference guide. Try to get familiar with the ⌨ keyboard shortcuts to help you navigate, add, copy, paste, delete, and run cells.\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/I_challenge_you-blueviolet) \n",
        "Think you can try navigating the rest of the notebook without using your mouse 🐭 at all. <br>\n",
        "Remember to navigate using your arrows 🔼 🔽 and the `enter`/`escape` key to enter/exit a cell. "
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 👋🏾 Hello World\n",
        "In the code cell below, enter `\"Hello World\"` enclosed in some quotation marks. \n",
        "\n",
        "```python\n",
        "\"Hello World\"\n",
        "```\n",
        "\n",
        "This simply just prints/output the `input` you provided which was enclosed double quotes `\"`."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"Hello Jing\""
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "But sometimes, you may want to print multiple outputs and control/modify the output. So more often you will utilize the `print` function. <code>print(\"Hello World\")</code>\n",
        "\n",
        "```python\n",
        "print(\"Hello World\")\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Can you modify `Hello World` and print something else out?"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Hello World\")\n",
        "print(\"Hello Jing\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634574547862
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Cell types\n",
        "\n",
        "📓 Notebook cells can be in two different formats, markdown or code cells. \n",
        "- 📃 Markdown - allows you to comment and document your notebook\n",
        "    - [Markdown Guide](https://www.markdownguide.org/) - The Markdown Guide is a free and open-source reference guide that explains how to use Markdown to format virtually any document. \n",
        "- 👩🏾‍💻 Code Cells - code cells are the actual runnable code.\n",
        "\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet)\n",
        "- Press the `escape` key to ensure you are not editing a code cell and then press either `m` or `y` to convert a cell to either format.\n",
        "- How would you add a code cell `below` this cell and convert it to a markdown cell using what shortcuts you have learned, ?"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Comments\n",
        "You will want to make it a habit to comment your code so you and others can otherstand what its purpose is.\n",
        "\n",
        "Single line comments is using a `#` character and any following string after will be ignored\n",
        "```python\n",
        "# This is a single line comment. \n",
        "print (\"Hello\")\n",
        "```"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# This is a single line comment and will be ignored\n",
        "print (\"Hello\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1633410144162
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Using Help\n",
        "The python `help`🆘 function is used to display the documentation of modules, functions, classes, keywords, etc.\n",
        "\n",
        "![syntax](https://img.shields.io/badge/Syntax-grey) \n",
        "```python\n",
        "help([object])\n",
        "```\n",
        "\n",
        "![syntax](https://img.shields.io/badge/Example-grey) \n",
        "```python\n",
        "help(print)\n",
        "```"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "help(\"print\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634574759177
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Importing modules\n",
        "A module is a file containing Python definitions and statements. There will be times you need to do something specific and most likely someone has already created a module you can use. \n",
        "In most cases you can save alot of time if there is a module that already exists you can leverage to help you get to your desired outcome faster 🚀. And who doesn't like to save time ⌚.\n"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 👍 Make sure package is installed\n",
        "If you ever want to use a module, you first must install it. The most common way is to use a native package manager like `pip` to install the module so you can `import` it. Remember you can't use what you don't have!\n",
        "\n",
        "Most of the time to install any module, you can reference the name your trying to import.\n",
        "```python\n",
        "!pip install <package_name>\n",
        "# Example: !pip install numpy\n",
        "```\n",
        "\n"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install numpy"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![Note](https://img.shields.io/badge/Please_Note-informational)\n",
        "There is also a magic `%pip` command that will ensure you install the module in the right kernel (rather than the instance of Python that launched the notebook)\n",
        "\n",
        "Be sure its the **first** line you have on your cell block."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%pip install numpy"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "<div style=\"background-color:#ffc107\">\n",
        "  <b><p style=\"color:#000000\">\n",
        "    Sometimes the above command might not work 😫. It could because of mismatch if versions, OS, where notebook is hosted. In that case, you will use the following command to ensure pip installs the module on the python kernel you're running Jupyter Notebooks.    \n",
        "  </p></b>\n",
        "</div>\n",
        "\n",
        "```python\n",
        "# Install a pip package in the current Jupyter kernel\n",
        "import sys\n",
        "!{sys.executable} -m pip install <package_name>\n",
        "```\n",
        "\n",
        "Or open a terminal 🖥 session and run this command so pip will load the module in the proper python kernel.\n",
        "```python\n",
        "python -m pip install <package_name>\n",
        "# Example: python -m pip install numpy\n",
        "```"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### ⏬ Import the modules you need\n",
        "\n",
        "Once you confirm pip has installed the module ✔, those modules can now be used in the current notebook 📒.\n",
        "\n",
        "You will import any module by using the `import` command along with the `name` of the module you want to import\n",
        "\n",
        "Sometimes packages have different names than their importable name.  `E.g. pip install scikit-learn -> import sklearn`\n",
        "\n",
        "```python\n",
        "import datetime\n",
        "print(datetime.datetime.now())\n",
        "# output: 2021-10-15 17:15:45.247946\n",
        "```\n",
        "\n",
        "If you don't require the whole module library, its always best practice to specify exactly what you want to import\n",
        "\n",
        "```python\n",
        "from datetime import datetime\n",
        "print(datetime.now())\n",
        "# output: 2021-10-15 17:15:45.247946\n",
        "```\n",
        "\n",
        "Notice also the line is shortened because you can call directly what you imported `datetime` instead of the full module path `datetime.datetime`"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from datetime import datetime\n",
        "print(datetime.now())"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "gather": {
          "logged": 1634649336218
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Importing module using `as`**\n",
        "\n",
        "![tip](https://img.shields.io/badge/Tip-blue) \n",
        "To make it easier to call modules, shorten the module name by using `as` to define an `alias`.\n",
        "\n",
        "```python\n",
        "from datetime import datetime as d\n",
        "print(d.now())\n",
        "```\n",
        "\n"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "from datetime import datetime as dt\n",
        "print(dt.now())"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "gather": {
          "logged": 1634575052281
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Restart the Kernel\n",
        "\n",
        "If you are not able to use the module, it may require restarting the kernel. You can do that by importing `IPython` and restarting it or click on the restart icon 🔃\n",
        "\n",
        "![Warning](https://img.shields.io/badge/Please_Remember-important)\n",
        "You will lose all cached variables when you restart the kernel."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import IPython\n",
        "IPython.Application.instance().kernel.do_shutdown(True) #automatically restarts kernel from cell."
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634333674289
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Variables\n",
        "\n",
        "A variable is a value that can change, depending on conditions or on information passed to the program\n",
        "\n",
        "![Note](https://img.shields.io/badge/Note-informational)\n",
        "- The Python interpreter automatically picks the most suitable built-in data-type for the variable if no type is provided\n",
        "- You cannot use python keywords as a variable name. You can see a list of keywords by typing `import keyword; print(keyword.kwlist)`"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Creating variables and assigning values\n",
        "\n",
        "We first will assign ```Hello World``` to the variables ```s1,s2```. We will then print the variables by referencing it in print.\n",
        "Try it below:\n",
        "```python\n",
        "s1 = \"Hello\"\n",
        "s2 = \"World\"\n",
        "print(s1,s2)\n",
        "```\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet)\n",
        "How would you print `Microsoft Sentinel` using what you know?"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s1 = \"Hello\"\n",
        "s2 = \"World\"\n",
        "s3 = \"!\"\n",
        "print(s1,s2,s3)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634575257676
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Assigning multiple variables\n",
        "- You can assign multiple values to multiple variables in one line.\n",
        "- **Note** that there must be the same number of arguments on the right and left sides of the = operator:\n",
        "\n",
        "![Example](https://img.shields.io/badge/Example-yellowgreen)\n",
        "```python\n",
        "a, b, c = 1, 2, 3\n",
        "print(a, b, c)\n",
        "```\n",
        "Exercise: Try assigning an additional variable with value to this list"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a, b, c = 1, 2, 3\n",
        "print(a, b, c)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634575444941
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![Note](https://img.shields.io/badge/Note-informational) Remember pretend the `mouse 🖱` has feelings and doesn't want to be touched, Practice using your `keyboard ⌨` **only**."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Temporary variables\n",
        "\n",
        "It is common to have temporary or dummy variable assignments for a cell. It is conventional to use the underscore for these type of unwanted values.\n",
        "\n",
        "![Example](https://img.shields.io/badge/Example-yellowgreen)\n",
        "```python\n",
        "a, b = 1, 2   ## assigns a,b the value 1,2\n",
        "_ = a+b       ## _ is temporary assignment that adds a and b together\n",
        "_temp = b-a\n",
        "print(a,b, \"equals\", _)   ## prints the output\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Exercise: change the unwanted variable `_` to the result of `b-a`"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a, b = 1, 2\n",
        "_ = a+b \n",
        "_temp = \"1\" + \"1\"\n",
        "print(a,b, \"equals\", _)\n",
        "print(\"_temp equals\", _temp, \"since 1 has quotes around it indicating a string data type\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634326294129
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Data Types\n",
        "\n",
        "|Data Type|Description|Example|\n",
        "|------|------|------|\n",
        "|int|Integers, floating-point, complex numbers|1,2,3,4,5|\n",
        "|bool|an expression that results in a value of either true/false.|True/False|\n",
        "|str|strings of characters| \"John\"|\n",
        "|list| mutable sequence that group various objects together | [1,True,\"John\"]\n",
        "|dict| Dictionary | {'name':'red','age':10}|\n",
        "|tuple|similar to list but they are immutable.|(123,'hello')|\n",
        "|set|unordered and mutable collections of arbitrary but hashable Python objects|{\"apple\",\"banana\",\"orange\"}|\n",
        "\n",
        "![Note](https://img.shields.io/badge/Additional_Documentation-darkgreen)\n",
        "- [Documentation - python.org - Data Types] (https://docs.python.org/3/library/datatypes.html)"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## String\n",
        "Strings can be declared a number of ways. \n",
        "\n",
        "Single quotes\n",
        "```python\n",
        "print('This string is in single quotes')\n",
        "```\n",
        "\n",
        "Double quotes\n",
        "```python\n",
        "print(\"This string is in double quotes\")\n",
        "```\n",
        "\n",
        "Triple double quotes\n",
        "```python\n",
        "print(\n",
        "\"\"\"\n",
        "This multi-line string\n",
        "is in triple double quotes\n",
        "\"\"\")\n",
        "```\n",
        "\n",
        "![Note](https://img.shields.io/badge/Question-grey)\n",
        "Why would you want different ways of declaring a string?"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('This string is in single quotes')\n",
        "print(\"This string is in double quotes\")\n",
        "print(\"\"\"\n",
        "This multi-line string\n",
        "is in triple quotes\"\"\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634324553119
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Answer**: Because this allows you to embed quotes inside a string by declaring it with another way. You cannot use the same quotes you used to declare the string because it would end the string and the output would not be what you wanted.\n",
        "<br><br>\n",
        "\n",
        "```python\n",
        "## This is wrong\n",
        "print(\" I am a string with \"quotes\" \")\n",
        "\n",
        "## This is right\n",
        "print(' I am a string with \"quotes\" ')\n",
        "print(\" I am a string with 'quotes' \")\n",
        "print(\"\"\" I am a string with 'two' types of \"quotes\" \"\"\") \n",
        "Output \n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Press `escape` if you need to and navigate ⬇. Press `enter` to edit the cell and try running the current cell. Can you fix it using what we learned?"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "print(\" I am getting pretty good with \"Azure Notebooks\" \")\n"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Escaping special characters\n",
        "If your string has special characters or punctuation, you may have problems using it. In order to do that, you will need to use the backslash `\\` key. This tells python to ignore the character that follows the backslash.\n",
        "```python\n",
        "print ('It\\'s getting \\'hot\\' in here')\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Try removing the backslash and run the cell. What happens?"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print ('It\\'s getting \\'hot\\' in here')"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1633361887581
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Inserting values into a string and evaluating expressions\n",
        "\n",
        "```python\n",
        "age = 30\n",
        "print(f\"You are {age} years old. {1 + 1}\")\n",
        "```\n",
        "\n",
        "Notice how we prefix `f` in front the string `\"You are {age} years old.\"`. This allows us to evaluate any expression within curly braces `{ }`. In this case, we grab the value for variable `age` and insert it into the string when evaluated."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "age = 30\n",
        "print(f\"You are {age} years old. {1 + 1}\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634329664549
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Numeric data\n",
        "\n",
        "There are three types of numbers used in Python: integers, floating, and complex numbers.\n",
        "\n",
        "```python\n",
        "x = 5    # int\n",
        "y = 10.024  # float\n",
        "z = 5j   # complex\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Run the cell below `(shift-enter)`. Make a guess what the `type()` command does?"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s = \"I am a string\"\n",
        "x = 5    # int\n",
        "y = 10.024  # float\n",
        "z = 5j   # complex\n",
        "\n",
        "print (\"Class\", \"\\t\\t\\t\", \"Value\")\n",
        "print (type(s), \"\\t\\t\", s)\n",
        "print (type(x), \"\\t\\t\", x)\n",
        "print (type(y), \"\\t\", y)\n",
        "print (type(z), \"\\t\", z)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1633446430017
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Here are some arithmetic operations you can perform\n",
        "\n",
        "| Operator     | Name           | Description                                            |\n",
        "|--------------|----------------|--------------------------------------------------------|\n",
        "| ``a + b``    | Addition       | Sum of ``a`` and ``b``                                 |\n",
        "| ``a - b``    | Subtraction    | Difference of ``a`` and ``b``                          |\n",
        "| ``a * b``    | Multiplication | Product of ``a`` and ``b``                             |\n",
        "| ``a / b``    | True division  | Quotient of ``a`` and ``b``                            |\n",
        "| ``a // b``   | Floor division | Quotient of ``a`` and ``b``, removing fractional parts |\n",
        "| ``a % b``    | Modulus        | Integer remainder after division of ``a`` by ``b``     |\n",
        "| ``a ** b``   | Exponentiation | ``a`` raised to the power of ``b``                     |\n",
        "| ``-a``       | Negation       | The negative of ``a``                                  |"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## Arithmatic Operations Examples\n",
        "print(True)\n",
        "print(5 + 5)\n",
        "print(5 - 3)\n",
        "print(10 / 2)\n",
        "print(5.0 / 2)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1633099458326
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Boolean\n",
        "\n",
        "<center>Comparison Operations</center>\n",
        "\n",
        "|Operation|Description|Operation|Description|\n",
        "|---|---|---|---|\n",
        "|a == b|a equal to b|a != b|a not equal to b|\n",
        "|a < b|a less than b|a > b|a greater than b|\n",
        "|a <= b|a less than or equal to b|a >= b|a greater than or equal to b|\n",
        "\n",
        "```python\n",
        "5.0 == 5\n",
        "'3' == 3\n",
        "True == True\n",
        "True == False\n",
        "True == 1\n",
        "True == 0\n",
        "'🍎' == '🍏'\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "▶ Run the following 👇🏾 cell block and identify why each expression either resolves true or false."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"5.0 == 5,\", 5.0 == 5)\n",
        "print(\"'5' == 5,\", '5' == 5)\n",
        "print(\"True == True,\", True == True)\n",
        "print(\"True == False,\", True == False)\n",
        "print(\"not True == False,\", not True == False)\n",
        "print(\"True == 1,\", True == 1)\n",
        "print(\"True == 0,\", True == 0)\n",
        "print(\"'🍎' == '🍏',\", '🍎' == '🍏')"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634328816465
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Combining Boolean values\n",
        "\n",
        "You can combine boolean values by using `and`,`or`, and `not`\n",
        "\n",
        "```python\n",
        "5 > 1 and \"🍎\" == \"🍌\"\n",
        "```\n",
        "\n",
        "Here `5 > 1` evaluates to true, but `\"apple\" == \"banana` evaluates to false. This then results to false.\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Run the following cell 👇🏾, and then see if you can make the result of both conditions evaluate to `True`."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "5 > 1 and \"🍎\" == \"🍌\""
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634328112352
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Converting Data Types\n",
        "\n",
        "There may be situations you will need to convert a data type to another in order for the script to work. \n",
        "```python\n",
        "\n",
        "int_to_float = float(10)         ## Convert integer to floating number\n",
        "str_to_float = float(\"200.1243\") ## Convert string to floating number\n",
        "\n",
        "print (int_to_float)\n",
        "print (str_to_float)\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Can you try converting a number/string with a decimal to an integer? What happens?"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "str_to_float = float(\"200.1243\")\n",
        "print (str_to_float)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634328930669
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Here are some more data types to practice with"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## Converting Data Types\n",
        "x = (5/2)\n",
        "print(\"Type:\", type(x), \", Output\", (x))\n",
        "\n",
        "## Convert to string\n",
        "x = str(5/2)\n",
        "print(\"Type:\", type(x), \", Output\", (x))\n",
        "\n",
        "## Convert to int \n",
        "x = int(5/2)\n",
        "print(\"Type:\", type(x), \", Output\", (x))\n",
        "\n",
        "## Convert from int to bool\n",
        "x = bool(0)\n",
        "print(\"Type:\", type(x), \", Output\", (x))\n"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634327770558
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Collections\n",
        "\n",
        "<center><b>There are four collection data types in Python</b></center><br>\n",
        "\n",
        "|Name|sort|indexed|mutable|duplicates|\n",
        "|---|---|---|---|---|\n",
        "|List|✅ ordered|✅ indexed|✅changeable|✅Allows duplicate members\n",
        "|Tuple|✅ ordered|✅ indexed|❌unchangeable|✅Allows duplicate members\n",
        "|Set|❌ unordered|❌Unindexed|✅changeable|❌No duplicate members\n",
        "|Dictionary|✅ ordered|✅ indexed|✅changeable|✅No duplicate keys, but duplicate values are ok\n",
        "\n",
        "There will be situations where a certain collection type makes more sense than another. Example is you want a set of distinct items with no duplicates `set`. Or you want a collection that you can grab the `age` or `name` of a person in a collection `dictionary`."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## List\n",
        "|Name|description|sort|indexed|mutable|duplicates|\n",
        "|---|---|---|---|---|---|\n",
        "|List|ordered sequence of values|✅ ordered|✅ indexed|✅changeable|✅Allows duplicate members\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Please_Note-blue) \n",
        "- A list is a sequence, where each element is assigned a position (index)\n",
        "- First position is 0. You can access each position using \n",
        "\n",
        "Allright, first lets create a list\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Syntax-grey) \n",
        "```python\n",
        "list_name = ['value1','value2','value3','value4','value5']\n",
        "```\n",
        "\n",
        "Notice how a list is enclosed in square brackets `[ ]`.\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Run the cell below to create a list, which also will be referenced in the following cells. Any variables created in the session, could be referenced later as long as the kernel was not restarted."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list = [1,2,3,4,5,6,7,8,9,10]\n",
        "my_list"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634328996269
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Access items from list\n",
        "You can access items in a list with the same `[ ]` square brackets, but inside you put the index location of what items you want returned.\n",
        "\n",
        "\n",
        "Lets print the third item in the list\n",
        "- Note: The very first position in a list is `0`, so the third item in the list is pulled by referencing `2`\n",
        "\n",
        "```python\n",
        "print(myList[2])\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "🏃🏾‍♀️ Run the following cell, but how would you print the last item on the list?"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(my_list[2])"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634329009048
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "You are ✔ correct if you answered:\n",
        "```python\n",
        "print(my_list[9])\n",
        "# 10\n",
        "```\n",
        "\n",
        "But you can also print the last item on the list by using a `-1`\n",
        "```python\n",
        "print(my_list[-1])\n",
        "# 10\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Using what you know, how would you get the 2nd from the last item on the list"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(my_list[-1])"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "gather": {
          "logged": 1634329028401
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![Answer](https://img.shields.io/badge/Answer-darkgreen) \n",
        "You would reference the index `-2` since any negative value starts from the right. `print(my_list[-2])`"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Adding item to the list\n",
        "\n",
        "You can add item to the list using the `append()` method."
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "my_list.append(1000); \n",
        "print(my_list)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "gather": {
          "logged": 1634329190852
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Modify a list\n",
        "\n",
        "You may want to modify values in a list\n",
        "```python\n",
        "myList[2] = 5000    #changed the 3rd item in list from 3 to 'changed'\n",
        "```"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list[2] = 5000\n",
        "print(my_list)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634329201769
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Removing item from list\n",
        "\n",
        "```python\n",
        "del(my_list[1])         ## deletes the 2nd item (1) in the list since we start with 0 first which is the number 2\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Remove the first two items on the list using a range `[<start>:<finish>]`"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "del(my_list[1]) \n",
        "print(my_list)        "
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1633447341129
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Merging Lists together\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Note-blue) \n",
        "- When you want to merge two lists together, you can simply use `+`\n",
        "- Note: There are still duplicates when lists are merged.\n",
        "\n",
        "Lets create list x,y and another variable `myList` that is a combination of both.\n",
        "```python\n",
        "new_list = [20, 21, 22, 23, 24];\n",
        "my_list = my_list + new_list\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Can you add more items to the list or even make another list and merge all 3 together using what we learned? "
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Concatenation\n",
        "new_list = [20, 21, 22, 23, 24];\n",
        "my_list = my_list + new_list\n",
        "print(my_list)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634329208702
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Slicing and Dicing a list\n",
        "There may be situations where you don't want the first item in a list or only want the first 5. You will need to reference the `range` you want after the list variable.\n",
        "\n",
        "![syntax](https://img.shields.io/badge/syntax-grey) \n",
        "```python\n",
        "my_list[<start_here>:<end_here>]\n",
        "```\n",
        "\n",
        "Lets slice (extract) the first and second item in the list\n",
        "```python\n",
        "print(my_listt[0:2])  ## 0 identifies where to start (value is grabbed). The 2 indicates the location you want to stop. (the value at the end location isn't pulled).\n",
        "```"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Full list:\", my_list)\n",
        "print(\"Spliced List:\", my_list[0:2])  ## Slice the first and second item in the list"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634329273002
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Checking if list contains a value\n",
        "\n",
        "You can check if a list contains a item by using `in`\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/syntax-grey) \n",
        "```python\n",
        "'search_word' in list\n",
        "```\n",
        "<br>\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "\n",
        "1. Modify the line and search for the number `10` in the list.\n",
        "2. How would you an `and` conditional to check for two values"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "1 in my_list"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "gather": {
          "logged": 1634329308659
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Counting\n",
        "\n",
        "Count how many items in a list by using `len(<list>)`\n",
        "```python\n",
        "len(my_list)\n",
        "```\n",
        "\n",
        "Count how many times an item is in the list `list_name.count(\"<what_to_search_for>\")`\n",
        "```python\n",
        "my_list.count(5)\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        " Count how many times the number 5 shows up in the list."
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "how_many_items = len(my_list)       ## Gets item count and assigns it to `how_many_items` variable\n",
        "how_many_times = my_list.count(1)   ## Counts how many times `1` shows up in `myList`\n",
        "\n",
        "print(my_list)\n",
        "print(\"The list has\", how_many_items, \"items.\")\n",
        "print(\"The number 1 shows up\", how_many_times, \"times.\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634329710277
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Getting the highest value in a list\n",
        "To get the highest number in the list you will use the `max()` function. You cannot calculate max if the values are not all numeric."
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "#Get the highest numeric year in the list\n",
        "print(my_list)\n",
        "print( max(my_list) )"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634329715569
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Lists can have various data types "
      ],
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": [
        "Elements in the lists can be different data types, but be careful of performing any calculation with mixed data types.\n",
        "```python\n",
        "    mylist = ['string1', 1, \"string2\", True]\n",
        "```"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "multitype_list = ['string1', 1, \"string2\", True]\n",
        "print(multitype_list)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Sets\n",
        "|Name|sort|indexed|mutable|duplicates|\n",
        "|---|---|---|---|---|\n",
        "|Set|❌ unordered|❌Unindexed|✅changeable|❌No duplicate members\n",
        "\n",
        "Sets are similar to list but is an unordered collection data type that is iterable, mutable and has no duplicate elements. \n",
        "- Unordered and sets cannot change once the set has been created."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lets create a set from the list and notice duplicates are removed\n",
        "```python\n",
        "basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}\n",
        "#> {'orange', 'banana', 'pear', 'apple'}\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Modify the line and add another fruit to the basket."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}\n",
        "print(basket)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634329825416
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Create set from string\n",
        "```python\n",
        "a = set('abracadabra')  ## Notice duplicates are removed.\n",
        "#> {'a', 'r', 'b', 'c', 'd'}\n",
        "```\n",
        "\n",
        "Run the following cell and do you understand whats happening ? Why is the list shorter 🤔?"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = set('abracadabra')\n",
        "print(a) \n",
        "\n",
        "fruits = set( {'🍎','🍏','🍏','🍊','🍌','🍏','🌮','🍉','🍌'} )\n",
        "print(b) "
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634329981497
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Add item to set\n",
        "```python\n",
        "a.add('z')\n",
        "#> {'a', 'c', 'r', 'b', 'z', 'd'}\n",
        "```"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a.add('z')\n",
        "print(a)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634330089711
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Making a set immutable (Cant be modified)\n",
        "If you ever want to declare a list and ensure the list is not modified, you can freeze the list using `frozenset(<set_name>)`\n",
        "\n",
        "```python\n",
        "b = frozenset('asdfagsa')\n",
        "#> frozenset({'f', 'g', 'd', 'a', 's'})\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Notice we add `Dallas` to the set `cities`. Uncomment `#` the commented line `#frozen_cities.add(\"Tampa\")` and run the cell again. What happens?"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## Create a cities set and adds Dallas to the set\n",
        "cities = {\"Houston\", \"New York\",\"San Diego\"}\n",
        "cities.add(\"Dallas\")\n",
        "print(cities)\n",
        "\n",
        "frozen_cities = frozenset(cities)\n",
        "#frozen_cities.add(\"Tampa\")\n",
        "print(frozen_cities)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Dictionary\n",
        "|Name|sort|indexed|mutable|duplicates|\n",
        "|---|---|---|---|---|\n",
        "|Dictionary|❌ unordered|✅ indexed|✅changeable|✅No duplicate members\n",
        "\n",
        "Dictionary consists of key-value pairs `{<key> : <value>}`. It is enclosed by curly braces {} and values can be assigned and accessed\n",
        "using square brackets `[]`."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Create a dictionary\n",
        "\n",
        "Lets create a dictionary object with a name and age key\n",
        "```python\n",
        "person={\n",
        "    'name' : 'bob',\n",
        "    'gender' : 'male',\n",
        "    'age' : 30\n",
        "}\n",
        "```"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "person={\n",
        "    'name' : 'bob',\n",
        "    'gender' : 'male',\n",
        "    'age' : 30\n",
        "}\n",
        "print(person)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634330143091
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Getting a property\n",
        "\n",
        "Lets grab the `age` property from this dictionary object by reference the right `key` which in this case its the string `\"age\"` enclosed in double quotes .\n",
        "```python\n",
        "print(person['age'])\n",
        "```\n"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(person['age'])"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1633447842051
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Get list of keys/values\n",
        "\n",
        "To get the list of keys or values only, you would specify the method \n",
        "\n",
        "Get list of keys\n",
        "```python\n",
        "print( person.keys() )\n",
        "# output: dict_keys(['name', 'gender', 'age'])\n",
        "```\n",
        "\n",
        "Get list of values\n",
        "```python\n",
        "print( person.values() )\n",
        "# output: dict_values(['bob', 'male', 30])\n",
        "```"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(person.keys())\n",
        "print(person.values())"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1633448011300
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Adding to dictionary\n",
        "\n",
        "To add to the list, you simply just reference an unused `key name` in the dictionary object\n",
        "```python\n",
        "person['location'] = 'US'\n",
        "# {'name': 'bob', 'gender': 'male', 'age': 30, 'location': 'US'}\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Try adding another item to the dictionary object."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "person['location'] = 'US'  ## This adds a location with the value US to the dictionary object\n",
        "print(person)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1633448116142
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Tuple\n",
        "|Name|sort|indexed|mutable|duplicates|\n",
        "|---|---|---|---|---|\n",
        "|Tuple|✅ ordered|✅ indexed|❌unchangeable|✅Allows duplicate members\n",
        "\n",
        "Tuples are like `lists` except cannot be changed\n",
        "\n",
        "```python\n",
        "tuple = (123,'hello')\n",
        "print(tuple)            #will output whole tuple. (123,'hello')\n",
        "print(tuple[0])         #will output first value. (123)\n",
        "```"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tuple = (123,'hello')\n",
        "print(tuple)\n",
        "print(tuple[0])\n",
        "print(tuple[1])"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634330171271
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<br>After running the previous cell, try updating the tuple by running the cell below\n",
        "```python\n",
        "tuple[1] = \"update\"\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Question-ff69b4) \n",
        "What happens when you run the cell and do you know why it happened based on how `tuples` work?"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tuple[1] = \"update\""
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Block Indentation\n",
        "Python uses indentation to define and control function, loops, and conditions. \n",
        "This makes Python easy to read, but the user must play close attention to the whitespace (space/tabs) usage. Always use 4 spaces for indentation and most code editors are able to convert tabs to spaces to reduce any error.\n",
        "\n",
        "<img src=\"data:image/png;base64,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\" width=\"300\"/>\n",
        "\n",
        "\n",
        "![Note](https://img.shields.io/badge/Note-blue) \n",
        "Do not mix tab and spaces. Stay consistent. Indentation Errors will occur or cause the program to do something unexpected"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Functions\n",
        "A function is a block of code which only runs when it is called. This is helpful to run repeatable blocks of code you plan on using often.\n",
        "\n",
        "![Note](https://img.shields.io/badge/Note-blue) \n",
        "- You can pass data, known as parameters, into a function.\n",
        "- A function can return data as a result.\n"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Creating a functions\n",
        "Declare the function name with \n",
        "Syntax\n",
        "```python\n",
        "def <function_name>()\n",
        "```\n",
        "Then any lines you want to belong to the function is associated by using 4 empty spaces\n",
        "\n",
        "![Note](https://img.shields.io/badge/Example-grey) \n",
        "```python\n",
        "def ping(): # Declare the function with `def <name>():`\n",
        "    print(\"pong\")\n",
        "```"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def ping():         \n",
        "    print(\"pong 🏐\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634330313560
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Call a function\n",
        "Call your custom function you declared by referencing the name of the function `ping()`"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "ping()"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "gather": {
          "logged": 1634330316599
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Passing information to functions\n",
        "Information can be passed into functions as arguments.\n",
        "```python\n",
        "def greeting(name):       ## we declare the parameter `name` as a variable that will be used in the nested code\n",
        "    print(\"Hello\",name)   ## we print Hello with the value of the name provided\n",
        "\n",
        "greeting(\"John\")          ## we call the function greeting and pass the argument `John` as the name\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "How would you pass another value to the greeting function and print it out on the response?\n",
        "- Example: Print a response like, \"Hello `<name>`, You are `<age>` years old\""
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def greeting(name):\n",
        "    print(\"Hello\", name)\n",
        "\n",
        "greeting(\"John\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634330363368
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can also pass multiple arguments by separating each value with a comma\n",
        "```python\n",
        "def greeting(name, age):\n",
        "    print(\"Hello\", name, \"You are\", age, \"years old.\")\n",
        "\n",
        "greeting(\"John\", 30)\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Can you pass third argument and print it in the output when the function is called?"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def greeting(name, age):\n",
        "    print(\"Hello\", name, \"You are\", age, \"years old.\")\n",
        "\n",
        "greeting(\"John\", 30)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1633380946549
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Commenting in functions\n",
        "Docstrings are not like regular comments. They are stored in the function documentation. You can then use `help()` to get some helpful guidance on the particular function\n",
        "\n",
        "Comment your function\n",
        "```python\n",
        "def ping():\n",
        "    \"\"\" This function replies pong. This is custom documentation you can build to describe the function \"\"\"\n",
        "    return \"pong\"\n",
        "\n",
        "ping()\n",
        "```\n",
        "\n",
        "Get help details on function\n",
        "```python\n",
        "help(ping)\n",
        "```\n"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def ping():\n",
        "    \"\"\" This function replies pong. This is custom documentation you can build to describe the function \"\"\"\n",
        "    return \"pong\"\n",
        "\n",
        "ping()\n",
        "help(ping)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1633363079900
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Multi-level indentation and nesting\n",
        "\n",
        "You can nest conditions, loops, and functions within each other. \n",
        "If a function is not indented to the same level it will not be considers as part of the parent class\n",
        "\n",
        "```python\n",
        "def separateFunction(provided_list):\n",
        "    #Loops are also indented and nested conditions start a new indentation\n",
        "    \n",
        "    for i in provided_list:  ## loop through each item in the list\n",
        "        \n",
        "        if i == 1:  ## We will check each `item` in the list for the value of `1`.\n",
        "            return True\n",
        "    return False\n",
        "\n",
        "separateFunction([2,3,5,6,1])\n",
        "```\n",
        "\n",
        "This will call the function `separateFunction()` and provide the list ``` [2,3,5,6,1]``` as an input argument for the function `separateFunction()`\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Try searching for another `item` in the array, or add an additional argument in `separateFunction()` to search against that argument instead of the static value `1`."
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "def separateFunction(provided_list):\n",
        "    \n",
        "    ## loop through each item in\n",
        "    for item in provided_list:\n",
        "        \n",
        "        ## We will check each `item` in the list for the value of `1`.\n",
        "        if item == 1:\n",
        "            return True\n",
        "    return False\n",
        "\n",
        "separateFunction([2,3,5,6,1])"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1631911040290
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Passing values into a function"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Default values in a function\n",
        "\n",
        "You can provide default values if you want to assume certain values. Then if input `IS` provided, it overrides the static default value.\n",
        "\n",
        "First lets create another function that has a `default value` for the greeting. We also will call `help()` function to get the documentation of the `greet()` function."
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "def greet(name=\"anonymous\", greeting=\"Hello\"):\n",
        "    \"\"\"\n",
        "        Print a greeting to the user `name` Optional parameter `greeting` can change what they're greeted with.\n",
        "        Example: greet(\"John\",\"Sup\")\n",
        "    \"\"\"\n",
        "    print(\"{} {}\".format(greeting, name))\n",
        "\n",
        "help(greet)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634330462945
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lets call the function first by providing no input or arguments\n",
        "\n",
        "```python\n",
        "greet()\n",
        "```"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "greet()"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "gather": {
          "logged": 1634330467905
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "This time lets call the function `greet()` but also provide the arguments `name='john'` and `greeting='sup'`\n",
        "\n",
        "We can pass arguments based on the position in the list\n",
        "```python\n",
        "greet(\"john\", \"sup\")\n",
        "# output: sup john\n",
        "```\n",
        "\n",
        "Or we can directly specify what value is for what argument (which now doesn't need to be in the proper list position)\n",
        "```python\n",
        "greet(greet=\"sup\", name=\"bob\")\n",
        "# output: sup bob\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Try passing different arguments in different positions. Or modify the function and add another argument that will be used in the response"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "## Call the greet function and pass a name\n",
        "greet(greeting=\"sup\", name=\"bob\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1633374319230
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Conditional statements"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "if/else/elif Example\n",
        "```python\n",
        "    if conditionA:\n",
        "        statementA\n",
        "    elif conditionB:\n",
        "        statementB\n",
        "    else:\n",
        "        statementD\n",
        "    \n",
        "    this line will always be executed (after the if/else)\n",
        "```"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Exercise: Run the cell below `shift-enter`, How would you modify the if statement to evaluate to false?"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Creating a conditional statement\n",
        "You will nest lines that you want included in each condition evaluated\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Run the following command and see if you can make the expression evaluate false?"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "a = 5;  ## Initializes variables a,b with values 2,4\n",
        "b = 2;\n",
        "\n",
        "#If block starts here\n",
        "if a > b:               # If the value of a > b, nested indented lines will run\n",
        "    print(\"✅\", a) \n",
        "else:                   # if above if statement evaluates to false, the following nested indented lines will run.\n",
        "    print(\"❌\", b)\n",
        "b = 2;"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634330597569
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### One-liner if statement (no indentation)\n",
        "\n",
        "![Please Note](https://img.shields.io/badge/Please_Note-yellow)\n",
        "Most style guides and linters (error checking) discourage using this as its not the best practice 👎. Try using lines and spaces as its easier to read for everyone else 💓\n",
        "\n",
        "You can write the if statement to one line if there isn't a need for nesting multiple lines within the statement.\n",
        "\n",
        "```python\n",
        "a = 5;     ## initializes variables a,b with values 2,4\n",
        "b = 2;\n",
        "\n",
        "if a > b : print(True, \",\", a)  ## Evaluate if a > b, If its true run this line, else run the else statement.\n",
        "else: print(False, \",\", b)\n",
        "```"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 5;\n",
        "b = 2;\n",
        "if a > b : print(True, \",\", a) \n",
        "else: print(False, \",\", b)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1633380445511
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 👍 Even shorter if statement for default values.\n",
        "\n",
        "You don't have to write a whole `conditional statement` if all you want is to check if a value exist or use a `default value` if the condition evaluates to `false`\n",
        "\n",
        "```python\n",
        "a = 5\n",
        "b = 3\n",
        "result = \"A is bigger than B\" if (a>b) else \"A is less than B\"\n",
        "\n",
        "print(result)\n",
        "```\n",
        "\n",
        "The value of `result` is `\"A is bigger than B\"` only if the expression in the following if statement evaluates to `True`, otherwise the value following `else` is used.\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Try writing another statement that maybe evaluates a string or collection."
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "a = 5\n",
        "b = 3\n",
        "result = \"A is bigger than B\" if (a>b) else \"A is less than B\"\n",
        "\n",
        "print(result)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "gather": {
          "logged": 1634330860589
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Using conditional statement to validate an input provided\n",
        "\n",
        "Example of searching a `list` based on the `input` provided\n",
        "![Exercise](https://img.shields.io/badge/Example-grey) \n",
        "```python\n",
        "mylist = [1,2,3,4,5]\n",
        "\n",
        "userInput = int(input(\"Enter a number from 1-10:\"))\n",
        "if userInput in mylist:\n",
        "    print(userInput, \"is in the list `mylist`\")\n",
        "```\n",
        "\n",
        "When this cell is ran, the `userInput` variable will call the `input()` function and request input from the user. After the input is provided, the cell will take the input value and check if it it matches any item in the list `my_list`. "
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "my_list = [1,2,3,4,5]\n",
        "userInput = int(input(\"Enter a number from 1-10:\"))\n",
        "if userInput in my_list:\n",
        "    print(userInput, \"is in the list `mylist`\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634330888235
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Loops\n",
        "Loops are simply computer instruction that will keep repeating until a specified condition is reached. "
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### For Loops\n",
        "- Used for interating over a sequence (list, tuple, dictionary, set) and runs a set of statements, once for each item in the list. The loop will end when it reaches the last item on the list its iterating.\n",
        "\n",
        "#### Simple For Loop\n",
        "```python\n",
        "print(\"== For Loops ==\")\n",
        "for x in range(0, 3):            ## Iterate from 0 to 3\n",
        "    print(\"Let's go %d\" % (x))   ## print `Let's go` and the populates the value of the variable `x`\n",
        "```\n",
        "\n",
        "We will loop starting at `0` and end at `3`. On each iteration, we will print the current value of `x`\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "How would you make the for loop iterate 10 times instead of 3?"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## For Loops\n",
        "print(\"== For Loops ==\")\n",
        "for x in range(0, 3):\n",
        "    print(f\"Let's go {x}\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634331086566
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can process any iterable (string, list, dict, etc) with a for loop\n",
        "```python\n",
        "my_list = [5,10,15,20,25]\n",
        "for item in my_list:\n",
        "    print(f\"{item} * 10 = {item * 10}\")\n",
        "```\n",
        "\n",
        "![Explained](https://img.shields.io/badge/Explained-blue) \n",
        "\n",
        "1. First we create the list of 5 values `[5,10,15,20,25]`\n",
        "2. then we will use the `for` loop to iterate through each item in the list and print the string for each item. "
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list = [5,10,15,20,25]\n",
        "for item in my_list:\n",
        "    print(f\"{item} * 10 = {item * 10}\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634701337837
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Nested for Loop\n",
        "```python\n",
        "print(\"\\n== Nested For Loops ==\")\n",
        "for x in range(0, 3):\n",
        "    for y in range(0,2):\n",
        "       print(\"Let's go %d %d\" % (x,y))\n",
        "```\n",
        "\n",
        "![Exercise](https://img.shields.io/badge/Exercise-blueviolet) \n",
        "Can you nest another `condition or loop` nested inside this `for loop` and output the values?"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## Nested for loop\n",
        "print(\"\\n== Nested For Loops ==\")\n",
        "for x in range(0, 3):\n",
        "    for y in range(0,2):\n",
        "       print(f\"Let's go {x} {y}\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634331190170
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Using For loop to iterate through array of dictionary objects\n",
        "\n",
        "```python\n",
        "states = [\n",
        "    {\"name\" : \"Alabama\", \"capital\" : \"Montgomery\", \"country\": \"United States\"},\n",
        "    {\"name\" : \"Colorado\", \"capital\" : \"Denver\", \"country\": \"United States\"},\n",
        "    {\"name\" : \"Texas\", \"capital\" : \"Austin\", \"country\": \"United States\"},\n",
        "    {\"name\" : \"New Mexico\", \"capital\" : \"Sante Fe\", \"country\": \"United States\"},\n",
        "]\n",
        "\n",
        "for state in states:\n",
        "    print(f\"{state['name']} is located in the {state['country']} and it's capital is {state['capital']}\")\n",
        "```\n",
        "\n",
        "![Explained](https://img.shields.io/badge/Explained-blue) \n",
        "\n",
        "1. First we initialize a `list(array)` of dictionary objects with key value pairs `name, capital, country`\n",
        "2. Then we use a `for loop` to iterate through each state and reference the `keys` within each dictionary item being iterated to retrieve the values. \n",
        "\n",
        "![Challenge](https://img.shields.io/badge/Challenge-blueviolet) \n",
        "Can you add another `key` to each dictionary object and print that key value when its been iterated in the `for` loop?"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "## Sort list by key name\n",
        "states = [\n",
        "    {\"name\" : \"Alabama\", \"capital\" : \"Montgomery\", \"country\": \"United States\"},\n",
        "    {\"name\" : \"Colorado\", \"capital\" : \"Denver\", \"country\": \"United States\"},\n",
        "    {\"name\" : \"Texas\", \"capital\" : \"Austin\", \"country\": \"United States\"},\n",
        "    {\"name\" : \"New Mexico\", \"capital\" : \"Sante Fe\", \"country\": \"United States\"},\n",
        "]\n",
        "\n",
        "for state in states:\n",
        "    print(f\"{state['name']} is located in the {state['country']} and it's capital is {state['capital']}\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "gather": {
          "logged": 1634702009335
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Iterating through dictionary key/values\n",
        "\n",
        "Let's use the same list, but iterate it a different way. Lets iterate each state and print the `key/value pair` for each item.\n",
        "```python\n",
        "for state in states:\n",
        "    for key, value in state.items():\n",
        "        print(f\"State:{state['name']}, Key:{key}, value:{value}\")\n",
        "```\n",
        "\n",
        "![Explained](https://img.shields.io/badge/Explained-blue) \n",
        "\n",
        "1. We first will iterate through each `state` in the `states` list.\n",
        "2. We then grab each `key and value` from `state.items()`\n",
        "3. We reference directly the `key and value` variables instead of calling `state[<key>]`"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for state in states:\n",
        "    for key, value in state.items():\n",
        "        print(f\"State:{state['name']}, Key:{key}, value:{value}\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634703058805
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Using For loop to enumerate through dictionary keys\n",
        "\n",
        "Or maybe you want the index location of each key in the list. You can enumerate the dictionary\n",
        "```python\n",
        "## enumerate through states\n",
        "for state in states:\n",
        "    for index, key in enumerate(state): ## use the enummerate function which will convert the dictionary object a list with an numeric index location you can reference.\n",
        "        print(f\"State:{state['name']}, index:{index}, key:{key}, value:{state[key]}\")\n",
        "```\n",
        "\n",
        "![Explained](https://img.shields.io/badge/Explained-blue) \n",
        "\n",
        "1. We first will iterate through each `state` in the `states` list.\n",
        "2. We iterate through each state then grab the `index and key` from `enumerate(state)`\n",
        "3. We now can reference the index location of the `keys` and use the `key` to reference properties in the `state` variable."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## enumerate through states\n",
        "for state in states:\n",
        "    for index, key in enumerate(state): ## use the enummerate function which will convert the dictionary object a list with an numeric index location you can reference.\n",
        "        print(f\"State:{state['name']}, index:{index}, key:{key}, value:{state[key]}\")"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634703554340
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Using Loop to modify list values\n",
        "\n",
        "You can use a loop to iterate through a list and modify values or execute lines for each item being looped.\n",
        "\n",
        "```python\n",
        "from datetime import datetime  ## Imports the datetime module needed to get current date.\n",
        "years = [1955,1987,1978,2019,1967,1955]  ## defines the array of years to loop through\n",
        "\n",
        "for year in years:\n",
        "    currentDate = datetime.today().year  ## grabs the current date\n",
        "    age =  currentDate - year  ## subtracts the value of x(year) from the current date\n",
        "    print(f\"date:{currentDate}, year:{year}, You are {age} years old.\" )  ## replaces all placeholders in curly braces with variable\n",
        "```\n",
        "\n",
        "![Note](https://img.shields.io/badge/Explained-blue) \n",
        "Import the datetime module and create the `years` array\n",
        "\n",
        "1. Import the datetime module to be used in the years array.\n",
        "2. `years` array is created that will used as the input to the `for` loop\n",
        "2. This example will iterate through each `year` in the years list `[1955,1987,1978,2019,1967,1955] `. \n",
        "    1. Inside this loop we first will calculate the `currentDate` variable by calling the imported `datetime` function and extracting the `year`.\n",
        "    2. We can then calculate the age by subtracting the `currentDate` for each `year` being looped.\n",
        "    3. Then we will print a line that outputs these variables being iterated.\n",
        "3. The last command to run is `printing` out the loop has completed.\n"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## This type of string formatting will require Python >= 3.6\n",
        "from datetime import datetime  ## Imports the datetime module needed to get current date.\n",
        "\n",
        "years = [1955,1987,1978,2019,1967,1955]  ## defines the array of years to loop through\n",
        "\n",
        "## This is the loop that will iterate through each year in the years array.\n",
        "print (\"--For loop start--\")\n",
        "for year in years:\n",
        "    currentDate = datetime.today().year  ## grabs the current date\n",
        "    age =  currentDate - year  ## subtracts the value of x(year) from the current date\n",
        "    print(f\"date:{currentDate}, year:{year}, You are {age} years old.\" )  ## replaces all placeholders in curly braces with variable\n",
        "\n",
        "print(years) ## This statement is printed outside of the while loop"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1634331446201
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### While Loop\n",
        "Most of the time you will be using for loops. This loop will continue to execute the nested statements (indented) in the while loop until a specified condition is true\n",
        "\n",
        "Example\n",
        "```python\n",
        "i = 0   # Initialization\n",
        "print(\"While Loop starting\")\n",
        "while (i < 10):    # Condition\n",
        "    print(f\"{i} is less than 10. Looping\")    # do_something\n",
        "    i = i + 1 # Why do we need this?\n",
        "\n",
        "print(\"While Loop has ended\")  ## Last line to run. notice its not nested in the loop so it runs last.\n",
        "```\n",
        "\n",
        "![Explanation](https://img.shields.io/badge/Explained-blue) \n",
        "This `while loop` example will run the lines nested in the while loop until `i` reaches a value that is greater than `10`"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## While Loop\n",
        "\n",
        "i = 0   # Initialization\n",
        "print(\"While Loop starting\")\n",
        "while (i < 10):    # Condition\n",
        "    print(f\"{i} is less than 10. Looping\")    # do_something\n",
        "    i = i + 1 # Why do we need this?\n",
        "\n",
        "print(\"While Loop has ended\") ## Last line to run. notice its not nested in the loop so it runs last."
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1633114658670
        },
        "jupyter": {
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Finished\n",
        "\n",
        "You are done 🎈🏁🐱‍👓 with part 1 of this Python Crash Course and you are well on your way to knowing Python.\n",
        "\n",
        "Have some cake to celebrate 🍰. If you are still thirsty🧉 for more, you should now be able to step into the other Notebooks 📓 and it may actually make sense!\n",
        "\n",
        "Remember to check back as the 2nd part of the series will focus on building on top of this knowledge by learning how to manipulate data using:\n",
        "\n",
        "![Pandas](https://img.shields.io/badge/pandas-%23150458.svg?style=for-the-badge&logo=pandas&logoColor=white)![NumPy](https://img.shields.io/badge/numpy-%23013243.svg?style=for-the-badge&logo=numpy&logoColor=white)\n",
        "\n",
        "We will use this knowledge to manipulate and restructure data in order to render charts and visualize output for investigation or sending it.\n",
        "\n",
        "Keep learning! ❤"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    }
  ],
  "metadata": {
    "kernel_info": {
      "name": "python3-azureml"
    },
    "kernelspec": {
      "name": "python3-azureml",
      "language": "python",
      "display_name": "Python 3.6 - AzureML"
    },
    "language_info": {
      "name": "python",
      "version": "3.6.9",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "microsoft": {
      "host": {
        "AzureML": {
          "notebookHasBeenCompleted": true
        }
      }
    },
    "nteract": {
      "version": "nteract-front-end@1.0.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 4
}