DataCamp.Course_034_Intermediate Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DataCamp.Course_034_Intermediate_Python\n",
    "\n",
    "### **Course Description**\n",
    "\n",
    "Learning Python is crucial for any aspiring data science practitioner. Learn to visualize real data with Matplotlib’s functions and get acquainted with data structures such as the dictionary and pandas DataFrame. This four-hour intermediate course will help you to build on your existing Python skills and explore new Python applications and functions that expand your repertoire and help you work more efficiently.\n",
    "\n",
    "You'll discover how dictionaries offer an alternative to Python lists, and why the pandas dataframe is the most popular way of working with tabular data. In the second chapter of this course, you’ll find out how you can create and manipulate datasets, and how to access them using these structures. Hands-on practice throughout the course will build your confidence in each area.\n",
    "\n",
    "As you progress, you’ll look at logic, control flow, filtering and loops. These functions work to control decision-making in Python programs and help you to perform more operations with your data, including repeated statements. You’ll finish the course by applying all of your new skills by using hacker statistics to calculate your chances of winning a bet.\n",
    "\n",
    "Once you’ve completed all of the chapters, you’ll be ready to apply your new skills in your job, new career, or personal project, and be prepared to move onto more advanced Python learning."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Matplotlib  (Module 01-034)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Basic plots with Matplotlib**\n",
    "\n",
    "Data visualization\n",
    "Very important in Data Analysis\n",
    "Explore data\n",
    "Report insights\n",
    "\n",
    "Matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "year = [1950, 1970, 1990, 2010]\n",
    "pop = [2.519, 3.692, 5.263, 6.972]\n",
    "plt.plot(year, pop)\n",
    "plt.show()\n",
    "\n",
    "Scatter plot\n",
    "import matplotlib.pyplot as plt\n",
    "year = [1950, 1970, 1990, 2010]\n",
    "pop = [2.519, 3.692, 5.263, 6.972]\n",
    "plt.scatter(year, pop)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Line plot (1)**\n",
    "\n",
    "With matplotlib, you can create a bunch of different plots in Python.\n",
    "The most basic plot is the line plot. A general recipe is given here.\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.plot(x,y)\n",
    "plt.show()\n",
    "\n",
    "In the video, you already saw how much the world population has grown\n",
    "over the past years. Will it continue to do so? The world bank has estimates\n",
    "of the world population for the years 1950 up to 2100. The years are loaded\n",
    "in your workspace as a list called year, and the corresponding populations\n",
    "as a list called pop.\n",
    "\n",
    "This course touches on a lot of concepts you may have forgotten,\n",
    "so if you ever need a quick refresher, download the Python for data\n",
    "science Cheat Sheet and keep it handy!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "year = [1900,1950, 2000, 2050, 2100]\n",
    "pop = [2.3, 3.4, 6.6, 9.9, 10.85]\n",
    "\n",
    "\n",
    "# Print the last item from year and pop\n",
    "print(year[-1])\n",
    "print(pop[-1])\n",
    "\n",
    "\n",
    "# Import matplotlib.pyplot as plt\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Make a line plot: year on the x-axis, pop on the y-axis\n",
    "plt.plot(year,pop)\n",
    "\n",
    "\n",
    "# Display the plot with plt.show()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Line plot (3)**\n",
    "\n",
    "Now that you've built your first line plot, let's start working on\n",
    "data that professor Hans Rosling used to build his beautiful bubble\n",
    "chart. It was collected in 2007. Two lists are available for you:\n",
    "\n",
    "    life_exp which contains the life expectancy for each country and\n",
    "    gdp_cap, which contains the GDP per capita (i.e. per person) for\n",
    "    each country expressed in US Dollars.\n",
    "\n",
    "GDP stands for Gross Domestic Product. It basically represents the size\n",
    "of the economy of a country. Divide this by the population and you get\n",
    "the GDP per capita.\n",
    "\n",
    "matplotlib.pyplot is already imported as plt, so you can get started\n",
    "straight away."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the last item of gdp_cap and life_exp\n",
    "print(gdp_cap[-1])\n",
    "print(life_exp[-1])\n",
    "\n",
    "\n",
    "# Make a line plot, gdp_cap on the x-axis, life_exp on the y-axis\n",
    "plt.plot(gdp_cap,life_exp)\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Scatter Plot (1)**\n",
    "\n",
    "When you have a time scale along the horizontal axis, the line plot is\n",
    "your friend. But in many other cases, when you're trying to assess if\n",
    "there's a correlation between two variables, for example, the scatter\n",
    "plot is the better choice. Below is an example of how to build a scatter\n",
    "plot.\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.scatter(x,y)\n",
    "plt.show()\n",
    "\n",
    "Let's continue with the gdp_cap versus life_exp plot, the GDP and life\n",
    "expectancy data for different countries in 2007. Maybe a scatter plot\n",
    "will be a better alternative?\n",
    "\n",
    "Again, the matplotlib.pyplot package is available as plt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Change the line plot below to a scatter plot\n",
    "plt.scatter(gdp_cap, life_exp)\n",
    "\n",
    "# Put the x-axis on a logarithmic scale\n",
    "plt.xscale('log')\n",
    "\n",
    "# Show plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Scatter plot (2)**\n",
    "\n",
    "In the previous exercise, you saw that the higher GDP usually\n",
    "corresponds to a higher life expectancy. In other words, there\n",
    "is a positive correlation.\n",
    "\n",
    "Do you think there's a relationship between population and life\n",
    "expectancy of a country? The list life_exp from the previous\n",
    "exercise is already available. In addition, now also pop is available,\n",
    "listing the corresponding populations for the countries in 2007.\n",
    "The populations are in millions of people."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import package\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Build Scatter plot\n",
    "plt.scatter(pop, life_exp)\n",
    "\n",
    "# Show plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Histogram**\n",
    "\n",
    "Explore dataset\n",
    "Get idea about distribution\n",
    "\n",
    "Matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "help(plt.hist)\n",
    "\n",
    "Help on function hist in module matplotlib.pyplot:\n",
    "hist(x, bins=10, range=None, normed=False, weights=None,\n",
    "cumulative=False, bottom=None, histtype='bar'\n",
    ", align='mid'\n",
    ",\n",
    "orientation='vertical'\n",
    ", rwidth=None, log=False, color=None,\n",
    "label=None, stacked=False, hold=None, data=None, **kwargs)\n",
    "Plot a histogram.\n",
    "Compute and draw the histogram of *x*. The return value is a\n",
    "tuple (*n*, *bins*, *patches*) or ([*n0*, *n1*, ...],\n",
    "*bins*, [*patches0*, *patches1*,...]) if the input contains\n",
    "multiple data.\n",
    "\n",
    "Matplotlib example\n",
    "values = [0,0.6,1.4,1.6,2.2,2.5,2.6,3.2,3.5,3.9,4.2,6]\n",
    "plt.hist(values, bins=3)\n",
    "plt.show()\n",
    "Population pyramid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Build a histogram (1)**\n",
    "\n",
    "life_exp, the list containing data on the life expectancy for different\n",
    "countries in 2007, is available in your Python shell.\n",
    "\n",
    "To see how life expectancy in different countries is distributed,\n",
    "let's create a histogram of life_exp.\n",
    "\n",
    "matplotlib.pyplot is already available as plt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create histogram of life_exp data\n",
    "plt.hist(life_exp)\n",
    "\n",
    "# Display histogram\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Build a histogram (2): bins**\n",
    "\n",
    "In the previous exercise, you didn't specify the number of bins.\n",
    "By default, Python sets the number of bins to 10 in that case.\n",
    "The number of bins is pretty important. Too few bins will\n",
    "oversimplify reality and won't show you the details. Too many\n",
    "bins will overcomplicate reality and won't show the bigger picture.\n",
    "\n",
    "To control the number of bins to divide your data in, you can\n",
    "set the bins argument.\n",
    "\n",
    "That's exactly what you'll do in this exercise. You'll be making\n",
    "two plots here. The code in the script already includes plt.show()\n",
    "and plt.clf() calls; plt.show() displays a plot; plt.clf()\n",
    "cleans it up again so you can start afresh.\n",
    "\n",
    "As before, life_exp is available and matplotlib.pyplot is\n",
    "imported as plt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build histogram with 5 bins\n",
    "plt.hist(life_exp,  bins=5)\n",
    "\n",
    "# Show and clean up plot\n",
    "plt.show()\n",
    "plt.clf()\n",
    "\n",
    "# Build histogram with 20 bins\n",
    "plt.hist(life_exp,  bins=20)\n",
    "\n",
    "# Show and clean up again\n",
    "plt.show()\n",
    "plt.clf()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Build a histogram (3): compare**\n",
    "\n",
    "In the video, you saw population pyramids for the present day\n",
    "and for the future. Because we were using a histogram, it was\n",
    "very easy to make a comparison.\n",
    "\n",
    "Let's do a similar comparison. life_exp contains life expectancy\n",
    "data for different countries in 2007. You also have access to a\n",
    "second list now, life_exp1950, containing similar data for 1950.\n",
    "Can you make a histogram for both datasets?\n",
    "\n",
    "You'll again be making two plots. The plt.show() and plt.clf()\n",
    "commands to render everything nicely are already included. Also\n",
    "matplotlib.pyplot is imported for you, as plt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Histogram of life_exp, 15 bins\n",
    "plt.hist(life_exp,  bins=15)\n",
    "\n",
    "# Show and clear plot\n",
    "plt.show()\n",
    "plt.clf()\n",
    "\n",
    "# Histogram of life_exp1950, 15 bins\n",
    "plt.hist(life_exp1950,  bins=15)\n",
    "\n",
    "# Show and clear plot again\n",
    "plt.show()\n",
    "plt.clf()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Customization**\n",
    "\n",
    "Data visualization\n",
    "Many options\n",
    "Different plot types\n",
    "Many customizations\n",
    "Choice depends on\n",
    "Data\n",
    "Story you want to tell\n",
    "\n",
    "Basic plot\n",
    "population.py\n",
    "import matplotlib.pyplot as plt\n",
    "year = [1950, 1951, 1952, 2100]\n",
    "pop = [2.538, 2.57, 2.62, 10.85]\n",
    "plt.plot(year, pop)\n",
    "plt.clf()\n",
    "plt.show()\n",
    "\n",
    "Axis labels\n",
    "population.py\n",
    "import matplotlib.pyplot as plt\n",
    "year = [1950, 1951, 1952, ..., 2100]\n",
    "pop = [2.538, 2.57, 2.62, ..., 10.85]\n",
    "plt.plot(year, pop)\n",
    "plt.xlabel('Year')\n",
    "plt.ylabel('Population')\n",
    "plt.show()\n",
    "\n",
    "Title\n",
    "population.py\n",
    "import matplotlib.pyplot as plt\n",
    "year = [1950, 1951, 1952, ..., 2100]\n",
    "pop = [2.538, 2.57, 2.62, ..., 10.85]\n",
    "plt.plot(year, pop)\n",
    "plt.xlabel('Year')\n",
    "plt.ylabel('Population')\n",
    "plt.title('World Population Projections')\n",
    "plt.show()\n",
    "\n",
    "Ticks\n",
    "population.py\n",
    "import matplotlib.pyplot as plt\n",
    "year = [1950, 1951, 1952, ..., 2100]\n",
    "pop = [2.538, 2.57, 2.62, ..., 10.85]\n",
    "plt.plot(year, pop)\n",
    "plt.xlabel('Year')\n",
    "plt.ylabel('Population')\n",
    "plt.title('World Population Projections')\n",
    "plt.yticks([0, 2, 4, 6, 8, 10])\n",
    "plt.show()\n",
    "\n",
    "Ticks (2)\n",
    "population.py\n",
    "import matplotlib.pyplot as plt\n",
    "year = [1950, 1951, 1952, ..., 2100]\n",
    "pop = [2.538, 2.57, 2.62, ..., 10.85]\n",
    "plt.plot(year, pop)\n",
    "plt.xlabel('Year')\n",
    "plt.ylabel('Population')\n",
    "plt.title('World Population Projections')\n",
    "plt.yticks([0, 2, 4, 6, 8, 10],['0','2B','4B','6B','8B','10B'])\n",
    "plt.show()\n",
    "\n",
    "Add historical data\n",
    "population.py\n",
    "import matplotlib.pyplot as plt\n",
    "year = [1950, 1951, 1952, ..., 2100]\n",
    "pop = [2.538, 2.57, 2.62, ..., 10.85]\n",
    "Add more data\n",
    "year = [1800, 1850, 1900] + year\n",
    "pop = [1.0, 1.262, 1.650] + pop\n",
    "plt.plot(year, pop)\n",
    "plt.xlabel('Year')\n",
    "plt.ylabel('Population')\n",
    "plt.title('World Population Projections')\n",
    "plt.yticks([0, 2, 4, 6, 8, 10],['0','2B','4B','6B','8B','10B'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Labels**\n",
    "\n",
    "It's time to customize your own plot. This is the fun part, you will\n",
    "see your plot come to life!\n",
    "\n",
    "You're going to work on the scatter plot with world development data:\n",
    "GDP per capita on the x-axis (logarithmic scale), life expectancy on\n",
    "the y-axis. The code for this plot is available in the script.\n",
    "\n",
    "As a first step, let's add axis labels and a title to the plot. You\n",
    "can do this with the xlabel(), ylabel() and title() functions,\n",
    "available in matplotlib.pyplot. This sub-package is already imported\n",
    "as plt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Basic scatter plot, log scale\n",
    "plt.scatter(gdp_cap, life_exp)\n",
    "plt.xscale('log')\n",
    "\n",
    "# Strings\n",
    "xlab = 'GDP per Capita [in USD]'\n",
    "ylab = 'Life Expectancy [in years]'\n",
    "title = 'World Development in 2007'\n",
    "\n",
    "# Add axis labels\n",
    "plt.xlabel(xlab)\n",
    "plt.ylabel(ylab)\n",
    "\n",
    "# Add title\n",
    "plt.title(title)\n",
    "\n",
    "# After customizing, display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ticks**\n",
    "\n",
    "The customizations you've coded up to now are available in the script,\n",
    "in a more concise form.\n",
    "\n",
    "In the video, Hugo has demonstrated how you could control the y-ticks\n",
    "by specifying two arguments:\n",
    "\n",
    "plt.yticks([0,1,2], [\"one\",\"two\",\"three\"])\n",
    "\n",
    "In this example, the ticks corresponding to the numbers 0, 1 and 2\n",
    "will be replaced by one, two and three, respectively.\n",
    "\n",
    "Let's do a similar thing for the x-axis of your world development\n",
    "chart, with the xticks() function. The tick values 1000, 10000 and\n",
    "100000 should be replaced by 1k, 10k and 100k. To this end, two\n",
    "lists have already been created for you: tick_val and tick_lab."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Scatter plot\n",
    "plt.scatter(gdp_cap, life_exp)\n",
    "\n",
    "# Previous customizations\n",
    "plt.xscale('log')\n",
    "plt.xlabel('GDP per Capita [in USD]')\n",
    "plt.ylabel('Life Expectancy [in years]')\n",
    "plt.title('World Development in 2007')\n",
    "\n",
    "# Definition of tick_val and tick_lab\n",
    "tick_val = [1000, 10000, 100000]\n",
    "tick_lab = ['1k', '10k', '100k']\n",
    "\n",
    "# Adapt the ticks on the x-axis\n",
    "plt.xticks(tick_val,tick_lab)\n",
    "\n",
    "# After customizing, display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Sizes**\n",
    "\n",
    "Right now, the scatter plot is just a cloud of blue dots,\n",
    "indistinguishable from each other. Let's change this.\n",
    "Wouldn't it be nice if the size of the dots corresponds\n",
    "to the population?\n",
    "\n",
    "To accomplish this, there is a list pop loaded in your workspace.\n",
    "It contains population numbers for each country expressed in millions.\n",
    "You can see that this list is added to the scatter method,\n",
    "as the argument s, for size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import numpy as np\n",
    "import numpy as np\n",
    "\n",
    "# Store pop as a numpy array: np_pop\n",
    "np_pop = np.array(pop)\n",
    "\n",
    "# Double np_pop\n",
    "np_pop = np_pop*2\n",
    "\n",
    "# Update: set s argument to np_pop\n",
    "plt.scatter(gdp_cap, life_exp, s = np_pop)\n",
    "\n",
    "# Previous customizations\n",
    "plt.xscale('log')\n",
    "plt.xlabel('GDP per Capita [in USD]')\n",
    "plt.ylabel('Life Expectancy [in years]')\n",
    "plt.title('World Development in 2007')\n",
    "plt.xticks([1000, 10000, 100000],['1k', '10k', '100k'])\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Colors**\n",
    "\n",
    "The code you've written up to now is available in the script.\n",
    "\n",
    "The next step is making the plot more colorful! To do this, a\n",
    "list col has been created for you. It's a list with a color for\n",
    "each corresponding country, depending on the continent the country\n",
    "is part of.\n",
    "\n",
    "How did we make the list col you ask? The Gapminder data contains\n",
    "a list continent with the continent each country belongs to.\n",
    "A dictionary is constructed that maps continents onto colors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict = {\n",
    "    'Asia':'red',\n",
    "    'Europe':'green',\n",
    "    'Africa':'blue',\n",
    "    'Americas':'yellow',\n",
    "    'Oceania':'black'\n",
    "}\n",
    "\n",
    "Nothing to worry about now; you will learn about dictionaries\n",
    "in the next chapter.\n",
    "\n",
    "# Specify c and alpha inside plt.scatter()\n",
    "plt.scatter(x = gdp_cap, y = life_exp, s = np.array(pop) * 2, c = col, alpha=0.8)\n",
    "\n",
    "# Previous customizations\n",
    "plt.xscale('log')\n",
    "plt.xlabel('GDP per Capita [in USD]')\n",
    "plt.ylabel('Life Expectancy [in years]')\n",
    "plt.title('World Development in 2007')\n",
    "plt.xticks([1000,10000,100000], ['1k','10k','100k'])\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Additional Customizations**\n",
    "\n",
    "If you have another look at the script, under\n",
    "Additional Customizations,\n",
    "you'll see that there are two plt.text() functions now.\n",
    "They add the words \"India\" and \"China\" in the plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scatter plot\n",
    "plt.scatter(x = gdp_cap, y = life_exp, s = np.array(pop) * 2, c = col, alpha = 0.8)\n",
    "\n",
    "# Previous customizations\n",
    "plt.xscale('log')\n",
    "plt.xlabel('GDP per Capita [in USD]')\n",
    "plt.ylabel('Life Expectancy [in years]')\n",
    "plt.title('World Development in 2007')\n",
    "plt.xticks([1000,10000,100000], ['1k','10k','100k'])\n",
    "\n",
    "# Additional customizations\n",
    "plt.text(1550, 71, 'India')\n",
    "plt.text(5700, 80, 'China')\n",
    "\n",
    "# Add grid() call\n",
    "plt.grid(True)\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries & Pandas  (Module 02-034)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Dictionaries, Part 1**\n",
    "\n",
    "List\n",
    "pop = [30.55, 2.77, 39.21]\n",
    "countries = [\"afghanistan\",\"albania\",\"algeria\"]\n",
    "ind_alb = countries.index(\"albania\")\n",
    "ind_alb\n",
    "1\n",
    "pop[ind_alb]\n",
    "2.77\n",
    "Not convenient\n",
    "Not intuitive\n",
    "\n",
    "Dictionary\n",
    "pop = [30.55, 2.77, 39.21]\n",
    "countries = [\"afghanistan\",\"albania\",\"algeria\"]\n",
    "# ...\n",
    "world = {\"afghanistan\":30.55,\"albania\":2.77,\"algeria\":39.21}\n",
    "world[\"albania\"]\n",
    "2.77"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Motivation for dictionaries**\n",
    "\n",
    "To see why dictionaries are useful, have a look at the two lists\n",
    "defined in the script. countries contains the names of some European\n",
    "countries. capitals lists the corresponding names of their capital."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definition of countries and capital\n",
    "countries = ['spain', 'france', 'germany', 'norway']\n",
    "capitals = ['madrid', 'paris', 'berlin', 'oslo']\n",
    "\n",
    "# Get index of 'germany': ind_ger\n",
    "ind_ger = countries.index('germany')\n",
    "\n",
    "# Use ind_ger to print out capital of Germany\n",
    "print(capitals[ind_ger])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Create dictionary**\n",
    "\n",
    "The countries and capitals lists are again available in the script.\n",
    "It's your job to convert this data to a dictionary where the country\n",
    "names are the keys and the capitals are the corresponding values.\n",
    "As a refresher, here is a recipe for creating a dictionary:\n",
    "\n",
    "my_dict = {\n",
    "   \"key1\":\"value1\",\n",
    "   \"key2\":\"value2\",\n",
    "}\n",
    "\n",
    "In this recipe, both the keys and the values are strings. This will\n",
    "also be the case for this exercise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definition of countries and capital\n",
    "countries = ['spain', 'france', 'germany', 'norway']\n",
    "capitals = ['madrid', 'paris', 'berlin', 'oslo']\n",
    "\n",
    "# From string in countries and capitals, create dictionary europe\n",
    "europe = { 'spain':'madrid', 'france':'paris', 'germany':'berlin', 'norway':'oslo' }\n",
    "\n",
    "# Print europe\n",
    "print(europe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Access dictionary**\n",
    "\n",
    "If the keys of a dictionary are chosen wisely, accessing the values in\n",
    "a dictionary is easy and intuitive. For example, to get the capital for\n",
    "    France from europe you can use:\n",
    "\n",
    "europe['france']\n",
    "\n",
    "Here, 'france' is the key and 'paris' the value is returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definition of dictionary\n",
    "europe = {'spain':'madrid', 'france':'paris', 'germany':'berlin', 'norway':'oslo' }\n",
    "\n",
    "# Print out the keys in europe\n",
    "print(europe.keys())\n",
    "\n",
    "# Print out value that belongs to key 'norway'\n",
    "print(europe['norway'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Dictionaries, Part 2**\n",
    "\n",
    "Recap\n",
    "Keys have to be \"immutable\" objects\n",
    "{0:\"hello\", True:\"dear\",\"two\":\"world\"}\n",
    "{0: 'hello', True: 'dear','two': 'world'}\n",
    "{[\"just\",\"to\",\"test\"]: \"value\"}\n",
    "TypeError: unhashable type: 'list'\n",
    "\n",
    "Dictionary\n",
    "world[\"sealand\"] = 0.000027\n",
    "world\n",
    "{'afghanistan': 30.55,\n",
    "'albania': 2.81,\n",
    "'algeria': 39.21,\n",
    "'sealand': 2.7e-05}\n",
    "\"sealand\" in world\n",
    "True\n",
    "\n",
    "Dictionary\n",
    "world[\"sealand\"] = 0.000028\n",
    "world\n",
    "{'afghanistan': 30.55,\n",
    "'albania': 2.81,\n",
    "'algeria': 39.21,\n",
    "'sealand': 2.8e-05}\n",
    "del(world[\"sealand\"])\n",
    "world\n",
    "{'afghanistan': 30.55,\n",
    "'albania': 2.81,\n",
    "'algeria': 39.21}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Dictionary Manipulation (1)**\n",
    "\n",
    "If you know how to access a dictionary, you can also assign a new\n",
    "value to it. To add a new key-value pair to europe you can use\n",
    "something like this:\n",
    "\n",
    "europe['iceland'] = 'reykjavik'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definition of dictionary\n",
    "europe = {'spain':'madrid', 'france':'paris', 'germany':'berlin', 'norway':'oslo' }\n",
    "\n",
    "# Add italy to europe\n",
    "europe['italy'] = 'rome'\n",
    "\n",
    "# Print out italy in europe\n",
    "print('italy' in europe)\n",
    "\n",
    "# Add poland to europe\n",
    "europe['poland'] = 'warsaw'\n",
    "\n",
    "# Print europe\n",
    "print(europe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Dictionary Manipulation (2)**\n",
    "\n",
    "Somebody thought it would be funny to mess with your accurately\n",
    "generated dictionary. An adapted version of the europe dictionary\n",
    "is available in the script.\n",
    "\n",
    "Can you clean up? Do not do this by adapting the definition of\n",
    "europe, but by adding Python commands to the script to update\n",
    "and remove key:value pairs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definition of dictionary\n",
    "europe = {'spain':'madrid', 'france':'paris', 'germany':'bonn',\n",
    "          'norway':'oslo', 'italy':'rome', 'poland':'warsaw',\n",
    "          'australia':'vienna' }\n",
    "\n",
    "# Update capital of germany\n",
    "europe['germany'] = 'berlin'\n",
    "\n",
    "# Remove australia\n",
    "del(europe['australia'])\n",
    "\n",
    "# Print europe\n",
    "print(europe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Dictionariception**\n",
    "\n",
    "Remember lists? They could contain anything, even other lists.\n",
    "Well, for dictionaries the same holds. Dictionaries can contain\n",
    "key:value pairs where the values are again dictionaries.\n",
    "\n",
    "As an example, have a look at the script where another version\n",
    "of europe - the dictionary you've been working with all\n",
    "along - is coded. The keys are still the country names, but the\n",
    "values are dictionaries that contain more information than just\n",
    "the capital.\n",
    "\n",
    "It's perfectly possible to chain square brackets to select\n",
    "elements. To fetch the population for Spain from europe, for\n",
    "example, you need:\n",
    "\n",
    "europe['spain']['population']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dictionary of dictionaries\n",
    "europe = { 'spain': { 'capital':'madrid', 'population':46.77 },\n",
    "           'france': { 'capital':'paris', 'population':66.03 },\n",
    "           'germany': { 'capital':'berlin', 'population':80.62 },\n",
    "           'norway': { 'capital':'oslo', 'population':5.084 } }\n",
    "\n",
    "\n",
    "# Print out the capital of France\n",
    "print(europe['france']['capital'])\n",
    "\n",
    "# Create sub-dictionary data\n",
    "data = { 'capital':'rome', 'population':59.83 }\n",
    "\n",
    "# Add data to europe under key 'italy'\n",
    "europe['italy'] = data\n",
    "\n",
    "# Print europe\n",
    "print(europe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Pandas, Part 1**\n",
    "\n",
    "Datasets in Python\n",
    "2D Numpy array?\n",
    "One data type\n",
    "\n",
    "pandas!\n",
    "High level data manipulation tool\n",
    "Wes McKinney\n",
    "Built on Numpy\n",
    "DataFrame\n",
    "\n",
    "DataFrame\n",
    "brics\n",
    "\n",
    "DataFrame from Dictionary\n",
    "dict = {\"country\":[\"Brazil\",\"Russia\",\"India\",\"China\",\"South Africa\"],\n",
    "    \"capital\":[\"Brasilia\",\"Moscow\",\"New Delhi\",\"Beijing\",\"Pretoria\"],\n",
    "    \"area\":[8.516, 17.10, 3.286, 9.597, 1.221]\n",
    "    \"population\":[200.4, 143.5, 1252, 1357, 52.98] }\n",
    "keys (column labels)\n",
    "values (data, column by column)\n",
    "import pandas as pd\n",
    "brics = pd.DataFrame(dict)\n",
    "\n",
    "DataFrame from Dictionary (2)\n",
    "brics\n",
    "area capital country population\n",
    "0 8.516 Brasilia Brazil 200.40\n",
    "1 17.100 Moscow Russia 143.50\n",
    "2 3.286 New Delhi India 1252.00\n",
    "3 9.597 Beijing China 1357.00\n",
    "4 1.221 Pretoria South Africa 52.98\n",
    "\n",
    "brics.index = [\"BR\",\"RU\",\"IN\",\"CH\",\"SA\"]\n",
    "brics\n",
    "area capital country population\n",
    "BR 8.516 Brasilia Brazil 200.40\n",
    "RU 17.100 Moscow Russia 143.50\n",
    "IN 3.286 New Delhi India 1252.00\n",
    "CH 9.597 Beijing China 1357.00\n",
    "SA 1.221 Pretoria South Africa 52.98\n",
    "\n",
    "DataFrame from CSV file\n",
    "brics.csv\n",
    ",country,capital,area,population\n",
    "BR,Brazil,Brasilia,8.516,200.4\n",
    "RU,Russia,Moscow,17.10,143.5\n",
    "IN,India,New Delhi,3.286,1252\n",
    "CH,China,Beijing,9.597,1357\n",
    "SA,South Africa,Pretoria,1.221,52.98\n",
    "CSV = comma-separated values\n",
    "\n",
    "DataFrame from CSV file\n",
    "brics.csv\n",
    ",country,capital,area,population\n",
    "BR,Brazil,Brasilia,8.516,200.4\n",
    "RU,Russia,Moscow,17.10,143.5\n",
    "IN,India,New Delhi,3.286,1252\n",
    "CH,China,Beijing,9.597,1357\n",
    "SA,South Africa,Pretoria,1.221,52.98\n",
    "brics = pd.read_csv(\"path/to/brics.csv\")\n",
    "brics\n",
    "Unnamed: 0 country capital area population\n",
    "0 BR Brazil Brasilia 8.516 200.40\n",
    "1 RU Russia Moscow 17.100 143.50\n",
    "2 IN India New Delhi 3.286 1252.00\n",
    "3 CH China Beijing 9.597 1357.00\n",
    "4 SA South Africa Pretoria 1.221 52.98\n",
    "\n",
    "DataFrame from CSV file\n",
    "brics = pd.read_csv(\"path/to/brics.csv\", index_col = 0)\n",
    "brics\n",
    "country population area capital\n",
    "BR Brazil 200 8515767 Brasilia\n",
    "RU Russia 144 17098242 Moscow\n",
    "IN India 1252 3287590 New Delhi\n",
    "CH China 1357 9596961 Beijing\n",
    "SA South Africa 55 1221037 Pretoria"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Dictionary to DataFrame (1)**\n",
    "\n",
    "Pandas is an open source library, providing high-performance, easy-to-use\n",
    "data structures and data analysis tools for Python. Sounds promising!\n",
    "\n",
    "The DataFrame is one of Pandas' most important data structures. It's\n",
    "basically a way to store tabular data where you can label the rows and\n",
    "the columns. One way to build a DataFrame is from a dictionary.\n",
    "\n",
    "In the exercises that follow you will be working with vehicle data from\n",
    "different countries. Each observation corresponds to a country and the\n",
    "columns give information about the number of vehicles per capita, whether\n",
    "people drive left or right, and so on.\n",
    "\n",
    "Three lists are defined in the script:\n",
    "\n",
    "    names, containing the country names for which data is available.\n",
    "    dr, a list with booleans that tells whether people drive left or\n",
    "    right in the corresponding country.\n",
    "    cpc, the number of motor vehicles per 1000 people in the\n",
    "    corresponding country.\n",
    "\n",
    "Each dictionary key is a column label and each value is a list which\n",
    "contains the column elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pre-defined lists\n",
    "names = ['United States', 'Australia', 'Japan', 'India', 'Russia', 'Morocco', 'Egypt']\n",
    "dr =  [True, False, False, False, True, True, True]\n",
    "cpc = [809, 731, 588, 18, 200, 70, 45]\n",
    "\n",
    "# Import pandas as pd\n",
    "import pandas as pd\n",
    "\n",
    "# Create dictionary my_dict with three key:value pairs: my_dict\n",
    "my_dict = {'country':['United States', 'Australia', 'Japan', 'India', 'Russia', 'Morocco', 'Egypt'],\n",
    "        'drives_right':[True, False, False, False, True, True, True],\n",
    "        'cars_per_cap':[809, 731, 588, 18, 200, 70, 45] }\n",
    "\n",
    "# Build a DataFrame cars from my_dict: cars\n",
    "cars = pd.DataFrame(my_dict)\n",
    "\n",
    "# Print cars\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Dictionary to DataFrame (2)**\n",
    "\n",
    "The Python code that solves the previous exercise is included in the script.\n",
    "Have you noticed that the row labels (i.e. the labels for the different\n",
    "observations) were automatically set to integers from 0 up to 6?\n",
    "\n",
    "To solve this a list row_labels has been created. You can use it to specify\n",
    "the row labels of the cars DataFrame. You do this by setting the index\n",
    "attribute of cars, that you can access as cars.index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Build cars DataFrame\n",
    "names = ['United States', 'Australia', 'Japan', 'India', 'Russia', 'Morocco', 'Egypt']\n",
    "dr =  [True, False, False, False, True, True, True]\n",
    "cpc = [809, 731, 588, 18, 200, 70, 45]\n",
    "cars_dict = { 'country':names, 'drives_right':dr, 'cars_per_cap':cpc }\n",
    "cars = pd.DataFrame(cars_dict)\n",
    "print(cars)\n",
    "\n",
    "# Definition of row_labels\n",
    "row_labels = ['US', 'AUS', 'JPN', 'IN', 'RU', 'MOR', 'EG']\n",
    "\n",
    "# Specify row labels of cars\n",
    "cars.index = row_labels\n",
    "\n",
    "# Print cars again\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**CSV to DataFrame (1)**\n",
    "\n",
    "Putting data in a dictionary and then building a DataFrame works,\n",
    "but it's not very efficient. What if you're dealing with millions\n",
    "of observations? In those cases, the data is typically available\n",
    "as files with a regular structure. One of those file types is the\n",
    "CSV file, which is short for \"comma-separated values\".\n",
    "\n",
    "To import CSV data into Python as a Pandas DataFrame you can use read_csv().\n",
    "\n",
    "Let's explore this function with the same cars data from the\n",
    "previous exercises. This time, however, the data is available\n",
    "in a CSV file, named cars.csv. It is available in your current\n",
    "working directory, so the path to the file is simply 'cars.csv'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import pandas as pd\n",
    "import pandas as pd\n",
    "\n",
    "# Import the cars.csv data: cars\n",
    "cars = pd.read_csv('cars.csv')\n",
    "\n",
    "# Print out cars\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**CSV to DataFrame (2)**\n",
    "\n",
    "Your read_csv() call to import the CSV data didn't generate an error,\n",
    "but the output is not entirely what we wanted. The row labels were\n",
    "imported as another column without a name.\n",
    "\n",
    "Remember index_col, an argument of read_csv(), that you can use to\n",
    "specify which column in the CSV file should be used as a row label?\n",
    "Well, that's exactly what you need here!\n",
    "\n",
    "Python code that solves the previous exercise is already included;\n",
    "can you make the appropriate changes to fix the data import?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import pandas as pd\n",
    "import pandas as pd\n",
    "\n",
    "# Fix import by including index_col\n",
    "cars = pd.read_csv('cars.csv', index_col = 0)\n",
    "\n",
    "# Print out cars\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Pandas, Part 2**\n",
    "\n",
    "brics\n",
    "import pandas as pd\n",
    "brics = pd.read_csv(\"path/to/brics.csv\", index_col = 0)\n",
    "brics\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "\n",
    "Index and select data\n",
    "Square brackets\n",
    "Advanced methods\n",
    "loc\n",
    "iloc\n",
    "\n",
    "Column Access [ ]\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "brics[\"country\"]\n",
    "BR Brazil\n",
    "RU Russia\n",
    "IN India\n",
    "CH China\n",
    "SA South Africa\n",
    "Name: country, dtype: object\n",
    "\n",
    "Column Access [ ]\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "type(brics[\"country\"])\n",
    "pandas.core.series.Series\n",
    "1D labelled array\n",
    "\n",
    "Column Access [ ]\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "brics[[\"country\"]]\n",
    "country\n",
    "BR Brazil\n",
    "RU Russia\n",
    "IN India\n",
    "CH China\n",
    "SA South Africa\n",
    "\n",
    "Column Access [ ]\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "type(brics[[\"country\"]])\n",
    "pandas.core.frame.DataFrame\n",
    "\n",
    "Column Access [ ]\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "\n",
    "brics[[\"country\",\"capital\"]]\n",
    "country capital\n",
    "BR Brazil Brasilia\n",
    "RU Russia Moscow\n",
    "IN India New Delhi\n",
    "CH China Beijing\n",
    "SA South Africa Pretoria\n",
    "\n",
    "Row Access [ ]\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "brics[1:4]\n",
    "country capital area population\n",
    "RU Russia Moscow 17.100 143.5\n",
    "IN India New Delhi 3.286 1252.0\n",
    "CH China Beijing 9.597 1357.0\n",
    "\n",
    "Row Access [ ]\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40 * 0 *\n",
    "RU Russia Moscow 17.100 143.50 * 1 *\n",
    "IN India New Delhi 3.286 1252.00 * 2 *\n",
    "CH China Beijing 9.597 1357.00 * 3 *\n",
    "SA South Africa Pretoria 1.221 52.98 * 4 *\n",
    "brics[1:4]\n",
    "country capital area population\n",
    "RU Russia Moscow 17.100 143.5\n",
    "IN India New Delhi 3.286 1252.0\n",
    "CH China Beijing 9.597 1357.0\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Discussion [ ]\n",
    "Square brackets: limited functionality\n",
    "Ideally\n",
    "2D Numpy arrays\n",
    "my_array[rows, columns]\n",
    "pandas\n",
    "loc (label-based)\n",
    "iloc (integer position-based)\n",
    "\n",
    "Row Access loc\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "brics.loc[\"RU\"]\n",
    "country Russia\n",
    "capital Moscow\n",
    "area 17.1\n",
    "population 143.5\n",
    "Name: RU, dtype: object\n",
    "Row as pandas Series\n",
    "\n",
    "Row Access loc\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "brics.loc[[\"RU\"]]\n",
    "country capital area population\n",
    "RU Russia Moscow 17.1 143.5\n",
    "DataFrame\n",
    "\n",
    "Row Access loc\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "brics.loc[[\"RU\",\"IN\",\"CH\"]]\n",
    "country capital area population\n",
    "RU Russia Moscow 17.100 143.5\n",
    "IN India New Delhi 3.286 1252.0\n",
    "CH China Beijing 9.597 1357.0\n",
    "\n",
    "Row & Column loc\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "brics.loc[[\"RU\",\"IN\",\"CH\"], [\"country\",\"capital\"]]\n",
    "country capital\n",
    "RU Russia Moscow\n",
    "IN India New Delhi\n",
    "CH China Beijing\n",
    "\n",
    "Row & Column loc\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "brics.loc[:, [\"country\",\"capital\"]]\n",
    "country capital\n",
    "BR Brazil Brasilia\n",
    "RU Russia Moscow\n",
    "IN India New Delhi\n",
    "CH China Beijing\n",
    "SA South Africa Pretoria\n",
    "\n",
    "Recap\n",
    "Square brackets\n",
    "Column access brics[[\"country\",\"capital\"]]\n",
    "Row access: only through slicing brics[1:4]\n",
    "loc (label-based)\n",
    "Row access brics.loc[[\"RU\",\"IN\",\"CH\"]]\n",
    "Column access brics.loc[:, [\"country\",\"capital\"]]\n",
    "Row & Column access\n",
    "brics.loc[[\"RU\",\"IN\",\"CH\"],[\"country\",\"capital\"]]\n",
    "\n",
    "Row Access iloc\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "brics.loc[[\"RU\"]]\n",
    "country capital area population\n",
    "RU Russia Moscow 17.1 143.5\n",
    "brics.iloc[[1]]\n",
    "country capital area population\n",
    "RU Russia Moscow 17.1 143.5\n",
    "\n",
    "Row Access iloc\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "brics.loc[[\"RU\",\"IN\",\"CH\"]]\n",
    "country capital area population\n",
    "RU Russia Moscow 17.100 143.5\n",
    "IN India New Delhi 3.286 1252.0\n",
    "CH China Beijing 9.597 1357.0\n",
    "\n",
    "Row Access iloc\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "brics.iloc[[1,2,3]]\n",
    "country capital area population\n",
    "RU Russia Moscow 17.100 143.5\n",
    "IN India New Delhi 3.286 1252.0\n",
    "CH China Beijing 9.597 1357.0\n",
    "\n",
    "Row & Column iloc\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "brics.loc[[\"RU\",\"IN\",\"CH\"], [\"country\",\"capital\"]]\n",
    "country capital\n",
    "RU Russia Moscow\n",
    "IN India New Delhi\n",
    "CH China Beijing\n",
    "\n",
    "Row & Column iloc\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "brics.iloc[[1,2,3], [0, 1]]\n",
    "country capital\n",
    "RU Russia Moscow\n",
    "IN India New Delhi\n",
    "CH China Beijing\n",
    "\n",
    "Row & Column iloc\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "brics.loc[:, [\"country\",\"capital\"]]\n",
    "country capital\n",
    "BR Brazil Brasilia\n",
    "RU Russia Moscow\n",
    "IN India New Delhi\n",
    "CH China Beijing\n",
    "SA South Africa Pretoria\n",
    "\n",
    "Row & Column iloc\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "brics.iloc[:, [0,1]]\n",
    "country capital\n",
    "BR Brazil Brasilia\n",
    "RU Russia Moscow\n",
    "IN India New Delhi\n",
    "CH China Beijing\n",
    "SA South Africa Pretoria"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Square Brackets (1)**\n",
    "\n",
    "In the video, you saw that you can index and select Pandas DataFrames\n",
    "in many different ways. The simplest, but not the most powerful way,\n",
    "is to use square brackets.\n",
    "\n",
    "In the sample code, the same cars data is imported from a CSV files\n",
    "as a Pandas DataFrame. To select only the cars_per_cap column from\n",
    "cars, you can use:\n",
    "\n",
    "cars['cars_per_cap']\n",
    "cars[['cars_per_cap']]\n",
    "\n",
    "The single bracket version gives a Pandas Series, the double bracket\n",
    "version gives a Pandas DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import cars data\n",
    "import pandas as pd\n",
    "cars = pd.read_csv('cars.csv', index_col = 0)\n",
    "\n",
    "# Print out country column as Pandas Series\n",
    "print(cars['country'])\n",
    "\n",
    "# Print out country column as Pandas DataFrame\n",
    "print(cars[['country']])\n",
    "\n",
    "# Print out DataFrame with country and drives_right columns\n",
    "print(cars[['country', 'drives_right']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Square Brackets (2)**\n",
    "\n",
    "Square brackets can do more than just selecting columns. You can also\n",
    "use them to get rows, or observations, from a DataFrame. The following\n",
    "call selects the first five rows from the cars DataFrame:\n",
    "\n",
    "cars[0:5]\n",
    "\n",
    "The result is another DataFrame containing only the rows you specified.\n",
    "\n",
    "Pay attention: You can only select rows using square brackets if you\n",
    "specify a slice, like 0:4. Also, you're using the integer indexes of\n",
    "the rows here, not the row labels!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import cars data\n",
    "import pandas as pd\n",
    "cars = pd.read_csv('cars.csv', index_col = 0)\n",
    "\n",
    "# Print out first 3 observations\n",
    "print(cars[0:3])\n",
    "\n",
    "# Print out fourth, fifth and sixth observation\n",
    "print(cars[3:6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**loc and iloc (1)**\n",
    "\n",
    "With loc and iloc you can do practically any data selection operation\n",
    "on DataFrames you can think of. loc is label-based, which means that\n",
    "you have to specify rows and columns based on their row and column\n",
    "labels. iloc is integer index based, so you have to specify rows and\n",
    "columns by their integer index like you did in the previous exercise.\n",
    "\n",
    "Try out the following commands in the IPython Shell to experiment\n",
    "with loc and iloc to select observations. Each pair of commands here\n",
    "gives the same result.\n",
    "\n",
    "cars.loc['RU']\n",
    "cars.iloc[4]\n",
    "\n",
    "cars.loc[['RU']]\n",
    "cars.iloc[[4]]\n",
    "\n",
    "cars.loc[['RU', 'AUS']]\n",
    "cars.iloc[[4, 1]]\n",
    "\n",
    "As before, code is included that imports the cars data as a Pandas DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import cars data\n",
    "import pandas as pd\n",
    "cars = pd.read_csv('cars.csv', index_col = 0)\n",
    "\n",
    "# Print out observation for Japan\n",
    "print(cars.loc['JPN'])\n",
    "print(cars.iloc[2])\n",
    "\n",
    "# Print out observations for Australia and Egypt\n",
    "print(cars.loc[['AUS','EG']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**loc and iloc (2)**\n",
    "\n",
    "loc and iloc also allow you to select both rows and columns from a\n",
    "DataFrame. To experiment, try out the following commands in the IPython\n",
    "Shell. Again, paired commands produce the same result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cars.loc['IN', 'cars_per_cap']\n",
    "cars.iloc[3, 0]\n",
    "\n",
    "cars.loc[['IN', 'RU'], 'cars_per_cap']\n",
    "cars.iloc[[3, 4], 0]\n",
    "\n",
    "cars.loc[['IN', 'RU'], ['cars_per_cap', 'country']]\n",
    "cars.iloc[[3, 4], [0, 1]]\n",
    "\n",
    "# Import cars data\n",
    "import pandas as pd\n",
    "cars = pd.read_csv('cars.csv', index_col = 0)\n",
    "\n",
    "# Print out drives_right value of Morocco\n",
    "print(cars.loc['MOR', 'drives_right'])\n",
    "\n",
    "# Print sub-DataFrame\n",
    "print(cars.loc[['RU', 'MOR'], ['country', 'drives_right']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**loc and iloc (3)**\n",
    "\n",
    "It's also possible to select only columns with loc and iloc. In both cases,\n",
    "you simply put a slice going from beginning to end in front of the comma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cars.loc[:, 'country']\n",
    "cars.iloc[:, 1]\n",
    "\n",
    "cars.loc[:, ['country','drives_right']]\n",
    "cars.iloc[:, [1, 2]]\n",
    "\n",
    "# Import cars data\n",
    "import pandas as pd\n",
    "cars = pd.read_csv('cars.csv', index_col = 0)\n",
    "\n",
    "# Print out drives_right column as Series\n",
    "print(cars.loc[:, 'drives_right'])\n",
    "\n",
    "# Print out drives_right column as DataFrame\n",
    "print(cars.iloc[:, [2]])\n",
    "\n",
    "# Print out cars_per_cap and drives_right as DataFrame\n",
    "print(cars.loc[:, ['cars_per_cap', 'drives_right']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logic, Control Flow and Filtering (Module 03-034)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Comparison Operators**\n",
    "\n",
    "Numpy recap\n",
    "Code from Intro to Python for Data Science, Chapter 4\n",
    "import numpy as np\n",
    "np_height = np.array([1.73, 1.68, 1.71, 1.89, 1.79])\n",
    "np_weight = np.array([65.4, 59.2, 63.6, 88.4, 68.7])\n",
    "bmi = np_weight / np_height ** 2\n",
    "bmi\n",
    "array([ 21.852, 20.975, 21.75 , 24.747, 21.441])\n",
    "bmi > 23\n",
    "array([False, False, False, True, False], dtype=bool)\n",
    "bmi[bmi > 23]\n",
    "array([ 24.747])\n",
    "Comparison operators: how Python values relate\n",
    "\n",
    "Numeric comparisons\n",
    "2 < 3\n",
    "True\n",
    "2 == 3\n",
    "False\n",
    "2 <= 3\n",
    "True\n",
    "3 <= 3\n",
    "True\n",
    "x = 2\n",
    "y = 3\n",
    "x < y\n",
    "True\n",
    "\n",
    "Other comparisons\n",
    "\"carl\" < \"chris\"\n",
    "True\n",
    "3 < \"chris\"\n",
    "TypeError: unorderable types: int() < str()\n",
    "3 < 4.1\n",
    "True\n",
    "\n",
    "Other comparisons\n",
    "bmi\n",
    "array([21.852, 20.975, 21.75 , 24.747, 21.441])\n",
    "bmi > 23\n",
    "array([False, False, False, True, False], dtype=bool)\n",
    "\n",
    "Comparators\n",
    "Comparator Meaning\n",
    "< Strictly less than\n",
    "<= Less than or equal\n",
    "> Strictly greater than\n",
    ">= Greater than or equal\n",
    "== Equal\n",
    "!= Not equal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Equality**\n",
    "\n",
    "To check if two Python values, or variables, are equal you can use ==.\n",
    "To check for inequality, you need !=. As a refresher, have a look at\n",
    "the following examples that all result in True. Feel free to try them\n",
    "out in the IPython Shell.\n",
    "\n",
    "2 == (1 + 1)\n",
    "\"intermediate\" != \"python\"\n",
    "True != False\n",
    "\"Python\" != \"python\"\n",
    "\n",
    "When you write these comparisons in a script, you will need to wrap a\n",
    "print() function around them to see the output.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Comparison of booleans\n",
    "print(True == False)\n",
    "\n",
    "# Comparison of integers\n",
    "print(-5 * 15 != 75)\n",
    "\n",
    "\n",
    "# Comparison of strings\n",
    "print(\"pyscript\" == \"PyScript\")\n",
    "\n",
    "\n",
    "# Compare a boolean with an integer\n",
    "print(True == 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Greater and less than**\n",
    "\n",
    "In the video, Hugo also talked about the less than and greater than signs,\n",
    "< and > in Python. You can combine them with an equals sign: <= and >=.\n",
    "Pay attention: <= is valid syntax, but =< is not.\n",
    "\n",
    "All Python expressions in the following code chunk evaluate to True:\n",
    "\n",
    "3 < 4\n",
    "3 <= 4\n",
    "\"alpha\" <= \"beta\"\n",
    "\n",
    "Remember that for string comparison, Python determines the relationship\n",
    "based on alphabetical order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Comparison of integers\n",
    "x = -3 * 6\n",
    "print(x >= -10)\n",
    "\n",
    "# Comparison of strings\n",
    "y = \"test\"\n",
    "print(\"test\" <= y)\n",
    "\n",
    "# Comparison of booleans\n",
    "print(True > False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Compare arrays**\n",
    "\n",
    "Out of the box, you can also use comparison operators with Numpy arrays.\n",
    "\n",
    "Remember areas, the list of area measurements for different rooms in your\n",
    "house from Introduction to Python? This time there's two Numpy arrays:\n",
    "my_house and your_house. They both contain the areas for the kitchen,\n",
    "living room, bedroom and bathroom in the same order, so you can compare them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create arrays\n",
    "import numpy as np\n",
    "my_house = np.array([18.0, 20.0, 10.75, 9.50])\n",
    "your_house = np.array([14.0, 24.0, 14.25, 9.0])\n",
    "\n",
    "# my_house greater than or equal to 18\n",
    "print(my_house >= 18)\n",
    "\n",
    "# my_house less than your_house\n",
    "print(my_house < your_house)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Boolean Operators**\n",
    "\n",
    "Boolean Operators\n",
    "and\n",
    "or\n",
    "not\n",
    "\n",
    "and\n",
    "True and True\n",
    "True\n",
    "x = 12\n",
    "x > 5 and x < 15\n",
    "True True\n",
    "True\n",
    "False and True\n",
    "False\n",
    "True and False\n",
    "False\n",
    "False and False\n",
    "False\n",
    "\n",
    "or\n",
    "True or True\n",
    "True\n",
    "False or True\n",
    "True\n",
    "True or False\n",
    "True\n",
    "False or False\n",
    "False\n",
    "y = 5\n",
    "y < 7 or y > 13\n",
    "True\n",
    "\n",
    "not\n",
    "not True\n",
    "False\n",
    "not False\n",
    "True\n",
    "\n",
    "NumPy\n",
    "bmi # calculation of bmi left out\n",
    "array([21.852, 20.975, 21.75 , 24.747, 21.441])\n",
    "bmi > 21\n",
    "array([True, False, True, True, True], dtype=bool)\n",
    "bmi < 22\n",
    "array([True, True, True, False, True], dtype=bool)\n",
    "bmi > 21 and bmi < 22\n",
    "ValueError: The truth value of an array with more than one element is\n",
    "ambiguous. Use a.any() or a.all()\n",
    "\n",
    "NumPy\n",
    "logical_and()\n",
    "logical_or()\n",
    "logical_not()\n",
    "\n",
    "np.logical_and(bmi > 21, bmi < 22)\n",
    "array([True, False, True, False, True], dtype=bool)\n",
    "bmi[np.logical_and(bmi > 21, bmi < 22)]\n",
    "array([21.852, 21.75, 21.441])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**and, or, not (1)**\n",
    "\n",
    "A boolean is either 1 or 0, True or False. With boolean operators such as and,\n",
    "or and not, you can combine these booleans to perform more advanced queries on\n",
    "your data.\n",
    "\n",
    "In the sample code, two variables are defined: my_kitchen and your_kitchen,\n",
    "representing areas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define variables\n",
    "my_kitchen = 18.0\n",
    "your_kitchen = 14.0\n",
    "\n",
    "# my_kitchen bigger than 10 and smaller than 18?\n",
    "print(my_kitchen>10 and my_kitchen<18)\n",
    "\n",
    "# my_kitchen smaller than 14 or bigger than 17?\n",
    "print(my_kitchen<14 or my_kitchen>17)\n",
    "\n",
    "# Double my_kitchen smaller than triple your_kitchen?\n",
    "print(my_kitchen*2 < your_kitchen*3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Boolean operators with Numpy**\n",
    "\n",
    "Before, the operational operators like < and >= worked with Numpy arrays\n",
    "out of the box. Unfortunately, this is not true for the boolean operators\n",
    "and, or, and not.\n",
    "\n",
    "To use these operators with Numpy, you will need np.logical_and(),\n",
    "np.logical_or() and np.logical_not(). Here's an example on the my_house\n",
    "and your_house arrays from before to give you an idea:\n",
    "\n",
    "np.logical_and(my_house > 13,\n",
    "               your_house < 15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create arrays\n",
    "import numpy as np\n",
    "my_house = np.array([18.0, 20.0, 10.75, 9.50])\n",
    "your_house = np.array([14.0, 24.0, 14.25, 9.0])\n",
    "\n",
    "# my_house greater than 18.5 or smaller than 10\n",
    "print(np.logical_or(my_house > 18.5, your_house < 10))\n",
    "\n",
    "# Both my_house and your_house smaller than 11\n",
    "print(np.logical_and(my_house < 11, your_house < 11))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **if, elif, else**\n",
    "\n",
    "Overview\n",
    "Comparison Operators\n",
    "< , > , >=, <=,==, !=\n",
    "Boolean Operators\n",
    "and , or , not\n",
    "Conditional Statements\n",
    "if , else , elif\n",
    "\n",
    "if\n",
    "if condition :\n",
    "expression\n",
    "control.py\n",
    "z = 4\n",
    "if z % 2 == 0 : # True\n",
    "print(\"z is even\")\n",
    "z is even\n",
    "\n",
    "if\n",
    "if condition :\n",
    "expression\n",
    "expression not part of if\n",
    "control.py\n",
    "z = 4\n",
    "if z % 2 == 0 : # True\n",
    "print(\"z is even\")\n",
    "z is even\n",
    "\n",
    "if\n",
    "if condition :\n",
    "expression\n",
    "control.py\n",
    "z = 4\n",
    "if z % 2 == 0 :\n",
    "print(\"checking \" + str(z))\n",
    "print(\"z is even\")\n",
    "checking 4\n",
    "z is even\n",
    "\n",
    "if\n",
    "if condition :\n",
    "expression\n",
    "control.py\n",
    "z = 5\n",
    "if z % 2 == 0 : # False\n",
    "print(\"checking \" + str(z))\n",
    "print(\"z is even\")\n",
    "\n",
    "else\n",
    "if condition :\n",
    "expression\n",
    "else :\n",
    "expression\n",
    "control.py\n",
    "z = 5\n",
    "if z % 2 == 0 : # False\n",
    "print(\"z is even\")\n",
    "else :\n",
    "print(\"z is odd\")\n",
    "z is odd\n",
    "\n",
    "elif\n",
    "if condition :\n",
    "expression\n",
    "elif condition :\n",
    "expression\n",
    "else :\n",
    "expression\n",
    "control.py\n",
    "z = 3\n",
    "if z % 2 == 0 :\n",
    "print(\"z is divisible by 2\") # False\n",
    "elif z % 3 == 0 :\n",
    "print(\"z is divisible by 3\") # True\n",
    "else :\n",
    "print(\"z is neither divisible by 2 nor by 3\")\n",
    "z is divisible by 3\n",
    "\n",
    "elif\n",
    "if condition :\n",
    "expression\n",
    "elif condition :\n",
    "expression\n",
    "else :\n",
    "expression\n",
    "\n",
    "control.py\n",
    "z = 6\n",
    "if z % 2 == 0 :\n",
    "print(\"z is divisible by 2\") # True\n",
    "elif z % 3 == 0 :\n",
    "print(\"z is divisible by 3\") # Never reached\n",
    "else :\n",
    "print(\"z is neither divisible by 2 nor by 3\")\n",
    "z is divisible by 2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Warmup**\n",
    "\n",
    "To experiment with if and else a bit, have a look at this code sample:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "area = 10.0\n",
    "if(area < 9) :\n",
    "    print(\"small\")\n",
    "elif(area < 12) :\n",
    "    print(\"medium\")\n",
    "else :\n",
    "    print(\"large\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**if**\n",
    "\n",
    "It's time to take a closer look around in your house.\n",
    "\n",
    "Two variables are defined in the sample code: room, a string that\n",
    "tells you which room of the house we're looking at, and area, the\n",
    "area of that room."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define variables\n",
    "room = \"kit\"\n",
    "area = 14.0\n",
    "\n",
    "# if statement for room\n",
    "if room == \"kit\" :\n",
    "    print(\"looking around in the kitchen.\")\n",
    "\n",
    "# if statement for area\n",
    "if area > 15 :\n",
    "    print(\"big place!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Add else**\n",
    "\n",
    "In the script, the if construct for room has been extended with an else\n",
    "statement so that \"looking around elsewhere.\" is printed if the condition\n",
    "room == \"kit\" evaluates to False.\n",
    "\n",
    "Can you do a similar thing to add more functionality to the if construct for area?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define variables\n",
    "room = \"kit\"\n",
    "area = 14.0\n",
    "\n",
    "# if-else construct for room\n",
    "if room == \"kit\" :\n",
    "    print(\"looking around in the kitchen.\")\n",
    "else :\n",
    "    print(\"looking around elsewhere.\")\n",
    "\n",
    "# if-else construct for area\n",
    "if area > 15 :\n",
    "    print(\"big place!\")\n",
    "else :\n",
    "    print(\"pretty small.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Customize further: elif**\n",
    "\n",
    "It's also possible to have a look around in the bedroom. The sample code\n",
    "contains an elif part that checks if room equals \"bed\". In that case,\n",
    "\"looking around in the bedroom.\" is printed out.\n",
    "\n",
    "It's up to you now! Make a similar addition to the second control structure\n",
    "to further customize the messages for different values of area."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define variables\n",
    "room = \"bed\"\n",
    "area = 14.0\n",
    "\n",
    "# if-elif-else construct for room\n",
    "if room == \"kit\" :\n",
    "    print(\"looking around in the kitchen.\")\n",
    "elif room == \"bed\":\n",
    "    print(\"looking around in the bedroom.\")\n",
    "else :\n",
    "    print(\"looking around elsewhere.\")\n",
    "\n",
    "# if-elif-else construct for area\n",
    "if area > 15 :\n",
    "    print(\"big place!\")\n",
    "elif area > 10:\n",
    "    print(\"medium size, nice!\")\n",
    "else :\n",
    "    print(\"pretty small.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Filtering pandas DataFrames**\n",
    "\n",
    "ics\n",
    "import pandas as pd\n",
    "brics = pd.read_csv(\"path/to/brics.csv\", index_col = 0)\n",
    "brics\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "\n",
    "Goal\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "Select countries with area over 8 million km2\n",
    "3 steps\n",
    "Select the area column\n",
    "Do comparison on area column\n",
    "Use result to select countries\n",
    "\n",
    "Step 1: Get column\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "brics[\"area\"]\n",
    "BR 8.516\n",
    "RU 17.100\n",
    "IN 3.286\n",
    "CH 9.597\n",
    "SA 1.221\n",
    "Name: area, dtype: float64 # - Need Pandas Series\n",
    "Alternatives:\n",
    "brics.loc[:,\"area\"]\n",
    "brics.iloc[:,2]\n",
    "\n",
    "Step 2: Compare\n",
    "brics[\"area\"]\n",
    "BR 8.516\n",
    "RU 17.100\n",
    "IN 3.286\n",
    "CH 9.597\n",
    "SA 1.221\n",
    "Name: area, dtype: float64\n",
    "brics[\"area\"] > 8\n",
    "BR True\n",
    "RU True\n",
    "IN False\n",
    "CH True\n",
    "SA False\n",
    "Name: area, dtype: bool\n",
    "is_huge = brics[\"area\"] > 8\n",
    "\n",
    "Step 3: Subset DF\n",
    "is_huge\n",
    "BR True\n",
    "RU True\n",
    "IN False\n",
    "CH True\n",
    "SA False\n",
    "Name: area, dtype: bool\n",
    "brics[is_huge]\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.4\n",
    "RU Russia Moscow 17.100 143.5\n",
    "CH China Beijing 9.597 1357.0\n",
    "\n",
    "Summary\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.988\n",
    "is_huge = brics[\"area\"] > 8\n",
    "brics[is_huge]\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.4\n",
    "RU Russia Moscow 17.100 143.5\n",
    "CH China Beijing 9.597 1357.0\n",
    "brics[brics[\"area\"] > 8]\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.4\n",
    "RU Russia Moscow 17.100 143.5\n",
    "CH China Beijing 9.597 1357.0\n",
    "\n",
    "Boolean operators\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "import numpy as np\n",
    "np.logical_and(brics[\"area\"] > 8, brics[\"area\"] < 10)\n",
    "BR True\n",
    "RU False\n",
    "IN False\n",
    "CH True\n",
    "SA False\n",
    "Name: area, dtype: bool\n",
    "brics[np.logical_and(brics[\"area\"] > 8, brics[\"area\"] < 10)]\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.4\n",
    "CH China Beijing 9.597 1357.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Driving right (1)**\n",
    "\n",
    "Remember that cars dataset, containing the cars per 1000 people (cars_per_cap)\n",
    "and whether people drive right (drives_right) for different countries (country)?\n",
    "The code that imports this data in CSV format into Python as a DataFrame is\n",
    "included in the script.\n",
    "\n",
    "In the video, you saw a step-by-step approach to filter observations from\n",
    "DataFrame based on boolean arrays. Let's start simple and try to find all\n",
    "observations in cars where drives_right is True.\n",
    "\n",
    "drives_right is a boolean column, so you'll have to extract it as a Series\n",
    "and then use this boolean Series to select observations from cars."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import cars data\n",
    "import pandas as pd\n",
    "cars = pd.read_csv('cars.csv', index_col = 0)\n",
    "\n",
    "# Extract drives_right column as Series: dr\n",
    "dr = cars.iloc[:,2]\n",
    "\n",
    "# Use dr to subset cars: sel\n",
    "sel = cars[dr]\n",
    "\n",
    "# Print sel\n",
    "print(sel)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Driving right (2)**\n",
    "\n",
    "The code in the previous example worked fine, but you actually\n",
    "unnecessarily created a new variable dr. You can achieve the\n",
    "same result without this intermediate variable. Put the code that\n",
    "computes dr straight into the square brackets that select\n",
    "observations from cars."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import cars data\n",
    "import pandas as pd\n",
    "cars = pd.read_csv('cars.csv', index_col = 0)\n",
    "\n",
    "# Convert code to a one-liner\n",
    "sel = cars[cars['drives_right']]\n",
    "\n",
    "# Print sel\n",
    "print(sel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Cars per capita (1)**\n",
    "\n",
    "Let's stick to the cars data some more. This time you want to find out\n",
    "which countries have a high cars per capita figure. In other words, in\n",
    "which countries do many people have a car, or maybe multiple cars.\n",
    "\n",
    "Similar to the previous example, you'll want to build up a boolean Series,\n",
    "that you can then use to subset the cars DataFrame to select certain\n",
    "observations. If you want to do this in a one-liner, that's perfectly fine!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import cars data\n",
    "import pandas as pd\n",
    "cars = pd.read_csv('cars.csv', index_col = 0)\n",
    "\n",
    "# Create car_maniac: observations that have a cars_per_cap over 500\n",
    "car_maniac = cars[cars['cars_per_cap']>500]\n",
    "\n",
    "# Print car_maniac\n",
    "print(car_maniac)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Cars per capita (2)**\n",
    "\n",
    "Remember about np.logical_and(), np.logical_or() and np.logical_not(),\n",
    "the Numpy variants of the and, or and not operators? You can also use\n",
    "them on Pandas Series to do more advanced filtering operations.\n",
    "\n",
    "Take this example that selects the observations that have a cars_per_cap\n",
    "between 10 and 80. Try out these lines of code step by step to see what's\n",
    "happening."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cpc = cars['cars_per_cap']\n",
    "between = np.logical_and(cpc > 10, cpc < 80)\n",
    "medium = cars[between]\n",
    "\n",
    "# Import cars data\n",
    "import pandas as pd\n",
    "cars = pd.read_csv('cars.csv', index_col = 0)\n",
    "\n",
    "# Import numpy, you'll need this\n",
    "import numpy as np\n",
    "\n",
    "# Create medium: observations with cars_per_cap between 100 and 500\n",
    "cpc = cars['cars_per_cap']\n",
    "between = np.logical_and(cpc > 100, cpc < 500)\n",
    "medium = cars[between]\n",
    "\n",
    "# Print medium\n",
    "print(medium)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops (Module 04-034)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **While loop**\n",
    "\n",
    "while loop\n",
    "\n",
    "    if -elif - else\n",
    "    control.py\n",
    "    Goes\n",
    "    through\n",
    "    construct\n",
    "    only\n",
    "    once!\n",
    "    z = 6\n",
    "    if z % 2 == 0:  # True\n",
    "        print(\"z is divisible by 2\")  # Executed\n",
    "    elif z % 3 == 0:\n",
    "        print(\"z is divisible by 3\")\n",
    "    else:\n",
    "    print(\"z is neither divisible by 2 nor by 3\")\n",
    "    ...  # Moving on\n",
    "    While\n",
    "    loop = repeated if statement\n",
    "\n",
    "While\n",
    "while condition :\n",
    "expression\n",
    "Numerically calculating model\n",
    "\"repeating action until condition is met\"\n",
    "Example\n",
    "Error starts at 50\n",
    "Divide error by 4 on every run\n",
    "Continue until error no longer > 1\n",
    "\n",
    "While\n",
    "while condition :\n",
    "expression\n",
    "while\n",
    "_\n",
    "loop.py\n",
    "error = 50.0\n",
    "while error > 1:\n",
    "error = error / 4\n",
    "print(error)\n",
    "Error starts at 50\n",
    "Divide error by 4 on every run\n",
    "Continue until error no longer > 1\n",
    "\n",
    "While\n",
    "while condition :\n",
    "expression\n",
    "while_loop.py\n",
    "error = 50.0\n",
    "50\n",
    "while error > 1: # True\n",
    "error = error / 4\n",
    "print(error)\n",
    "12.5\n",
    "\n",
    "While\n",
    "while condition :\n",
    "expression\n",
    "while_loop.py\n",
    "error = 50.0\n",
    "12.5\n",
    "while error > 1: # True\n",
    "error = error / 4\n",
    "print(error)\n",
    "12.5\n",
    "3.125\n",
    "\n",
    "While\n",
    "while condition :\n",
    "expression\n",
    "while_loop.py\n",
    "error = 50.0\n",
    "3.125\n",
    "while error > 1: # True\n",
    "    error = error / 4\n",
    "print(error)\n",
    "12.5\n",
    "3.125\n",
    "0.78125\n",
    "\n",
    "While\n",
    "while condition :\n",
    "expression\n",
    "while_loop.py\n",
    "error = 50.0\n",
    "0.78125\n",
    "while error > 1: # False\n",
    "error = error / 4\n",
    "print(error)\n",
    "12.5\n",
    "3.125\n",
    "0.78125\n",
    "\n",
    "While\n",
    "while condition :\n",
    "expression\n",
    "while_loop.py\n",
    "error = 50.0\n",
    "while error > 1 : # always True\n",
    "error = error / 4\n",
    "print(error)\n",
    "50\n",
    "50\n",
    "50\n",
    "50\n",
    "50\n",
    "50\n",
    "50\n",
    "...\n",
    "DataCamp: session\n",
    "disconnected\n",
    "Local system: Control + C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**while: warming up**\n",
    "\n",
    "The while loop is like a repeated if statement. The code is executed over and over again, as long as the condition is True. Have another look at its recipe.\n",
    "\n",
    "while condition :\n",
    "    expression\n",
    "\n",
    "Can you tell how many printouts the following while loop will do?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "while x < 4 :\n",
    "    print(x)\n",
    "    x = x + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Basic while loop**\n",
    "\n",
    "Below you can find the example from the video where the error variable,\n",
    "initially equal to 50.0, is divided by 4 and printed out on every run:\n",
    "\n",
    "error = 50.0\n",
    "while error > 1 :\n",
    "    error = error / 4\n",
    "    print(error)\n",
    "\n",
    "This example will come in handy, because it's time to build a while loop\n",
    "yourself! We're going to code a while loop that implements a very basic\n",
    "control system for an inverted pendulum. If there's an offset from standing\n",
    "perfectly straight, the while loop will incrementally fix this offset.\n",
    "\n",
    "Note that if your while loop takes too long to run, you might have made\n",
    "a mistake. In particular, remember to indent the contents of the loop!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize offset\n",
    "offset = 8\n",
    "\n",
    "# Code the while loop\n",
    "while offset != 0 :\n",
    "    print(\"correcting...\")\n",
    "    offset = offset - 1\n",
    "    print(offset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Add conditionals**\n",
    "\n",
    "The while loop that corrects the offset is a good start, but what if offset\n",
    "negative? You can try to run the following code where offset is initialized\n",
    "to -6:\n",
    "\n",
    "Initialize offset\n",
    "offset = -6\n",
    "\n",
    "Code the while loop\n",
    "while offset != 0 :\n",
    "    print(\"correcting...\")\n",
    "    offset = offset - 1\n",
    "    print(offset)\n",
    "\n",
    "but your session will be disconnected. The while loop will never stop running,\n",
    "because offset will be further decreased on every run. offset != 0 will never\n",
    "become False and the while loop continues forever.\n",
    "\n",
    "Fix things by putting an if-else statement inside the while loop. If your code\n",
    "is still taking too long to run, you probably made a mistake!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize offset\n",
    "offset = -6\n",
    "\n",
    "# Code the while loop\n",
    "while offset != 0 :\n",
    "    print(\"correcting...\")\n",
    "    if offset > 0 :\n",
    "      offset = offset - 1\n",
    "    else :\n",
    "      offset = offset + 1\n",
    "    print(offset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **for loop**\n",
    "\n",
    "    for loop\n",
    "        for var in seq:\n",
    "            expression\n",
    "    \"for each var in seq, execute expression\"\n",
    "\n",
    "fam\n",
    "family.py\n",
    "fam = [1.73, 1.68, 1.71, 1.89]\n",
    "print(fam)\n",
    "[1.73, 1.68, 1.71, 1.89]\n",
    "\n",
    "fam\n",
    "family.py\n",
    "fam = [1.73, 1.68, 1.71, 1.89]\n",
    "print(fam[0])\n",
    "print(fam[1])\n",
    "print(fam[2])\n",
    "print(fam[3])\n",
    "1.73\n",
    "1.68\n",
    "1.71\n",
    "1.89\n",
    "\n",
    "for loop\n",
    "for var in seq :\n",
    "expression\n",
    "family.py\n",
    "fam = [1.73, 1.68, 1.71, 1.89]\n",
    "for height in fam :\n",
    "print(height)\n",
    "\n",
    "for loop\n",
    "for var in seq :\n",
    "expression\n",
    "family.py\n",
    "fam = [1.73, 1.68, 1.71, 1.89]\n",
    "for height in fam :\n",
    "print(height)\n",
    "first iteration\n",
    "height = 1.73\n",
    "1.73\n",
    "\n",
    "for loop\n",
    "for var in seq :\n",
    "expression\n",
    "family.py\n",
    "fam = [1.73, 1.68, 1.71, 1.89]\n",
    "for height in fam :\n",
    "print(height)\n",
    "second iteration\n",
    "height = 1.68\n",
    "1.73\n",
    "1.68\n",
    "\n",
    "for loop\n",
    "for var in seq :\n",
    "expression\n",
    "family.py\n",
    "fam = [1.73, 1.68, 1.71, 1.89]\n",
    "for height in fam :\n",
    "print(height)\n",
    "1.73\n",
    "1.68\n",
    "1.71\n",
    "1.89\n",
    "No access to indexes\n",
    "\n",
    "for loop\n",
    "for var in seq :\n",
    "expression\n",
    "family.py\n",
    "fam = [1.73, 1.68, 1.71, 1.89]\n",
    "???\n",
    "index 0: 1.73\n",
    "index 1: 1.68\n",
    "index 2: 1.71\n",
    "index 3: 1.89\n",
    "\n",
    "enumerate\n",
    "for var in seq :\n",
    "expression\n",
    "family.py\n",
    "fam = [1.73, 1.68, 1.71, 1.89]\n",
    "for index, height in enumerate(fam) :\n",
    "print(\"index \" + str(index) + \": \" + str(height))\n",
    "index 0: 1.73\n",
    "index 1: 1.68\n",
    "index 2: 1.71\n",
    "index 3: 1.89\n",
    "\n",
    "Loop over string\n",
    "for var in seq :\n",
    "expression\n",
    "strloop.py\n",
    "for c in \"family\" :\n",
    "print(c.capitalize())\n",
    "F\n",
    "A\n",
    "M\n",
    "I\n",
    "L\n",
    "Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Loop over a list**\n",
    "\n",
    "Have another look at the for loop that Hugo showed in the video:\n",
    "\n",
    "fam = [1.73, 1.68, 1.71, 1.89]\n",
    "for height in fam :\n",
    "    print(height)\n",
    "\n",
    "As usual, you simply have to indent the code with 4 spaces to tell Python\n",
    "which code should be executed in the for loop.\n",
    "\n",
    "The areas variable, containing the area of different rooms in your house,\n",
    "is already defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# areas list\n",
    "areas = [11.25, 18.0, 20.0, 10.75, 9.50]\n",
    "\n",
    "# Code the for loop\n",
    "for areas in areas :\n",
    "    print(areas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Indexes and values (1)**\n",
    "\n",
    "Using a for loop to iterate over a list only gives you access to every\n",
    "list element in each run, one after the other. If you also want to access\n",
    "the index information, so where the list element you're iterating over\n",
    "is located, you can use enumerate().\n",
    "\n",
    "As an example, have a look at how the for loop from the video was converted:\n",
    "\n",
    "fam = [1.73, 1.68, 1.71, 1.89]\n",
    "for index, height in enumerate(fam) :\n",
    "    print(\"person \" + str(index) + \": \" + str(height))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# areas list\n",
    "areas = [11.25, 18.0, 20.0, 10.75, 9.50]\n",
    "\n",
    "# Change for loop to use enumerate() and update print()\n",
    "for index, area in enumerate(areas) :\n",
    "    print(\"room \" + str(index) + \": \" + str(area))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Indexes and values (2)**\n",
    "\n",
    "For non-programmer folks, room 0: 11.25 is strange. Wouldn't it be better\n",
    "if the count started at 1?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# areas list\n",
    "areas = [11.25, 18.0, 20.0, 10.75, 9.50]\n",
    "\n",
    "# Code the for loop\n",
    "for index, area in enumerate(areas) :\n",
    "    print(\"room \" + str(index+1) + \": \" + str(area))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Loop over list of lists**\n",
    "\n",
    "Remember the house variable from the Intro to Python course?\n",
    "Have a look at its definition in the script. It's basically a\n",
    "list of lists, where each sublist contains the name and area\n",
    "of a room in your house.\n",
    "\n",
    "It's up to you to build a for loop from scratch this time!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# house list of lists\n",
    "house = [[\"hallway\", 11.25],\n",
    "         [\"kitchen\", 18.0],\n",
    "         [\"living room\", 20.0],\n",
    "         [\"bedroom\", 10.75],\n",
    "         [\"bathroom\", 9.50]]\n",
    "\n",
    "# Build a for loop from scratch\n",
    "for room in house:\n",
    "    print(\"the \" + str(room[0]) + \" is \" + str(room[1]) + \" sqm\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Loop Data Structures Part 1**\n",
    "\n",
    "Dictionary\n",
    "for var in seq :\n",
    "expression\n",
    "dictloop.py\n",
    "world = { \"afghanistan\":30.55,\n",
    "\"albania\":2.77,\n",
    "\"algeria\":39.21 }\n",
    "for key, value in world :\n",
    "print(key + \"--\" + str(value))\n",
    "ValueError: too many values to\n",
    "unpack (expected 2)\n",
    "\n",
    "Dictionary\n",
    "for var in seq :\n",
    "expression\n",
    "dictloop.py\n",
    "world = { \"afghanistan\":30.55,\n",
    "\"albania\":2.77,\n",
    "\"algeria\":39.21 }\n",
    "for key, value in world.items() :\n",
    "print(key + \"--\" + str(value))\n",
    "algeria -- 39.21\n",
    "afghanistan -- 30.55\n",
    "albania -- 2.77\n",
    "\n",
    "Dictionary\n",
    "for var in seq :\n",
    "expression\n",
    "dictloop.py\n",
    "world = { \"afghanistan\":30.55,\n",
    "\"albania\":2.77,\n",
    "\"algeria\":39.21 }\n",
    "for k, v in world.items() :\n",
    "print(k + \"--\" + str(v))\n",
    "algeria -- 39.21\n",
    "afghanistan -- 30.55\n",
    "albania -- 2.77\n",
    "\n",
    "Numpy Arrays\n",
    "for var in seq :\n",
    "expression\n",
    "nploop.py\n",
    "import numpy as np\n",
    "np_height = np.array([1.73, 1.68, 1.71, 1.89, 1.79])\n",
    "np_weight = np.array([65.4, 59.2, 63.6, 88.4, 68.7])\n",
    "bmi = np_weight / np_height ** 2\n",
    "for val in bmi :\n",
    "print(val)\n",
    "21.852\n",
    "20.975\n",
    "21.750\n",
    "24.747\n",
    "21.441\n",
    "\n",
    "2D Numpy Arrays\n",
    "nploop.py\n",
    "import numpy as np\n",
    "np_height = np.array([1.73, 1.68, 1.71, 1.89, 1.79])\n",
    "np_weight = np.array([65.4, 59.2, 63.6, 88.4, 68.7])\n",
    "meas = np.array([np_height, np_weight])\n",
    "for val in meas :\n",
    "print(val)\n",
    "[ 1.73 1.68 1.71 1.89 1.79]\n",
    "[ 65.4 59.2 63.6 88.4 68.7]\n",
    "\n",
    "2D Numpy Arrays\n",
    "nploop.py\n",
    "import numpy as np\n",
    "np_height = np.array([1.73, 1.68, 1.71, 1.89, 1.79])\n",
    "np_weight = np.array([65.4, 59.2, 63.6, 88.4, 68.7])\n",
    "meas = np.array([np_height, np_weight])\n",
    "for val in np.nditer(meas) :\n",
    "print(val)\n",
    "1.73\n",
    "1.68\n",
    "1.71\n",
    "1.89\n",
    "1.79\n",
    "65.4\n",
    "...\n",
    "\n",
    "Recap\n",
    "Dictionary\n",
    "for key, val in my_\n",
    "dict.items() :\n",
    "Numpy array\n",
    "for val in np.nditer(my_array) :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Loop over dictionary**\n",
    "\n",
    "In Python 3, you need the items() method to loop over a dictionary:\n",
    "\n",
    "world = { \"afghanistan\":30.55,\n",
    "          \"albania\":2.77,\n",
    "          \"algeria\":39.21 }\n",
    "\n",
    "for key, value in world.items() :\n",
    "    print(key + \" -- \" + str(value))\n",
    "\n",
    "Remember the europe dictionary that contained the names of some European\n",
    "countries as key and their capitals as corresponding value? Go ahead and\n",
    "write a loop to iterate over it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definition of dictionary\n",
    "europe = {'spain': 'madrid', 'france': 'paris', 'germany': 'berlin',\n",
    "          'norway': 'oslo', 'italy': 'rome', 'poland': 'warsaw', 'austria': 'vienna'}\n",
    "\n",
    "# Iterate over europe\n",
    "for key, value in europe.items():\n",
    "    print(\"the capital of \" + key + \" is \" + str(value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Loop over Numpy array**\n",
    "\n",
    "If you're dealing with a 1D Numpy array, looping over all elements can\n",
    "be as simple as:\n",
    "\n",
    "for x in my_array :\n",
    "    ...\n",
    "\n",
    "If you're dealing with a 2D Numpy array, it's more complicated. A 2D\n",
    "array is built up of multiple 1D arrays. To explicitly iterate over\n",
    "all separate elements of a multi-dimensional array, you'll need this\n",
    "syntax:\n",
    "\n",
    "for x in np.nditer(my_array) :\n",
    "    ...\n",
    "\n",
    "Two Numpy arrays that you might recognize from the intro course are\n",
    "available in your Python session: np_height, a Numpy array containing\n",
    "the heights of Major League Baseball players, and np_baseball, a 2D\n",
    "Numpy array that contains both the heights (first column) and weights\n",
    "(second column) of those players."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Import numpy as np\n",
    "import numpy as np\n",
    "\n",
    "# For loop over np_height\n",
    "for val in np_height :\n",
    "    print(str(val) + \" inches\")\n",
    "\n",
    "# For loop over np_baseball\n",
    "for val in np.nditer(np_baseball) :\n",
    "    print(val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Loop Data Structures Part 2**\n",
    "\n",
    "brics\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98\n",
    "dfloop.py\n",
    "import pandas as pd\n",
    "brics = pd.read_csv(\"brics.csv\", index_col = 0)\n",
    "\n",
    "for, first try\n",
    "dfloop.py\n",
    "import pandas as pd\n",
    "brics = pd.read_csv(\"brics.csv\", index_col = 0)\n",
    "for val in brics :\n",
    "print(val)\n",
    "country\n",
    "capital\n",
    "area\n",
    "population\n",
    "\n",
    "iterrows\n",
    "dfloop.py\n",
    "import pandas as pd\n",
    "brics = pd.read_csv(\"brics.csv\", index_col = 0)\n",
    "for lab, row in brics.iterrows():\n",
    "print(lab)\n",
    "print(row)\n",
    "BR\n",
    "country Brazil\n",
    "capital Brasilia\n",
    "area 8.516\n",
    "population 200.4\n",
    "Name: BR, dtype: object\n",
    "...\n",
    "RU\n",
    "country Russia\n",
    "capital Moscow\n",
    "area 17.1\n",
    "population 143.5\n",
    "Name: RU, dtype: object\n",
    "IN ...\n",
    "\n",
    "Selective print\n",
    "dfloop.py\n",
    "import pandas as pd\n",
    "brics = pd.read_csv(\"brics.csv\", index_col = 0)\n",
    "for lab, row in brics.iterrows():\n",
    "print(lab + \": \" + row[\"capital\"])\n",
    "BR: Brasilia\n",
    "RU: Moscow\n",
    "IN: New Delhi\n",
    "CH: Beijing\n",
    "SA: Pretoria\n",
    "\n",
    "Add column\n",
    "dfloop.py\n",
    "import pandas as pd\n",
    "brics = pd.read_csv(\"brics.csv\", index_col = 0)\n",
    "for lab, row in brics.iterrows() :\n",
    "- Creating Series on every iteration\n",
    "brics.loc[lab,\"name_length\"] = len(row[\"country\"])\n",
    "print(brics)\n",
    "country capital area population name_length\n",
    "BR Brazil Brasilia 8.516 200.40 6\n",
    "RU Russia Moscow 17.100 143.50 6\n",
    "IN India New Delhi 3.286 1252.00 5\n",
    "CH China Beijing 9.597 1357.00 5\n",
    "SA South Africa Pretoria 1.221 52.98 12\n",
    "\n",
    "apply\n",
    "dfloop.py\n",
    "import pandas as pd\n",
    "brics = pd.read_csv(\"brics.csv\", index_col = 0)\n",
    "brics[\"name_length\"] = brics[\"country\"].apply(len)\n",
    "print(brics)\n",
    "country capital area population\n",
    "BR Brazil Brasilia 8.516 200.40\n",
    "RU Russia Moscow 17.100 143.50\n",
    "IN India New Delhi 3.286 1252.00\n",
    "CH China Beijing 9.597 1357.00\n",
    "SA South Africa Pretoria 1.221 52.98"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Loop over DataFrame (1)**\n",
    "\n",
    "Iterating over a Pandas DataFrame is typically done with the iterrows()\n",
    "method. Used in a for loop, every observation is iterated over and on\n",
    "every iteration the row label and actual row contents are available:\n",
    "\n",
    "for lab, row in brics.iterrows() :\n",
    "    ...\n",
    "\n",
    "In this and the following exercises you will be working on the cars\n",
    "DataFrame. It contains information on the cars per capita and whether\n",
    "people drive right or left for seven countries in the world."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import cars data\n",
    "import pandas as pd\n",
    "cars = pd.read_csv('cars.csv', index_col = 0)\n",
    "\n",
    "# Iterate over rows of cars\n",
    "for lab, row in cars.iterrows() :\n",
    "    print(lab)\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Loop over DataFrame (2)**\n",
    "\n",
    "The row data that's generated by iterrows() on every run is a Pandas\n",
    "Series. This format is not very convenient to print out. Luckily,\n",
    "you can easily select variables from the Pandas Series using square\n",
    "brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for lab, row in brics.iterrows() :\n",
    "    print(row['country'])\n",
    "\n",
    "# Import cars data\n",
    "import pandas as pd\n",
    "cars = pd.read_csv('cars.csv', index_col = 0)\n",
    "\n",
    "# Adapt for loop\n",
    "for lab, row in cars.iterrows() :\n",
    "    print(str(lab) + \": \" + str(row['cars_per_cap']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Add column (1)**\n",
    "\n",
    "In the video, Hugo showed you how to add the length of the country\n",
    "names of the brics DataFrame in a new column:\n",
    "\n",
    "for lab, row in brics.iterrows() :\n",
    "    brics.loc[lab, \"name_length\"] = len(row[\"country\"])\n",
    "\n",
    "You can do similar things on the cars DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import cars data\n",
    "import pandas as pd\n",
    "cars = pd.read_csv('cars.csv', index_col = 0)\n",
    "\n",
    "# Code for loop that adds COUNTRY column\n",
    "for lab, row in cars.iterrows() :\n",
    "    cars.loc[lab, \"COUNTRY\"] = row[\"country\"].upper()\n",
    "\n",
    "\n",
    "# Print cars\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Add column (2)**\n",
    "\n",
    "Using iterrows() to iterate over every observation of a Pandas\n",
    "DataFrame is easy to understand, but not very efficient. On every\n",
    "iteration, you're creating a new Pandas Series.\n",
    "\n",
    "If you want to add a column to a DataFrame by calling a function\n",
    "on another column, the iterrows() method in combination with a\n",
    "for loop is not the preferred way to go. Instead, you'll want to\n",
    "use apply().\n",
    "\n",
    "Compare the iterrows() version with the apply() version to get\n",
    "the same result in the brics DataFrame:\n",
    "\n",
    "for lab, row in brics.iterrows() :\n",
    "    brics.loc[lab, \"name_length\"] = len(row[\"country\"])\n",
    "\n",
    "brics[\"name_length\"] = brics[\"country\"].apply(len)\n",
    "\n",
    "We can do a similar thing to call the upper() method on every name\n",
    "in the country column. However, upper() is a method, so we'll need\n",
    "a slightly different approach:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import cars data\n",
    "import pandas as pd\n",
    "cars = pd.read_csv('cars.csv', index_col = 0)\n",
    "\n",
    "# Use .apply(str.upper)\n",
    "for lab, row in cars.iterrows() :\n",
    "    cars[\"COUNTRY\"] = cars[\"country\"].apply(str.upper)\n",
    "\n",
    "# # Print cars\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Case Study: Hacker Statistics (Module 05-034)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **How to solve?**\n",
    "\n",
    "Analytical\n",
    "Simulate the process\n",
    "Hacker statistics!\n",
    "\n",
    "Random generators\n",
    "import numpy as np\n",
    "np.random.rand() # Pseudo-random numbers\n",
    "0.9535543896720104 # Mathematical formula\n",
    "np.random.seed(123) # Starting from a seed\n",
    "np.random.rand()\n",
    "0.6964691855978616\n",
    "np.random.rand()\n",
    "0.28613933495037946\n",
    "\n",
    "Random generators\n",
    "np.random.seed(123)\n",
    "np.random.rand()\n",
    "0.696469185597861 # Same seed: same random numbers!\n",
    "np.random.rand() # Ensures \"reproducibility\"\n",
    "0.28613933495037946\n",
    "\n",
    "Coin toss\n",
    "game.py\n",
    "import numpy as np\n",
    "np.random.seed(123)\n",
    "coin = np.random.randint(0,2) # Randomly generate 0 or 1\n",
    "print(coin)\n",
    "0\n",
    "\n",
    "Coin toss\n",
    "game.py\n",
    "import numpy as np\n",
    "np.random.seed(123)\n",
    "coin = np.random.randint(0,2) # Randomly generate 0 or 1\n",
    "print(coin)\n",
    "if coin == 0:\n",
    "print(\"heads\")\n",
    "else:\n",
    "print(\"tails\")\n",
    "0\n",
    "heads"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Random float**\n",
    "\n",
    "Randomness has many uses in science, art, statistics, cryptography, gaming, gambling,\n",
    "and other fields. You're going to use randomness to simulate a game.\n",
    "\n",
    "All the functionality you need is contained in the random package, a sub-package of\n",
    "numpy. In this exercise, you'll be using two functions from this package:\n",
    "\n",
    "    seed(): sets the random seed, so that your results are reproducible between\n",
    "    simulations. As an argument, it takes an integer of your choosing. If you\n",
    "    call the function, no output will be generated.\n",
    "    rand(): if you don't specify any arguments, it generates a random float\n",
    "    between zero and one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import numpy as np\n",
    "import numpy as np\n",
    "\n",
    "# Set the seed\n",
    "np.random.seed(123)\n",
    "\n",
    "# Generate and print random float\n",
    "print(np.random.rand())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Roll the dice**\n",
    "\n",
    "In the previous exercise, you used rand(), that generates a random float\n",
    "between 0 and 1.\n",
    "\n",
    "As Hugo explained in the video you can just as well use randint(), also a\n",
    "function of the random package, to generate integers randomly. The following\n",
    "call generates the integer 4, 5, 6 or 7 randomly. 8 is not included.\n",
    "\n",
    "import numpy as np\n",
    "np.random.randint(4, 8)\n",
    "\n",
    "Numpy has already been imported as np and a seed has been set. Can you\n",
    "roll some dice?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import numpy and set seed\n",
    "import numpy as np\n",
    "np.random.seed(123)\n",
    "\n",
    "# Use randint() to simulate a dice\n",
    "print(np.random.randint(1, 7))\n",
    "\n",
    "# Use randint() again\n",
    "print(np.random.randint(1, 7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Determine your next move**\n",
    "\n",
    "In the Empire State Building bet, your next move depends on the number of eyes you\n",
    "throw with the dice. We can perfectly code this with an if-elif-else construct!\n",
    "\n",
    "The sample code assumes that you're currently at step 50. Can you fill in the\n",
    "missing pieces to finish the script? numpy is already imported as np and the\n",
    "seed has been set to 123, so you don't have to worry about that anymore.\n",
    "\n",
    "Numpy is imported, seed is set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Starting step\n",
    "step = 50\n",
    "\n",
    "# Roll the dice\n",
    "dice = np.random.randint(1, 7)\n",
    "\n",
    "# Finish the control construct\n",
    "if dice <= 2 :\n",
    "    step = step - 1\n",
    "elif  dice <= 5:\n",
    "    step = step + 1\n",
    "else :\n",
    "    step = step + np.random.randint(1,7)\n",
    "\n",
    "# Print out dice and step\n",
    "print(dice)\n",
    "print(step)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Heads or Tails**\n",
    "\n",
    "headtails.py\n",
    "import numpy as np\n",
    "np.random.seed(123)\n",
    "outcomes = []\n",
    "for x in range(10) :\n",
    "coin = np.random.randint(0, 2)\n",
    "if coin == 0 :\n",
    "outcomes.append(\"heads\")\n",
    "else :\n",
    "outcomes.append(\"tails\")\n",
    "print(outcomes)\n",
    "['heads','tails','heads','heads','heads','heads','heads','tails','tails','heads']\n",
    "\n",
    "Heads or Tails: Random Walk\n",
    "headtailsrw.py\n",
    "import numpy as np\n",
    "np.random.seed(123)\n",
    "tails = [0]\n",
    "for x in range(10) :\n",
    "coin = np.random.randint(0, 2)\n",
    "tails.append(tails[x] + coin)\n",
    "print(tails)\n",
    "[0, 0, 1, 1, 1, 1, 1, 1, 2, 3, 3]\n",
    "\n",
    "Step to Walk\n",
    "outcomes\n",
    "['heads','tails','heads','heads','heads','heads','heads','tails','tails','heads']\n",
    "tails\n",
    "[0, 0, 1, 1, 1, 1, 1, 1, 2, 3, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The next step**\n",
    "\n",
    "Before, you have already written Python code that determines the next step\n",
    "based on the previous step. Now it's time to put this code inside a for loop\n",
    "so that we can simulate a random walk.\n",
    "\n",
    "Numpy is imported, seed is set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize random_walk\n",
    "random_walk = [0]\n",
    "\n",
    "# Complete the ___\n",
    "for x in range(100) :\n",
    "    # Set step: last element in random_walk\n",
    "    step = int(random_walk[-1])\n",
    "\n",
    "    # Roll the dice\n",
    "    dice = np.random.randint(1,7)\n",
    "\n",
    "    # Determine next step\n",
    "    if dice <= 2:\n",
    "        step = step - 1\n",
    "    elif dice <= 5:\n",
    "        step = step + 1\n",
    "    else:\n",
    "        step = step + np.random.randint(1,7)\n",
    "\n",
    "    # append next_step to random_walk\n",
    "    random_walk.append(step)\n",
    "\n",
    "# Print random_walk\n",
    "print(random_walk)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**How low can you go?**\n",
    "\n",
    "Things are shaping up nicely! You already have code that calculates your\n",
    "location in the Empire State Building after 100 dice throws. However, there's\n",
    "something we haven't thought about - you can't go below 0!\n",
    "\n",
    "A typical way to solve problems like this is by using max(). If you pass max()\n",
    "two arguments, the biggest one gets returned. For example, to make sure that a\n",
    "variable x never goes below 10 when you decrease it, you can use:\n",
    "\n",
    "x = max(10, x - 1)\n",
    "\n",
    "\n",
    "Numpy is imported, seed is set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize random_walk\n",
    "random_walk = [0]\n",
    "\n",
    "for x in range(100) :\n",
    "    step = random_walk[-1]\n",
    "    dice = np.random.randint(1,7)\n",
    "\n",
    "    if dice <= 2:\n",
    "        # Replace below: use max to make sure step can't go below 0\n",
    "        step = max(0, step - 1)\n",
    "    elif dice <= 5:\n",
    "        step = step + 1\n",
    "    else:\n",
    "        step = step + np.random.randint(1,7)\n",
    "\n",
    "    random_walk.append(step)\n",
    "\n",
    "print(random_walk)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Visualize the walk**\n",
    "\n",
    "Let's visualize this random walk! Remember how you could use matplotlib to build a line plot?\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.plot(x, y)\n",
    "plt.show()\n",
    "\n",
    "The first list you pass is mapped onto the x axis and the second list is mapped onto the y axis.\n",
    "\n",
    "If you pass only one argument, Python will know what to do and will use the index of the list to map onto the x axis, and the values in the list onto the y axis.\n",
    "\n",
    "Numpy is imported, seed is set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialization\n",
    "random_walk = [0]\n",
    "\n",
    "for x in range(100) :\n",
    "    step = random_walk[-1]\n",
    "    dice = np.random.randint(1,7)\n",
    "\n",
    "    if dice <= 2:\n",
    "        step = max(0, step - 1)\n",
    "    elif dice <= 5:\n",
    "        step = step + 1\n",
    "    else:\n",
    "        step = step + np.random.randint(1,7)\n",
    "\n",
    "    random_walk.append(step)\n",
    "\n",
    "# Import matplotlib.pyplot as plt\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Plot random_walk\n",
    "plt.plot(random_walk)\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Random Walk**\n",
    "\n",
    "headtailsrw.py\n",
    "import numpy as np\n",
    "np.random.seed(123)\n",
    "tails = [0]\n",
    "for x in range(10) :\n",
    "coin = np.random.randint(0, 2)\n",
    "tails.append(tails[x] + coin)\n",
    "\n",
    "100 runs\n",
    "distribution.py\n",
    "import numpy as np\n",
    "np.random.seed(123)\n",
    "final_tails = []\n",
    "for x in range(100) :\n",
    "tails = [0]\n",
    "for x in range(10) :\n",
    "coin = np.random.randint(0, 2)\n",
    "tails.append(tails[x] + coin)\n",
    "final_tails.append(tails[-1])\n",
    "print(final_tails)\n",
    "[3, 6, 4, 5, 4, 5, 3, 5, 4, 6, 6, 8, 6, 4, 7, 5, 7, 4, 3, 3, ..., 4]\n",
    "\n",
    "Histogram, 100 runs\n",
    "distribution.py\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "np.random.seed(123)\n",
    "final_tails = []\n",
    "for x in range(100) :\n",
    "tails = [0]\n",
    "for x in range(10) :\n",
    "coin = np.random.randint(0, 2)\n",
    "tails.append(tails[x] + coin)\n",
    "final_tails.append(tails[-1])\n",
    "plt.hist(final_tails, bins = 10)\n",
    "plot.show()\n",
    "\n",
    "Histogram, 1,000 runs\n",
    "distribution.py\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "np.random.seed(123)\n",
    "final_tails = []\n",
    "for x in range(1000) : # <--\n",
    "tails = [0]\n",
    "for x in range(10) :\n",
    "coin = np.random.randint(0, 2)\n",
    "tails.append(tails[x] + coin)\n",
    "final_tails.append(tails[-1])\n",
    "plt.hist(final_tails, bins = 10)\n",
    "plot.show()\n",
    "\n",
    "Histogram, 10,000 runs\n",
    "distribution.py\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "np.random.seed(123)\n",
    "final_tails = []\n",
    "for x in range(10000) : # <--\n",
    "    tails = [0]\n",
    "    for x in range(10) :\n",
    "        coin = np.random.randint(0, 2)\n",
    "        tails.append(tails[x] + coin)\n",
    "    final_tails.append(tails[-1])\n",
    "plt.hist(final_tails, bins = 10)\n",
    "plot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Simulate multiple walks**\n",
    "\n",
    "A single random walk is one thing, but that doesn't tell you if you have a\n",
    "good chance at winning the bet.\n",
    "\n",
    "To get an idea about how big your chances are of reaching 60 steps, you can\n",
    "repeatedly simulate the random walk and collect the results. That's exactly\n",
    "what you'll do in this exercise.\n",
    "\n",
    "The sample code already sets you off in the right direction. Another for loop\n",
    "is wrapped around the code you already wrote. It's up to you to add some bits\n",
    "and pieces to make sure all of the results are recorded correctly.\n",
    "\n",
    "Note: Don't change anything about the initialization of all_walks that is given.\n",
    "Setting any number inside the list will cause the exercise to crash!\n",
    "\n",
    "Numpy is imported; seed is set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize all_walks (don't change this line)\n",
    "all_walks = []\n",
    "\n",
    "# Simulate random walk 10 times\n",
    "for i in range(10)  :\n",
    "\n",
    "    # Code from before\n",
    "    random_walk = [0]\n",
    "    for x in range(100) :\n",
    "        step = random_walk[-1]\n",
    "        dice = np.random.randint(1,7)\n",
    "\n",
    "        if dice <= 2:\n",
    "            step = max(0, step - 1)\n",
    "        elif dice <= 5:\n",
    "            step = step + 1\n",
    "        else:\n",
    "            step = step + np.random.randint(1,7)\n",
    "        random_walk.append(step)\n",
    "\n",
    "    # Append random_walk to all_walks\n",
    "    all_walks.append(random_walk)\n",
    "\n",
    "# Print all_walks\n",
    "print(all_walks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Visualize all walks**\n",
    "\n",
    "all_walks is a list of lists: every sub-list represents a single random walk.\n",
    "If you convert this list of lists to a Numpy array, you can start making\n",
    "interesting plots! matplotlib.pyplot is already imported as plt.\n",
    "\n",
    "The nested for loop is already coded for you - don't worry about it. For now,\n",
    "focus on the code that comes after this for loop.\n",
    "\n",
    "\n",
    "numpy and matplotlib imported, seed set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize and populate all_walks\n",
    "all_walks = []\n",
    "for i in range(10) :\n",
    "    random_walk = [0]\n",
    "    for x in range(100) :\n",
    "        step = random_walk[-1]\n",
    "        dice = np.random.randint(1,7)\n",
    "        if dice <= 2:\n",
    "            step = max(0, step - 1)\n",
    "        elif dice <= 5:\n",
    "            step = step + 1\n",
    "        else:\n",
    "            step = step + np.random.randint(1,7)\n",
    "        random_walk.append(step)\n",
    "    all_walks.append(random_walk)\n",
    "\n",
    "# Convert all_walks to Numpy array: np_aw\n",
    "np_aw = np.array(all_walks)\n",
    "\n",
    "# Plot np_aw and show\n",
    "plt.plot(np_aw)\n",
    "plt.show()\n",
    "\n",
    "# Clear the figure\n",
    "plt.clf()\n",
    "\n",
    "# Transpose np_aw: np_aw_t\n",
    "np_aw_t = np.transpose(np_aw)\n",
    "\n",
    "# Plot np_aw_t and show\n",
    "plt.plot(np_aw_t)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Implement clumsiness**\n",
    "\n",
    "With this neatly written code of yours, changing the number of times the\n",
    "random walk should be simulated is super-easy. You simply update the range()\n",
    "function in the top-level for loop.\n",
    "\n",
    "There's still something we forgot! You're a bit clumsy and you have a 0.1%\n",
    "chance of falling down. That calls for another random number generation.\n",
    "Basically, you can generate a random float between 0 and 1. If this value\n",
    "is less than or equal to 0.001, you should reset step to 0.\n",
    "\n",
    "\n",
    "numpy and matplotlib imported, seed set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simulate random walk 250 times\n",
    "all_walks = []\n",
    "for i in range(50) :\n",
    "    random_walk = [0]\n",
    "    for x in range(100) :\n",
    "        step = random_walk[-1]\n",
    "        dice = np.random.randint(1,7)\n",
    "        if dice <= 2:\n",
    "            step = max(0, step - 1)\n",
    "        elif dice <= 5:\n",
    "            step = step + 1\n",
    "        else:\n",
    "            step = step + np.random.randint(1,7)\n",
    "\n",
    "        # Implement clumsiness\n",
    "        if np.random.rand() <= 0.001:\n",
    "            step = 0\n",
    "\n",
    "        random_walk.append(step)\n",
    "    all_walks.append(random_walk)\n",
    "\n",
    "# Create and plot np_aw_t\n",
    "np_aw_t = np.transpose(np.array(all_walks))\n",
    "plt.plot(np_aw_t)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Plot the distribution**\n",
    "\n",
    "All these fancy visualizations have put us on a sidetrack. We still\n",
    "have to solve the million-dollar problem: What are the odds that you'll\n",
    "reach 60 steps high on the Empire State Building?\n",
    "\n",
    "Basically, you want to know about the end points of all the random walks\n",
    "you've simulated. These end points have a certain distribution that you\n",
    "can visualize with a histogram.\n",
    "\n",
    "Note that if your code is taking too long to run, you might be plotting\n",
    "\n",
    "numpy and matplotlib imported, seed set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simulate random walk 500 times\n",
    "all_walks = []\n",
    "for i in range(500) :\n",
    "    random_walk = [0]\n",
    "    for x in range(100) :\n",
    "        step = random_walk[-1]\n",
    "        dice = np.random.randint(1,7)\n",
    "        if dice <= 2:\n",
    "            step = max(0, step - 1)\n",
    "        elif dice <= 5:\n",
    "            step = step + 1\n",
    "        else:\n",
    "            step = step + np.random.randint(1,7)\n",
    "        if np.random.rand() <= 0.001 :\n",
    "            step = 0\n",
    "        random_walk.append(step)\n",
    "    all_walks.append(random_walk)\n",
    "\n",
    "# Create and plot np_aw_t\n",
    "np_aw_t = np.transpose(np.array(all_walks))\n",
    "\n",
    "# Select last row from np_aw_t: ends\n",
    "ends = np.array(np_aw_t)[-1]\n",
    "\n",
    "# Plot histogram of ends, display plot\n",
    "plt.hist(ends)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# END"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.0 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.10.0"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "26de051ba29f2982a8de78e945f0abaf191376122a1563185a90213a26c5da77"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}