python_data_science1o1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Humboldt-WI/bads/blob/master/python_data_science1o1.ipynb) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L3WS_UbWixlo"
   },
   "source": [
    "# Python for Data Science 1o1\n",
    "\n",
    "## Table of Contents\n",
    "\n",
    "Welcome to our Python for Data Science 1o1 notebook. This notebook is designed for self-study. It coveres a broad set of concepts that you will see in the BADS module and, more generally, when using Python in a data science context. Overall, the following topics are covered:\n",
    "\n",
    "1.   Jupyter Notebook\n",
    "2.   Common Math Functions\n",
    "3.   Using Variables\n",
    "4.   Data Types\n",
    "5.   More About Object-Oriented Programming (OOP)\n",
    "6.   If-Statements and Loops\n",
    "7.   Dictionaries\n",
    "8.   Functions\n",
    "9.   Libraries\n",
    "10.   Getting Help\n",
    "11.  NumPy\n",
    "12.  Pandas Series\n",
    "13.  Pandas DataFrame\n",
    "14.  Random Number Generation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "T0WIRTv0jRT8"
   },
   "source": [
    "# Jupyter Notebook\n",
    "\n",
    "The Jupyter Notebook is one common place along with Google Colabs where we recommend creating your code. Notice that the notebook is composed of multiple cells of code and text. It is advised to use these in combination to ensure that each one of your projects is easy to follow."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-YG2-vkboJAx"
   },
   "source": [
    "## Cell Types\n",
    "\n",
    "There are two types of cells in a Jupyter notebooks and many other Python editing platforms. These are text cells (more formally called markdown cells) and code cells. Text cells (like this one) are to explain the context of the code or a data science concept and walk readers through logic or background information. Text cells support basic formatting including **bolding**, _italics_, ```code snippits``` but also  lists, indented text and more (see, e.g., [https://www.markdownguide.org/cheat-sheet/](https://www.markdownguide.org/cheat-sheet/)). \n",
    "\n",
    "Code can then be run sequentially as readers review the notebook and go through the text cells. Outputs of these cells can be saved too so they do not have to be run again. However, if the local machine didn't just run the code and there are no saved values for it to load, the results may need to be run the full way through again to be replicated.\n",
    "\n",
    "You can change the cell content with 'm' for markup and 'y' for code. Remember that you need to be in selection (or command) mode.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zHSOVhTijVPT"
   },
   "source": [
    "## Editing Cells\n",
    "\n",
    "Cells have multiple modes. When the cell marker is blue, you can select cells with the keyboard arrows and handle them by creating new cells, moving, copying or deleting them. When you press 'Enter' while selecting a cell, you jump into editing mode and can change the content of a cell, e.g. by writing code.\n",
    "\n",
    "The types of actions you can perform are listed under Help > Keyboard shortcuts:\n",
    "\n",
    "*   New cells are inserted with a (above) or b (below)\n",
    "*   Cells can be c copied, x cut and v pasted\n",
    "*   Cells are deleted by pressing d two times\n",
    "*   To run a cell and select the next cell: Shift + Enter\n",
    "*   While typing, use Tab to finish the object name for you and Shift + Tab to see the documentation \n",
    "\n",
    "It is worth remembering the shortcuts to work efficiently. There are other commands like having your code start with '!' so Python runs the command in command prompt or '%' which indicates that the next function's argument will be the entire line (similarly, '%%' means the function's argument is the entire cell). More about functions will come up shortly.\n",
    "\n",
    "Familiarise yourself with these functions before you continue."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7VeKJR1iY8lR"
   },
   "source": [
    "# Common Math Operations\n",
    "\n",
    "Let's first use Python as a calculator and see how it behaves. Notice the cells of code as mentioned earlier. Cells often only display one output although all lines of code are executed. If you'd like it to produce multiple at once, it can be useful to use the print command as shown at the end. Python will explicitly print all outputs in any print command (even if there are multiple).\n",
    "\n",
    "By adding the character '#', you are telling Python to ignore the following characters on the same line. This is called creating a **comment** and can be very useful to explain your code to others."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "U3hGuMdXXwr1",
    "outputId": "004508e3-902c-45f6-82da-7df14934d34b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+1 # Python will ignore everything after '#'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "h4QjhlRdZIlO",
    "outputId": "b8acb8b3-660b-4d8f-91b4-3d3b81c52bc4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33.3"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "333/10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "U2Bp6LmbtmsZ",
    "outputId": "d362351b-a835-4c63-a49e-a50773fb49aa"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "333 // 10 # returns you the floor of the quotient (result of the division rounded down to the nearest integer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "Q8lcepY0ZJfh",
    "outputId": "4cb03ef2-1635-4ea3-afe6-ef1ea7ba4cf7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+1/2 # Python follows order of operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "3-rYmacKt6aa",
    "outputId": "12baff33-f6fc-4cb5-9f42-1e4355811abc"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "333 % 10 # returns remainder of the division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "rasjMTsdZQaY",
    "outputId": "5377a4aa-d078-46ee-94af-1cee6ae8e764"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "27"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 ** 3 # Python uses '**' instead of '^' for exponents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "X-OyqvFHDwzi",
    "outputId": "8fe19bb9-a783-4b0e-9905-5bf54fe21cd0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pow(2,3) # pow(base, exponent) can also raise numbers to an exponent. We will talk more about functions soon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "NaS9qxJGcAHQ",
    "outputId": "aeff4789-04c5-438c-dd3a-3f2b0897d62f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 4\n"
     ]
    }
   ],
   "source": [
    "print(1+1, 2+2) # if you need to print multiple items, separate them with a ',' in the print() function. You can also call print() multiple times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "if0BUi9fD8qK"
   },
   "outputs": [],
   "source": [
    "# Understanding check: produce the output of 4 to the power of 2 AND the floor of 12421 divided by 11 in ONE LINE in this cell\n",
    "\n",
    "# answer: print(pow(4,2), 12421 // 11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r0dz5f-GZZbW"
   },
   "source": [
    "# Using Variables\n",
    "\n",
    "One very useful feature of nearly every programming language is the ability to give a fixed name to variables. Simply use the formula:\n",
    "\n",
    "```\n",
    "variable_name = desired_value\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "**Note:** Your variable names MUST NOT begin with a number, include a dash or space.\n",
    "\n",
    "After this, every time you type the variable name, Python will refer to the value it has been assigned. If the same variable name is ever used, the value will be overwritten.\n",
    "\n",
    "Python will consider all types of text as some kind of variable or command. If you ever want to create or reference actual text, it must be between quotation marks. This is called a string in Python. If you want Python to ignore text all together, use '#' to indicate a comment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "BR0APH8EZVQX",
    "outputId": "bb991430-47f7-41e2-e708-7ec341fc772d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 1 # all future cells will now refer to a as 1\n",
    "b = 2 # similarly, all future cells will refer to b as 2\n",
    "\n",
    "a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "GuI9bLX1oUxN",
    "outputId": "38509089-ff82-41f7-bbc1-07079cb278c1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a, b = 1, 2 # assigns variables above in the same way but in one line\n",
    "\n",
    "a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "nmLwGwJNoc_U",
    "outputId": "e15e8c9e-0e6c-4704-b90b-c93399ba38c1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = z = 1 # another way to assign multiple variables of the same value\n",
    "\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "uX-mSDoLZgrv",
    "outputId": "885359b7-7860-4d03-d1a9-3494ad326447"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "dtpGIaWPZjN_",
    "outputId": "56c1aa98-d98e-4691-cc6e-9e474af7aead"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a*5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "erO3QQ3jc37m",
    "outputId": "0f9a524d-996a-40ba-ba10-18e8b923b43a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b ** 5 # remember '**' means exponent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "wIBHVYW2Zkr3",
    "outputId": "c8747503-c875-4019-bdbb-8b13100e6daf"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "502"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 500 # if you use the same variable name again, you overwrite the previous value\n",
    "\n",
    "a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "JmwnRDGIv043",
    "outputId": "2d6b2a56-e021-4203-bbc4-bcd4f3ea3f11"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "502"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# By default, Python only displays the last line of output from a cell\n",
    "\n",
    "a*b # This line will be executed in Python, but since the next line causes an output and it comes afterwards, only its output will be displayed\n",
    "\n",
    "a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "mdamvwcNOdeN",
    "outputId": "83fbcaaa-951c-43a5-dc4d-bbc380ed3d7c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000 502\n"
     ]
    }
   ],
   "source": [
    "print(a*b, a+b) # using print and a comma separating items will print everything"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "U9RsDfwWZ_iw"
   },
   "outputs": [],
   "source": [
    "#Can I just write? # this will generate an error because Python will try to look up the value assigned to each word as a variable and find nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "p4lgFDRhNzjo",
    "outputId": "7ec154d2-2a4b-4503-9fb5-867418303592"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "you can't add strings to numbers\n"
     ]
    }
   ],
   "source": [
    "a = \"you can't add strings to numbers\" # if you want to generate text for Python to store in memory, use quotation marks around the text to create a string (str for short)\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "P8plSRHFaOYP",
    "outputId": "1e0d4bd1-1b6f-4874-d6af-b7dfbc9d3c93"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"you can't add strings to numbers, but you can add strings together!\""
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = \", but you can add strings together!\"\n",
    "\n",
    "a+b # you can even concatenate (attach) strings if you'd like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "9iSIREPGEV4-"
   },
   "outputs": [],
   "source": [
    "# Understanding check: assign the number 42 to the variable named meaning_of_life, then find the remainder of the division of meaning_of_life by 10\n",
    "\n",
    "# meaning_of_life = 42\n",
    "# meaning_of_life % 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "h3RId00UE4g8"
   },
   "outputs": [],
   "source": [
    "# Understanding check: assign the string 'Dude, Where's My Car?' to the variable movie_name, multiply this movie_name by 3, what happens?\n",
    "\n",
    "# movie_name = \"Dude, Where's My Car?\"\n",
    "# movie_name*3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kj8xftILbIbh"
   },
   "source": [
    "# Data Types\n",
    "\n",
    "There are _many_ data types in Python. To check the type of an object, use the function `type( )`.\n",
    "\n",
    "\n",
    "The most common ones that you will encounter as a data scientist are:\n",
    "\n",
    "\n",
    "*   integer (eg. 100)\n",
    "*   float (eg. 100.0)\n",
    "*   string (eg. 'Hello World!')\n",
    "*   boolean (eg. True)\n",
    "*   list (eg. ['one', 'two', 'three'] )\n",
    "*   tuples (eg. ('one', 'two', 'three') )\n",
    "*   range (eg. range(0,9,3) )\n",
    "*   dictionary (eg. {'mammal': 'platypus', 'fish': 'eel'} )\n",
    "*   NumPy array\n",
    "*   Pandas Series (in future demo notebooks)\n",
    "*   Pandas DataFrame (in future demo notebooks)\n",
    "\n",
    "Aside from these, you will definitely see many more. Let's explore these a bit.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "W2XI4ysgpS15"
   },
   "source": [
    "## Integers and Floats\n",
    "\n",
    "These are going to likely be the most common types that you will encounter. **Integers are whole numbers** while **floats contain decimals**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "D6RG79VGiOkN",
    "outputId": "3a9cb67a-0df3-41a8-b07e-d5d2d33cf6ea"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'> <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "\n",
    "b = 5.0\n",
    "\n",
    "print(type(a), type(b)) # integers have no decimals while floats do"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "L-qC2xiEo1oH",
    "outputId": "87313905-b241-46da-bb29-59ba7bdf1bae"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(b) # converts b to an integer, note that if we do not assign this back to b by executing 'b=int(b)', b will not change"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "BFP8duKUo-f8",
    "outputId": "f668593f-34b5-4e6a-9d63-92f0264cfc68"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = int(b)\n",
    "\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HOfwItbGpnGv"
   },
   "source": [
    "## Strings\n",
    "\n",
    "Strings are like pieces of text. They are always enclosed between quotation marks, single or double quotes both work. You can convert numbers to strings too. Note that they will now have all the properties of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "OD6thTMwi9b9"
   },
   "outputs": [],
   "source": [
    "c = \"any text between single or double quotes is a string\" # you can use single or double quotes around strings\n",
    "d = 'any text between single or double quotes is a string'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "3ImbP2TmpQCs",
    "outputId": "3fdb787d-abdf-4c00-933a-d9ec8751f584"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'5555555555'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = str(a) # if we want to turn the number that we assigned to a into a string, we can use the str( ) function\n",
    "\n",
    "a*10 # now instead of 5*10, Python is performing '5'*10 so it will paste '5' 10 times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "nayOBSjtwFeb",
    "outputId": "d74c5434-247f-40ba-f1cf-86c164e89c4e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = int(a) # you can change a string back to a number back by using int() or float()\n",
    "\n",
    "a*10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "HegZNoglp9Rw",
    "outputId": "116eb7b3-01ad-487e-83a5-137dd0178a8a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a y\n"
     ]
    }
   ],
   "source": [
    "print(c[0], c[2]) # you can find the nth letter in a string by enclosing n-1 in square brackets (since Python starts counting at 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "-K1ZpgZcqThq",
    "outputId": "3376cac4-86d9-466f-ebfc-e45363c12f81"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "52"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(c) # gives you the number of characters in the string, this will be useful in Natural Language Processing (NLP) and more"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MIHtfvtNqdXJ"
   },
   "source": [
    "Other tricks with strings can be found here: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Df7IJwUaj18-"
   },
   "source": [
    "## Booleans\n",
    "\n",
    "**Booleans** take on two possible values (pay attention to capitalisation):\n",
    "*    `True`\n",
    "*    `False`\n",
    "\n",
    "These can be used to evaluate conditions. To check if something is equal and get a Boolean value, use `==`. Recall that `=` assigns variables. You can also create conditions using `<`, `>` and:\n",
    "\n",
    "*   `>=` greater than or equal to\n",
    "*   `<=` less than or equal to\n",
    "*   `!=` not equal to\n",
    "*   `is` and `is not` also yield Booleans, however they require exact identity matches unlike `==` and `!=` .\n",
    "\n",
    "Keep in mind, many other functions and syntax return Boolean values. For example, there is the function ``` isinstance(x, var_type) ``` which returns the corresponding Boolean value if variable x is equivalent to the type specified. Always check functions' outputs so you can handle their data types in an effective way.\n",
    "\n",
    "`True` also corresponds to the value `1` while `False` corresponds to `0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "m6cC6-oAjzXP",
    "outputId": "d3b50449-b994-49b3-d988-3fd68c135bdd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False True True False\n"
     ]
    }
   ],
   "source": [
    "e = 5\n",
    "\n",
    "f = 5.00\n",
    "\n",
    "print(e>f, e==f,  e>=f, e!=f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "nStSbQYirHaV",
    "outputId": "099e9943-63cb-4079-f517-3ef5352cb81c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(e is f) # note that since e is not the exact same as f, \"is\" returns False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "reU_bEd1lut3",
    "outputId": "815dba03-429f-44b0-a10f-7fa073970583"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "c = \"any text between single or double quotes is a string\"\n",
    "d = 'any text between single or double quotes is a string'\n",
    "\n",
    "print(c == d) # as mentioned, even though the second uses single quotations, it is equivalent in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "EAfeqEEHl6U1",
    "outputId": "d21f1b10-0ab2-47e8-a2ce-73655afe1f7a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(isinstance(c, str)) # many functions may return Boolean values like this one which checks if variable c is a string (use the short form str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "7l2oNl0luZ3H",
    "outputId": "61be9e4d-adb3-44c6-da6d-ad3b658437e6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True True\n"
     ]
    }
   ],
   "source": [
    "print(True == 1, False == 0) # the Boolean value of True is equal to 1, similarly, the Boolean value of False is equal to 0. \n",
    "# this will be useful for categorical variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "N80QBYDwPDJ5",
    "outputId": "17002ead-bd72-46b6-b9eb-1288b750f7d1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'> <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "# Python only recognizes False and True as a Boolean value, FALSE and false (TRUE and true) are considered possible variable names.\n",
    "print(type(False), type(True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "id": "17OEWkgyQlZ1"
   },
   "outputs": [],
   "source": [
    "# print(type(FALSE)) # only False works as a boolean value, otherwise, Python thinks it's a variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Spq3Eb-9rdNm"
   },
   "source": [
    "We can combine conditions with:\n",
    "*    `and` (all must be satisfied)\n",
    "*    `or` (at least 1 must be satisfied)\n",
    "*    `not` (reverses result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "3ObcvKL0rcw9",
    "outputId": "d69509e8-16e8-4699-d541-a5dbed9943c7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = 1\n",
    "q = 2\n",
    "\n",
    "p > q and p < q # since both must be satisfied, but each is mutually exclusive in this case, this must be False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "zX7ev-SGr5Si",
    "outputId": "ed96799d-63e2-49c6-9e2b-8cb9534b690c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p > q or p < q # since one of these is true, it is True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "gRQ4Ccdir8Fg",
    "outputId": "07b308c5-acf0-4b6f-f098-e6350353eb69"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not (p == q) # the expression in brackets is False but 'not' reverses that"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4MkujAJju98-"
   },
   "source": [
    "## Lists, Indexing & Slicing\n",
    "\n",
    "**Lists** are a sequenced container of items. Items can be of virtually any type (strings, other lists, tuples, integers...). Lists are created by putting contents sequentially in square brackets separated by commas. You can initialize an empty list to be filled by putting an empty set of square brackets.\n",
    "\n",
    "Each item in a list has a uniquely callable position which is called an **index**. Indices can be labelled but can always be referred to by number as well. Numbering in Python always starts at 0. So, to access the first item in a list, you must call `list_name[0]`.  This is called Zero-Based Indexing and differs from programming languages like R, which use One-Based Indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "fsOM2q3lvgvc",
    "outputId": "4b2dbcbb-612c-4f2f-b63a-2520502f2b34"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "just_some_empty_list = [] # initalizing empty lists will be useful later on, this simple trick is worth remembering for loops later\n",
    "\n",
    "type(just_some_empty_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "aW4KDIK9vveT",
    "outputId": "eee876f5-d1b8-45cc-a3af-f745fa10ad81"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cucumber'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "whats_in_my_fridge = ['cucumber', 'pasta sauce', 'leftovers', 'margarine', 'tomato'] # create a list just putting items between square brackets separated by commas, you could even create a list of lists!\n",
    "\n",
    "whats_in_my_fridge[0] # calls first element of list or the item at index 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "wIKl2JTWl0OF",
    "outputId": "bb0f3877-c2be-4b5e-fab7-0d9ff1343caa"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tomato'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "whats_in_my_fridge[-1] # items can be called using negative numbers, the final item in the list is index -1, second last is -2 and so on"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "gHo02o5dxFgN",
    "outputId": "b21e0988-e837-4d4d-e366-c6044bc54a1f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cucumber', 'kartoffelsalat', 'leftovers', 'margarine', 'tomato']\n"
     ]
    }
   ],
   "source": [
    "whats_in_my_fridge[1] = 'kartoffelsalat' # you can replace items using indexing, here item 2 (indexed at 1) is replaced\n",
    "\n",
    "print(whats_in_my_fridge)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "xOhY836jyVaA",
    "outputId": "cec8d686-f6bc-47c7-dac9-1ec2467337fa"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cucumber', 'kartoffelsalat', 'margarine', 'tomato']\n"
     ]
    }
   ],
   "source": [
    "del whats_in_my_fridge[2] #if I ate my leftovers, we can delete it from the list like so\n",
    "\n",
    "print(whats_in_my_fridge)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PMjdqfJszoCr"
   },
   "source": [
    "**Slicing** is how data is often selected in Python. Use the index plus `:`. The `:` can be read as _up to but not including_ .\n",
    "\n",
    "For example, `2:10` means _item indexed at 2 up to but not including item indexed at 10_. If you don't Include a start point or an end point for slicing, Python will start at the very beginning of the index or go to the very end of the index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "fJcmxWAJxYvJ",
    "outputId": "474fbb68-12aa-47ae-aaf0-f809e86252ab"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cucumber', 'kartoffelsalat']"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "whats_in_my_fridge[0:2] # select the first item (with index 0) up to but not including the third item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "BT8s8UQMx13q",
    "outputId": "636ddf19-f991-452e-fb17-1182e37a2706"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['margarine', 'tomato']"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "whats_in_my_fridge[2:] # select item 3 up to the end of the list. If we wrote [:2], Python would have fetched the very beginning up to but not including item 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "BixxvmYwm0bc",
    "outputId": "28658acc-11f5-412a-b7af-ccfb0a67d58a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cucumber', 'kartoffelsalat', 'margarine', 'tomato', 'apples']"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "what_i_want_in_fridge = ['apples']\n",
    "\n",
    "tomorrow_in_my_fridge = whats_in_my_fridge + what_i_want_in_fridge\n",
    "\n",
    "tomorrow_in_my_fridge # you can also add two lists to combine them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "UhJK3dTzy0rz",
    "outputId": "51d62ac8-4659-4b06-af3a-ad9b54d3f83a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cucumber', 'kartoffelsalat', 'margarine', 'tomato', 'spring rolls']\n"
     ]
    }
   ],
   "source": [
    "whats_in_my_fridge.append('spring rolls') # each data type has associated 'methods and attributes'. For example, lists have the .append() method which adds a new specified item\n",
    "\n",
    "# it is very useful to learn more about possible methods and attributes of your data types as they will make programming much easier, we will discuss these soon\n",
    "\n",
    "print(whats_in_my_fridge)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "9q0YajPdzFrb",
    "outputId": "61a03e76-3863-4980-c2ff-26d2d10eb995"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cucumber', 'hummus', 'margarine', 'tomato', 'spring rolls'] ['cucumber', 'hummus', 'margarine', 'tomato', 'spring rolls']\n"
     ]
    }
   ],
   "source": [
    "whats_in_your_fridge = whats_in_my_fridge # let's create a new list based on our old list\n",
    "\n",
    "whats_in_your_fridge[1] = 'hummus' # let's change one item in this new list\n",
    "\n",
    "print(whats_in_your_fridge, whats_in_my_fridge) # wait, we changed YOUR fridge, why did my fridge change too?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "fi8pNHhrziHl",
    "outputId": "a23fb514-3fd8-4864-9737-eddceb0208ba"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cucumber', 'hummus', 'guacamole', 'tomato', 'spring rolls'] ['cucumber', 'hummus', 'margarine', 'tomato', 'spring rolls']\n"
     ]
    }
   ],
   "source": [
    "# variable names refer to the original list, to create a copy which you want to edit completely separately, use the list method .copy()\n",
    "\n",
    "whats_in_your_fridge = whats_in_my_fridge.copy()\n",
    "\n",
    "whats_in_your_fridge[2] = 'guacamole'\n",
    "\n",
    "print(whats_in_your_fridge, whats_in_my_fridge)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "klol8pB-8A2A"
   },
   "source": [
    "### List Comprehensions\n",
    "If you want to apply the same function to every item in a list, you can use a list comprehension. This is a simple version of what is called a loop, which we will learn more about later. This takes on the following format:\n",
    "\n",
    "> [_action_ `for` _dummy_item_name_ `in` _list_ ]\n",
    "\n",
    "Python interprets this as the following:\n",
    "\n",
    "1.   Take the first item in the list and temporarily label it `dummy_item_name`\n",
    "2.   Perform _action_ on the item labelled as `dummy_item_name`\n",
    "3.   Put result in a new list\n",
    "4.   Repeat steps 1-3 for the next list item until the list is complete\n",
    "\n",
    "By doing this, we quickly create a new list based on our last list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "KWpxjoO471wr",
    "outputId": "57fbd59d-10c4-4d9d-c0de-4fbf60a4dc59"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 6, 9, 6, 12]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[len(dummy) for dummy in whats_in_my_fridge] # here we get the length of each string in the list, we can literally use anything for the dummy name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "hsAvgMsDIHPe",
    "outputId": "5242a890-7085-4114-80bc-9e69bedf07eb"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['c', 'h', 'm', 't', 's']"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_list = [item[0] for item in whats_in_my_fridge] # here is another example where we get the first letter of every item, to save it we need to assign it to a new name\n",
    "\n",
    "new_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "frIlePOZIWC8"
   },
   "source": [
    "Other tricks with lists can be found here: https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cjdoQKQ5WF8_"
   },
   "source": [
    "## Tuples\n",
    "\n",
    "Tuples are objects stored together. These objects cannot be altered, which makes tupels and lists different. Instead of being stored in **square** brackets, tuples are stored in **round** brackets. If you have one item, you can just follow it with `,` and it will be a single item tuple.\n",
    "\n",
    "Again, unlike lists, **tuples cannot be altered**. You can convert them to lists or break them into multiple items and alter them that way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "q8plxJmoWhN9",
    "outputId": "4669624f-7ca1-4df7-f778-72eb78b0097b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cool_tuple = ('ponies', 'unicorns', 'sharks with laser beams on their heads')\n",
    "\n",
    "type(cool_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "IUjCrThFW2vg",
    "outputId": "01daf0f6-02da-439b-9eb5-df84399b6aa9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sharks with laser beams on their heads'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cool_tuple[2] # indexing works the same way as lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "id": "dgk0bsigCo1h"
   },
   "outputs": [],
   "source": [
    "# cool_tuple[2] = 'lame animal like a squirrel' # will not work because tuples are immutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "rJ69tJnwXOde",
    "outputId": "5f9928e3-ff49-4f2a-be74-e3b62176ce2d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I want ponies ,  unicorns and especially sharks with laser beams on their heads\n"
     ]
    }
   ],
   "source": [
    "item_1, item_2, item_3 = cool_tuple # you can break tuples up into individual elements by assigning each to a variable\n",
    "\n",
    "print('I want', item_1, ', ', item_2, 'and especially', item_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "id": "0SZJn5C_rCiB"
   },
   "outputs": [],
   "source": [
    "# del cool_tuple[2] # again, tuples do not support any sort of alteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "qsBCzKFyXAZ3",
    "outputId": "3becb3c9-e053-450c-88c0-2bd7304b5942"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ponies', 'unicorns', 'sharks with laser beams on their heads']"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cool_list = list(cool_tuple) # tuples CANNOT be changed, but you can turn them into a list and then altered that way\n",
    "\n",
    "cool_list # notice the square brackets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "KV6gF7ghmTDK",
    "outputId": "e0fec922-422a-425e-c901-3e8b7ea38900"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('ponies', 'unicorns', 'sharks with laser beams on their heads', True)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "another_cool_tuple = True, # if you want a tuple with one item, you don't even need brackets, just put a comma after the object\n",
    "\n",
    "cool_tuple + another_cool_tuple # adding tuples just causes them to get combined together, you can assign this to a new variable if you'd like"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Gg0LfXLdRVLn"
   },
   "source": [
    "## Other Data Types\n",
    "\n",
    "As mentioned, there are many other data types. Some are only available after loading a specific library into Python. As you load new libraries, check its documentation to learn more about how you can effectively use its elements including tailor-made data types. We will also introduce several specific data types as we go along."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8ylrBMvBPMef"
   },
   "source": [
    "## Operations With Common Data Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "id": "HpYHXdsyFicz"
   },
   "outputs": [],
   "source": [
    "# Understanding check: adjust these variable types\n",
    "\n",
    "meaning_of_life = 42\n",
    "\n",
    "# turn this variable into a string using the str() function, save as a new variable called meaning_of_life2\n",
    "\n",
    "meaning_of_life2 = str(meaning_of_life)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "id": "aBaN_2GuDMy8"
   },
   "outputs": [],
   "source": [
    "# after, turn the variable back into a integer and overwrite it using the same name\n",
    "\n",
    "meaning_of_life2 = int(meaning_of_life2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "L0ei3wUZDPws",
    "outputId": "ddb09077-e12f-4cc8-cb06-e462a54c32af"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hum'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the first 3 letters of the second item in my fridge\n",
    "\n",
    "whats_in_my_fridge[1][:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "id": "Ssvqaeq9DRrE"
   },
   "outputs": [],
   "source": [
    "# What is the difference between =, == and is in Python?\n",
    "\n",
    "# What is 0 indexing?\n",
    "\n",
    "# Which one of these two can we edit: lists or tuples?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "id": "8bfiT7yTDbQF"
   },
   "outputs": [],
   "source": [
    "# how do we unpack the following tuple into drink_1, drink_2 and drink_3\n",
    "\n",
    "drinks = ('mate', 'coffee', 'Redbull')\n",
    "\n",
    "drink_1, drink_2, drink_3 = drinks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "GA45Wf4vIcUe",
    "outputId": "0646b1f1-26bc-42e3-d47f-55f6aeb9032b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[66, 2, 0.02, 200, 4, 90]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# manipulate the following list\n",
    "\n",
    "numbers = [100000, 10, 1, .01, 100, 2]\n",
    "\n",
    "# remove the second number from this list\n",
    "del numbers[1]\n",
    "\n",
    "# change the first number to 33\n",
    "numbers[0] = 33\n",
    "\n",
    "# add 45 to the end of this list\n",
    "numbers.append(45)\n",
    "\n",
    "# multiply each of these numbers by 2 using a list comprehension\n",
    "[n*2 for n in numbers] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7ou6AvTzGVoe"
   },
   "source": [
    "# More About Object-Oriented Programming (Classes, Methods, Attributes)\n",
    "\n",
    "Python is an object-oriented language. Every element of code that you encounter is called an 'object'. Each 'object' has a 'class' or 'type'. The class or type of an object dictates how it can interact with other objects.\n",
    "\n",
    "In Object Oriented Programming (OOP), there is generally a difference between class and type. However, since Python 3, these ideas have been merged. Traditionally, types are built-in with the original program. Primitive types are the most basic objects built in the program, like string or integer. Classes are created by users for different functions. So you can create a class, but you cannot create a type. Each time you create an object, it is called an **instance** of that class/type.\n",
    "\n",
    " **However, as mentioned, now the idea of class and type have been merged in Python 3**.\n",
    "\n",
    "Every data type/class has its own methods and attributes attached to it. It is very useful to get to know these as they encompass common tasks which may otherwise require you to import functions which are not actually necessary.\n",
    "\n",
    "**Methods** are functions specific to the class/type of your object. **They will always use your object as its first argument, since this is done automatically by calling a method, you do not have to write this explicitly**. They can sometimes take additional arguments as well. Check the documentation of the object to see what other method arguments exist.\n",
    "\n",
    "The format to call one of your object's methods is as follows:\n",
    "\n",
    "\n",
    "```\n",
    "object_name.method(possible_arguments_if_any)\n",
    "```\n",
    "\n",
    "**Attributes** are properties of your object which can be displayed. The format to call them is similar but note the absence of parentheses:\n",
    "\n",
    "```\n",
    "object_name.attribute\n",
    "```\n",
    "Attributes are more common in more advanced data types. In the final section for today, we will see some with NumPy arrays.\n",
    "\n",
    "Let's see an example of a class that we create ourselves:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "id": "LW6pUAZu9lh3"
   },
   "outputs": [],
   "source": [
    "class person(): # let's create a new class called person, typically upon creating a new instance of this class, you'd assign it to a variable name as we've been doing above\n",
    "    \"\"\"Class person for human interaction\"\"\"\n",
    "    def __init__(self, name, age=None): # this says that upon creating a instance of an object of class person, we need to give it a name and an age (otherwise age will be None)\n",
    "        \"\"\"\n",
    "        We can write help text like this starting and ending \n",
    "        with three quotations.\n",
    "        \"\"\"\n",
    "        self.name = name # here's how we assign attributes, now if we call the variable which represents our person and add .name, we will see this person's name\n",
    "        self.age = age # same thing, this time for age\n",
    "        \n",
    "    def happy_birthday(self): # here is a method for our person object, when we call variable_name.happy_birthday(), the following will be run\n",
    "        \"\"\"Wish a happy birtday\"\"\"\n",
    "        print(f'Happy Birthday, dear {self.name}.') # we get a little birthday wish!\n",
    "        if self.age is not None: # and they go up in age\n",
    "            self.age += 1\n",
    "            print(f'{self.age} years, eh?') # and they get that loving reminder of how many times they've successfully made it around the sun\n",
    "        return None\n",
    "    \n",
    "    def greeting(self): # note in all of these methods, self was the first argument showing that for every method, by default, the first argument is the object itself (hidden by Python)\n",
    "        \"\"\"Greet the person\"\"\"\n",
    "        print(f'Hi {self.name}! How are you doing?') # here we can create a method where we are greeting our person object\n",
    "        return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "5nKM0-kUE5fU",
    "outputId": "70558e21-573e-46d7-b2b6-35ac2a60bbb5"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.person at 0x15cdb301990>"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dracula = person('Vlad Tepes', age=588)\n",
    "\n",
    "dracula #__main__ means that this is defined in the main module (defined here)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "viVQkbotFeCK",
    "outputId": "c2d1c50f-55b4-4736-b97c-4e6b248f6b93"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Vlad Tepes'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dracula.name # check attribute name, remember attributes use no parentheses, it is a characteristic of our instance/object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "1VYkncoaFffY",
    "outputId": "838667bc-824c-42c9-9037-cdc317830722"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "588"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dracula.age # check attribute age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "id": "H84SaCKNFbhX",
    "outputId": "de69dd19-fe57-46f8-c2ae-6561e560cc91"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Happy Birthday, dear Vlad Tepes.\n",
      "589 years, eh?\n"
     ]
    }
   ],
   "source": [
    "dracula.happy_birthday() # use the method happy_birthday(), now the happy_birthday() function will be applied to our instance of person (dracula)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "_ug8hx3eFgoF",
    "outputId": "724ba2c1-d696-44c0-c832-f23f5dee70ea"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "589"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dracula.age # check to see if the method worked (he got 1 year older)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "id": "S84sGP39I6WG"
   },
   "outputs": [],
   "source": [
    "dracula.age = 588 # we can change an attribute like so"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "zHX_wmtSEa0o",
    "outputId": "8939a721-7425-4de2-97c0-fb8beef802f5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi Vlad Tepes! How are you doing?\n"
     ]
    }
   ],
   "source": [
    "# Check your understanding: Greet Dracula using our previously created method. Although the argument method can be left blank, what is included in the arguments of this method behind the scenes?\n",
    "\n",
    "dracula.greeting()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "id": "Y-9a3DB5Et5v"
   },
   "outputs": [],
   "source": [
    "# Dracula prefers the name Count Dracula, can you change his name to a string with this text?\n",
    "\n",
    "dracula.name = 'Count Dracula'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "12gGdGCnHecn"
   },
   "source": [
    "The above example on creating our own class and equipping it with attributes and methods helps us to better understand some of the things we did earlier on. In fact, we have made used of OOP concepts ever since starting this demo notebook, just that we did not notice (or had to bother). To stress this point, let's come back to the list data type discussed above. \n",
    "\n",
    "**Lists** have many useful methods. You can view some of the most useful here: https://docs.python.org/3/tutorial/datastructures.html .\n",
    "\n",
    "Let's observe some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "QlVHu9tpGUBO",
    "outputId": "8d546ea4-d719-4ebe-ad89-4c5ac93acbbb"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['roar', 'truck', 'muffle', 'fuzzy']"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "words_i_like = ['fuzzy', 'muffle', 'truck']  # nothing new here\n",
    "\n",
    "words_i_like.append('roar')  # ok, so when using the function append(), we actually call a method in the class list, just as if we call method greeting() in our class person\n",
    " \n",
    "\n",
    "words_i_like.reverse()  # yet another call of a method. This time, however, the method does not require us to specify an argument. The entire functioning \n",
    "# of the method is based on data that is stored together with the object. Here, this data are just the entries in the list\n",
    "\n",
    "words_i_like  # notice how the order of words that we like has changed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "SvlRsLsOIs2P",
    "outputId": "ba8c98c9-bb47-42df-8477-e6f2361c9a76"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['truck', 'roar', 'muffle', 'fuzzy']"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "words_i_like.sort(reverse=True)\n",
    "\n",
    "words_i_like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "sqNcl226E_lZ",
    "outputId": "c6e87491-85fb-4a2f-bb5c-3738004069db"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'fuzzy'"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check your understanding: Pop the last item off the list using the appropriate method, note that this method removes the last item forever\n",
    "\n",
    "words_i_like.pop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qooROjS1JkBg"
   },
   "source": [
    "**Strings** also have many methods associated. You can review all here: https://docs.python.org/3/library/stdtypes.html#string-methods ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "tc02P-AyJprq",
    "outputId": "b733259f-d1d1-4b14-8e08-d16c88dd1d70"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SHE SELLS SEA SHELLS BY THE SEA SHORE'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sea_shells = 'she sells sea shells by the sea shore'\n",
    "\n",
    "sea_shells.upper() # upper case method, this does not overwrite the variable in all caps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "8P31xzUvFQY_",
    "outputId": "50a5200c-8e5f-4d5a-b1d4-14beb1653aa9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['she', 'sells', 'sea', 'shells', 'by', 'the', 'sea', 'shore']"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check your understanding: Split the string by blank space (' ') using a method and appropriate argument\n",
    "\n",
    "sea_shells.split(sep=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WVhv-8-tuvZF"
   },
   "source": [
    "\n",
    "We will see more attributes in more complex objects like the NumPy array coming up later in the demo notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jPWwNRkwMN5_"
   },
   "source": [
    "Check your understanding: What is a method and what is an attribute? How are they similar and how are they different?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "a1S_CTmlMFav"
   },
   "source": [
    "# If-Statements and Loops\n",
    "\n",
    "If-Statements evaluate a condition and proceed in a certain fashion based on the returned value.\n",
    "\n",
    "Loops perform an action recursively until a condition is met or the action has been performed on all applicable items."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wInQsLyXQbJd"
   },
   "source": [
    "## If-Statements\n",
    "If-Statements in Python take the form:\n",
    "\n",
    "\n",
    "```\n",
    "if condition == True:\n",
    " action\n",
    "else:\n",
    " action\n",
    " ```\n",
    "\n",
    "If there are multiple conditions, you can extend this with elif (as many times as needed):\n",
    "```\n",
    "if condition_1 == True:\n",
    " action\n",
    "elif condition_2 == True:\n",
    "  action\n",
    "elif condition_3 == True:\n",
    "  action\n",
    "...\n",
    "else:\n",
    " action\n",
    " ```\n",
    "Let's observe some simple if-statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "wNLNv0oyMfAx",
    "outputId": "19ef3f5f-21bc-4d9a-99c2-eacbe20cdbcd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no logic :(\n"
     ]
    }
   ],
   "source": [
    "if 1 > 2 :\n",
    "  print('logic!')\n",
    "else:\n",
    "  print('no logic :(')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "5H3x0IhhMyNW",
    "outputId": "9eda447d-d15b-408c-dc3d-e5f3bfbc5196"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logic!\n"
     ]
    }
   ],
   "source": [
    "if 2 > 1 :\n",
    "  print('logic!')\n",
    "else:\n",
    "  print('no logic :(')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "-aEudjONM_qb",
    "outputId": "63b1e8bd-ee88-43bb-fa56-883df8437ee7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['area 51', 'bermuda triangle', 'el dorado', 'atlantis']"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "places_to_visit = ['area 51', 'bermuda triangle', 'el dorado']\n",
    "\n",
    "if 'atlantis' not in places_to_visit: # for lists, we can use 'in' and 'not in' to return a Boolean\n",
    "  places_to_visit.append('atlantis')\n",
    "else:\n",
    "  places_to_visit\n",
    "\n",
    "places_to_visit\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "id": "wk6I0faWN73g",
    "outputId": "41710bb1-c463-412c-9c39-7a06f6a880aa"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Oops, looks like I put 100 in my bag. I'll just take one.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "toothbrushes_packed = 100 # adjust this to be 0, 1 and above 1 to demonstrate different results\n",
    "\n",
    "if toothbrushes_packed == 0:\n",
    "  toothbrushes_packed += 1 # this format adds 1 to the variable on the left, it is another useful trick for loops\n",
    "  print('Thanks for reminding me, I just packed', toothbrushes_packed, '!')\n",
    "elif toothbrushes_packed == 1:\n",
    "  print('All set! I already packed', toothbrushes_packed, '!')\n",
    "else:\n",
    "  print('Oops, looks like I put', toothbrushes_packed, 'in my bag. I\\'ll just take one.') # we need to put \\ in front of ' so that Python treats ' as a character and not the end of the string\n",
    "  toothbrushes_packed=1 # reset the variable back to 1\n",
    "\n",
    "toothbrushes_packed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eFd4S6b5QowM"
   },
   "source": [
    "## Loops\n",
    "\n",
    "Loops iterate through a sequence of items (such as a list) and perform an action on each item.\n",
    "\n",
    "For-loops are the most common type of loop that you will encounter. They take the following form:\n",
    "\n",
    "```\n",
    "for dummy_item_name in sequence:\n",
    "  ... dummy_item_name ...\n",
    "```\n",
    "\n",
    "To process this, Python will take each item in sequence one by one and temporarily assign it to the variable name `dummy_item_name`. The action on the next line will then take that item by using dummy_item_name execute it accordingly.\n",
    "\n",
    "1.   Take the first item in the sequence and temporarily label it `dummy_item_name`\n",
    "2.   Perform _action_ on the item with it labelled as `dummy_item_name`\n",
    "3.   Repeat steps 1-2 for the next item until the sequence is complete\n",
    "\n",
    "We have already seen this type of structure in list comprehensions which are like a condensed for-loop to create new lists from items of another list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "hC0VIT1PRHD7",
    "outputId": "d83d6680-3cd8-4a13-ab84-40a354bc4d84"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 16, 9, 8]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "place_name_length=[] # initializing an empty list before the loop allows us to simply add items to it within the loop\n",
    "\n",
    "for place in places_to_visit: # for each item in places_to_visit, assign the temporary label 'place'\n",
    "  place_name_length.append(len(place)) # apply this action to each item 'place' one by one\n",
    "\n",
    "place_name_length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 84
    },
    "id": "Pkg5hq8EwFeF",
    "outputId": "171277fc-42f9-42bc-de69-37b556e5600a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My number 1 place to visit is area 51\n",
      "My number 2 place to visit is bermuda triangle\n",
      "My number 3 place to visit is el dorado\n",
      "My number 4 place to visit is atlantis\n"
     ]
    }
   ],
   "source": [
    "for index, place in enumerate(places_to_visit): # enumerate() gives an index number for each item in the list\n",
    "  print('My number', index+1, 'place to visit is', place) # since indexing starts at 0, it is more natural when counting for us to add 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 101
    },
    "id": "ya5Bl0cFRpAG",
    "outputId": "91745d72-c8a7-4209-b4c5-2e0c75950e9e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "16\n",
      "36\n",
      "64\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "num_list = [10, 2, 6, 4, 8]\n",
    "\n",
    "for num in sorted(num_list):\n",
    "  print(num**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "uAHc_1qRMkXv",
    "outputId": "9da0d7ec-0e8f-4b53-e0c2-8ff511c54f62"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sweet, more apples!\n"
     ]
    }
   ],
   "source": [
    "# Check your understanding:\n",
    "\n",
    "# create the two variables: apples with the value 10 and oranges as 2. Create an if-statement which returns 'sweet, more apples!' if apples is larger than oranges, otherwise 'darn, more oranges'\n",
    "\n",
    "apples = 10\n",
    "oranges = 2\n",
    "\n",
    "if apples > oranges:\n",
    "  print('sweet, more apples!')\n",
    "else:\n",
    "  print('darn, more oranges!')\n",
    "\n",
    "# change oranges to be 100, and check that the output changes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "PsaDMlR2NYxx",
    "outputId": "8d094c6b-daf0-429b-acac-eee6d67f328a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "So... True is the same as 1 in Python\n"
     ]
    }
   ],
   "source": [
    "# Check your understanding:\n",
    "\n",
    "# Use an if-statement to check if the Boolean value of True is equal to 1, if it is, print 'So... True is the same as 1 in Python', otherwise it prints 'Wait, what?'\n",
    "\n",
    "if True == 1:\n",
    "  print('So... True is the same as 1 in Python')\n",
    "else:\n",
    "  print('Wait, what?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "wkuYgxUKN-11",
    "outputId": "8c5cdc73-68f0-4357-c6e3-50d67c2d3bf5"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[400, 4, 484, 0.04000000000000001]"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check your understanding:\n",
    "\n",
    "# Create a for-loop that returns a list of squares (call this some_nums_sq) for the list some_nums = [20, 2, 22, 0.2]\n",
    "\n",
    "some_nums = [20, 2, 22, 0.2]\n",
    "\n",
    "some_nums_sq = []\n",
    "for n in some_nums:\n",
    "    some_nums_sq.append(n ** 2)\n",
    "\n",
    "some_nums_sq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Xwy39al3PV2e"
   },
   "source": [
    "# Dictionaries\n",
    "\n",
    "Dictionaries are another data type. While they may look like lists, their main focus is storing items as key-value pairs. There is a label (key) which corresponds with a value or set of values.\n",
    "\n",
    "This system makes it very easy to look up values according to specific keys. If you imagine key's as column (or row) names, values could be column (row) values. As you can imagine, this means that many dictionaries are very easy to turn into common data structures which we will be using later on.\n",
    "\n",
    "Dictionaries have the following form:\n",
    "\n",
    "\n",
    "```\n",
    "dict_1 = {key_1 : value_1, key_2 : value_2} # for one value per key\n",
    "dict_2 = {key_1:[value_1_1, value_1_2,...], key_2:[value_2_1, value_2_2,...], ...} # use lists for multiple values per key\n",
    "```\n",
    "It is also possible for a key's value to be another dictionary (dictionary-ception!). You may see this in practice.\n",
    "\n",
    "Let's take a look at some examples of dictionaries and how to use them.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "id": "G966HNkSQVo3"
   },
   "outputs": [],
   "source": [
    "new_dict = {} # how to initialize a new dictionary for a loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "KOZ7kb2FSSei",
    "outputId": "ba8a8d07-8d96-499d-f2df-4720f83901f0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['Lesotho', 'Laos', 'Luxembourg'])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l_countries_capitals = {'Lesotho' : 'Matheru', 'Laos' : 'Vientiane', 'Luxembourg' : 'Luxembourg'}\n",
    "\n",
    "l_countries_capitals.keys() # check the keys of the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "Qk2fl-z5StZJ",
    "outputId": "c0156402-af47-4c83-bcbd-9331b220f8ad"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['Matheru', 'Vientiane', 'Luxembourg'])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l_countries_capitals.values() # check values in the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "6rq1xIh_SxQR",
    "outputId": "3f9d167e-cc85-4d16-cda1-ee1ca489592e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Vientiane'"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l_countries_capitals['Laos'] # look up a specific value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 84
    },
    "id": "4oFgBkboTZE5",
    "outputId": "51d803b4-adaa-4c4e-d2e9-ec6ace090d77"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Lesotho': 'Matheru',\n",
       " 'Laos': 'Vientiane',\n",
       " 'Luxembourg': 'Luxembourg',\n",
       " 'Lebanon': 'Sidon'}"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l_countries_capitals['Lebanon'] = 'Sidon' # add a new value, then edit it later\n",
    "\n",
    "l_countries_capitals # note that unlike lists, order in dictionaries is not fixed, Lebanon was not attached at the end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 84
    },
    "id": "LBQNTccnTx9B",
    "outputId": "af9ec42f-1181-4549-c073-278a2e6b88e2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Lesotho': 'Matheru',\n",
       " 'Laos': 'Vientiane',\n",
       " 'Luxembourg': 'Luxembourg',\n",
       " 'Lebanon': 'Beirut'}"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l_countries_capitals['Lebanon'] = 'Beirut'\n",
    "\n",
    "l_countries_capitals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "TMqZV-EYVxQl",
    "outputId": "dbb50cbd-775f-4f1e-b1ce-c85045ed40a6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Luxembourg' in l_countries_capitals # check if the key exists in the dictionary with in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "oxZ55HEuUbQp",
    "outputId": "63918e0d-2942-4d65-a9d2-c0bae5a7b20e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sabaidi!\n"
     ]
    }
   ],
   "source": [
    "if 'Laos' in l_countries_capitals: # this is very useful for creating if-statements\n",
    "  print('Sabaidi!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "ygETg5I1UuJf",
    "outputId": "dc84f141-c75b-416b-9f81-a58f56cedd21"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aww, we should add them!\n"
     ]
    }
   ],
   "source": [
    "if 'Latvia' in l_countries_capitals:\n",
    "  print('Sveiki!')\n",
    "else:\n",
    "  print('Aww, we should add them!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 84
    },
    "id": "4D7Z8X0aU-ll",
    "outputId": "6cc54ccd-483e-42f4-c28f-91743bcdd50d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "So, we have Matheru which is the capital of Lesotho .\n",
      "So, we have Vientiane which is the capital of Laos .\n",
      "So, we have Luxembourg which is the capital of Luxembourg .\n",
      "So, we have Beirut which is the capital of Lebanon .\n"
     ]
    }
   ],
   "source": [
    "for key, val in l_countries_capitals.items(): # iterate over a dictionary using .items(), this will return a tuple of (key, value) which we can break up immediately\n",
    "  print('So, we have', val, 'which is the capital of', key, '.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "SwjYwpfRCacS",
    "outputId": "84f0ffff-d816-4c1f-91ee-57188ec0ce04"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['mammal', 'reptile', 'bird'])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check your understanding: create a dictionary called aus_animals whose keys are the strings mammal, reptile and bird.\n",
    "# Assign the values crocodile, emu and kangaroo to the correct key\n",
    "\n",
    "aus_animals = {\"mammal\":\"kangaroo\", \"reptile\": \"crocodile\", \"bird\": \"emu\"}\n",
    "\n",
    "# look up the keys of your dictionary using the right method\n",
    "\n",
    "aus_animals.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "Nf8FnBOaD5jg",
    "outputId": "dc0f7d97-8e8f-4ca5-a196-2af9cfb2189f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['kangaroo', 'crocodile', 'emu'])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# look up the values of your dictionary using the right method\n",
    "\n",
    "aus_animals.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "gVqCYBWTD_Ey",
    "outputId": "32a7b811-8460-4816-d982-468fd7394299"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'emu'"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check the value stored under the key \"bird\"\n",
    "\n",
    "aus_animals[\"bird\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "id": "8HIs3XUHEE3R"
   },
   "outputs": [],
   "source": [
    "# change the value of the mammal key to koala\n",
    "\n",
    "aus_animals[\"mammal\"] = \"koala\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 84
    },
    "id": "D2bAl6jhEVb5",
    "outputId": "a70a8b31-a313-4b0d-aeed-a731ff3d71ca"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'mammal': 'koala',\n",
       " 'reptile': 'crocodile',\n",
       " 'bird': 'cockatoo',\n",
       " 'amphibian': 'tree frog'}"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# use the .update() method on aus_animals and use the following dictionary as the argument and describe the change:\n",
    "\n",
    "more_animals = {\"amphibian\": \"tree frog\", \"bird\": \"cockatoo\"}\n",
    "\n",
    "aus_animals.update(more_animals)\n",
    "\n",
    "aus_animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 84
    },
    "id": "uD8i0iNzGYuA",
    "outputId": "08669e9e-471b-4d1b-e28b-3877974666f0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A classic Australian mammal is a koala\n",
      "A classic Australian reptile is a crocodile\n",
      "A classic Australian bird is a cockatoo\n",
      "A classic Australian amphibian is a tree frog\n"
     ]
    }
   ],
   "source": [
    "# use a for loop to print the following sentence for each animal: A classic Australian [animal type] is a [example animal]\n",
    "\n",
    "for key, value in aus_animals.items():\n",
    "  print(\"A classic Australian\", key, \"is a\", value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iFNdnj8H-lXu"
   },
   "source": [
    "# Functions\n",
    "\n",
    "There are a large number of functions available in Python which perform specific tasks. We already saw one function, `print( )`. If a function for your purpose doesn't exist, you can always create your own very simply.\n",
    "\n",
    "Inside the parentheses of functions are **arguments**. These give more details on what actions the function should take. Arguments are separated by commas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EBkfaJvI5FAj"
   },
   "source": [
    "## Pre-Built Functions\n",
    "Python comes with some functions already built in for very basic uses. Most of the time, you will have to import other libraries to do pretty much anything with the program. Here are some examples of built-in functions in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "hG6I5f_HJ2uC",
    "outputId": "b626a162-7fa6-4e09-e18d-6896d5f11f8b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.1"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(3.14, 1) # round takes 2 arguments, the first argument is the number to round and the second is the number of desired decimal places"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RV2Xqbb0KK0V"
   },
   "source": [
    "Some functions require you to specify the argument name as well. For example, `print( )` allows us to add a separator between items to print. You must specify this argument by typing `sep=` and identifying the character to print between items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "CxdykqDfLLdI",
    "outputId": "d3afaadb-2164-4699-d6a4-96ee61dbeeb8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "please...bring...snacks\n"
     ]
    }
   ],
   "source": [
    "print('please', 'bring', 'snacks', sep='...')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1sKrirW4ypCj"
   },
   "source": [
    "A full list of Python's built in functions are here: https://docs.python.org/3/library/functions.html .\n",
    "\n",
    "Some of the most important functions here are ones that force variables to become different types such as set( ), str( ) and range( ) among others. You wil learn about these types in the next topic of the tutorial.\n",
    "\n",
    "As mentioned, in most cases, you will be loading a **library** of new functions to add to these built-in functions. We will be looking at libraries soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dN7carUw5JLT"
   },
   "source": [
    "## Creating Functions\n",
    "\n",
    "It is very easy to create your own new function in Python. The following form is necessary:\n",
    "\n",
    "\n",
    "```\n",
    "def function_name (arg1, arg2 = default_value, arg3 ...):\n",
    "    ...arg1...arg2...arg3...\n",
    "    return val;\n",
    "```\n",
    "\n",
    "Let's look at some examples.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "ykf8qvBq5IY0",
    "outputId": "e96e0fb6-da6f-4cc6-a06f-228da5654839"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "250.0"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def div_two(x):\n",
    "    return x/2\n",
    "\n",
    "div_two(500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "kutf8szB9Ytv",
    "outputId": "1a443136-410c-4d64-834d-3bfcfe2528a3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"I'll come back...never!\""
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add_dramatic_pause(word1,word2, drama_level=1):\n",
    "  \"\"\" Puts a desired number of elipses between two words. \n",
    "  Very useful if you want a lot of drama. \"\"\" # using three quotation marks is standard to describe your function, this is a multi-line comment\n",
    "  dramatic_phrase = word1 + '...'*drama_level + word2\n",
    "  return dramatic_phrase\n",
    "\n",
    "add_dramatic_pause('I\\'ll come back', 'never!') # since drama_level has a default value of 1, we can omit it in the call if that level is ok"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "1XUjV3sUBmFx",
    "outputId": "fb631198-4b20-41c8-80b8-6e59a28d955f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'please.........bring me a cookie'"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "last_words = add_dramatic_pause('please', 'bring me a cookie', drama_level=3) # by using return, you can assign the output to a variable\n",
    "\n",
    "last_words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "7iNSBowxES1T",
    "outputId": "a56ab4e1-5ec1-4685-ec82-dc7136dcffcc"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"In my opinion......pineapple doesn't belong on pizza\""
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def create_pizza_controversy(): # your whole function can just be an execution of other functions\n",
    "  pizza_drama = add_dramatic_pause('In my opinion', 'pineapple doesn\\'t belong on pizza', drama_level=2)\n",
    "  return pizza_drama\n",
    "\n",
    "create_pizza_controversy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p9ggSBMsCbeu"
   },
   "source": [
    "## Lambda Functions\n",
    "\n",
    "We can also create short functions using the following format:\n",
    "```\n",
    "function_name = lambda arg1, arg2: ...arg1...arg2\n",
    "```\n",
    "Let's create a similar example to before using this format.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "GVCv1sswDUcN",
    "outputId": "ecfdfafe-ece1-4966-c06b-f3f479ae81ba"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'please!!!bring me a cookie!!!'"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exclamatory_drama = lambda word1, word2, drama_level=1: word1 + '!!!'*drama_level + word2 + '!!!'*drama_level\n",
    "\n",
    "exclamatory_drama('please', 'bring me a cookie') # we can adjust drama_level here too if we want, it is by default set to 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "rHEwnhSqHWrc",
    "outputId": "705d6df6-3d0b-4fd8-ef82-4c29563ecdf6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "218.33333333333334"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check your understanding: create a function which changes degrees in Fahrenheit to Celsius (first subtract 32, then multiply by 5/9)\n",
    "\n",
    "def f_to_c(temp_f):\n",
    "  return (temp_f - 32) * (5/9)\n",
    "\n",
    "# Many American recipes ask to set the oven to 425F, what is that in C? (~ 218 C)\n",
    "\n",
    "f_to_c(425)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "ATWPXsUyIpbI",
    "outputId": "6466e3ed-c0ea-4eeb-9c1e-c501c3cc57f9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "218.33333333333334"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check your understanding: create the same function as a lambda function and test the value 425 F again\n",
    "\n",
    "f_to_c_lambda = lambda temp_f: (temp_f - 32) * (5/9)\n",
    "\n",
    "f_to_c_lambda(425)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yBX1b_dURFka"
   },
   "source": [
    "# Getting Help\n",
    "\n",
    "Use `help()` to get more information about any class of an object or function. It is optional to use quotes for this. If you need help about a specific function in a libary, that library must first be installed and imported.\n",
    "\n",
    "If you type `help()` without an argument, Python will begin prompting you for what you need.\n",
    "\n",
    "While you will likely spend a long time browsing blogs for working examples or StackOverflow for solutions to problems, it is often a good idea to read up on different elements of Python from the direct site or creators of its libraries (https://www.python.org/about/help/). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 218
    },
    "id": "c6nz5PuluUu2",
    "outputId": "4c11442f-5b84-4e88-ee12-7428460cfb3d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function print in module builtins:\n",
      "\n",
      "print(...)\n",
      "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "    \n",
      "    Prints the values to a stream, or to sys.stdout by default.\n",
      "    Optional keyword arguments:\n",
      "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "    sep:   string inserted between values, default a space.\n",
      "    end:   string appended after the last value, default a newline.\n",
      "    flush: whether to forcibly flush the stream.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 218
    },
    "id": "sWut1BxLuXDM",
    "outputId": "a86ce005-a797-48ee-f7c4-218cd5553581"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function print in module builtins:\n",
      "\n",
      "print(...)\n",
      "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "    \n",
      "    Prints the values to a stream, or to sys.stdout by default.\n",
      "    Optional keyword arguments:\n",
      "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "    sep:   string inserted between values, default a space.\n",
      "    end:   string appended after the last value, default a newline.\n",
      "    flush: whether to forcibly flush the stream.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help('print')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In case you are lazy with typing, just like me, you can also use the following shorthand form to get the same type of help output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1;31mDocstring:\u001b[0m\n",
       "print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
       "\n",
       "Prints the values to a stream, or to sys.stdout by default.\n",
       "Optional keyword arguments:\n",
       "file:  a file-like object (stream); defaults to the current sys.stdout.\n",
       "sep:   string inserted between values, default a space.\n",
       "end:   string appended after the last value, default a newline.\n",
       "flush: whether to forcibly flush the stream.\n",
       "\u001b[1;31mType:\u001b[0m      builtin_function_or_method\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 372
    },
    "id": "bGj4kTvHutB6",
    "outputId": "0b469040-f898-4ef8-923e-e374c0eab862"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Welcome to Python 3.10's help utility!\n",
      "\n",
      "If this is your first time using Python, you should definitely check out\n",
      "the tutorial on the internet at https://docs.python.org/3.10/tutorial/.\n",
      "\n",
      "Enter the name of any module, keyword, or topic to get help on writing\n",
      "Python programs and using Python modules.  To quit this help utility and\n",
      "return to the interpreter, just type \"quit\".\n",
      "\n",
      "To get a list of available modules, keywords, symbols, or topics, type\n",
      "\"modules\", \"keywords\", \"symbols\", or \"topics\".  Each module also comes\n",
      "with a one-line summary of what it does; to list the modules whose name\n",
      "or summary contain a given string such as \"spam\", type \"modules spam\".\n",
      "\n",
      "\n",
      "You are now leaving help and returning to the Python interpreter.\n",
      "If you want to ask for help on a particular object directly from the\n",
      "interpreter, you can type \"help(object)\".  Executing \"help('string')\"\n",
      "has the same effect as typing a particular string at the help> prompt.\n"
     ]
    }
   ],
   "source": [
    "help()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bnQRgOohz_TH"
   },
   "source": [
    "# Libraries\n",
    "\n",
    "Python has a plethora of libraries which serve an even more enormous amount of purposes. In this course, you will encounter a lot of NumPy, pandas, matplotlib, seaborn and scikit-learn. Many others will likely come of use which you may have to dig into yourself for your own purposes.\n",
    "\n",
    "To begin using a library, we must install it. This can be done in several ways:\n",
    "\n",
    "1.   Install manually via Anaconda Netvigator (Environments)\n",
    "2.   Install via Anaconda terminal (advised at set-up stage) - recommended\n",
    "3.   Install in Jupyter notebook (`!{sys.executable} -m pip install numpy` OR `!conda install --yes --prefix {sys.prefix} numpy`)\n",
    "4.   Install in Jupyter notebook via `!pip install` - suitable when using Colab but not recommended when running a notebook on your local machine\n",
    "\n",
    "After a successful installation, you must import it. Often, we will use `as` afterwards to give it an alias. There are common aliases for many libraries. For example, NumPy is always given np and Pandas, pd.\n",
    "\n",
    "If you want to use a specific function from this library, first type the library name (or alias) and then `.`, then the function name. You can also rename the function for simpler use later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "id": "g3pgKO8ouMtj"
   },
   "outputs": [],
   "source": [
    "# !pip install numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "id": "RxFgp4F-0QFG"
   },
   "outputs": [],
   "source": [
    "# math functionality\n",
    "import numpy as np\n",
    "# data frame capabilities similar to data.table in R\n",
    "import pandas as pd\n",
    "# plotting functionality\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "# statistical data visualization\n",
    "import seaborn as sns\n",
    "# scikit-learn (sklearn) is *the* standard package for machine learning in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "yUIWiR0J0tRp",
    "outputId": "075489d3-53c3-4e37-d49f-d3757064b476"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean([2, 4, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "6N3LfitS1r4-",
    "outputId": "d2001f30-b723-471b-9fba-607a55a5be86"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "average = np.mean # this now assigns the variable average to act like np.mean()\n",
    "\n",
    "average([2,4,6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BCg2OM1a01Qj"
   },
   "source": [
    "If you only want to import a specific function from a library instead of the whole thing, you can use the following format:\n",
    "\n",
    "> from _library_ import _function_\n",
    "\n",
    "This saves disc space and reduces the chance that you'll have multiple functions of the same name imported. \n",
    "\n",
    "You also do not have to write the library name in front of the function when you do this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "PFLJXt5j0z5D",
    "outputId": "0fd28f0f-9d7d-49ec-f18e-65bab67024f6"
   },
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "scaler = StandardScaler()  # don't worry about what a StandardScaler might be and what it can do for now"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JKyldpZfaD6b"
   },
   "source": [
    "# NumPy\n",
    "\n",
    "This package is one of the most important to understand for data science and business analytics. It includes many functions and data types that speed up task time when dealing with numbers. \n",
    "\n",
    "One of the most useful data classes is the **NumPy array**, which only allows the storage of one data type at a time (unlike a list, tuple or dictionary where entries can be anything). This means that calculations are faster and more efficient. The documentation for NumPy arrays is here: https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "id": "p1ZfMzw5PDPo"
   },
   "outputs": [],
   "source": [
    "# !pip install numpy # install NumPy if you haven't yet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "N4p2l_-VaY2v",
    "outputId": "f3cd1a83-be78-4aff-cc00-a668ce5a22e9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "ourlist = [1,2,3,4,5]\n",
    "\n",
    "ourlist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "9dwBFjNEaqDx",
    "outputId": "0cab803d-9e4a-4b16-ded3-cba4f1ddc4ac"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(ourlist) # convert list to an NumPy array, here we must indicate to Python that we are taking the array function from the NumPy library by putting np. in front of array()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "3wUEJsfYasZ1",
    "outputId": "e4b45c5d-69a2-4852-b39c-9fa27be02efc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.         1.41421356 1.73205081 2.         2.23606798] [  2.71828183   7.3890561   20.08553692  54.59815003 148.4131591 ]\n"
     ]
    }
   ],
   "source": [
    "print(np.sqrt(ourlist),np.exp(ourlist)) # NumPy functions will often apply a transformation to each element individually"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "3UoFH92Hatpv",
    "outputId": "6654bb54-091b-4c70-aa36-be8d38ad1de7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "listoflists=[[1,2,3],[4,5,6],[7,8,9]]\n",
    "listoflists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 67
    },
    "id": "8rTP7QTJavMX",
    "outputId": "49ca02bc-b46f-4191-aa80-68d4cb78ba57"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(listoflists) # if we have many lists, they will be converted to multiple arrays, each array can be seen as a dimension (like coordinates x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "wZEKJmljayRj",
    "outputId": "cf33454b-ad13-4225-fb29-f8bef539e8db"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(0,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 67
    },
    "id": "6ahvE6O7a7li",
    "outputId": "97f835e5-2c28-4526-fcd0-658c608dbfed"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3,4)) # matrix with all 1s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "id": "ZtSDaSkYa9cx",
    "outputId": "2e931228-389e-4fd9-c309-a4e69f74d3e6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.55555556, 1.11111111, 1.66666667, 2.22222222,\n",
       "       2.77777778, 3.33333333, 3.88888889, 4.44444444, 5.        ])"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0,5,10) # returns evenly spaced numbers over a specified interval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 118
    },
    "id": "Sl0EAjrfa_hY",
    "outputId": "f98c58f1-ff06-4a3c-a53e-1e36d4447999"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0., 0., 0.],\n",
       "       [0., 1., 0., 0., 0., 0.],\n",
       "       [0., 0., 1., 0., 0., 0.],\n",
       "       [0., 0., 0., 1., 0., 0.],\n",
       "       [0., 0., 0., 0., 1., 0.],\n",
       "       [0., 0., 0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(6) # identity matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "id": "c_Y8gaZZbEsL",
    "outputId": "a6772af4-857d-43c4-e838-c5db88022fea"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  0,  0,  0,  0,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17, 18, 19])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# setting a value with index range (broadcasting)\n",
    "some_array = np.arange(0,20)\n",
    "some_array[0:5]=0\n",
    "some_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "bJMGgfS6bL0_",
    "outputId": "7aa4f92c-ff00-45b7-c563-47c5b6e0d4ac"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0])"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Important note!\n",
    "slice_of_some_array = some_array[0:4] # let's take a slice of this array and assign it to a new variable\n",
    "slice_of_some_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "KZ0ppfpFbPny",
    "outputId": "b74f81f8-ff44-4b85-efdf-b5e95ede16b8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([999, 999, 999, 999])"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slice_of_some_array[:] = 999 # change some values in the array\n",
    "slice_of_some_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "id": "gebOUZcXbTVi",
    "outputId": "2876448a-e516-4a98-d687-c9d771fe5007"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([999, 999, 999, 999,   0,   5,   6,   7,   8,   9,  10,  11,  12,\n",
       "        13,  14,  15,  16,  17,  18,  19])"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "some_array # remember how when we changed a renamed list, the original list changed? Same problem!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "QhtGlV7KbUr7",
    "outputId": "e9e2f479-fc9d-4dfb-e2d4-794e1427f936"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([999, 999, 999, 999])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slice_of_some_array=some_array[0:4].copy() # create a separate duplicate to change independently\n",
    "slice_of_some_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "id": "U47KTI8ibWSC",
    "outputId": "0d91e42f-9d1e-4185-9f13-8a7aaeef5d93"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([999, 999, 999, 999,   0,   5,   6,   7,   8,   9,  10,  11,  12,\n",
       "        13,  14,  15,  16,  17,  18,  19])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slice_of_some_array[:]=0 # reset some values\n",
    "some_array # now we see no changes occurred to the original"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 67
    },
    "id": "R_B6i4c2bYgt",
    "outputId": "25e329a1-8b06-4a01-fd26-99cb275af69e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True,  True, False, False, False, False, False,\n",
       "       False, False,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 10\n",
    "\n",
    "some_array > x # creates an array which checks if each item in the array satisfies the condition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "f0wWzisjpphG",
    "outputId": "8aa0afb4-1beb-4918-e6b7-15881954c865"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([999, 999, 999, 999,  11,  12,  13,  14,  15,  16,  17,  18,  19])"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "some_array[some_array > x ] # this will now only display items in the array for which the condition is True (>10), this is an easy way to filter for a condition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "id": "nMcggsVWbfSc",
    "outputId": "6a4b5e21-36da-44b3-d964-f1023b28ec7b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.38288751,  0.43341397, -1.38903229, -0.47408332],\n",
       "       [-1.44218672, -0.01738369, -0.46815342,  0.89470685]])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# randomisation will matter a lot for us\n",
    "np.random.randn(2,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "0sHbmAVKbhep",
    "outputId": "b13f2412-b123-47e4-ccd7-ebb1894cb39c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 96, 74, 73, 53])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# return random integers from 'low' (inclusive) to 'high' (exclusive)\n",
    "np.random.randint(1,100,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "id": "ugGWz8UWbk-B",
    "outputId": "9717b372-e776-4d9f-f0c1-89c5363f0d46"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17, 18, 19, 20, 21, 22, 23, 24])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "other_array = np.arange(25)\n",
    "other_array # other_array.TAB will show you which methods you can use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "3UpBrzP8bm3k",
    "outputId": "41a11821-5c99-4ffc-e51a-c096bf45f5e7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "other_array.max() # common method for arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 101
    },
    "id": "wF_4LqM-boAz",
    "outputId": "b29a4d8b-0fc5-4510-b5b8-32bc961a5bff"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8,  9],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [15, 16, 17, 18, 19],\n",
       "       [20, 21, 22, 23, 24]])"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "other_array.reshape(5,5) # another important method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "6XZLk5e-bpRG",
    "outputId": "e7d676cf-46bb-406a-b755-cdbf53f4f054"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25,)"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "other_array.shape # this is an ATTRIBUTE rather than a method, hence no () at the end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "TAYOmIPyaxaD",
    "outputId": "1b93975e-0c3f-468b-a845-94eaf60ae81f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30 0 60 11.180339887498949\n"
     ]
    }
   ],
   "source": [
    "# Check your understanding: create a NumPy array of the numbers 0, 10, 20, 30\n",
    "\n",
    "new_array = np.array([0, 10, 20, 30])\n",
    "\n",
    "# print the max, min, sum and standard deviation of the array using methods\n",
    "\n",
    "print(new_array.max(), new_array.min(), new_array.sum(), new_array.std())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "GJxkTtyTcAnS",
    "outputId": "cacfd96a-d595-4694-d704-255aff0212ba"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the first element of the array using slicing\n",
    "new_array[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "qP2gOTF7b4t7",
    "outputId": "5d297730-c872-438b-de98-8e1c7ab5c955"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20, 30])"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the last two elements of the array\n",
    "new_array[-2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "id": "0vpvx74fbk90",
    "outputId": "c1c836f3-4459-4662-83f5-e8ed1851b5ec"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0, 10],\n",
       "       [20, 30]])"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reshape the new array to 2x2\n",
    "\n",
    "new_array.reshape((2,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JgyWLxhAXp8n"
   },
   "source": [
    "# Pandas\n",
    "\n",
    "The Python package 'pandas' provides fast and flexible data structures that make handling data easier. It incorporates data structures and different functions for manipulating tabular data. You will be using this library quite a lot throughout your time as a data scientist or a business analyst. It is very useful to have a strong grasp of how it works.\n",
    "\n",
    "Pandas provides two main data structures:\n",
    "\n",
    "*   Series\n",
    "*   DataFrames\n",
    "\n",
    "You can always check out the documentation which includes many alternative explanations for this library here: https://pandas.pydata.org/docs/ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "id": "PYMLSn__Xo2I"
   },
   "outputs": [],
   "source": [
    "import pandas as pd # first we have to import the library, the common alias for pandas is pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QcrOOhm9iVlh"
   },
   "source": [
    "\n",
    "## Pandas Series\n",
    "\n",
    "Series are defined as one dimensional, labelled vectors that are capable of carrying any data type. They are comparable to a column of a dataset. If you have your data initially as a list or a NumPy array, you can easily convert the object to a pandas series using `pd.Series(object)`.\n",
    "\n",
    "A good question: How does a Pandas Series differ from a list in Python? Python list items always use 0 indexing and cannot be renamed. Series allow for re-indexing using custom names. This is useful if there are specific row names that we want to use in our data set.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 218
    },
    "id": "RsZ0LRzKY342",
    "outputId": "d418e4a0-b476-49a2-8e7e-b66cc6c07871"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    3\n",
      "1    2\n",
      "2    0\n",
      "3    1\n",
      "4    2\n",
      "dtype: int64\n",
      "0    1\n",
      "1    4\n",
      "2    2\n",
      "3    0\n",
      "4    0\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "Anna = pd.Series([3, 2, 0, 1, 2]) # create a new series with values, note that the argument is in list-format\n",
    "print(Anna)\n",
    "\n",
    "John = pd.Series([1, 4, 2, 0, 0]) # example with a list of numeric values but we can use any data type\n",
    "print(John)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 118
    },
    "id": "QPhu52H9ZIrc",
    "outputId": "8ef3ce3d-9790-4aed-da69-a36580c5a136"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cucumber        2\n",
      "hummus          5\n",
      "guacamole       1\n",
      "tomato          1\n",
      "spring rolls    1\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# As you can see, both these series automatically use 0 indexing, however we can customise this!\n",
    "\n",
    "Taylor = pd.Series([2, 5, 1, 1, 1], index=whats_in_your_fridge) # set the index argument to equal label names in the form of a list. Lengths must be equal!\n",
    "print(Taylor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "HBgggeVcZ0Mt",
    "outputId": "aa5a56e1-c2f7-4fb9-e63b-589c400456b3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(whats_in_your_fridge) # check length using the len() function, works for lists, dictionaries and even strings!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 84
    },
    "id": "ZLq-mtozh9Xr",
    "outputId": "35ea94ad-ba88-4d12-a0ae-199e76fca3e4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    0\n",
       "3    1\n",
       "4    2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Anna[2:] # you can also perform slicing on Series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {
    "id": "kqv88dWirlMK"
   },
   "outputs": [],
   "source": [
    "Taylor.name = 'Taylor' # label the whole series by setting the .name attribute, this will be the column label when we add it to a DataFrame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1xhGrpBZicMa"
   },
   "source": [
    "You can see all the methods and attributes associated to Series on the official pandas website: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.html .\n",
    "\n",
    "There are also plenty tutorials on YouTube which can teach you a lot of other useful tricks with Series."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6maCLgCwaAI5"
   },
   "source": [
    "## Pandas DataFrame\n",
    "\n",
    "A DataFrame is a data structure with two dimensions: columns and rows. Each column can have a different datatype and all can be contained in the same DataFrame simultaneously. This is perfect for business analytics and data science cases.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DCCgmDlskjqa"
   },
   "source": [
    "### Creating DataFrames\n",
    "To create a DataFrame, you can use dictionaries, Pandas series, lists or NumPy arrays using the `concat()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 232
    },
    "id": "3WDxSWL8f3tg",
    "outputId": "19612dbe-b12d-4c63-a0ca-277cc3c1f8bf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'food': ['flour', 'sugar', 'baking_powder', 'baked_beans', 'tomato_sauce'], 'person_a': [3, 2, 0, 1, 1], 'person_b': [0, 3, 7, 2, 0], 'person_c': [0, 1, 1, 0, 0], 'person_d': [1, 1, 2, 5, 1]}\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>food</th>\n",
       "      <th>person_a</th>\n",
       "      <th>person_b</th>\n",
       "      <th>person_c</th>\n",
       "      <th>person_d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>flour</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>sugar</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>baking_powder</td>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>baked_beans</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>tomato_sauce</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            food  person_a  person_b  person_c  person_d\n",
       "0          flour         3         0         0         1\n",
       "1          sugar         2         3         1         1\n",
       "2  baking_powder         0         7         1         2\n",
       "3    baked_beans         1         2         0         5\n",
       "4   tomato_sauce         1         0         0         1"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a data frame from scratch\n",
    "\n",
    "pantry_inventory = {\n",
    "    'food' : ['flour', 'sugar', 'baking_powder', 'baked_beans', 'tomato_sauce'], # each of these dictionary keys are column names, and the values are contents of the columns\n",
    "    'person_a' : [3, 2, 0, 1, 1], \n",
    "    'person_b': [0, 3, 7, 2, 0],\n",
    "    'person_c': [0, 1, 1, 0, 0],\n",
    "    'person_d': [1, 1, 2, 5, 1]\n",
    "}\n",
    "\n",
    "print(pantry_inventory)\n",
    "\n",
    "pantry_inventory_df = pd.DataFrame(pantry_inventory) # you can convert dictionaries to DataFrames\n",
    "\n",
    "pantry_inventory_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 134
    },
    "id": "7h4i7C1qYXY5",
    "outputId": "bb410e0e-7a16-49dd-bc73-f8f7c20e5adc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   0  1\n",
      "0  3  1\n",
      "1  2  4\n",
      "2  0  2\n",
      "3  1  0\n",
      "4  2  0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "pandas.core.frame.DataFrame"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Combining Series to create a DataFrame\n",
    "\n",
    "fridge_inventory_df = pd.concat([Anna, John], axis=1) # axis = 1 refers to columns, as such pandas will treat person_a and person_b as columns and put them beside each other\n",
    "\n",
    "# if instead we used axis=0, pandas will treat person_a and person_b as rows and paste person_b vertically below person_a\n",
    "\n",
    "print(fridge_inventory_df)\n",
    "\n",
    "type(fridge_inventory_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4HqmlyFZYr-V"
   },
   "source": [
    "### Naming of Columns and Index\n",
    "\n",
    "DataFrames can add row names and column names (also known as a row index/indices and column index/indices). This will be useful when we have to refer to rows or columns later on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 118
    },
    "id": "OsZlEJ9zYrT3",
    "outputId": "6cf2c6da-462d-4581-98c4-c9e6d30e7835"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              person_a  person_b\n",
      "cucumber             3         1\n",
      "hummus               2         4\n",
      "margarine            0         2\n",
      "tomato               1         0\n",
      "spring rolls         2         0\n"
     ]
    }
   ],
   "source": [
    "# We can then set the column index \n",
    "fridge_inventory_df.index = whats_in_my_fridge # use a pre-existing list with the same length again, you can also create a new list here\n",
    "# fridge_inventory_df.index = ['cucumber', 'humus', 'margarine', 'tomato', 'spring_rolls'] # this gives the same result\n",
    "\n",
    "# We can also add a row names (row index)\n",
    "fridge_inventory_df.columns = ['person_a', 'person_b'] # or specify with a new list\n",
    "print(fridge_inventory_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 134
    },
    "id": "Pb490UP4g6Bq",
    "outputId": "0f94c93c-54b4-44a8-e001-e77222b00ccf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               person_a  person_b  person_c  person_d\n",
      "food                                                 \n",
      "flour                 3         0         0         1\n",
      "sugar                 2         3         1         1\n",
      "baking_powder         0         7         1         2\n",
      "baked_beans           1         2         0         5\n",
      "tomato_sauce          1         0         0         1\n"
     ]
    }
   ],
   "source": [
    "# Set index using an existing column\n",
    "\n",
    "pantry_inventory_df = pantry_inventory_df.set_index('food') # the argument must be the column's name as a string\n",
    "print(pantry_inventory_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CPkXUzjAZ35x"
   },
   "source": [
    "### Slicing and Dicing with Pandas\n",
    "\n",
    "We had a little introduction to indexing and slicing before. Now we are dealing with a two dimensional DataFrame. This requires additional information on indexing. We can do this easiest with `.loc[]` (location) and `.iloc[]` (integer location) in this section.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "edSvD9P9hfED"
   },
   "source": [
    "\n",
    "#### .loc[ ]\n",
    "\n",
    "This function is used for labels which means we will refer to the specific row names and column names. If we use `:` for slicing, it will include all of the rows or columns in between. Note that when using `loc[]`, the end of the selection is included.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "YCQH8uU3aVoI",
    "outputId": "00354fc1-ad20-4ee9-ae26-7d8cc9ac820e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# How many baked beans does person_a have? \n",
    "                        # rows      # columns\n",
    "pantry_inventory_df.loc['baked_beans', 'person_a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "akLdHi_xaVoR",
    "outputId": "284188c8-b1ba-419a-e27c-3decd3aa24c9"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>person_a</th>\n",
       "      <th>person_b</th>\n",
       "      <th>person_c</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>food</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>sugar</th>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>baking_powder</th>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>baked_beans</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tomato_sauce</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               person_a  person_b  person_c\n",
       "food                                       \n",
       "sugar                 2         3         1\n",
       "baking_powder         0         7         1\n",
       "baked_beans           1         2         0\n",
       "tomato_sauce          1         0         0"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# When selecting multiple rows and columns, the same rules apply as before. We can use ':' to set a range\n",
    "\n",
    "pantry_inventory_df.loc[ 'sugar':'tomato_sauce', 'person_a':'person_c'] # note that unlike slicing with numbers, .loc slicing includes the final column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6KFL3CW8aVoU"
   },
   "source": [
    "#### .iloc[ ]\n",
    "\n",
    "Integer location or `iloc[] `instead uses numeric positions of columns. The format of these numbers is identical to slicing. Note that unlike `loc[]` but similar to regular slicing, the end of the selection is excluded in the result. If you'd like to include everything up to the end of the index, you can simply end the slice with `:`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "CcZBm3qQaVoV",
    "outputId": "b1876a46-6056-4932-eda7-7cc85fb7a09e"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>person_a</th>\n",
       "      <th>person_b</th>\n",
       "      <th>person_c</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>food</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>sugar</th>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>baking_powder</th>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>baked_beans</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tomato_sauce</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               person_a  person_b  person_c\n",
       "food                                       \n",
       "sugar                 2         3         1\n",
       "baking_powder         0         7         1\n",
       "baked_beans           1         2         0\n",
       "tomato_sauce          1         0         0"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pantry_inventory_df.iloc[1:5, 0:3] # The same data frame as above, just using .iloc instead"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "NO6cawb0aVoZ",
    "outputId": "0aae1e0e-1b49-4cc7-b214-7c892ba24339"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>person_a</th>\n",
       "      <th>person_b</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>food</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>flour</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sugar</th>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>baking_powder</th>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>baked_beans</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tomato_sauce</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               person_a  person_b\n",
       "food                             \n",
       "flour                 3         0\n",
       "sugar                 2         3\n",
       "baking_powder         0         7\n",
       "baked_beans           1         2\n",
       "tomato_sauce          1         0"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pantry_inventory_df.iloc[:, :2] # just like slicing, to select all rows for example from the columns up until 'person_b', set ':' as the first argument in iloc[]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zddsfEM3amNs"
   },
   "source": [
    "### Changing DataFrames\n",
    "\n",
    "When working with DataFrames, there are several operations we can do to ensure they are in the format we ultimitaly need it in. We will go through the following:\n",
    "\n",
    "\n",
    "1.   Adding and Extracting Columns \n",
    "2.   Inner and Outer Joins\n",
    "3.   Appending DataFrames\n",
    "4.   Transposing DataFrames\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DVg4vUSHhl7z"
   },
   "source": [
    "#### Adding and Extracting Columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "2YtwbiJVaexL",
    "outputId": "5d8b463d-8f3d-476e-a3ce-95e80aa0f586"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>person_a</th>\n",
       "      <th>person_b</th>\n",
       "      <th>person_d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>cucumber</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>hummus</th>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>margarine</th>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tomato</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spring rolls</th>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              person_a  person_b  person_d\n",
       "cucumber             3         1         0\n",
       "hummus               2         4         0\n",
       "margarine            0         2         1\n",
       "tomato               1         0         0\n",
       "spring rolls         2         0         1"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can also simply name your new column, then set it equal to the values for that column\n",
    "fridge_inventory_df['person_d'] = [0, 0, 1, 0, 1]\n",
    "fridge_inventory_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "SCTH7GbtblLX",
    "outputId": "41112daf-c73c-4388-f4ab-2397a0a59019"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pandas.core.series.Series"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can extract a pandas series from a column \n",
    "person_d =  fridge_inventory_df.person_d # one way, only works if the column already exists\n",
    "# person_d = fridge_inventory_df['person_d'] # this would also work\n",
    "type(person_d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "M-SFVWHCdSYS"
   },
   "source": [
    "#### Inner Join\n",
    "\n",
    "Let's say two columns that you want to add together have different row names. You should join the data based to make sure your relevant rows match up. As such, like in SQL and set theory, we can specify for the `concat()` function to use an inner join (only allow matches to show up in result). If you are unfamiliar with set theory, it is important to refamiliarize yourself with the topic as it is very useful in dealing with data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "3TMIkkS5blag",
    "outputId": "d361a026-b03b-49f1-c7a1-e7306d735c8c"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>person_a</th>\n",
       "      <th>person_b</th>\n",
       "      <th>person_d</th>\n",
       "      <th>Taylor</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>cucumber</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>hummus</th>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tomato</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spring rolls</th>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              person_a  person_b  person_d  Taylor\n",
       "cucumber             3         1         0       2\n",
       "hummus               2         4         0       5\n",
       "tomato               1         0         0       1\n",
       "spring rolls         2         0         1       1"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.concat([fridge_inventory_df, Taylor], join= 'inner', axis=1) # Inner join only combines observations found in both data sets, i.e. magarine gets ommitted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_4rk3K0Bhw8S"
   },
   "source": [
    "#### Outer Join\n",
    "\n",
    "As surmisable from its name, outer joins will keep everything possible. As such, there may be certain combinations with values that are missing. For example, if the second data set introduces a new column but does not contain one row in the original data set. In this case, we do not know that row's value for the new column being introduced. An example of this is below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "yEqz74rvblgV",
    "outputId": "eccc1f89-5152-473c-bbdb-5fb01b7bff7f"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>person_a</th>\n",
       "      <th>person_b</th>\n",
       "      <th>person_d</th>\n",
       "      <th>Taylor</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>cucumber</th>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>hummus</th>\n",
       "      <td>2.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>margarine</th>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tomato</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spring rolls</th>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>guacamole</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              person_a  person_b  person_d  Taylor\n",
       "cucumber           3.0       1.0       0.0     2.0\n",
       "hummus             2.0       4.0       0.0     5.0\n",
       "margarine          0.0       2.0       1.0     NaN\n",
       "tomato             1.0       0.0       0.0     1.0\n",
       "spring rolls       2.0       0.0       1.0     1.0\n",
       "guacamole          NaN       NaN       NaN     1.0"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# it keeps all obervations and creates missing values (labelled as NaN), which will be discussed shortly\n",
    "fridge_inventory_df = pd.concat([fridge_inventory_df, Taylor], axis=1) # concat() by default uses an outer join\n",
    "fridge_inventory_df # person_c has guacamole, which we didn't see in our original df, as such pandas does not know what values to add for other columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fkjHnbath59y"
   },
   "source": [
    "#### Appending Data Frames\n",
    "\n",
    "To add new rows to a dataframe, we can use the append method and add more rows. This acts identical to `pd.concat([df1,df2],axis=0)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "36z25CNUgACH",
    "outputId": "a1afa444-550d-47df-bc1d-2d95076c251a"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\temp\\ipykernel_14512\\2815802419.py:1: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  inventory_df = fridge_inventory_df.append(pantry_inventory_df)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>person_a</th>\n",
       "      <th>person_b</th>\n",
       "      <th>person_d</th>\n",
       "      <th>Taylor</th>\n",
       "      <th>person_c</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>cucumber</th>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>hummus</th>\n",
       "      <td>2.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>margarine</th>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tomato</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spring rolls</th>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>guacamole</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>flour</th>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sugar</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>baking_powder</th>\n",
       "      <td>0.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>baked_beans</th>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tomato_sauce</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               person_a  person_b  person_d  Taylor  person_c\n",
       "cucumber            3.0       1.0       0.0     2.0       NaN\n",
       "hummus              2.0       4.0       0.0     5.0       NaN\n",
       "margarine           0.0       2.0       1.0     NaN       NaN\n",
       "tomato              1.0       0.0       0.0     1.0       NaN\n",
       "spring rolls        2.0       0.0       1.0     1.0       NaN\n",
       "guacamole           NaN       NaN       NaN     1.0       NaN\n",
       "flour               3.0       0.0       1.0     NaN       0.0\n",
       "sugar               2.0       3.0       1.0     NaN       1.0\n",
       "baking_powder       0.0       7.0       2.0     NaN       1.0\n",
       "baked_beans         1.0       2.0       5.0     NaN       0.0\n",
       "tomato_sauce        1.0       0.0       1.0     NaN       0.0"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inventory_df = fridge_inventory_df.append(pantry_inventory_df)\n",
    "inventory_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "TMPhMjbXmp5B",
    "outputId": "eb2d5de9-fa9c-4f53-c1e3-6cbb1325e668"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>person_a</th>\n",
       "      <th>person_b</th>\n",
       "      <th>person_c</th>\n",
       "      <th>person_d</th>\n",
       "      <th>Taylor</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>flour</th>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sugar</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>baking_powder</th>\n",
       "      <td>0.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>baked_beans</th>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tomato_sauce</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>cucumber</th>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>hummus</th>\n",
       "      <td>2.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>margarine</th>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tomato</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spring rolls</th>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>guacamole</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               person_a  person_b  person_c  person_d  Taylor\n",
       "flour               3.0       0.0       0.0       1.0     NaN\n",
       "sugar               2.0       3.0       1.0       1.0     NaN\n",
       "baking_powder       0.0       7.0       1.0       2.0     NaN\n",
       "baked_beans         1.0       2.0       0.0       5.0     NaN\n",
       "tomato_sauce        1.0       0.0       0.0       1.0     NaN\n",
       "cucumber            3.0       1.0       NaN       0.0     2.0\n",
       "hummus              2.0       4.0       NaN       0.0     5.0\n",
       "margarine           0.0       2.0       NaN       1.0     NaN\n",
       "tomato              1.0       0.0       NaN       0.0     1.0\n",
       "spring rolls        2.0       0.0       NaN       1.0     1.0\n",
       "guacamole           NaN       NaN       NaN       NaN     1.0"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inventory_df = pd.concat([pantry_inventory_df,fridge_inventory_df],axis=0)\n",
    "inventory_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "2RyCU5BbgfR7",
    "outputId": "fe0ad283-113f-4936-b8aa-5902213fe542"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\temp\\ipykernel_14512\\600932492.py:1: FutureWarning: The series.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  Anna.append(John) # Appending Series works the same\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0    3\n",
       "1    2\n",
       "2    0\n",
       "3    1\n",
       "4    2\n",
       "0    1\n",
       "1    4\n",
       "2    2\n",
       "3    0\n",
       "4    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Anna.append(John) # Appending Series works the same"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zgbzKJB4iBAe"
   },
   "source": [
    "#### Transposing a DataFrame\n",
    "\n",
    "Transposing is switching the rows and columns of a matrix. We can do tihs a well with the simply attribute `.T`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "dwSt5fVVdoLd",
    "outputId": "08c9a207-2349-46bf-e54c-bc78844ff753"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>flour</th>\n",
       "      <th>sugar</th>\n",
       "      <th>baking_powder</th>\n",
       "      <th>baked_beans</th>\n",
       "      <th>tomato_sauce</th>\n",
       "      <th>cucumber</th>\n",
       "      <th>hummus</th>\n",
       "      <th>margarine</th>\n",
       "      <th>tomato</th>\n",
       "      <th>spring rolls</th>\n",
       "      <th>guacamole</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>person_a</th>\n",
       "      <td>3.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>person_b</th>\n",
       "      <td>0.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>person_c</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>person_d</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Taylor</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          flour  sugar  baking_powder  baked_beans  tomato_sauce  cucumber  \\\n",
       "person_a    3.0    2.0            0.0          1.0           1.0       3.0   \n",
       "person_b    0.0    3.0            7.0          2.0           0.0       1.0   \n",
       "person_c    0.0    1.0            1.0          0.0           0.0       NaN   \n",
       "person_d    1.0    1.0            2.0          5.0           1.0       0.0   \n",
       "Taylor      NaN    NaN            NaN          NaN           NaN       2.0   \n",
       "\n",
       "          hummus  margarine  tomato  spring rolls  guacamole  \n",
       "person_a     2.0        0.0     1.0           2.0        NaN  \n",
       "person_b     4.0        2.0     0.0           0.0        NaN  \n",
       "person_c     NaN        NaN     NaN           NaN        NaN  \n",
       "person_d     0.0        1.0     0.0           1.0        NaN  \n",
       "Taylor       5.0        NaN     1.0           1.0        1.0  "
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# If instead we want our observations to be per person (rows represent observations generally), we can transpose the DataFrame as well\n",
    "inventory_df = inventory_df.T\n",
    "inventory_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "df7miMEvgz4Y"
   },
   "source": [
    "### Missing Values\n",
    "It will be very common to find missing values here and there in real data sets before they are pre-processed for analysis. Knowing how to deal with them is critical as many calculations do not accept null values.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 195
    },
    "id": "ax8iyh46hB4n",
    "outputId": "3650b816-a700-4fe1-fb1c-52cf3e74b7d3"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>flour</th>\n",
       "      <th>sugar</th>\n",
       "      <th>baking_powder</th>\n",
       "      <th>baked_beans</th>\n",
       "      <th>tomato_sauce</th>\n",
       "      <th>cucumber</th>\n",
       "      <th>hummus</th>\n",
       "      <th>margarine</th>\n",
       "      <th>tomato</th>\n",
       "      <th>spring rolls</th>\n",
       "      <th>guacamole</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>person_a</th>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>person_b</th>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>person_c</th>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>person_d</th>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Taylor</th>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          flour  sugar  baking_powder  baked_beans  tomato_sauce  cucumber  \\\n",
       "person_a  False  False          False        False         False     False   \n",
       "person_b  False  False          False        False         False     False   \n",
       "person_c  False  False          False        False         False      True   \n",
       "person_d  False  False          False        False         False     False   \n",
       "Taylor     True   True           True         True          True     False   \n",
       "\n",
       "          hummus  margarine  tomato  spring rolls  guacamole  \n",
       "person_a   False      False   False         False       True  \n",
       "person_b   False      False   False         False       True  \n",
       "person_c    True       True    True          True       True  \n",
       "person_d   False      False   False         False       True  \n",
       "Taylor     False       True   False         False      False  "
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inventory_df.isna() # Returns a matrix with boolean whether or not a value is missing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 218
    },
    "id": "yErSbtdNhB4q",
    "outputId": "078130dd-b431-4b2b-da82-f9754ac0c780"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "flour            1\n",
       "sugar            1\n",
       "baking_powder    1\n",
       "baked_beans      1\n",
       "tomato_sauce     1\n",
       "cucumber         1\n",
       "hummus           1\n",
       "margarine        2\n",
       "tomato           1\n",
       "spring rolls     1\n",
       "guacamole        4\n",
       "dtype: int64"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inventory_df.isna().sum() # You can use the function .sum() to add up the amount of missing values per column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Nh_5ofYixuZ0"
   },
   "source": [
    "In terms of dealing with these values, we have a few options.\n",
    "\n",
    "*   Leave them and use arguments to skip them\n",
    "*   Remove rows or columns with null values\n",
    "*   Fill all null values with a value (like 0, mean or median)\n",
    "*   Impute the value using a function (explained later, more advanced)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 47
    },
    "id": "sHuJ-zpRhB4t",
    "outputId": "ef3d52be-be3c-48ff-eb65-825b91e4c0f1"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>flour</th>\n",
       "      <th>sugar</th>\n",
       "      <th>baking_powder</th>\n",
       "      <th>baked_beans</th>\n",
       "      <th>tomato_sauce</th>\n",
       "      <th>cucumber</th>\n",
       "      <th>hummus</th>\n",
       "      <th>margarine</th>\n",
       "      <th>tomato</th>\n",
       "      <th>spring rolls</th>\n",
       "      <th>guacamole</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [flour, sugar, baking_powder, baked_beans, tomato_sauce, cucumber, hummus, margarine, tomato, spring rolls, guacamole]\n",
       "Index: []"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inventory_df.dropna() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 195
    },
    "id": "CJSFj5JyhB4x",
    "outputId": "d5eb48e2-aa81-41f0-96d2-35e0b4a3161b"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>flour</th>\n",
       "      <th>sugar</th>\n",
       "      <th>baking_powder</th>\n",
       "      <th>baked_beans</th>\n",
       "      <th>tomato_sauce</th>\n",
       "      <th>cucumber</th>\n",
       "      <th>hummus</th>\n",
       "      <th>margarine</th>\n",
       "      <th>tomato</th>\n",
       "      <th>spring rolls</th>\n",
       "      <th>guacamole</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>person_a</th>\n",
       "      <td>3.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>person_b</th>\n",
       "      <td>0.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>person_c</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>person_d</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Taylor</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          flour  sugar  baking_powder  baked_beans  tomato_sauce  cucumber  \\\n",
       "person_a    3.0    2.0            0.0          1.0           1.0       3.0   \n",
       "person_b    0.0    3.0            7.0          2.0           0.0       1.0   \n",
       "person_c    0.0    1.0            1.0          0.0           0.0       0.0   \n",
       "person_d    1.0    1.0            2.0          5.0           1.0       0.0   \n",
       "Taylor      0.0    0.0            0.0          0.0           0.0       2.0   \n",
       "\n",
       "          hummus  margarine  tomato  spring rolls  guacamole  \n",
       "person_a     2.0        0.0     1.0           2.0        0.0  \n",
       "person_b     4.0        2.0     0.0           0.0        0.0  \n",
       "person_c     0.0        0.0     0.0           0.0        0.0  \n",
       "person_d     0.0        1.0     0.0           1.0        0.0  \n",
       "Taylor       5.0        0.0     1.0           1.0        1.0  "
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inventory_df = inventory_df.fillna(0) # fills all NaN values with the value in the argument, in this case 0\n",
    "inventory_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 195
    },
    "id": "fuIBaKCuduo_",
    "outputId": "e819cf9b-7d88-46a1-9871-499000bcc064"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>observation</th>\n",
       "      <th>recent_visit</th>\n",
       "      <th>location</th>\n",
       "      <th>freq</th>\n",
       "      <th>last_purchase</th>\n",
       "      <th>newsletter</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>obs_1</td>\n",
       "      <td>1</td>\n",
       "      <td>berlin</td>\n",
       "      <td>0</td>\n",
       "      <td>20.12</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>obs_2</td>\n",
       "      <td>0</td>\n",
       "      <td>berlin</td>\n",
       "      <td>0</td>\n",
       "      <td>10.54</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>obs_3</td>\n",
       "      <td>0</td>\n",
       "      <td>munich</td>\n",
       "      <td>1</td>\n",
       "      <td>15.27</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>obs_4</td>\n",
       "      <td>1</td>\n",
       "      <td>berlin</td>\n",
       "      <td>1</td>\n",
       "      <td>55.10</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>obs_5</td>\n",
       "      <td>0</td>\n",
       "      <td>munich</td>\n",
       "      <td>0</td>\n",
       "      <td>27.89</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  observation  recent_visit location  freq  last_purchase  newsletter\n",
       "0       obs_1             1   berlin     0          20.12           1\n",
       "1       obs_2             0   berlin     0          10.54           0\n",
       "2       obs_3             0   munich     1          15.27           1\n",
       "3       obs_4             1   berlin     1          55.10           1\n",
       "4       obs_5             0   munich     0          27.89           1"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "# Check your understanding:\n",
    "\n",
    "marketing_info_dict = {\n",
    "    'observation':['obs_1', 'obs_2','obs_3','obs_4', 'obs_5'],\n",
    "    'recent_visit':[1,0,0,1,0],\n",
    "    'location':['berlin', 'berlin', 'munich', 'berlin', 'munich'],\n",
    "    'freq':[0,0,1,1,0],\n",
    "    'last_purchase':[20.12, 10.54,15.27, 55.10, 27.89],\n",
    "    'newsletter':[1,0,1,1,1]\n",
    "}\n",
    "\n",
    "# convert this dictionary to a pandas DataFrame and save it as marketing_info\n",
    "\n",
    "marketing_info = pd.DataFrame(marketing_info_dict)\n",
    "\n",
    "marketing_info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 225
    },
    "id": "_NOIKMMlgJwc",
    "outputId": "0461cf24-895a-4c09-9fb6-4731e874fdc6"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>recent_visit</th>\n",
       "      <th>location</th>\n",
       "      <th>freq</th>\n",
       "      <th>last_purchase</th>\n",
       "      <th>newsletter</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>observation</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>obs_1</th>\n",
       "      <td>1</td>\n",
       "      <td>berlin</td>\n",
       "      <td>0</td>\n",
       "      <td>20.12</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>obs_2</th>\n",
       "      <td>0</td>\n",
       "      <td>berlin</td>\n",
       "      <td>0</td>\n",
       "      <td>10.54</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>obs_3</th>\n",
       "      <td>0</td>\n",
       "      <td>munich</td>\n",
       "      <td>1</td>\n",
       "      <td>15.27</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>obs_4</th>\n",
       "      <td>1</td>\n",
       "      <td>berlin</td>\n",
       "      <td>1</td>\n",
       "      <td>55.10</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>obs_5</th>\n",
       "      <td>0</td>\n",
       "      <td>munich</td>\n",
       "      <td>0</td>\n",
       "      <td>27.89</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             recent_visit location  freq  last_purchase  newsletter\n",
       "observation                                                        \n",
       "obs_1                   1   berlin     0          20.12           1\n",
       "obs_2                   0   berlin     0          10.54           0\n",
       "obs_3                   0   munich     1          15.27           1\n",
       "obs_4                   1   berlin     1          55.10           1\n",
       "obs_5                   0   munich     0          27.89           1"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# set the index to column one using the set_index method\n",
    "marketing_info = marketing_info.set_index(\"observation\")\n",
    "\n",
    "marketing_info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "IdS2ItQNnEc3",
    "outputId": "968e78fb-169c-446e-dbe1-f2051c082746"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.series.Series'> <class 'pandas.core.frame.DataFrame'>\n"
     ]
    }
   ],
   "source": [
    "# print the type of the selection of the recent_visit column using one square bracket and two square brackets\n",
    "\n",
    "print(type(marketing_info['recent_visit']),\n",
    "      type(marketing_info[['recent_visit']]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "CbbZ3WDBnYUh",
    "outputId": "b668bd1a-3899-44b8-eaf1-192e3c8dac64"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55.1 55.1\n"
     ]
    }
   ],
   "source": [
    "# use .loc[] to print the value 55.10 in the data frame, then use .iloc[] to do the same\n",
    "\n",
    "print(marketing_info.loc[\"obs_4\",\"last_purchase\"],\n",
    "      marketing_info.iloc[3,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 118
    },
    "id": "sUpLADhvoqaM",
    "outputId": "20db342c-7817-441b-934e-8503e103ded4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "recent_visit          0\n",
      "location         munich\n",
      "freq                  1\n",
      "last_purchase     15.27\n",
      "newsletter            1\n",
      "Name: obs_3, dtype: object <class 'pandas.core.series.Series'>\n"
     ]
    }
   ],
   "source": [
    "# use loc or iloc to select all of row which is indexed at 2. What type of object is this?\n",
    "print(marketing_info.iloc[2,:], type(marketing_info.iloc[2,:]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "QmiboVfKmLeH",
    "outputId": "8e6db8b6-fece-4452-e75f-3ff66de22aca"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25.784000000000002"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# select the last purchase column, then use the .mean() method to get its mean\n",
    "\n",
    "marketing_info['last_purchase'].mean()\n",
    "\n",
    "marketing_info.last_purchase.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "Ikx1CbhUmuBV",
    "outputId": "315dace1-bcbf-4ae0-f131-a2a4a7d3427a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['berlin', 'munich'], dtype=object)"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# find the unique values found in the location column using the method .unique() on the column\n",
    "\n",
    "marketing_info['location'].unique()\n",
    "\n",
    "marketing_info.location.unique()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bvOrF8CKqpYW"
   },
   "source": [
    "# Random Data Generation\n",
    "\n",
    "To conduct experiments, it can be very useful to create a random dataset with known properties. Knowing the characteristics of the dataset allows us to confirm the efficacy of quantitative methods.\n",
    "\n",
    "Python offers functions which facilitate this process. We can take advantage of the NumPy and random libraries to help us create random datasets and collect data from them. We can then use matplotlib.pyplot to display visuals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {
    "id": "2jU3DLWau7bC"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "np.random.seed(123) # set a seed for random number generation so you get reproducible results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {
    "id": "jAcW8dr48OuO"
   },
   "outputs": [],
   "source": [
    "mu = 10 # let's set our mean, for standard normal must be 0\n",
    "sigma = 1 # set the variance, for standard normal must be 1\n",
    "n = 10000 # set our sample size\n",
    "\n",
    "x = np.random.normal(mu, sigma, size=n) # create a sample!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "id": "gHYeC-pf9puI",
    "outputId": "1fbdc5bc-1f66-437e-ef24-79b4d81618fe"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 8.9143694 , 10.99734545, 10.2829785 ,  8.49370529,  9.42139975,\n",
       "       11.65143654,  7.57332076,  9.57108737, 11.26593626,  9.1332596 ])"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:10] # there is no head.() or .tail() method for NumPy arrays, so use slicing to take a look"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 265
    },
    "id": "tCwNlD4301re",
    "outputId": "9d0fbf91-8136-4916-b095-374fdc85b81f"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "_ = plt.hist(x, bins=100, cumulative=False, histtype='stepfilled') # to create a PDF, we can use a histogram "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 265
    },
    "id": "9NSqiMUirj2x",
    "outputId": "b40153ab-51d4-4588-86da-3e8cafa4312c"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "_ = plt.hist(x, bins=100, cumulative=True, histtype='stepfilled') # for a CDF, we can use a histogram that is cumulative"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WJFmCp3QA-Ve"
   },
   "source": [
    "Let's use the random number generator to create an entire DataFrame. We just have to insert each of the NumPy arrays into the data argument. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 195
    },
    "id": "bXOnn6St-cxl",
    "outputId": "2589ffb1-c4c7-428a-c26c-2cba090f56c0"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>variable_1</th>\n",
       "      <th>variable_2</th>\n",
       "      <th>variable_3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>8.914369</td>\n",
       "      <td>37.951516</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10.997345</td>\n",
       "      <td>84.352661</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>10.282978</td>\n",
       "      <td>57.552660</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>8.493705</td>\n",
       "      <td>218.897630</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>9.421400</td>\n",
       "      <td>132.875031</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   variable_1  variable_2  variable_3\n",
       "0    8.914369   37.951516         1.0\n",
       "1   10.997345   84.352661         0.0\n",
       "2   10.282978   57.552660         0.0\n",
       "3    8.493705  218.897630         0.0\n",
       "4    9.421400  132.875031         0.0"
      ]
     },
     "execution_count": 202,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.random.normal(100, 50, size=n) # create another variable with a different mean and variance\n",
    "\n",
    "z = np.random.randint(2,size=n) # if you want to create a random dummy variable\n",
    "\n",
    "df = pd.DataFrame(data=[x,y,z], index=['variable_1', 'variable_2', 'variable_3']) # create a DataFrame\n",
    "\n",
    "df = df.T # transpose so that each variable is a column rather than a row\n",
    "\n",
    "df.head() # check that the df appears as expected"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zkLseolUvDlu"
   },
   "source": [
    "# Additional Information\n",
    "\n",
    "It is highly recommended to get familiar with the basics of Python to unlock its potential. Here is mostly official documentation for the aforementioned topics. There are many other blogs or videos online which explain much about these basics in great detail. It can be helpful to hear these concepts a few times from different people to fully grasp them.\n",
    "\n",
    "Jupyter Notebook Documentation: https://jupyter-notebook.readthedocs.io/en/stable/\n",
    "\n",
    "Simple Math Operations in Python: https://docs.python.org/2.4/lib/typesnumeric.html\n",
    "\n",
    "Python Documentation of Simple Data Types: https://docs.python.org/3/library/stdtypes.html\n",
    "\n",
    "Python Documentation for Loops: https://docs.python.org/3/tutorial/controlflow.html\n",
    "\n",
    "Python Documentation for Defining Functions: https://docs.python.org/3/tutorial/controlflow.html#defining-functions \n",
    "\n",
    "Overview of Object-Oriented Programming in Python for Beginners: www.youtube.com/watch?v=JeznW_7DlB0 (independent YouTuber)\n",
    "\n",
    "Python Documentation for Package Installation: https://packaging.python.org/tutorials/installing-packages/\n",
    "\n",
    "NumPy Beginner's Tutorial from the Official Website: https://numpy.org/doc/stable/user/absolute_beginners.html \n",
    "\n",
    "pandas Beginner's 10 min Tutorial from the Official Website: https://pandas.pydata.org/docs/user_guide/10min.html#min\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hqn0pCx3v3HA"
   },
   "source": [
    "## (Extra) Other Useful Object Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sQA38M9K_IOW"
   },
   "source": [
    "### Ranges\n",
    "\n",
    "Create a sequence of numbers using the format:\n",
    "\n",
    "> `range(start, end, skip)`\n",
    "\n",
    "This is a very efficient way to create a sequence of numbers with a pattern. \n",
    "You can find more information o ranges here: https://docs.python.org/3/library/stdtypes.html#range "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "EzQID1jf_8m3",
    "outputId": "f6f493f7-045f-41d7-f758-b80dd1c6f47f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "13\n",
      "16\n",
      "19\n",
      "22\n",
      "25\n",
      "28\n",
      "31\n",
      "34\n",
      "37\n",
      "40\n",
      "43\n",
      "46\n",
      "49\n"
     ]
    }
   ],
   "source": [
    "our_numbers = range(10,50,3)\n",
    "\n",
    "for number in our_numbers: # this is called a for loop, we will learn it soon\n",
    "  print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "F54HU7k0ABYk"
   },
   "source": [
    "### Sets\n",
    "\n",
    "List where everything is unique. Duplicate items will be removed. Very useful when you need to check membership and differences. Converting a list to a set can be done by simply using the function `set( )` on a list. You can find more information on this type here: https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "0LwOkCXxAMla",
    "outputId": "38fb2c0f-1475-44e6-fc97-8c9696acecbc"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'cat', 'mouse'}"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set_a = {'cat', 'dog', 'mouse'}\n",
    "\n",
    "set_b = {'dog', 'wolf', 'hyena'}\n",
    "\n",
    "set_a.difference(set_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "pqYbkfvZAgfb",
    "outputId": "eda7f092-53d3-4972-daf1-26149812e0a0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'dog'}"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set_a.intersection(set_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "MR48g23YAi1g",
    "outputId": "e81aacb9-b4ec-4886-e507-5117c70b68e2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'cat', 'dog', 'hyena', 'mouse', 'wolf'}"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set_a.union(set_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "kieIPFYKF3Ny",
    "outputId": "35ed3d8f-55b1-4599-d184-4bb4e4cfaca6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'cucumber', 'hummus', 'margarine', 'spring rolls', 'tomato'}"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(whats_in_my_fridge) # turn a list into a set"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "1_nb_python_intro.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "0d59063d68e7723de5ed538f052e9a0cf5060d8feb35a125775eb36a31b4dca6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}