Lesson4_Python_Programming_User_Defined_Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programming with Python\n",
    "**SWC workshop: February 23-24, 2019**\n",
    "#### This lesson is based on Software and Data Carpentry lessons:  \n",
    "* http://swcarpentry.github.io/python-novice-inflammation/\n",
    "* https://datacarpentry.org/python-ecology-lesson/\n",
    "\n",
    "**Instructor: Joe Cloud**  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learning Objectives:\n",
    "* Understand general structure of Python program\n",
    "* Learn how to write user-defined functions\n",
    "* Learn how to run python scripts from the command line\n",
    "* Learn how to pass arguments to python scripts from the command line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we start, let's make a folder called `python_programming` inside `SWC_spring2019` folder. Then copy `gapminder.txt` from `Data` folder to `python_programming`. You can do that from `SWC_spring2019` folder using the terminal with Bash commands:   \n",
    "`$ mkdir Python_programming`    \n",
    "`$ cp Data/gapminder.txt python_programming/`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### General structure of Python program  \n",
    "Let's start by revisiting the script your wrote with Balan yesterday:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "##This is  MeanGdpPlot.py script\n",
    "\n",
    "#Import pandas and pylab\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt      \n",
    "\n",
    "#read data into python\n",
    "my_file = pd.read_csv(\"gapminder.txt\", sep = \"\\t\")\n",
    "\n",
    "#select information about Africa\n",
    "Africa = my_file[my_file.continent == \"Africa\"]\n",
    "\n",
    "#calculate the mean\n",
    "Africa_Mean = Africa.iloc[:,5].mean()\n",
    "\n",
    "#Do the same for Europe\n",
    "Europe = my_file[my_file.continent == \"Europe\"]\n",
    "Europe_Mean = Europe.iloc[:,5].mean()\n",
    "\n",
    "# Create a List to store the values\n",
    "continents = [\"Africa\",\"Europe\"]\n",
    "mean_gdp = [Africa_Mean, Europe_Mean]\n",
    "\n",
    "# Set figure width to 10 and height to 8\n",
    "fig_size = plt.rcParams[\"figure.figsize\"]\n",
    "fig_size[0] = 10\n",
    "fig_size[1] = 8\n",
    "plt.rcParams[\"figure.figsize\"] = fig_size\n",
    "\n",
    "#Plot the graph with Y axis label and Title\n",
    "plt.bar(continents,mean_gdp,align='center')\n",
    "plt.ylabel('Mean GDP/Capita')\n",
    "plt.title('Mean GDP per Capita in Africa Vs Europe')\n",
    "plt.savefig(\"Mean_GDP_Plot.png\")\n",
    "\n",
    "# For personal visualization:\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general python program can subdivided into following parts:\n",
    "\n",
    "* Script description (brief summary about what the script does)\n",
    "* Import statements ( tell us what libraries are used in the program)\n",
    "* Loading data (tells us what data is used in the program)\n",
    "* Data analysis (selecting parts of the data we are interested in and analyzing it (stats + visualization)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might want to document these parts in your script to improve the readability of your program. Something like this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#!/usr/bin/env python3\n",
    "\n",
    "\"\"\" \n",
    "This is  MeanGdpPlot.py script\n",
    "This script uses gapminder.txt to calculate and plot mean GDP per capita for African and European countries \n",
    "\"\"\"\n",
    "\n",
    "####### import statements ##########\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt      \n",
    "\n",
    "####### reading data into Python ##########\n",
    "my_file = pd.read_csv(\"gapminder.txt\", sep = \"\\t\")\n",
    "\n",
    "\n",
    "####### data analysis #########\n",
    "#select information about Africa\n",
    "Africa = my_file[my_file.continent == \"Africa\"]\n",
    "\n",
    "#calculate the mean\n",
    "Africa_Mean = Africa.iloc[:,5].mean()\n",
    "\n",
    "#Do the same for Europe\n",
    "Europe = my_file[my_file.continent == \"Europe\"]\n",
    "Europe_Mean = Europe.iloc[:,5].mean()\n",
    "\n",
    "# Create a List to store the values\n",
    "continents = [\"Africa\",\"Europe\"]\n",
    "mean_gdp = [Africa_Mean, Europe_Mean]\n",
    "\n",
    "# Set figure width to 10 and height to 8\n",
    "fig_size = plt.rcParams[\"figure.figsize\"]\n",
    "fig_size[0] = 10\n",
    "fig_size[1] = 8\n",
    "plt.rcParams[\"figure.figsize\"] = fig_size\n",
    "\n",
    "#Plot the graph with Y axis label and Title\n",
    "plt.bar(continents,mean_gdp,align='center')\n",
    "plt.ylabel('Mean GDP/Capita')\n",
    "plt.title('Mean GDP per Capita in Africa Vs Europe')\n",
    "plt.savefig(\"Mean_GDP_Plot.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### User-defined functions\n",
    "\n",
    "There is a large improvement we can make to this script. Notice that we repeat some commands two times in this script. We select data about Africa, calculate mean gdp and then do the same for Europe. This way of writing a program introduces potential to make typos every time we type the command. It also makes script long and tedious to read - what if I wanted to calculate mean GDP for all 142 countries in our dataset? There is a better way to write a script that requires repeating the same commands with different inputs. If you find yourself rewriting the same command in your script, you should write a function to do the task. \n",
    "  \n",
    "You have used function before: `pd.read_table()` is a function that reads file into python. This function takes a file as an argument and outputs a dataframe. This is a `built-in` function, it was written by python developers, and python knows what it is when you try to use it. You can think of `pd.read_table()` as a script name for a script that includes many lines of code that allows the user to load files into python. Or think of `pd.read_table()` as an alias to a multi-line script. Notice that we provide different file names to this function and it executed identical code to every file we provide. Think again about our program - it would be nice to have a function `getContinent()` so that when we use it, we could just provide the name of the continent we are interested in and get back the subset of the data frame with the information about the requested continent. There is no built-in function for that, but we can write one ourselves. When we write our own functions, they are called `user-defined` functions.  \n",
    "  \n",
    "Let's start with an example first, and we will return to `getContinent()` later.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember, functions gather a sequence of operations into a whole, preserving it for ongoing use. Functions provide:\n",
    "\n",
    "* a name we can remember and invoke it by\n",
    "* relief from the need to remember the individual operations\n",
    "* a defined set of inputs and expected outputs\n",
    "\n",
    "Let's see how functions do that with an example.\n",
    "Let's define a function that adds 10 to any number we give to it, call it `AddTen()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def AddTen(number):\n",
    "    answer = 10 + number\n",
    "    return answer    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The definition opens with `def` keyword followed by the name of your new function(AddTen). The input into the function is provided in parentheses. The input to the function is also known as a parameter. In this case we have just one, but there could be more. The first line of function definition ends with `:`.   The body of the function — the statements that are executed when it runs — is indented below the definition line. Indentation is required in Python and 4 spaces are usually recommended. The body of the function is the set of statements that are executed when the function is used (or called). The body concludes with a return keyword followed by the return value.\n",
    "\n",
    "When we call the function, the values we pass to it are assigned to those variables so that we can use them inside the function. The last line within the function is what Python will evaluate as a returning value. For example, let’s try running our function. Calling our own function is no different from calling any other function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AddTen(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here number variable gets the value of 5, and commands inside the functions are executed. The output of the functions is specified by `return` statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Challenge 1**\n",
    "\n",
    "Write a function called `fence` that takes two parameters called `original` and `wrapper` and returns a new string that has\n",
    "the wrapper character at the beginning and end of the original.  \n",
    "Hint: to concatinate strings, use `+` operator\n",
    "Example of function call:  \n",
    "`fence('name', '---')`  \n",
    "Expected output:  \n",
    "`---name---`  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution to challenge 1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fence(original, wrapper):  \n",
    "    new_string=wrapper + original + wrapper\n",
    "    return new_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'---Joe---'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fence('Joe','---')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's get back to our script analyzing gapminder.txt and see how we can improve it with user-defined functions.\n",
    "What tasks could we wrap up in a function here?\n",
    "\n",
    "What repetitive tasks are we performing?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#!/usr/bin/env python3\n",
    "\"\"\" \n",
    "This is  MeanGdpPlot.py script\n",
    "This script uses gapminder.txt to calculate and plot mean GDP per capita for African and European countries \n",
    "\"\"\"\n",
    "\n",
    "####### import statements ##########\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt      \n",
    "import pylab\n",
    "\n",
    "####### reading data into Python ##########\n",
    "my_file = pd.read_csv(\"gapminder.txt\", sep = \"\\t\")\n",
    "\n",
    "\n",
    "####### data analysis #########\n",
    "#select information about Africa\n",
    "Africa = my_file[my_file.continent == \"Africa\"]\n",
    "\n",
    "#calculate the mean\n",
    "Africa_Mean = Africa.iloc[:,5].mean()\n",
    "\n",
    "#Do the same for Europe\n",
    "Europe = my_file[my_file.continent == \"Europe\"]\n",
    "Europe_Mean = Europe.iloc[:,5].mean()\n",
    "\n",
    "# Create a List to store the values\n",
    "continents = [\"Africa\",\"Europe\"]\n",
    "mean_gdp = [Africa_Mean, Europe_Mean]\n",
    "\n",
    "# Set figure width to 10 and height to 8\n",
    "fig_size = plt.rcParams[\"figure.figsize\"]\n",
    "fig_size[0] = 10\n",
    "fig_size[1] = 8\n",
    "plt.rcParams[\"figure.figsize\"] = fig_size\n",
    "\n",
    "#Plot the graph with Y axis label and Title\n",
    "plt.bar(continents,mean_gdp,align='center')\n",
    "plt.ylabel('Mean GDP/Capita')\n",
    "plt.title('Mean GDP per Capita in Africa Vs Europe')\n",
    "plt.savefig(\"Mean_GDP_Plot.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are using `my_file[my_file.continent == \"Africa\"]` twice - for Africa and Europe.  This is a long line, you really do not want to type it over and over if you need information about more than one contient.  So how can we write `getContinent()` function that would take a data frame and a name of a continent as inputs and output the data frame that ONLY contains information about that continent? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    country continent  year  lifeExp       pop    gdpPercap\n",
      "24  Algeria    Africa  1952   43.077   9279525  2449.008185\n",
      "25  Algeria    Africa  1957   45.685  10270856  3013.976023\n",
      "26  Algeria    Africa  1962   48.303  11000948  2550.816880\n",
      "27  Algeria    Africa  1967   51.407  12760499  3246.991771\n",
      "28  Algeria    Africa  1972   54.518  14760787  4182.663766\n",
      "    country continent  year  lifeExp      pop    gdpPercap\n",
      "12  Albania    Europe  1952    55.23  1282697  1601.056136\n",
      "13  Albania    Europe  1957    59.28  1476505  1942.284244\n",
      "14  Albania    Europe  1962    64.82  1728137  2312.888958\n",
      "15  Albania    Europe  1967    66.22  1984060  2760.196931\n",
      "16  Albania    Europe  1972    67.69  2263554  3313.422188\n"
     ]
    }
   ],
   "source": [
    "def getContinent(continent, df):\n",
    "    my_continent = df[df.continent == continent]\n",
    "    return my_continent\n",
    "\n",
    "# call getContinent() function with `Africa`\n",
    "Africa=getContinent('Africa', my_file)\n",
    "print(Africa.head())\n",
    "\n",
    "# call getContinent() function with `Europe`\n",
    "Europe=getContinent('Europe', my_file)\n",
    "print(Europe.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Min advantage of functions: we define/write function one time, but use it multiple times."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How else can the code be simplified with user-defined functions?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get mean of any column from data frame\n",
    "def getMean(column_name, df):\n",
    "    return df.loc[:,column_name].mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_bar(continents_list, meanData_list, y_label, title, figure_name):\n",
    "    # Set figure width to 10 and height to 8\n",
    "    fig_size = plt.rcParams[\"figure.figsize\"]\n",
    "    fig_size[0] = 10\n",
    "    fig_size[1] = 8\n",
    "    plt.rcParams[\"figure.figsize\"] = fig_size\n",
    "\n",
    "    #Plot the graph with Y axis label and Title\n",
    "    plt.bar(continents_list,meanData_list,align='center')\n",
    "    plt.ylabel(y_label)\n",
    "    plt.title(title)\n",
    "    plt.savefig(figure_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some might notice that the matplotlib params will not change every time the function is called. \n",
    "So it may be better to place it outside the function.\n",
    "\n",
    "With these changes, our script would look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\" \n",
    "This is  MeanPlot.py script\n",
    "This script uses gapminder.txt to calculate and plot mean GDP per capita for African and European countries \n",
    "\"\"\"\n",
    "\n",
    "####### import statements ##########\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt      \n",
    "import pylab\n",
    "\n",
    "####### user-defined functions #########\n",
    "def getContinent(continent, df):\n",
    "    my_continent = df[df.continent == continent]\n",
    "    return my_continent\n",
    "\n",
    "def getMean(column_name, df):\n",
    "    return df.loc[:,column_name].mean()\n",
    "\n",
    "def plot_bar(continents_list, meanData_list, y_label, title, figure_name):\n",
    "    # Set figure width to 10 and height to 8\n",
    "    fig_size = plt.rcParams[\"figure.figsize\"]\n",
    "    fig_size[0] = 10\n",
    "    fig_size[1] = 8\n",
    "    plt.rcParams[\"figure.figsize\"] = fig_size\n",
    "\n",
    "    #Plot the graph with Y axis label and Title\n",
    "    plt.bar(continents_list,meanData_list,align='center')\n",
    "    plt.ylabel(y_label)\n",
    "    plt.title(title)\n",
    "    plt.savefig(figure_name)\n",
    "\n",
    "####### end user-defined functions #########\n",
    "\n",
    "\n",
    "####### reading data into Python ##########\n",
    "my_file = pd.read_csv(\"gapminder.txt\", sep = \"\\t\")\n",
    "\n",
    "\n",
    "####### data analysis #########\n",
    "#select information about Africa\n",
    "Africa=getContinent('Africa', my_file)\n",
    "\n",
    "#calculate the mean\n",
    "Africa_mean=getMean('gdpPercap', Africa)\n",
    "\n",
    "#Do the same for Europe\n",
    "Europe = getContinent('Europe', my_file)\n",
    "Europe_mean=getMean('gdpPercap', Europe)\n",
    "\n",
    "# Create a List to store the values\n",
    "continents = [\"Africa\",\"Europe\"]\n",
    "means = [Africa_Mean, Europe_Mean]\n",
    "\n",
    "# plot\n",
    "plot_bar(continents, means, 'meanGDP', 'Mean GDP per capita: Africa vs Europe', 'Mean_Gdp.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have an improved script here, but we are still repeting `getContinent()` and `getMean()` functions twice.  \n",
    "\n",
    "**Challenge 2**  \n",
    "Write a function called `getMeanPerContinent()` that will take `continent`,`column_name` and `df` parameters and output the mean of a user-specified column for user-specified continent?  \n",
    "\n",
    "**Solution** to Challenge 2:  \n",
    "Option 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getMeanPerContinent(continent, column_name, df):\n",
    "    my_continent = df[df.continent == continent]\n",
    "    continent_mean=my_continent.loc[:,column_name].mean()\n",
    "    return my_mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Option 2:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getMeanPerContinent(continent, column_name, df):\n",
    "    my_continent=getContinent(continent, df)\n",
    "    continent_mean=getMean(column_name, my_continent)\n",
    "    return continent_mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which one is better? Why?  \n",
    "The second option reuses the functions we already defined and if we need to use just `getContinent()` or `getMean()` functions separetely, we still can do it. It is better to write small functions that do specific tasks and then combine them to perform more complicated tasks.  \n",
    "This is our first taste of how larger programs are built: we define basic operations, then combine them in ever-large chunks to get the effect we want. Real-life functions will usually be larger than the ones shown here — typically half a dozen to a few dozen lines — but they shouldn’t ever be much longer than that, or the next person who reads it won’t be able to understand what’s going on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With this improvement, our script will look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnQAAAHiCAYAAABhvlEMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xu8Z1Vd//HXuxkQVBSQ0ZQZHFLSUNN0REzrYWKA16GHV1IZjeJRYZpZKmXh9SeW5eXnLVIU8IKE9oPSJELJbgiDIApETAgyKDIwXBK8NPj5/bHXoS+Hc2bOXL7ne9bM6/l4fB+z91pr7732Pud8z3vW3ut7UlVIkiSpXz8x6Q5IkiRp6xjoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJOkzZTkF5JcPsHjJ8lHk9yU5LxZ2ky0j5Lml4FOmpAkVyX5UZK9ppVfmKSSLJ9An3ZL8hetb7cl+VaS05I8YaRNtbrvJbkxydlJXjhtP+ck+UFrc0OSzyZ54Hyfz7hU1T9X1cOm1tv1etq2Pk6SjyXZMMO1ezLwy8DSqjpgLn1cSNp5/ah9f0y9vjbpfkk9M9BJk/VN4PCplSSPAu45iY4kuQfwReBRwLOA+wA/A5wCPH1a80dX1b2BhwEfA96X5NhpbV7R2vw0sDvwrvH1/s5Rq+3mPS3JvYDnArcAL5lW/WDgqqq6bZZtF4+5e9vCn1bVvUdej96SnXRyrtLYbTdvflKnTgaOGFlfBZw02iDJPZK8s42WfTfJh5Ls2ur2SPJ3Sda1229/l2TpyLbnJHlLkn9N8t9J/mH6iOCIlwJLgcOq6htVdUdV3VZVp1XVG2faoKpuqKqTgd8CjklyvxnarAc+Azxypn20Pr49yXlJbk1yepI9R+oPTPJvSW5O8rUkT5m27duS/CtwO/BTM+x/WRshXNdGFN/Xyh+S5Iut7IYkn0iy+8h2VyU5Jsml7dp+NMkure4pSda25ZOBfYC/bSNNr23lf53kuiS3JPlykkfMct1n81zgZuDNDN8XU/06Evgw8MR2vDdN9SfJ65JcB3x0tI9bcx2mXcsPJnnntLLTk/xeW35dkmvb99rlSQ7azHNmer9b2Z0joEnemGHU+ONJbgVe1n5G3p3k2+317vYflDv3l+QP2/ldleTFI/ue9edL6omBTpqsc4H7JPmZJIuAFwEfn9bmOIZRrscADwX2Bv6k1f0E8FGGEZt9gO8D75u2/a8CLwfuD+wM/P4sfXkacOZsoz6bcDqwGLjb7b8WIJ8LXLiR7Y8Afg14ILABeG/bdm/gc8BbgT1b3z+TZMnIti8FjgJ2A66eduxFwN+18uUM1+6UqWrg7cCDGEYilwFvnNavFwOHAA9h+Bq8YXrHq+qlwLeAZ7eRpj9tVX8P7Mdw3b8KfGKkX7+a5OKNXA8YQtynWn8fnuRx7XgfAX4T+Pd2vKmR0Z9kuEYPbtdjW16HKZ8CXpgkbb97AAcDpyR5GPAK4PFVtRvDdbtqE+e4pVYCpzGM/H4C+CPgQIafkUczfB+Ofq1+EtiL4bxXAce3/sLGf76kflSVL1++JvBi+GX3NIZfPG8HDgXOYghGxfCLN8BtwENGtnsi8M1Z9vkY4KaR9XOAN4ys/zbwhVm2/UfguGn7uhm4Fbh8pLyAh86w/XXAi0eOe3vb/lqGX7pLZjnuOdOOuz/wI2AR8Drg5GntzwRWjWz75o1c4ycC64DFc/h6HAZcOO3r85sj688A/qstPwVYO/1ruZF9796u233n+L2xD/Bj4DEj5/yekfqXAf8ysv6Uds12mVa2dmuvw7S6MITXX2zrvwF8sS0/FLi+fU/vtIljfAz4Qfv+mHqdONO1nX59GcLml6fV/xfwjJH1QxhuSU/tbwNwr5H6U4E/ZjN/vnz5Wsgvnz2QJu9k4MvAvky73QosYXim7oI2KALDL6FFAEnuyfBs2qHAHq1+tySLquqOtn7dyP5uB+49Sz9uZBghA6CqLgJ2b7e6PryxE0iyU+vr+pHiV1bVRrcbcc3I8tXATgwjKg8Gnp/k2SP1OwFfmmXb6ZYBV1fVhhn6/ADgPcAvMIzu/QRw0yb69aCNn8ad+14EvA14PsN1+XGr2ovhmbhNeSlwWfsawBCI/zzJ71fV/8yyzbqq+sEsdVt7HQCoqkpyCsNzn19mGP39eKtbk+R3GQLXI5KcCfxeVX17lj69s6ruNuI5R9O/5g/irqOz079WN9VdR56n6jf68yX1xFuu0oRV1dUMkyOeAXx2WvUNDLdRH1FVu7fXfWuYbADwGoaJCU+oqvsAv9jKw+Y7Gzg4w8P4m2slwyjIjB+hMQfLRpb3Af6H4dyvYRih233kda+qOm6kfW1kv9cA+2TmB+f/T9v2Ue3avYS7X7fp/ZotnEzvw68yXJOnAfdlGG1lhv3P5gjgp9ozeNcBf8EQBp+xkW3GeR1GfQp4XpIHA09geD5y6EDVJ6vqyQxBvIB3bGQ/s7mNkYlBLRwvmdZm+rl+ux1zyvSv1R7Tvq+n6jf18yV1w0AnLQxHAk+dNopAVf0Y+CvgXUnuD8NzZUkOaU12Y/iFdHOGiQTTZ5pujpOA7wB/k+SRSRa1SQArZtsgyZ7tAfP3A++oqhu38NgvSbJ/G3F8M3BaG2H8OPDsJIdM9ac95L5047u703ntnI5Lcq+2/ZNa3W7A94Bb2rN6fzDD9kcnWdqu7R8Bn57lON/lrhMydgN+yDDqeU+G0DQnSZ7I8MzeAQy3vR/DMKHkk9x1As3m2NrrcKequpAhCH2Y4ZnLm1u/H5bkqW0ywg8Yvi9/PPueZvWfwC5JntlGft8A3GMT23wKeEOSJe2ZzT/h7s+ivinJzkl+gWEW91/P4edL6oaBTloAquq/qmr1LNWvA9YA57ZZff/IMCoH8G5gV4ZfsOcCX9iKPvwA+CXgUoaJCLcClwOPB14wrfnXknyv9evXgVdX1dY8SH4yw3NV1wG7AK9sfbqGYaTrDxmeAbuGIXDM6b2rhcJnMzzf9S1gLTD1mXlvAh7LcAv0c9x9dBSGEPUPwJUMz2m9dZZDvZ0hUNyc5PcZwvHVDM8PXsrwtblTkhcnuWSWfa0CTq+qr1fVdVMvhtuiz8rIDOC52gbXYbpPMow+fnKk7B4MEwxuYPg63h84ZiP7eG3u+jl0N7S+3sLwrOeHGa7fba2/G/NWYDVwMfB1hkkoo1+r6xhuI3+b4fb1b1bVf7S6jf18Sd1I1cZG6SVpvJKcA3x8M563mxdJrgJ+var+cdJ90ZbL8DE3H6+quY7qSl1yhE6SJKlzBjpJkqTOectVkiSpc47QSZIkdc5AJ0mS1Lkd7i9F7LXXXrV8+fJJd0OSJGmTLrjgghuqavqHa9/NDhfoli9fzurVs33clyRJ0sKR5OpNt/KWqyRJUvcMdJIkSZ0z0EmSJHXOQCdJktQ5A50kSVLnDHSSJEmdM9BJkiR1zkAnSZLUOQOdJElS5wx0kiRJnTPQSZIkdc5AJ0mS1DkDnSRJUucMdJIkSZ0z0EmSJHXOQCdJktQ5A50kSVLnDHSSJEmdM9BJkiR1bvGkOyBJ2nzLX/+5SXdB2qFdddwzJ92Fu3CETpIkqXMGOkmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnq3NgCXZITklyf5Bsz1L0mSSXZq60nyXuTrElycZLHjrRdleSK9lo1Uv64JF9v27w3ScZ1LpIkSQvZOEfoPgYcOr0wyTLgYOBbI8VPB/Zrr6OAD7a2ewLHAk8ADgCOTbJH2+aDwG+MbHe3Y0mSJO0IxhboqurLwPoZqt4FvBaokbKVwEk1OBfYPckDgUOAs6pqfVXdBJwFHNrq7lNV51ZVAScBh43rXCRJkhayeX2GLslK4Nqq+tq0qr2Ba0bW17ayjZWvnaFckiRph7N4vg6U5J7AHzLcbp1XSY5iuJXLPvvsM9+HlyRJGqv5HKF7CLAv8LUkVwFLga8m+UngWmDZSNulrWxj5UtnKJ9RVR1fVSuqasWSJUu2walIkiQtHPMW6Krq61V1/6paXlXLGW6TPraqrgPOAI5os10PBG6pqu8AZwIHJ9mjTYY4GDiz1d2a5MA2u/UI4PT5OhdJkqSFZJwfW/Ip4N+BhyVZm+TIjTT/PHAlsAb4K+C3AapqPfAW4Pz2enMro7X5cNvmv4C/H8d5SJIkLXRje4auqg7fRP3ykeUCjp6l3QnACTOUrwYeuXW9lCRJ6p9/KUKSJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzYwt0SU5Icn2Sb4yU/VmS/0hycZK/SbL7SN0xSdYkuTzJISPlh7ayNUleP1K+b5KvtPJPJ9l5XOciSZK0kI1zhO5jwKHTys4CHllVPwv8J3AMQJL9gRcBj2jbfCDJoiSLgPcDTwf2Bw5vbQHeAbyrqh4K3AQcOcZzkSRJWrDGFuiq6svA+mll/1BVG9rqucDStrwSOKWqflhV3wTWAAe015qqurKqfgScAqxMEuCpwGlt+xOBw8Z1LpIkSQvZJJ+h+zXg79vy3sA1I3VrW9ls5fcDbh4Jh1PlM0pyVJLVSVavW7duG3VfkiRpYZhIoEvyR8AG4BPzcbyqOr6qVlTViiVLlszHISVJkubN4vk+YJKXAc8CDqqqasXXAstGmi1tZcxSfiOwe5LFbZRutL0kSdIOZV5H6JIcCrwWeE5V3T5SdQbwoiT3SLIvsB9wHnA+sF+b0bozw8SJM1oQ/BLwvLb9KuD0+ToPSZKkhWScH1vyKeDfgYclWZvkSOB9wG7AWUkuSvIhgKq6BDgVuBT4AnB0Vd3RRt9eAZwJXAac2toCvA74vSRrGJ6p+8i4zkWSJGkhG9st16o6fIbiWUNXVb0NeNsM5Z8HPj9D+ZUMs2AlSZJ2aP6lCEmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXNjC3RJTkhyfZJvjJTtmeSsJFe0f/do5Uny3iRrklyc5LEj26xq7a9Ismqk/HFJvt62eW+SjOtcJEmSFrJxjtB9DDh0WtnrgbOraj/g7LYO8HRgv/Y6CvggDAEQOBZ4AnAAcOxUCGxtfmNku+nHkiRJ2iGMLdBV1ZeB9dOKVwIntuUTgcNGyk+qwbnA7kkeCBwCnFVV66vqJuAs4NBWd5+qOreqCjhpZF+SJEk7lPl+hu4BVfWdtnwd8IC2vDdwzUi7ta1sY+VrZyiXJEna4UxsUkQbWav5OFaSo5KsTrJ63bp183FISZKkeTPfge677XYp7d/rW/m1wLKRdktb2cbKl85QPqOqOr6qVlTViiVLlmz1SUiSJC0k8x3ozgCmZqquAk4fKT+izXY9ELil3Zo9Ezg4yR5tMsTBwJmt7tYkB7bZrUeM7EuSJGmHsnhcO07yKeApwF5J1jLMVj0OODXJkcDVwAta888DzwDWALcDLweoqvVJ3gKc39q9uaqmJlr8NsNM2l2Bv28vSZKkHc7YAl1VHT5L1UEztC3g6Fn2cwJwwgzlq4FHbk0fJUmStgf+pQhJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzi3eVIMkjwEeClxSVZeNv0uSJEnaHBsdoUvyJ8CpwHOBzyX5jXnplSRJkuZsUyN0LwQeU1W3J7kf8AXgr8bfLUmSJM3Vpp6h+2FV3Q5QVTfOob0kSZLm2aZG6H4qyRltOcBDRtapqueMrWeSJEmak00FupXT1t85ro5IkiRpy2w00FXVP00tJ1nSytaNu1OSJEmau03Nck2SY5PcAFwO/GeSdW326xZL8uoklyT5RpJPJdklyb5JvpJkTZJPJ9m5tb1HW1/T6peP7OeYVn55kkO2pk+SJEm92tQkh1cDTwYeX1V7VtUewBOAJyV59ZYcMMnewCuBFVX1SGAR8CLgHcC7quqhwE3AkW2TI4GbWvm7WjuS7N+2ewRwKPCBJIu2pE+SJEk921SgeylweFV9c6qgqq4EXgIcsRXHXQzsmmQxcE/gO8BTgdNa/YnAYW15ZVun1R+UJK38lKr6YevfGuCAreiTJElSlzYV6HaqqhumF7bn6HbakgNW1bUMkyu+xRDkbgEuAG6uqg2t2Vpg77a8N3BN23ZDa3+/0fIZtpEkSdphbCrQ/WgL62aVZA+G0bV9gQcB92K4ZTo2SY5KsjrJ6nXrnNMhSZK2L5v62JJHJ7l1hvIAu2zhMZ8GfHNqtmySzwJPAnZPsriNwi0Frm3trwWWAWvbLdr7AjeOlE8Z3eYuqup44HiAFStW1Bb2W5IkaUHa6AhdVS2qqvvM8NqtqrbolivDrdYDk9yzPQt3EHAp8CXgea3NKuD0tnxGW6fVf7GqqpW/qM2C3RfYDzhvC/skSZLUrU2N0N1Fm6E6NZP02yPPvM1ZVX0lyWnAV4ENwIUMo2efA05J8tZW9pG2yUeAk5OsAdYzzGylqi5JcipDGNwAHF1Vd2xufyRJknq30UCX5BiGiRFvbkX/zjApYSeGmadv35KDVtWxwLHTiq9khlmqVfUD4Pmz7OdtwNu2pA+SJEnbi01Ning+8Ocj6zdW1aMYPvvtmWPrlSRJkuZsU4GOqrptZPU9rewOYNdxdUqSJElzt6lAd+8kd05+qKqPwfDnuID7jLFfkiRJmqNNBbrTgL9Mcs+pgiT3Aj7E//5VB0mSJE3QpgLdHwPXA99KckGSrwJXAd9tdZIkSZqwjc5ybc/KvT7Jm4CHtuI1VfX9sfdMkiRJczKnz6Grqu8n2Q1YDvzc8HnAUFUnja9rkiRJmos5BbokJwMPAS4Cpj68twADnSRJ0oTN9S9FrAD2b39yS5IkSQvIJj+HrvkG8JPj7IgkSZK2zFxH6PYCLk1yHvDDqcKqes5YeiVJkqQ5m2uge+M4OyFJkqQtN9dZrv807o5IkiRpy8zpGbokByY5P8n3kvwoyR1Jbh135yRJkrRpc50U8T7gcOAKYFfg14H3j6tTkiRJmru5Bjqqag2wqKruqKqPAoeOr1uSJEmaq7lOirg9yc7ARUn+FPgOmxEGJUmSND5zDWUvbW1fAdwGLAOeO65OSZIkae7mOsv16iS7Ag+sqjeNuU+SJEnaDHOd5fpshr/j+oW2/pgkZ4yzY5IkSZqbud5yfSNwAHAzQFVdBOw7pj5JkiRpM8w10P1PVd0yray2dWckSZK0+eY6y/WSJL8KLEqyH/BK4N/G1y1JkiTN1VxH6H4HeATwQ+CTwC3Aq8bVKUmSJM3dXAPd/u21GNgFWAmcP65OSZIkae7mesv1E8DvA98Afjy+7kiSJGlzzTXQrauqvx1rTyRJkrRF5hrojk3yYeBshufoAKiqz46lV5IkSZqzuQa6lwMPB3bif2+5FmCgkyRJmrC5BrrHV9XDxtoTSZIkbZG5znL9tyT7j7UnkiRJ2iJzHaE7ELgoyTcZnqELUFX1s2PrmSRJkuZkroHu0LH2QpIkSVtsToGuqq4ed0ckSZK0Zeb6DJ0kSZIWKAOdJElS5wx0kiRJnTPQSZIkdc5AJ0mS1DkDnSRJUucMdJIkSZ0z0EmSJHXOQCdJktQ5A50kSVLnDHSSJEmdM9BJkiR1zkAnSZLUOQOdJElS5yYS6JLsnuS0JP+R5LIkT0yyZ5KzklzR/t2jtU2S9yZZk+TiJI8d2c+q1v6KJKsmcS6SJEmTNqkRuvcAX6iqhwOPBi4DXg+cXVX7AWe3dYCnA/u111HABwGS7AkcCzwBOAA4dioESpIk7UjmPdAluS/wi8BHAKrqR1V1M7ASOLE1OxE4rC2vBE6qwbnA7kkeCBwCnFVV66vqJuAs4NB5PBVJkqQFYRIjdPsC64CPJrkwyYeT3At4QFV9p7W5DnhAW94buGZk+7WtbLZySZKkHcokAt1i4LHAB6vq54Db+N/bqwBUVQG1rQ6Y5Kgkq5OsXrdu3bbarSRJ0oIwiUC3FlhbVV9p66cxBLzvtluptH+vb/XXAstGtl/aymYrv5uqOr6qVlTViiVLlmyzE5EkSVoI5j3QVdV1wDVJHtaKDgIuBc4ApmaqrgJOb8tnAEe02a4HAre0W7NnAgcn2aNNhji4lUmSJO1QFk/ouL8DfCLJzsCVwMsZwuWpSY4ErgZe0Np+HngGsAa4vbWlqtYneQtwfmv35qpaP3+nIEmStDBMJNBV1UXAihmqDpqhbQFHz7KfE4ATtm3vJEmS+uJfipAkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJMkSercxAJdkkVJLkzyd2193yRfSbImyaeT7NzK79HW17T65SP7OKaVX57kkMmciSRJ0mRNcoTuVcBlI+vvAN5VVQ8FbgKObOVHAje18ne1diTZH3gR8AjgUOADSRbNU98lSZIWjIkEuiRLgWcCH27rAZ4KnNaanAgc1pZXtnVa/UGt/UrglKr6YVV9E1gDHDA/ZyBJkrRwTGqE7t3Aa4Eft/X7ATdX1Ya2vhbYuy3vDVwD0Opvae3vLJ9hm7tIclSS1UlWr1u3bluehyRJ0sTNe6BL8izg+qq6YL6OWVXHV9WKqlqxZMmS+TqsJEnSvFg8gWM+CXhOkmcAuwD3Ad4D7J5kcRuFWwpc29pfCywD1iZZDNwXuHGkfMroNpIkSTuMeR+hq6pjqmppVS1nmNTwxap6MfAl4Hmt2Srg9LZ8Rlun1X+xqqqVv6jNgt0X2A84b55OQ5IkacGYxAjdbF4HnJLkrcCFwEda+UeAk5OsAdYzhECq6pIkpwKXAhuAo6vqjvnvtiRJ0mRNNNBV1TnAOW35SmaYpVpVPwCeP8v2bwPeNr4eSpIkLXz+pQhJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjpnoJMkSeqcgU6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzhnoJEmSOmegkyRJ6pyBTpIkqXMGOkmSpM4Z6CRJkjq3eNId2B4tf/3nJt0FaYd31XHPnHQXJGneOEInSZLUuXkPdEmWJflSkkuTXJLkVa18zyRnJbmi/btHK0+S9yZZk+TiJI8d2deq1v6KJKvm+1wkSZIWgkmM0G0AXlNV+wMHAkcn2R94PXB2Ve0HnN3WAZ4O7NdeRwEfhCEAAscCTwAOAI6dCoGSJEk7knkPdFX1nar6alv+b+AyYG9gJXBia3YicFhbXgmcVINzgd2TPBA4BDirqtZX1U3AWcCh83gqkiRJC8JEn6FLshz4OeArwAOq6jut6jrgAW15b+Cakc3WtrLZyiVJknYoEwt0Se4NfAb43aq6dbSuqgqobXiso5KsTrJ63bp122q3kiRJC8JEAl2SnRjC3Ceq6rOt+LvtVirt3+tb+bXAspHNl7ay2crvpqqOr6oVVbViyZIl2+5EJEmSFoBJzHIN8BHgsqr6i5GqM4CpmaqrgNNHyo9os10PBG5pt2bPBA5OskebDHFwK5MkSdqhTOKDhZ8EvBT4epLloP3HAAAFh0lEQVSLWtkfAscBpyY5ErgaeEGr+zzwDGANcDvwcoCqWp/kLcD5rd2bq2r9/JyCJEnSwjHvga6q/gXILNUHzdC+gKNn2dcJwAnbrneSJEn98S9FSJIkdc5AJ0mS1DkDnSRJUucMdJIkSZ0z0EmSJHXOQCdJktQ5A50kSVLnDHSSJEmdM9BJkiR1zkAnSZLUOQOdJElS5wx0kiRJnTPQSZIkdc5AJ0mS1DkDnSRJUucMdJIkSZ0z0EmSJHXOQCdJktQ5A50kSVLnDHSSJEmdM9BJkiR1zkAnSZLUOQOdJElS5wx0kiRJnTPQSZIkdc5AJ0mS1DkDnSRJUucMdJIkSZ0z0EmSJHXOQCdJktQ5A50kSVLnDHSSJEmdM9BJkiR1zkAnSZLUOQOdJElS5wx0kiRJnTPQSZIkdc5AJ0mS1DkDnSRJUucMdJIkSZ0z0EmSJHXOQCdJktQ5A50kSVLnDHSSJEmdM9BJkiR1zkAnSZLUOQOdJElS5wx0kiRJnes+0CU5NMnlSdYkef2k+yNJkjTfug50SRYB7weeDuwPHJ5k/8n2SpIkaX51HeiAA4A1VXVlVf0IOAVYOeE+SZIkzaveA93ewDUj62tbmSRJ0g5j8aQ7MB+SHAUc1Va/l+TySfZHXdgLuGHSndCWyzsm3QNpk3yf6dg8vsc8eC6Neg901wLLRtaXtrK7qKrjgePnq1PqX5LVVbVi0v2QtP3yfUbbUu+3XM8H9kuyb5KdgRcBZ0y4T5IkSfOq6xG6qtqQ5BXAmcAi4ISqumTC3ZIkSZpXXQc6gKr6PPD5SfdD2x1v0UsaN99ntM2kqibdB0mSJG2F3p+hkyRJ2uEZ6LTdS3JYkkry8JGyP0tySZI/m6H9c/wzcpI2JskdSS4aefmeoYnylqu2e0k+DTwI+GJVHdvKbgH2rKo7prVdXFUbJtBNSR1J8r2quvcWbuv7jLY5R+i0XUtyb+DJwJEMH2tDkjOAewMXJHlhko8l+VCSrwB/muRlSd7X2j4gyd8k+Vp7/Xwr/39JLmijfEfNfHRJO5okVyXZqy2vSHJOW35jkpOT/CtwcpJdknw0ydeTXJjkl1q7lyU5Pck5Sa5IcuzIvl+S5Lw2IviX7e+ZS8B2MMtV2oSVwBeq6j+T3JjkcVX1nPa/68cAJHk6w4dS/3xV3ZHkZSPbvxf4p6r6lfbmOfU/8l+rqvVJdgXOT/KZqrpxHs9L0mTtmuSikfW3V9WnN7HN/sCTq+r7SV4DVFU9qj0O8g9Jfrq1OwB4JHA7w/vL54DbgBcCT6qq/0nyAeDFwEnb8qTULwOdtneHA+9py6e09QtmaPfX02+/Nk8FjgBo9be08lcm+ZW2vAzYDzDQSTuO70/9p3AznFFV32/LTwb+L0BV/UeSq4GpQHfW1H8Qk3y2td0API4h4AHsCly/daeg7YmBTtutJHsyBLJHJSmGD5+uJH8wQ/PbNmO/TwGeBjyxqm5vt1R22foeS9oObOB/H2ea/r4w1/eZ6Q+3FxDgxKo6Ziv6pu2Yz9Bpe/Y84OSqenBVLa+qZcA3gV/YjH2cDfwWQJJFSe4L3Be4qYW5hwMHbuuOS+rWVQwjaQDP3Ui7f2a4ZUq71boPcHmr++Uke7ZHOg4D/pXhveh5Se7fttkzyZz+aLt2DAY6bc8OB/5mWtlnWvlcvQr4pSRfZ7hVuz/wBWBxksuA44Bzt0FfJfVl12kfW3JcK38T8J4kq4GZHuOY8gHgJ9p7y6eBl1XVD1vdeQzvVRcDn6mq1VV1KfAGhmftLgbOAh44hvNSp/zYEkmSFog2KWtFVb1i0n1RXxyhkyRJ6pwjdJIkSZ1zhE6SJKlzBjpJkqTOGegkSZI6Z6CTJEnqnIFOkiSpcwY6SZKkzv1/2Cg1d/E+sxYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\" \n",
    "This is  MeanPlot.py script\n",
    "This script uses gapminder.txt to calculate and plot mean GDP per capita for African and European countries \n",
    "\"\"\"\n",
    "\n",
    "####### import statements ##########\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt      \n",
    "import pylab\n",
    "\n",
    "####### user-defined functions #########\n",
    "def getContinent(continent, df):\n",
    "    my_continent = df[df.continent == continent]\n",
    "    return my_continent\n",
    "\n",
    "def getMean(column_name, df):\n",
    "    return df.loc[:,column_name].mean()\n",
    "\n",
    "def getMeanPerContinent(continent, column_name, df):\n",
    "    my_continent=getContinent(continent, df)\n",
    "    continent_mean=getMean(column_name, my_continent)\n",
    "    return continent_mean\n",
    "\n",
    "def plot_bar(continents_list, meanData_list, y_label, title, figure_name):\n",
    "    # Set figure width to 10 and height to 8\n",
    "    fig_size = plt.rcParams[\"figure.figsize\"]\n",
    "    fig_size[0] = 10\n",
    "    fig_size[1] = 8\n",
    "    plt.rcParams[\"figure.figsize\"] = fig_size\n",
    "\n",
    "    #Plot the graph with Y axis label and Title\n",
    "    plt.bar(continents_list,meanData_list,align='center')\n",
    "    plt.ylabel(y_label)\n",
    "    plt.title(title)\n",
    "    plt.savefig(figure_name)\n",
    "\n",
    "####### end user-defined functions #########\n",
    "\n",
    "\n",
    "####### reading data into Python ##########\n",
    "my_file = pd.read_csv(\"gapminder.txt\", sep = \"\\t\")\n",
    "\n",
    "\n",
    "####### data analysis #########\n",
    "\n",
    "#calculate means for Africa and Europe\n",
    "Africa_Mean = getMeanPerContinent('Africa','gdpPercap', my_file)\n",
    "Europe_Mean = getMeanPerContinent('Europe','gdpPercap', my_file)\n",
    "\n",
    "# Create a List to store the values\n",
    "continents = [\"Africa\",\"Europe\"]\n",
    "means = [Africa_Mean, Europe_Mean]\n",
    "\n",
    "# plot\n",
    "plot_bar(continents, means, 'meanGDP', 'Mean GDP per capita: Africa vs Europe', 'Mean_Gdp.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice, we are moving as much code as possible into functions. This improves readability and makes our program more modular.\n",
    "The data analysis part of the script is easy to read, if we really want to know means per continent were calculated, we can look it up in function definintion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Running Python scripts from the command line\n",
    "\n",
    "Jupyter notebook is helpful for writing scripts for its interactive feature where you can check that every command works as intended. But at the end, python scripts are just text files with a series of commands written in the order of execution. We can save our final script as `MeanPlot.py` into our `Python_programming` directory. Now you can open terminal, navigate to `Python_programming`  and run this script from the command line:  \n",
    "`$ python MeanPlot.py`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Passing command-line arguments to python scripts\n",
    "\n",
    "Remember how you passed command-line arguments to Bash script yesterday?   \n",
    "`$ ./MyScript.sh inputFile`  \n",
    "In Bash, there are special variables, `$1`,`$2`, ... inside shell script. The values assigned to these variables are supplied at the command line.  \n",
    "In Python, command-line arguments are stored in a special list, `sys.argv`. To use this list we need to import `sys` library.  \n",
    "Let's modify MeanPlot.py to supply input file at the command line. Call it `MeanPLot2.py`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" \n",
    "This is  MeanPlot2.py script\n",
    "This script uses gapminder.txt to calculate and plot mean GDP per capita for African and European countries \n",
    "\"\"\"\n",
    "\n",
    "####### import statements ##########\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt      \n",
    "import pylab\n",
    "import sys\n",
    "\n",
    "####### user-defined functions #########\n",
    "def getContinent(continent, df):\n",
    "    my_continent = df[df.continent == continent]\n",
    "    return my_continent\n",
    "\n",
    "def getMean(column_name, df):\n",
    "    return df.loc[:,column_name].mean()\n",
    "\n",
    "def getMeanPerContinent(continent, column_name, df):\n",
    "    my_continent=getContinent(continent, df)\n",
    "    continent_mean=getMean(column_name, my_continent)\n",
    "    return continent_mean\n",
    "\n",
    "def plot_bar(continents_list, meanData_list, y_label, title, figure_name):\n",
    "    # Set figure width to 10 and height to 8\n",
    "    fig_size = plt.rcParams[\"figure.figsize\"]\n",
    "    fig_size[0] = 10\n",
    "    fig_size[1] = 8\n",
    "    plt.rcParams[\"figure.figsize\"] = fig_size\n",
    "\n",
    "    #Plot the graph with Y axis label and Title\n",
    "    plt.bar(continents_list,meanData_list,align='center')\n",
    "    plt.ylabel(y_label)\n",
    "    plt.title(title)\n",
    "    plt.savefig(figure_name)\n",
    "    \n",
    "####### end user-defined functions #########\n",
    "\n",
    "\n",
    "####### reading data into Python ##########\n",
    "inFile = sys.argv[1]\n",
    "my_file = pd.read_table(inFile)\n",
    "\n",
    "\n",
    "####### data analysis #########\n",
    "\n",
    "#calculate means for Africa and Europe\n",
    "Africa_Mean = getMeanPerContinent('Africa','gdpPercap', my_file)\n",
    "Europe_Mean = getMeanPerContinent('Europe','gdpPercap', my_file)\n",
    "\n",
    "# Create a List to store the values\n",
    "continents = [\"Africa\",\"Europe\"]\n",
    "means = [Africa_Mean, Europe_Mean]\n",
    "\n",
    "# plot\n",
    "plot_bar(continents, means, 'meanGDP', 'Mean GDP per capita: Africa vs Europe', 'Mean_Gdp.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To run this script from the command line, save as MeanPlot2.py, open terminal and type:  \n",
    "`$ python MeanPlot2.py gapminder.txt`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Challenge 3**  \n",
    "Modify `MeanPlot2.py` to plot mean life expectancy for 3 continents of your choice. Save as `MeanPlot3.py`  \n",
    "\n",
    "  \n",
    "**Solution to Challenge 3**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" \n",
    "This is  MeanPlot2.py script\n",
    "This script uses gapminder.txt to calculate and plot mean GDP per capita for African and European countries \n",
    "\"\"\"\n",
    "\n",
    "####### import statements ##########\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt      \n",
    "import pylab\n",
    "import sys\n",
    "\n",
    "####### user-defined functions #########\n",
    "def getContinent(continent, df):\n",
    "    my_continent = df[df.continent == continent]\n",
    "    return my_continent\n",
    "\n",
    "def getMean(column_name, df):\n",
    "    return df.loc[:,column_name].mean()\n",
    "\n",
    "def getMeanPerContinent(continent, column_name, df):\n",
    "    my_continent=getContinent(continent, df)\n",
    "    continent_mean=getMean(column_name, my_continent)\n",
    "    return continent_mean\n",
    "\n",
    "def plot_bar(continents_list, meanData_list, y_label, title, figure_name):\n",
    "    # Set figure width to 10 and height to 8\n",
    "    fig_size = plt.rcParams[\"figure.figsize\"]\n",
    "    fig_size[0] = 10\n",
    "    fig_size[1] = 8\n",
    "    plt.rcParams[\"figure.figsize\"] = fig_size\n",
    "\n",
    "    #Plot the graph with Y axis label and Title\n",
    "    plt.bar(continents_list,meanData_list,align='center')\n",
    "    plt.ylabel(y_label)\n",
    "    plt.title(title)\n",
    "    plt.savefig(figure_name)\n",
    "    \n",
    "####### end user-defined functions #########\n",
    "\n",
    "\n",
    "####### reading data into Python ##########\n",
    "inFile = sys.argv[1]\n",
    "my_file = pd.read_table(inFile)\n",
    "\n",
    "\n",
    "####### data analysis #########\n",
    "\n",
    "#calculate means for Africa and Europe\n",
    "Africa_Mean = getMeanPerContinent('Africa','gdpPercap', my_file)\n",
    "Europe_Mean = getMeanPerContinent('Europe','gdpPercap', my_file)\n",
    "Asia_Mean = getMeanPerContinent('Asia','gdpPercap', my_file)\n",
    "\n",
    "# Create a List to store the values\n",
    "continents = [\"Africa\",\"Europe\", \"Asia\"]\n",
    "means = [Africa_Mean, Europe_Mean, Asia_Mean]\n",
    "\n",
    "# plot\n",
    "plot_bar(continents, means, 'meanGDP', 'Mean GDP per capita: Africa vs Europe vs Asia', 'Mean_Gdp.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Challenge 3  OLD - DON'T USE**\n",
    "\n",
    "Modify `MeanPlot2.py` to plot mean life expectancy for 3 countries of your choice. Save as `MeanPlot3.py`  \n",
    "Remember, you can view the list of available countries with `my_file['country'].unique()` command in Jupyter Notebook\n",
    "or from the terminal like this: `cut -f1 gapminder.txt|sort|uniq`  \n",
    "  \n",
    "**Solution to Challenge 3**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" \n",
    "This is  MeanPlot3.py script\n",
    "This script uses gapminder.txt to calculate and plot mean life expectancy for Norway, Uruguay and Mexico\n",
    "\"\"\"\n",
    "\n",
    "####### import statements ##########\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt      \n",
    "import pylab\n",
    "import sys\n",
    "\n",
    "####### user-defined functions #########\n",
    "def getCountry(country, df):\n",
    "    my_country = df[df.country == country]\n",
    "    return my_country\n",
    "\n",
    "def getMean(column_name, df):\n",
    "    return df.loc[:,column_name].mean()\n",
    "\n",
    "def getMeanPerCountry(country, column_name, df):\n",
    "    my_country=getCountry(country, df)\n",
    "    country_mean=getMean(column_name, my_country)\n",
    "    return country_mean\n",
    "\n",
    "def plot_bar(country_list, meanData_list, y_label, title, figure_name):\n",
    "    # Set figure width to 10 and height to 8\n",
    "    fig_size = plt.rcParams[\"figure.figsize\"]\n",
    "    fig_size[0] = 10\n",
    "    fig_size[1] = 8\n",
    "    plt.rcParams[\"figure.figsize\"] = fig_size\n",
    "\n",
    "    #Plot the graph with Y axis label and Title\n",
    "    plt.bar(country_list,meanData_list,align='center')\n",
    "    plt.ylabel(y_label)\n",
    "    plt.title(title)\n",
    "    plt.savefig(figure_name)\n",
    "    \n",
    "####### end user-defined functions #########\n",
    "\n",
    "\n",
    "####### reading data into Python ##########\n",
    "inFile = sys.argv[1]\n",
    "my_file = pd.read_table(inFile)\n",
    "\n",
    "\n",
    "####### data analysis #########\n",
    "\n",
    "#calculate means for Africa and Europe\n",
    "Norway_Mean = getMeanPerCountry('Norway','lifeExp', my_file)\n",
    "Urugay_Mean = getMeanPerCountry('Uruguay','lifeExp', my_file)\n",
    "Mexico_Mean = getMeanPerCountry('Mexico','lifeExp', my_file)\n",
    "\n",
    "# Create a List to store the values\n",
    "countries = [\"Norway\",\"Uruguay\",\"Mexico\"]\n",
    "means = [Norway_Mean, Urugay_Mean, Mexico_Mean]\n",
    "\n",
    "# plot\n",
    "plot_bar(countries, means, 'mean Life expectancy', 'Mean Life expectancy', 'Mean_lifeExp.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run this: `python MeanPlot3.py gapminder.txt`\n",
    "\n",
    "Given extra time: Discuss `__main__`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resources:\n",
    "https://www.tutorialspoint.com/python/python_functions.htm  \n",
    "https://realpython.com/documenting-python-code/"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}