python_intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "q5hKi_RV0-oR"
   },
   "source": [
    "This Lesson is presented using a popular tool in python called Ipython notebooks/ Juypter notebooks. They allow you to run scripts of any size in individual cells and output the results without having to run an entire large script. To run the code examples in this lesson press shift + enter or click on a cell and press the play button that appears. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "syB6etCihWIY"
   },
   "source": [
    "# **Intro Python Programming**\n",
    "\n",
    ">Programming revolves around the storing, manipulation and displaying of data. So let's start with the most basic principle: storing data. In programming, data is stored in what is called a \"variable\". A variable declares a space in memory where you can store data. You can think of a variable as a named box that can hold various types of data. In python you declare a variable like so:\n",
    "\n",
    "> `<variable_name> = <expr>`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Jhqx429VhdeW"
   },
   "outputs": [],
   "source": [
    "\n",
    "i_am_a_variable = 123"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DTqcY_FIxDhj"
   },
   "source": [
    "There are rules to what a variable can be named:\n",
    "\n",
    "*   It must begin with a letter or an underscore (though underscores are generally reserved for special use cases but this is only convention and not enforced programmatically)\n",
    "*   They are case sensitive\n",
    "* They cannot be python keywords or built-in function names. To get a list of those names you can run the following code:\n",
    "\n",
    "**Do not worry about everything that is going on here right now we will cover all of it shortly just know that these are some of the built-in ways to check for words you can and cannot use in python variable names.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qtz8eRRDwwVE"
   },
   "outputs": [],
   "source": [
    "# try and run these cells by pressing shift + enter\n",
    "import keyword\n",
    "keyword.kwlist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zJfdM41AzlbP"
   },
   "outputs": [],
   "source": [
    "# To check if a specefic word is a key word\n",
    "keyword.iskeyword('as')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xUuWUR81wwf6"
   },
   "outputs": [],
   "source": [
    "import builtins\n",
    "dir(builtins)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cJxxZiaH5RYl"
   },
   "source": [
    ">>What's going on with those hashmarks?\n",
    ">>> The hashmarks are comments in python. Comments are ignored by the python interpreter and therefore only show up in your code. Multiline comments are done with triple qutoes:\n",
    "\n",
    "                                                  ```\n",
    "                                                  '''\n",
    "                                                  Im a\n",
    "                                                  multiline\n",
    "                                                  comment\n",
    "                                                  '''\n",
    "                                                  ```\n",
    "                                                  \n",
    ">>>Comments are a good way to leave other developers and yourself notes about how your code works.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "i8jLyxoW18pW"
   },
   "source": [
    "**Valid Variable Examples:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Bdn7DThGwwnp"
   },
   "outputs": [],
   "source": [
    "variable = \"Foo\"\n",
    "camelCaseVariable = 2020\n",
    "snake_case_variable = \"Sneks\"\n",
    "IM_CONSTANT = \"I am not supposed to change\"\n",
    "thisworks = \"but is not readable\"\n",
    "THISALSOWORKS = \"still not a good idea though\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Rnn6Z7du3G3f"
   },
   "source": [
    "**Invaild Variable Examples:**\n",
    "\n",
    ">Invalid variable names will raise errors and most modern IDE's (Integrated Development Environment) will warn you before you run your program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jZFjfrcAwwqj"
   },
   "outputs": [],
   "source": [
    "as = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GIRKukAv3mZa"
   },
   "outputs": [],
   "source": [
    "1TooMany = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Soq8mFoH3yWn"
   },
   "outputs": [],
   "source": [
    "no-kebob-here = \"You put the lime in the coconut\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vkupN5YH4U3r"
   },
   "source": [
    "Built-in function names are actually just variable names so if you try to assign a value to them they will not throw an error since that is technically a valid thing to do with a variable. But this will have unintended consequences as you will see below. Do not worry if you are not sure what a function is we will cover that later on but for this example know that the sum function takes a list of numbers and returns their sum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "Gmv9KvQC5YSg",
    "outputId": "5d60eaa0-92e5-4f63-8464-58fe36c21bee"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 1,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "some_variable = [8,8]\n",
    "sum(some_variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KOupPE0B4Hpg"
   },
   "outputs": [],
   "source": [
    "sum = 5 + 5\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ejjnFTZG4x2r"
   },
   "outputs": [],
   "source": [
    "# the sum function has now been repalced with the number 16 and no longer works as intended\n",
    "sum(some_variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "f68Mk1qzX6yI"
   },
   "source": [
    ">As you can see a Type Error is thrown. But what is a type error? \n",
    "\n",
    ">> In programming, data can have different types and most high-level programming languages such as Python and Java will have similar data types. In Python you can have the following types:\n",
    "\n",
    "> **Numbers**\n",
    ">> [Numbers](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex) can have a couple different types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4jFXcJf6ZJ-r"
   },
   "outputs": [],
   "source": [
    "a = 10 # a signed integer\n",
    "b = 10.0 # a floating point number which is also called a float or a decimal\n",
    "c = 12.1j #or complex(12.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LWJuZol-40Na"
   },
   "source": [
    "> **Strings**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jJGVwk8B4wPO"
   },
   "outputs": [],
   "source": [
    "d = \"I am string\"\n",
    "e = 'Im also string'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OePSokCY7fjO"
   },
   "source": [
    ">**Boolean values**\n",
    ">> Boolean (bool) values are either true or false and are case sensitive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "HZmMIUoECdcV",
    "outputId": "3340182b-a5e0-4b58-dc1d-81e56e512968"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = True\n",
    "g = False\n",
    "#h = false # this is not a bool value\n",
    "0 == False\n",
    "1 == True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1VPK3l-LDaqm"
   },
   "source": [
    ">>Boolean values can be used to create logical statements within your code. They can be used in Boolean operations and comparisons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "lSFAow9OEYw-",
    "outputId": "8d0b4286-fe28-4211-be66-599b4bffa859"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 6\n",
    "y = 10\n",
    "x < y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "NBYRBo5PEs0H",
    "outputId": "ab95d392-20ac-4d21-b3df-5b136b89f878"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 6,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x > y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SxFN35CNE-sy"
   },
   "source": [
    "Python is a dynamically typed language which allows the same variable to hold different types of data. This can get a little confusing in large programs where variables may switch types at some point. One way we can check what type a variable is by using the `type()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "GHdTZ5PkE-HU",
    "outputId": "f4f9081c-0759-4177-c461-4ec39441b179"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 7,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "qFApzmnYGsT0",
    "outputId": "3fa3f9e1-8254-4ea4-97b8-6352fbd125ae"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 8,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "4gqaaK-KGvxH",
    "outputId": "f1589408-d678-4e47-9d98-30639a418c3b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 11,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "hQnD1e2gG0Dn",
    "outputId": "16764781-e5e2-4297-af39-201b9e85e1fd"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 13,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "srxjupEms10X"
   },
   "source": [
    "> Above we can see what we are using greater than and less than symbols to do some comparison. There are a handful of useful comparators in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "Jd92cdZGtOuG",
    "outputId": "5b42fab0-037d-4c27-ac12-eadbd6ab03ce"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 21,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# greater than equal to/ less than equal to\n",
    "10 <= 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "6Ah79dNytri6",
    "outputId": "ef97af1e-6f69-407f-cef0-0393a626ca1f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 22,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a equal to\n",
    "\n",
    "12 == 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "PeHNC9xGt2G5",
    "outputId": "3dc8cc42-16a1-46c9-a870-dce6a062e8c7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# not equal to\n",
    "\n",
    "5 != 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rDRcTxA8ubm0"
   },
   "source": [
    "> It should be noted that an error will be raised if you try to compare two data types that are not the same with an exception when comparing ints and floats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 164
    },
    "colab_type": "code",
    "id": "se8Bejf_unir",
    "outputId": "41f9803a-a7c2-4505-a3a9-fc5eb2020572"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "ignored",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-28-e561aea7bd98>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m5\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;34m\"hello\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: '>' not supported between instances of 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "5 > \"hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "9zcsJMY9u40L",
    "outputId": "d21c55ef-0460-4793-ec2b-58cdcb9fd1e1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 < 5.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aGnXl8p6G-kx"
   },
   "source": [
    "**Functions**\n",
    "> Functions are the building blocks of a program. They are pieces of reusable code. We have already seen a couple different functions already: `dir()`, `sum()` and `type()`. Functions take in some data, perform some computations and return the data to be used elsewhere. Functions are declared using the `def` keyword which is short for, you guessed it, define. `def` is followed by the function name, parentheses and a colon\n",
    "\n",
    ">> `def <function_name>():`\n",
    "\n",
    "> In python whitespace defines what pieces of code belong to what function. This is called scope. In other programming languages such as Java, the scope is defined using curly brackets. Variables declared within a certain scope are only available in that scope unless they are \"returned\" out of that scope or are explicitly marked as being part of the global scope. Let us look at some examples of both functions and scope."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "30aTNgDlKe3j",
    "outputId": "917e084f-2055-452d-f407-fcf43876402d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am function inside a function\n"
     ]
    }
   ],
   "source": [
    "def i_am_a_simple_function():\n",
    "  print(\"I am function inside a function\")\n",
    "  \n",
    "i_am_a_simple_function() # this called a function call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "vJgELP1hKxCH",
    "outputId": "1d2cc6a6-d1da-47e9-e058-0991f2c56d89"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "def add_somethings():\n",
    "  z = 4+4\n",
    "  print(z)\n",
    "  \n",
    "add_somethings()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NIXcBnsALLDX"
   },
   "source": [
    "> In the function above z is declared within the scope of the add_somethings function. If we try to access z outside the scope of the function we get an error `NameError: name 'z' is not defined` since z does not exist in the outer scope. \n",
    "\n",
    "> Also in the above function we used a function called `print()`. The print function takes a variable or piece of data such as a string and prints the value to console so that users can read it. If we were running these examples in a python script we would not see any of the outputs without print statements but since we are using juypter notebooks it prints the values in most cases for us as a convenience. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 165
    },
    "colab_type": "code",
    "id": "X1T1S-CiLGjS",
    "outputId": "74b58a4b-964e-48a0-be1f-a11d5bdee3c1"
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "ignored",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-20-3a710d2a84f8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mz\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'z' is not defined"
     ]
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "k6K2Ls1YOgPM"
   },
   "source": [
    "> There are two ways to get your data from your function scope to the outside scope. You can use a `return` statement which will \"return\" your data back to the outside scope or you mark your variable with the `global` keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "rOSLcMsjOfu3",
    "outputId": "d3e00de5-dcc5-4961-d174-5257d7dbd0b6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Funny black and white bears'"
      ]
     },
     "execution_count": 55,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def lets_return():\n",
    "  pandas = \"Funny black and white bears\"\n",
    "  return pandas\n",
    "\n",
    "lets_return()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "W6WVf-EZPe52"
   },
   "source": [
    "> You can store returned values in variables. If you do not store the value or assign it for use someplace the returned value will be lost.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "fiWLnGPnMxBK",
    "outputId": "3f830963-1026-4e3b-8fd8-f378570634e6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Funny black and white bears'"
      ]
     },
     "execution_count": 7,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lets_return() # prints the value but since the value is not stored anywhere is can not be accessed for later use.\n",
    "print(pandas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "pfpiEzTPP8p-",
    "outputId": "7bc9dd69-f04f-4126-dc11-d7110ada13c7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Funny black and white bears\n"
     ]
    }
   ],
   "source": [
    "pandas = lets_return()\n",
    "print(pandas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "CkQuHPDNnQNS",
    "outputId": "532aaa53-0026-4ad2-dcb4-a492eb7c728b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def global_superstar():\n",
    "  global im_everywhere # a variable can not be intialized and declared global at the same time\n",
    "  im_everywhere = 20\n",
    "  \n",
    "global_superstar()\n",
    "print(im_everywhere)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "F1jCYnj2QZRZ"
   },
   "source": [
    "> We can input data from the outside scope to use in a function by declaring function parameters inside of the parentheses. Function parameters are basically variable declarations that are available inside the function scope. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "Aruk8R5fRRBR",
    "outputId": "bdcc1189-5d88-485c-b982-3ce81602acc9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Strings are very low carb\n",
      "125015\n"
     ]
    }
   ],
   "source": [
    "def lets_consume_data(tasty_snack):\n",
    "  print(tasty_snack)\n",
    "  \n",
    "lets_consume_data(\"Strings are very low carb\")\n",
    "lets_consume_data(125015)\n",
    "lets_consume_data(pandas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 72
    },
    "colab_type": "code",
    "id": "CRdU-wxvuyEH",
    "outputId": "fe499978-2ee8-47c8-f818-e55fba4f01fe"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I will be one gaint sentence made from\n",
      " smaller chunks\n",
      "75\n"
     ]
    }
   ],
   "source": [
    "def i_love_params(first, second, third, fourth):\n",
    "  # demostrates different types of string concatenation\n",
    "  all_parts = first + second\n",
    "  all_parts += third\n",
    "  all_parts += fourth\n",
    "  print(all_parts)\n",
    "  \n",
    "i_love_params(\"I will \", \"be one gai\", \"nt sentence made from\\n\", \" smaller chunks\")\n",
    "i_love_params(15, 10, 30, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "s0yYhdHxx2-F"
   },
   "source": [
    "> What if you do not pass an argument in when a function expects one?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 165
    },
    "colab_type": "code",
    "id": "c0IpucYwyC2n",
    "outputId": "3af36a7b-c701-4783-c002-4b1a6e27d411"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "ignored",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-8dfd4c5e2d8d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mi_love_params\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"I will \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"nt sentence made from\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\" smaller chunks\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: i_love_params() missing 1 required positional argument: 'fourth'"
     ]
    }
   ],
   "source": [
    "i_love_params(\"I will \", \"nt sentence made from\", \" smaller chunks\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tJjITNpPyWHf"
   },
   "source": [
    "> A TypeError will be thrown letting you know that you are missing an argument. What about if you want the program to run regardless of what is passed in? You can use default values for your arguments.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "UuPT3Z01xVnD",
    "outputId": "5e95db15-7938-49c0-cf0a-7a8f0dddf977"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.0"
      ]
     },
     "execution_count": 16,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def i_will_still_work(a=12, b=12, c=10):\n",
    "  super_cool_value = (a+c) / b\n",
    "  return super_cool_value\n",
    "\n",
    "i_will_still_work(a=8, c=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "G6rzDoZhyv9m",
    "outputId": "9e73d9c1-ee5c-4eea-e5ed-3d87150b4207"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.18"
      ]
     },
     "execution_count": 18,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i_will_still_work(8,100) # if you do not specify what the parameter the values belong to they will default to the order they are defined in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "1gIwnxLEzHaM",
    "outputId": "a6ffb7d8-9db5-4dff-de81-7237d42286c3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.8333333333333333"
      ]
     },
     "execution_count": 19,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i_will_still_work()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jU4aZrlNzfCr"
   },
   "source": [
    "**Data Structures**\n",
    "> Now that you know the basics of variables and how functions work, let's talk about the different ways to store collections of data or variables. Working with one or two variables is not very useful when it comes to data analysis. We often have thousands if not millions of data points that we need to work with and if we had to assign each one of those into a variable we would never get anything done and our fingers would hurt from typing. Python comes with a bunch of built-in data structures that allow us to work with collections of data as large as our system can handle. \n",
    "\n",
    ">**List**\n",
    ">> List is one of the most common data structures that you will see in Python. A list is exactly what it sounds like, a list of data points. Lists are denoted by the use of square brackets `[]`.  You can declare them empty or containing data like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2VshNq5i2jNl"
   },
   "outputs": [],
   "source": [
    "im_an_empty_list = []\n",
    "im_a_list_of_numbers = [1,2,3,4,5,6,8,9,10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rfQQ3AYf5Ktk"
   },
   "source": [
    ">List are mutable, have persistent order and usually homogeneous. That maybe be a short sentence but there is a lot going so let's break it down.\n",
    "\n",
    "> List are mutable meaning that they can be updated and changed. You can think of something that is mutable as being able to mutate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "hufOKXzL5KLv",
    "outputId": "d0ce3c4b-3e6d-4241-dedf-5fd61d1cf276"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100, 12, 4, 500]\n",
      "[100, 4, 500]\n"
     ]
    }
   ],
   "source": [
    "some_list = [100, 12, 4]\n",
    "some_list.append(500)\n",
    "print(some_list)\n",
    "some_list.pop(1)\n",
    "print(some_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9248nTTk7gGD"
   },
   "source": [
    "> List have persistent ordering meaning that an item can be accessed using the same index as long as the list has not been changed.\n",
    "> Lists by default do not stop you from mixing data types within it but in practice, this usually does not make sense to do since you can not generally do the same operations on different data types.\n",
    "\n",
    ">In the example above `some_list.append(500)`, the `.append()` portion is what is called a method. A method is a function that belongs to a class and performs actions on that class. We will not be covering object-oriented programming and writing classes in depth in this workshop but we will cover what they are and how you interact with them since you will encounter them everywhere. A class is a blueprint for an object. It defines a set of methods and properties that are common to all objects of the same type. Objects are literally everywhere in programming. We have already encountered a couple of classes in this tutorial. [List](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range) is an example of a class. Classes are not objects. This may sound confusing so let's try out an analogy. You can think of a class as a recipe. The recipe includes all the ingredients and instructions on how fast to mix the batter and how long to bake it but it is not yet a physical cake just instructions. Once you mix all the ingredients and bake the cake then you have an actual object,  cake. The main thing to remember about classes and objects right now is that they have their own functions called methods. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "ek9ZPrGIjp7t",
    "outputId": "2f088598-0069-4aaa-ced9-ad8b5d408bcf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 12, 100, 500]\n"
     ]
    }
   ],
   "source": [
    "some_list.sort()\n",
    "print(some_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GPDe4JmziVVg"
   },
   "source": [
    "> **Tuples**\n",
    ">> A tuple is very similar to a list with the main difference being that a tuple is immutable meaning that they cannot be mutated. Tuples are denoted by the use of parentheses `()`. Tuples can be instantiated in two ways:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3etrvdydhI6p"
   },
   "outputs": [],
   "source": [
    "im_an_empty_tuple = ()\n",
    "look_no_paraenthesis = 1,2,3,4\n",
    "some_tuple = (1,2,3,5)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "a4pCWsqsl1uj"
   },
   "source": [
    "> A note on naming sequence data types. It is good practice to name your list or tuples the plural representation of what the data represents. For instance, if you had a list of city names it would make sense to name your list names or better yet city_names.\n",
    "\n",
    "> **Common list and tuple operations**\n",
    ">> List and tuples fall under the branch of types called Sequence Types. These types have common operations that can be used on any of the sequence types. Here are some of the common ones:\n",
    "\n",
    ">> Getting a value by index. In Python, sequence indexing is 0 based. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "j2iW1UIghSK9",
    "outputId": "fbbc9ea0-04e6-4e9a-d8b3-a8001574bae0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "500\n"
     ]
    }
   ],
   "source": [
    "print(some_tuple[0])\n",
    "print(some_list[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hsUzYsJXnu4C"
   },
   "source": [
    ">> Checking if a value is in or not in a dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "e0-vhb6WoCcH",
    "outputId": "b886dc2f-300d-4369-ce92-a7fb1336d8bc"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "12 in some_tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "NbSCIVNAoF3M",
    "outputId": "3ea779b2-9ea2-4449-d901-11bb25655cc7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 in some_tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FIF-g32RoULn"
   },
   "source": [
    ">> Length of dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "seOXZkNEoOUY",
    "outputId": "a2ba8d9a-7bbf-47dc-ebc1-bebdd26e3bab"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 24,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(some_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "R7zb5V4Aoj17"
   },
   "source": [
    ">> The Min and Max of a dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "YmcvhY6pojGp",
    "outputId": "88fd78a4-7e02-4fbe-af75-571e5bc8f9cd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(min(some_tuple))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "fo5CkGD3oswS",
    "outputId": "22b73e10-1a46-4e14-beeb-66b99862366d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "500\n"
     ]
    }
   ],
   "source": [
    "print(max(some_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MwrhKxVboxjk"
   },
   "source": [
    "> A complete list of the built-in common sequence operations can be found [here](https://docs.python.org/3/library/stdtypes.html#common-sequence-operations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "psSIrCAhlisi"
   },
   "source": [
    "> **Dictionaries**\n",
    ">> Dictionaries are used to store key-value pairs and are mutable. Dictionaries are denoted by curly brackets `{}`. Like lists and tuples, dictionaries can be instantiated in multiple ways. Here are a couple of common ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "58KvozT_lVvO",
    "outputId": "781db5d5-3bad-43f1-ecf6-4cca3ae9603c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'one': 1, 'two': 2, 'three': 3}\n",
      "{'one': 1, 'two': 2, 'three': 3}\n"
     ]
    }
   ],
   "source": [
    "im_an_empty_dict = {}\n",
    "some_dict = {'one': 1, 'two': 2, 'three': 3}\n",
    "print(some_dict)\n",
    "use_construct = dict(one=1, two=2, three=3)\n",
    "print(use_construct)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AhBmHlJnza9B"
   },
   "source": [
    ">> Dictionaries have many common operations by default. Some of the common ones are:\n",
    "\n",
    ">> Add a new key-value pair"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "rA2aZHn0zJ_h",
    "outputId": "266ffdbe-f237-4bbb-c9b0-674e18ad18d9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'one': 1, 'two': 2, 'three': 3, 'four': 4}\n"
     ]
    }
   ],
   "source": [
    "some_dict['four'] = 4\n",
    "print(some_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZhM2D_l6zyQM"
   },
   "source": [
    ">> Remove a pair"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "tJE6k_iWzpAn",
    "outputId": "b3bc776f-79d0-45d4-b450-4f41cabdb780"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'one': 1, 'two': 2, 'three': 3}\n"
     ]
    }
   ],
   "source": [
    "del some_dict['four']\n",
    "print(some_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lyBfAs720Hws"
   },
   "source": [
    ">> get all keys and items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "lAaE2mpQz9d4",
    "outputId": "e3f3c117-441c-4ec9-a853-523cacdaddf9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['one', 'two', 'three'])"
      ]
     },
     "execution_count": 40,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "some_dict.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "1VRTdAmb0ZZL",
    "outputId": "f47e0c04-5423-4eef-b926-0d49b1bde1cb"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([1, 2, 3])"
      ]
     },
     "execution_count": 42,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "some_dict.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "4u4N1_M80StE",
    "outputId": "7c7f320b-1df9-427c-f979-6295971a1f0f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('one', 1), ('two', 2), ('three', 3)])"
      ]
     },
     "execution_count": 41,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "some_dict.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ymyMCCG50gcG"
   },
   "source": [
    ">> Check if dict contains key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "Wd5sh57L0e57",
    "outputId": "33a4dbe2-3f89-4e43-b886-4b19d9ca7850"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 44,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'four' in some_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "f_YWL3bJ0WjX",
    "outputId": "4300f629-be73-4bf0-e8ab-50c13676f9aa"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 45,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'three' in some_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Q4kGNWtV0ySK"
   },
   "source": [
    "> A complete list of dictionary operations can be found [here](https://docs.python.org/3/library/stdtypes.html#mapping-types-dict). I would like to jump back to functions again. I want to talk about some of the functions that python comes with out of the box but wanted to wait until you had some sort of idea what a method and classes are. \n",
    "\n",
    "> Python comes with some pretty handy functions right from the get-go. Some of my favorites are:\n",
    "\n",
    ">> `dir([object])` - the dir function lists what methods are available to certain class/object. If you do not pass in an object, it will tell what functions are available in the current scope."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TlNpqgeLTyKo"
   },
   "outputs": [],
   "source": [
    "dir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7DnQmotAT2X9"
   },
   "outputs": [],
   "source": [
    "dir(some_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-SIGKXGmUJjs"
   },
   "outputs": [],
   "source": [
    "dir(some_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VcckP7ATUNEf"
   },
   "source": [
    ">>`help()` - help is interesting as it is a little program all in itself. If you type `help()` without any arguments, it will start an interactive help console. You can also pass it a class such as `list` to get documentation for that class or pass in a class plus a method to get info on that specific method like so `list.append`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 109
    },
    "colab_type": "code",
    "id": "dey2D2oQUWj6",
    "outputId": "cf022679-a357-4299-f6a1-5f3dabbf7557"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "append(...)\n",
      "    L.append(object) -> None -- append object to end\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(list.append)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "I4mI1q_8Wu_R"
   },
   "source": [
    ">> `input()` - takes an input from a user."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "7Jmx-J3dWX0p",
    "outputId": "f48ca3d4-6312-4053-bd0a-61734cbdebf2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter something, anything at all: 6\n"
     ]
    }
   ],
   "source": [
    "s = input(\"Please enter something, anything at all: \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "D8jXSNWWWrcj",
    "outputId": "cdcae73a-fdce-485d-85af-fa4f6c84fead"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'6'"
      ]
     },
     "execution_count": 25,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "REDPypbvb4t0"
   },
   "source": [
    ">> `map()`- map takes a function and applies that function to each value of an iterable and returns a iterator. Iterator behave differently from other sequence data types as we will see in this example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "UqTZnx_WXHnY"
   },
   "outputs": [],
   "source": [
    "import copy\n",
    "\n",
    "print(im_a_list_of_numbers)\n",
    "\n",
    "def crazy_math(number):\n",
    "  return (number * 2 // 6)**3 % 2\n",
    "  \n",
    "map_iterator = map(crazy_math, im_a_list_of_numbers)\n",
    "\n",
    "map_iterator2 = copy.deepcopy(map_iterator)\n",
    "\n",
    "print(map_iterator)\n",
    "print(list(map_iterator))\n",
    "print(next(map_iterator2))\n",
    "print(next(map_iterator2))\n",
    "print(next(map_iterator2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wRxwXfvvdeJ5"
   },
   "source": [
    ">> copy.deepcopy?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4mp3YnZngbgc"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "btW9TC-ogby4"
   },
   "source": [
    ">A full list of the built-in python functions can be found [here](https://docs.python.org/3/library/functions.html#map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7kOBrobD1SSU"
   },
   "source": [
    "**A deeper look at Strings**\n",
    "> Earlier we introduced strings but did not cover any of the aspects of strings. Strings are actually a data structure like list, tuples and dictionaries. Strings are sequences of unicode code points and they are immutable. Now that we have a better understanding of methods and functions lets take a look at the mthods provided to us to use on strings. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Nk_7hfhP0try"
   },
   "outputs": [],
   "source": [
    "short_string = \"my name is Wild Westies and I am a cat and armadillo wrangler\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "QnPXNIBHM3bH",
    "outputId": "642946d4-a887-4a42-ceb2-82414f1517e3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['U+006D', 'U+0079', 'U+0020', 'U+006E', 'U+0061', 'U+006D', 'U+0065', 'U+0020', 'U+0069', 'U+0073', 'U+0020', 'U+0057', 'U+0069', 'U+006C', 'U+0064', 'U+0020', 'U+0057', 'U+0065', 'U+0073', 'U+0074', 'U+0069', 'U+0065', 'U+0073', 'U+0020', 'U+0061', 'U+006E', 'U+0064', 'U+0020', 'U+0049', 'U+0020', 'U+0061', 'U+006D', 'U+0020', 'U+0061', 'U+0020', 'U+0063', 'U+0061', 'U+0074', 'U+0020', 'U+0061', 'U+006E', 'U+0064', 'U+0020', 'U+0061', 'U+0072', 'U+006D', 'U+0061', 'U+0064', 'U+0069', 'U+006C', 'U+006C', 'U+006F', 'U+0020', 'U+0077', 'U+0072', 'U+0061', 'U+006E', 'U+0067', 'U+006C', 'U+0065', 'U+0072']\n"
     ]
    }
   ],
   "source": [
    "points = []\n",
    "for char in short_string:\n",
    "  points.append('U+{:04X}'.format(ord(char)))\n",
    "  \n",
    "print(points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aWqiWr419_lF"
   },
   "source": [
    ">You can think of a string as a tuple of code points which means that it can use the common sequence operations that we talked about earlier\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "T_kqYLPC2rsR",
    "outputId": "55776224-a391-4296-fd23-49e754c37c13"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "m\n",
      "i\n"
     ]
    }
   ],
   "source": [
    "print(short_string[0])\n",
    "print(short_string[12])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "n5vONKXu20Zy",
    "outputId": "2634048f-08b3-4539-a377-251e47f4355a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 60,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'my' in short_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "93KcLPyH-m_s",
    "outputId": "6ed2fe5f-5fdb-447e-d246-7aff7ebc3a4b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 61,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'arm' in short_string # will match substrings and is case senstive"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_9LnOrS1_E7g"
   },
   "source": [
    "> Strings also have extensive list of methods to handle a variety of situations. Some common methods are:\n",
    "\n",
    ">Capitalizing the first letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "Us-vfJ2P-3mU",
    "outputId": "d514ec92-febd-48ec-d27a-2b82db225669"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is wild westies and i am a cat and armadillo wrangler\n"
     ]
    }
   ],
   "source": [
    "upper = short_string.capitalize() # returns a copy\n",
    "print(upper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "V98UotY1_5BL",
    "outputId": "52407d76-7599-48d9-fb71-b4b89d4eb95f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'my name is Wild Westies and I am a cat and armadillo wrangler'"
      ]
     },
     "execution_count": 67,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "short_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zb0SVTD8_nmH"
   },
   "source": [
    "> Convert all characters to lower case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "YqEh86-d_loU",
    "outputId": "7cf7c513-3994-4857-e1a9-98ab598811f1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'my name is wild westies and i am a cat and armadillo wrangler'"
      ]
     },
     "execution_count": 68,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "upper.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-naHa3tJCViJ"
   },
   "source": [
    "> remove trailing characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "XynYmOWeAaTW",
    "outputId": "10a0968e-409b-4848-d7d4-a46b57efb059"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'I am a line with new line and return characters\\n\\n\\r'\n"
     ]
    }
   ],
   "source": [
    "new_lines = \"I am a line with new line and return characters\\n\\n\\r\"\n",
    "print(repr(new_lines))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "8IidCfh3A7Ee",
    "outputId": "00c67db4-6441-43ba-ff75-2dda930b97f0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'I am a line with new line and return characters'\n"
     ]
    }
   ],
   "source": [
    "print(repr(new_lines.rstrip()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1vqz9VM3DB1O"
   },
   "source": [
    "> Split text based on Seporator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 243
    },
    "colab_type": "code",
    "id": "A44bxYusA-Ro",
    "outputId": "5d9329bd-fee9-4b76-ef2d-5fea2cb029ce"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['my',\n",
       " 'name',\n",
       " 'is',\n",
       " 'Wild',\n",
       " 'Westies',\n",
       " 'and',\n",
       " 'I',\n",
       " 'am',\n",
       " 'a',\n",
       " 'cat',\n",
       " 'and',\n",
       " 'armadillo',\n",
       " 'wrangler']"
      ]
     },
     "execution_count": 78,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "short_string.split(' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "9FbIpa8sDLkb",
    "outputId": "27af4a38-09cc-45eb-c917-4ff3cd78b097"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['I am sentence', ' with unneeded', ' commas in it']"
      ]
     },
     "execution_count": 79,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "commas = 'I am sentence, with unneeded, commas in it'\n",
    "commas.split(',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yf7-qEmmDiI3"
   },
   "source": [
    "> Format a string. This is especialy useful for debugging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "VXro2cpEDaYf",
    "outputId": "ac529944-9a96-494e-a66e-93bdf853d0e3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pandas are funny black and white bears'"
      ]
     },
     "execution_count": 57,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Pandas are {0}\".format(pandas.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "qSkLiIzRDhwR",
    "outputId": "683144eb-5db1-4305-91e0-c9ec346362ce"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'6 was my favorite number but now it is 0.75'"
      ]
     },
     "execution_count": 83,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fav = 6\n",
    "\"{0} was my favorite number but now it is {1}\".format(fav, 6/8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "Zez8uGGREZ7X",
    "outputId": "b8d5aabe-1343-4803-b3e4-ecea06425b8a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'We can form larger sentences from lists of strings. By joining them together'"
      ]
     },
     "execution_count": 87,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_o_strings = ['We can form', ' larger sentences from', ' lists of strings.', ' By joining them together']\n",
    "base = ''\n",
    "base.join(list_o_strings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2qIx26RPGecT"
   },
   "source": [
    "> Count sub string occurances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "fFuYzXiHGSSk",
    "outputId": "2d6944e0-aae5-4f35-e7be-e67ec05c1622"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 89,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "short_string.count('am')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Cnl1J9q-HHzF"
   },
   "source": [
    "> Find position of a substring in a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "DrRDcw_QGmYQ",
    "outputId": "f18a2dcc-e49c-409d-9f0d-d39d14f90061"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 90,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "short_string.find('Wild')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Q2e9ivNlLu6X"
   },
   "source": [
    ">The full list of string methods can be found [here](https://docs.python.org/3/library/stdtypes.html#string-methods)\n",
    "\n",
    "**Control Flow**\n",
    "\n",
    "> When writing software programs we often have the need to control the flow of execution of certain parts program based on certain conditions. Python comes with a couple different ways to do this. The following ideas are not specific to python, you will see these in most programs. But the impletation here is specific to python. \n",
    "\n",
    "> The first statement we are going to look at is the if verstile if statement. The basic syntax for a if statement is `if <expression>:` with the following lines indented. The code in the if statement is only executed if the expression evalutes to `True`. Lets look at an example:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "qaY2CHIuLqCQ",
    "outputId": "7f46f584-dc8d-47b3-a969-6da7fe9a3da0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Y is large and in charge\n"
     ]
    }
   ],
   "source": [
    "x = 12\n",
    "y = 20\n",
    "if x < y:\n",
    "  print(\"Y is large and in charge\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IUKPsYe2Sa4Y"
   },
   "source": [
    "> If statements can be nested within each other"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "ynj8QDyOMFch",
    "outputId": "24f96839-2edd-4684-c536-baeb92b6d2b1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Y is still large and in charge\n",
      "x is smaller than y and x and y are both numbers\n"
     ]
    }
   ],
   "source": [
    "z = 0\n",
    "if x < y:\n",
    "  print(\"Y is still large and in charge\")\n",
    "  if type(x) == type(z):\n",
    "    print(\"x is smaller than y and x and y are both numbers\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XQSkq6nGTQo_"
   },
   "source": [
    "> If statements can have optional else statements that will execute if the expression evalutes to `False`.  To add an else statement to an if statement you add the keyword `else:` on the same 'level' as the if statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "KCu_4ZYmS3jS",
    "outputId": "d9b0e298-bcdb-47ff-db24-bb9e466637d0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Y is still large and in charge\n"
     ]
    }
   ],
   "source": [
    "if x > y:\n",
    "  print(\"x is the greatest\")\n",
    "else:\n",
    "  print(\"Y is still large and in charge\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "J1yAIjF7Ti16",
    "outputId": "b5ee51e2-334d-4fc3-bab4-f1fbc80fcfd0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Y is still large and in charge\n",
      "we can be friends but we are not the same type\n"
     ]
    }
   ],
   "source": [
    "z = \"Now am a string\"\n",
    "if x < y:\n",
    "  print(\"Y is still large and in charge\")\n",
    "  if type(x) == type(z):\n",
    "    print(\"x is smaller than y and x and y are both numbers\")\n",
    "  else:\n",
    "    print(\"we can be friends but we are not the same type\")\n",
    "else:\n",
    "  print(\"Everything has failed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WA1AZdGDVc4R"
   },
   "source": [
    "> In compound statements like the one above if the first condition fails then the rest of the statement does not run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "V7IQo5FAVW1d",
    "outputId": "599d6236-2b82-4d82-a634-bc673b5d0d95"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Everything has failed\n"
     ]
    }
   ],
   "source": [
    "x = 100\n",
    "if x < y:\n",
    "  print(\"Y is still large and in charge\")\n",
    "  if type(x) == type(z):\n",
    "    print(\"x is smaller than y and x and y are both numbers\")\n",
    "  else:\n",
    "    print(\"we can be friends but we are not the same type\")\n",
    "else:\n",
    "  print(\"Everything has failed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qM9d7mh1V2FG"
   },
   "source": [
    "> If statements can also have else if statements. Else if statements run if the condition above it fails and acts like an 'else' if it's expression evalute to true. An else statement is still optional when using an else if statement The syntax for an else if is `elif:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "J0dEnS0tVu4s",
    "outputId": "b4451972-d18d-4e54-9241-2ca28cf01120"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X is 100\n"
     ]
    }
   ],
   "source": [
    "if x < y:\n",
    "  print(\"x is small again\")\n",
    "elif x == 100:\n",
    "  print(\"X is 100\")\n",
    "elif x > y:\n",
    "  print(\"Is is still on top\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jNNCEru4XvZQ"
   },
   "source": [
    "> The next control statement we have already seen and it is the for loop. The for loop allows us to iterate over sequence data types such as lists and tuples also known as an iterable. The syntax for a for loop is: `for <item> in <iterable>:` followed by indentation. `<item>` is just a variable that is used to hold the current value of the iterable. It can be called whatever you want but is good practice to use the singular name of what your list name is. For instance if we had the city_names list we talked about earlier we could replace `<item>` with city or name. This helps the readability of our code. Here is an example:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 121
    },
    "colab_type": "code",
    "id": "SzMIJ_mYXZfa",
    "outputId": "95659244-c956-4b20-9131-54bbb61d17a5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Phoenix is 7 characters long\n",
      "Boston is 6 characters long\n",
      "Las Vegas is 9 characters long\n",
      "Portland is 8 characters long\n",
      "New York is 8 characters long\n",
      "Santa Fe is 8 characters long\n"
     ]
    }
   ],
   "source": [
    "city_names = \"phoenix\", \"boston\", \"las vegas\", \"portland\", \"new york\", \"santa fe\"\n",
    "for city in city_names:\n",
    "  print(city.title() + \" is \" + str(len(city)) + \" characters long\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WC7IB9wIbuzd"
   },
   "source": [
    "> Whats the deal with the str thing going on with the len function?\n",
    "\n",
    ">>  len is a builtin function that returns the length of sequence type\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "jesjpRoDbY76",
    "outputId": "30f82627-66c5-48a7-d3f9-ff543965e150"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 4,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(len(city_names))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-VPb8zIIchHw"
   },
   "source": [
    ">>We are then trying to concatinate the int 6 to string which is not allowed since they are different data type. The solution is to convert or cast the int to a string data type using `str()`.  It is possible to cast between all data types. we could cast to an int by using `int()`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "ygZkHSlUcbHR",
    "outputId": "3ba63812-dece-41ca-e32e-4ba783846916"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 5,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(str(len(city_names)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "kVlBnnOqdRjG",
    "outputId": "51d5e6fb-9edb-4412-db70-9860395979e6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 6,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(float(len(city_names)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "g05KQfU_d1Ri"
   },
   "source": [
    ">Alright back to for loops. Sometimes it is useful to know the index of value in an iterable. For this we can use the `enumerate()` method. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 121
    },
    "colab_type": "code",
    "id": "SjK-yBP_dV6P",
    "outputId": "9b8a5eea-cf54-4752-edb1-84b5f1281734"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 phoenix\n",
      "1 boston\n",
      "2 las vegas\n",
      "3 portland\n",
      "4 new york\n",
      "5 santa fe\n"
     ]
    }
   ],
   "source": [
    "for index, city in enumerate(city_names):\n",
    "  print(index, city).format()\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "syJQVJVSx2aF"
   },
   "source": [
    ">in order to loop over a dictionary we must use a dictionary method called `items()`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "VCHOMCWjyQxk",
    "outputId": "ee8e5486-9828-4b5b-a740-aaa0328244f3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one 1\n",
      "two 2\n",
      "three 3\n"
     ]
    }
   ],
   "source": [
    "for key, value in some_dict.items(): # you will generally see key value written as k, v but they can anything you like\n",
    "  print(key, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vb4ZpW0cmqlN"
   },
   "source": [
    "> In some cases such as game you may want to continue looping over a piece a code as long as certain conditions are true. For this python has the while loop. The syntax for the a while loop is `while <condition>:` follow by indentation. Lets take a look:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 561
    },
    "colab_type": "code",
    "id": "nw7b73ZQeZ6F",
    "outputId": "d80101b8-fe65-4d7f-93a4-a1b18e46d0d8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n",
      "20\n",
      "21\n",
      "22\n",
      "23\n",
      "24\n",
      "25\n",
      "26\n",
      "27\n",
      "28\n",
      "29\n",
      "30\n",
      "31\n",
      "32\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "rand_number = random.randint(1,100)\n",
    "x = 1\n",
    "while x < rand_number:\n",
    "  print(x)\n",
    "  x += 1 # incrementors and also use -,/,*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "pPPs5wpao-Q8"
   },
   "source": [
    "> An important thing to remember when using while loops is that your condition must evaluate to False at somepoint otherwise your will get an infinite loop. When using control flow statements you may want to skip over an iteration or break out of the loop altogether at some point. To do this python comes with the `break` and `continue` statements. The break statement will terminate the loop while the continue statement will skip over the current iteration. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "colab_type": "code",
    "id": "MESQUvR5ohlc",
    "outputId": "d162ceda-658e-4330-afca-1a9691088bbc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "We are going to get a break!!\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "while x < rand_number:\n",
    "  print(x)\n",
    "  if x % 3 == 0:\n",
    "    print(\"We are going to get a break!!\")\n",
    "    break\n",
    "  x += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6rymrq9xqru_"
   },
   "outputs": [],
   "source": [
    "x = 1\n",
    "while x < rand_number:\n",
    "  if x % 3 == 0:\n",
    "    print(\"{0} is a friend of three\".format(x))\n",
    "    x += random.randint(0,2)\n",
    "    continue\n",
    "  x += 1\n",
    "  print(\"{0} who needs three, what a sucker\".format(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "196ZGoD5y2bq"
   },
   "source": [
    "> When using control flow statements you may want to check multiple conditions. For this python comes with logical operators that make this easy. There are logical and, or, and not.\n",
    "\n",
    "> For an expression to evaluate to true when using an and statement all parts of the expression must be true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "FBKrBStyrle9",
    "outputId": "17057772-163e-4d72-89d6-81f199ac5589"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "both are true\n"
     ]
    }
   ],
   "source": [
    "a, b, c, d = 4, 6, 7, 8\n",
    "\n",
    "if a < b and c < d:\n",
    "  print(\"both are true\")\n",
    "  \n",
    "if d < a and c < d:\n",
    "  print(\"one of us is lying\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IaGF6Ctx0VQJ"
   },
   "source": [
    "> When using logical or only on part of the expression needs to be true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "hFUjXStOz_A0",
    "outputId": "06374b7c-c773-48b6-d4a8-b3937844cf32"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "both are true\n",
      "one of us is lying\n"
     ]
    }
   ],
   "source": [
    "if a < b or c < d:\n",
    "  print(\"both are true\")\n",
    "  \n",
    "if d < a or c < d:\n",
    "  print(\"one of us is lying but its ok now\")\n",
    "  \n",
    "if a > b or c > d:\n",
    "  print(\"nothing is real\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Yw6COo931CVi"
   },
   "source": [
    "> Not is used to reverse the logical state of an expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "SRfvTWYr0mB-",
    "outputId": "47e4a810-f2bd-4375-8287-7d05100a0b2a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 40,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not(a < b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pj72DpYd06vC"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Copy of python_intro.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}