Intro__Bootcamp.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UCwhQJWJLGbI"
   },
   "source": [
    "# Introduction to Python\n",
    "\n",
    "Welcome to your guided first steps on Python. In today's lesson, we'll walk you through some of the core concepts of Python, including variables, functions, loops, and logic. We will introduce these concepts in the context of tasks you might often find yourself doing when using Python to work with social data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iO4uA8eZLMyX"
   },
   "source": [
    "# Jupyter Notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NN4SfCzvK5Kr"
   },
   "source": [
    "Let's start by familarizing ourselves with the app we'll be using to run Python code: the Jupyter Notebook.\n",
    "\n",
    "Jupyter provides a web-based interactive computing platform where we can use code, narrative text, equations and visualizations. It will allow us to practice python programming. \n",
    "\n",
    "Throughout a notebook, you will see this cell or box:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "90i6dMkCz0T5"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "K2PuuDNOz-g6"
   },
   "source": [
    "You can write code inside a cell by clicking inside the box to select it.\n",
    "\n",
    "When we write code in it, we can run it by clicking the run button on the top that looks like a play button."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "EDAPh8XS0MHK",
    "outputId": "23dc5e22-7a61-4ad8-e3dc-6c7515c9855c"
   },
   "outputs": [],
   "source": [
    "print(3+5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EBbgQ8-wGfiI"
   },
   "source": [
    "Another way to run the code on your box is with the keyboard shortcut *Shift + Enter*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "lpl39CP0GbOj",
    "outputId": "ba0689f8-d5f3-4cb4-f78d-a69cc2b8588a"
   },
   "outputs": [],
   "source": [
    "print(2+2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you write code, it can be a good idea to leave a *comment* that explains in plain english what you are doing. In python, you do this by starting a line with the # sign. You can write any text you want after the # sign, and python will ignore it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lines starting with the # sign are comments, which are ignored by python and can contain any text you want.\n",
    "# The code below adds two numbers and prints the result\n",
    "print(1+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hMAtwngE0Pet"
   },
   "source": [
    "To create a new cell, press the \"plus\" button on the top. This will add a new cell below the currently selected one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "h-M5WtUMKcnK"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AQkEYkbRLdXz"
   },
   "source": [
    "# Variables and Statements\n",
    "\n",
    "Learning objectives\n",
    "* Understand what a variable is\n",
    "* Know the difference between variables and values\n",
    "* Create a variable\n",
    "* Do things with a variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NBnp5mXO5MQP"
   },
   "source": [
    "We will first learn to create **variables**. \n",
    "\n",
    "A Python variable is a memory space used to store values.\n",
    "\n",
    "You can think of this memory space as a container. The container is assigned a **name**, and inside of it, it contains a specific value, such as a letter or a number.\n",
    "\n",
    "A **value** is the fundamental thing (e.g., a letter, a number, a sign or a combination of these) that the program manipulates. For our purposes, we will also refer to them as **objects**.\n",
    "\n",
    "We can easily draw a comparison to mathematical variables in social science. For example, in a study you might have collected participant's ages. Suppose Participant A is age 29. As a social scientist, you might record this data under the label \"Participant_A_Age\". In this example, the label \"Participant_A_Age\" is the *name*, and the actual numerical age, 29, is the *value*.\n",
    "\n",
    "In Python, we can represent this using the \"=\" syntax, which assigns a value to a named variable. The name goes on the left side and the value goes on the right side. Variable names can be any combinations of letters, numbers and underscores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dR7LkJx07J-y"
   },
   "outputs": [],
   "source": [
    "Participant_A_Age = 29"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2mJnrcTjEFJX"
   },
   "source": [
    "From now on, in any code we write, our notebook will remember the value assigned to the variable \"Participant_A_Age\". We can therefore use the name \"Participant_A_Age\" to access the stored value, for example we can print it out: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Participant_A_Age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Unzk6mtytVo-"
   },
   "source": [
    "Naming variables and using the function *print* will be enough for us to program the writing of a first simple sentence.  \n",
    "\n",
    "For example, if I create variables for a participant's identifier and their age, then I can recall these values into a sentence that uses them.\n",
    "\n",
    "The rest of the text in my sentence, I can include by separating it from the variables with commas and enclosing it in quotation marks. Like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "XbkPIGcF_uCa",
    "outputId": "71b5be28-8173-4058-abb2-026b10c90186"
   },
   "outputs": [],
   "source": [
    "age_1= 34\n",
    "Response_ID = 1\n",
    "print('Participant', Response_ID, 'is', age_1, 'years old.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1kZfwelLLyod"
   },
   "source": [
    "# Types of Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AxFWvP4gxLYm"
   },
   "source": [
    "According to the kind of values that make them up, variables can be of different types.\n",
    "\n",
    "This is important because different kinds of variables will be subject to different rules and operations.\n",
    "\n",
    "What kind of variables can you think of? (Hint: consider the different kinds of data you might collect in a study)\n",
    "\n",
    "*(We'll pause here to let you make some guesses)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZVCEZzpXxmne"
   },
   "source": [
    "The first type of variables we will look at are those made of **integers** and we will call them *(int)*\n",
    "\n",
    "An integer is a number that we can count. A whole number. Say, 3. Or 345. Intergers allow us to count the number of whole things we have. \n",
    "\n",
    "Fractions (or numbers with decimals) instead are called **floating numbers** *(float)*\n",
    "\n",
    "A floating number is a fractional number and it allows us to measure the dimension of something. For example, my thumb is 59.32 mm long.\n",
    "\n",
    "Lastly, we have variables made of letters or text and symbols, and we call those string variables or **strings** *(str)*.\n",
    "\n",
    "Here are some examples of all three types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Participant_B_Age = 34 # an int variable\n",
    "Participant_B_Salary = 42.75 # a float variable\n",
    "Participant_B_Hometown = \"Ithaca\" # a str variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WGBktiIBuIhF"
   },
   "source": [
    "Try setting a variable for your name and one for the city where you were born. Then have the notebook print out a sentence saying where you were born.\n",
    "\n",
    "What type of variable were the name and city?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "O6GxmpNluXxt"
   },
   "outputs": [],
   "source": [
    "# Write your solution here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DHk7IMk4zOEs"
   },
   "source": [
    "You can use the function *type* to have the notebook tell you what type a variable is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "QUwvs5bh5etf",
    "outputId": "8f796e58-bf61-4305-b78c-ff11d5dd77f8"
   },
   "outputs": [],
   "source": [
    "type(Participant_B_Hometown)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Vke40G5A5e1x"
   },
   "source": [
    "The function *type* can also be used with values rather than variable names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "O6IAsODy5tBS",
    "outputId": "b1b522bb-2314-44f0-f3bc-ad15cf18b7f8"
   },
   "outputs": [],
   "source": [
    "type(52)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jSzPvmP2Llgl"
   },
   "source": [
    "# Calculations with Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EsCQPSGxuYLj"
   },
   "source": [
    "How can we have the notebook print how old Participant 1 will be in three years?\n",
    "\n",
    "We already have a variable for their age. So we can create a new one for their age in three years and have it print out.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "UASqRUXxv0kO",
    "outputId": "6377f343-b564-415d-b2f2-a53237cc425b"
   },
   "outputs": [],
   "source": [
    "Later_Age_1 = age_1 + 3\n",
    "print(Later_Age_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5zknGcpDMvD-"
   },
   "source": [
    "This has added an *int variable* with an *int value*.\n",
    "\n",
    "To multiply we will use the asterix symbol *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "574zZCMyNVLQ",
    "outputId": "d9561f41-98ed-428c-a9c5-35b81931e3fc"
   },
   "outputs": [],
   "source": [
    "b=3*3\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VPS4Z08-Nbfl"
   },
   "source": [
    "This has multiplied two *int values*.\n",
    "\n",
    "To divide we will use the slash symbol /."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "D11UEPKQN2yt",
    "outputId": "7db14961-ce35-42f0-beda-cd51198d785c"
   },
   "outputs": [],
   "source": [
    "c=5/2\n",
    "print(c)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "i8__n5q2OIh5"
   },
   "source": [
    "In this case we divided two *int* values and obtained a *float* one"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tqOwV2S30OC2"
   },
   "source": [
    "To square a number we will use the double asterisk symbol `**`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "BxgbYFrb0RPp",
    "outputId": "532d58b6-6b34-4420-e1cc-f8b0ab45d26c"
   },
   "outputs": [],
   "source": [
    "d=3**2\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6xlVldEY5tNj"
   },
   "source": [
    "Many operations are valid for string values and variables too.\n",
    "\n",
    "By \"adding them\" with a '+' we can concatenate them, like blocks into sentences.\n",
    "\n",
    "I can create a variable made of two string values for my full name. I make sure to separate the string values with quotation marks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "P-XYILiI6val",
    "outputId": "fc4593aa-a4d6-4ec5-9371-2fe2b1bd6979"
   },
   "outputs": [],
   "source": [
    "Hometown = 'Saint'+'Louis'\n",
    "\n",
    "print(Hometown)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ilNYylovO8mG"
   },
   "source": [
    "As you can see, the two words have been assembled one next to the other. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qdPiUe3bPQwC"
   },
   "source": [
    "I may want to add a space here. What kind of value is a space and how can you add it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "jOmphwxBNgGs",
    "outputId": "98c1c5e4-2540-45bd-d05f-dc695c3a94d0"
   },
   "outputs": [],
   "source": [
    "type(' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "A5DN9gASPU7g",
    "outputId": "73428236-ee5c-495c-b283-9a64004890a0"
   },
   "outputs": [],
   "source": [
    "Hometown = 'Saint'+' '+'Louis'\n",
    "print(Hometown)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_y4tsQjkVFjo"
   },
   "source": [
    "Numbers written in between ' ' will show as string variables instead of integers variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "T_4ZhhrmVRG4",
    "outputId": "176dc838-3cb8-4b14-b423-cc0f96546f94"
   },
   "outputs": [],
   "source": [
    "print('Participat', Response_ID, 'is', '34')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AaAzpQG1Pkbu"
   },
   "source": [
    "What would happen if I want to add a string value to an integer value? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 184
    },
    "id": "eALLi07-Uc0Z",
    "outputId": "d34dd4ec-784c-42c9-cea7-06659492b3e1"
   },
   "outputs": [],
   "source": [
    "e='participant'+1\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jWdL-XB3N2RM"
   },
   "source": [
    "The code cell above holds a mistake because variables of different types cannot be added."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iTDyOix-MWam"
   },
   "source": [
    "# Operations Mixing Variable Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r8KDYq5Hw3GI"
   },
   "source": [
    "Python has a trick that will allows us to use different variable types in one same operation: casting.\n",
    "\n",
    "Casting a variable or value is converting it to another type. To convert it, we will type first the type we want the variable to have, and right after, we type in a parenthesis the variable. For example: *str(1)*.\n",
    "\n",
    "We saw before that writing a number between quotation marks will show it as a string value. If  that is true, then adding two numbers in quotations would concatenate them:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "YkSk0AZ9V7ty",
    "outputId": "ff1dd11d-c08f-4a7d-f20e-8495c7f417a4"
   },
   "outputs": [],
   "source": [
    "print('1' + '2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Lg5moI-GWS8n"
   },
   "source": [
    "How could I convert (cast) this string ('2') into an integer to use it in a sum?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "FBwKQjOu-amc",
    "outputId": "ab873520-e8c3-4b9e-e9a0-638d49d551a3"
   },
   "outputs": [],
   "source": [
    "print(1 + int('2'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_emNrlDh_N-h"
   },
   "source": [
    "We can also cast an int value into a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "9ekT9tIA_Ws7",
    "outputId": "360ea666-3d14-4071-9ff3-c74a2a531208"
   },
   "outputs": [],
   "source": [
    "print(str(1) + '2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1b5-a2mLOjf5"
   },
   "source": [
    "Great. Questions so far?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hCDsmIg8XOUk"
   },
   "source": [
    "# Functions\n",
    "\n",
    "Learning Objectives:\n",
    "\n",
    "*   Understand the concept of a function and syntax of a function\n",
    "*   View examples of methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NCPCOZreXZc8"
   },
   "source": [
    "A function is like a button, that when pressed (called) will do an action to a variable. \n",
    "\n",
    "When we created a variable, we taught the program what value to recall when we write the variable name.\n",
    "\n",
    "When we create a function, we instead teach the program what action to perform when we write the function name.\n",
    "\n",
    "To create a function, use the following syntax:\n",
    "- The keyword \"def\" (short for \"define\")\n",
    "- The name of the function (like variables, can contain letters, numbers, and underscores)\n",
    "- Parentheses containing one or more *arguments* (we'll explain what this means shortly)\n",
    "- A colon after the closing parentheses\n",
    "- One or more lines of code that are indented. These indented lines of code define the actions that will be performed in the function, and are referred to as the function's *body*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "aBaAAky6X3Su"
   },
   "outputs": [],
   "source": [
    "def increase_age(starting_age):\n",
    "    later_age = starting_age + 3\n",
    "    print(\"The age after 3 years will be\", later_age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above example defines a function that adds 3 to a starting_age and prints the result in a sentence. Importantly, in this definition, starting_age does not refer to a specific variable or value. Instead, it is a placeholder, which in Python is referred to as an *argument*. The idea is that the function represents a \"generic\" action that can be done to any variable or value. When you call the function (press the button), you have to tell it what *specific* variable or value to act on. You do this typing the function name and then putting the variable or value in parentheses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "SvomqfVCjfuS",
    "outputId": "e53878c4-e5fb-4827-c17f-7042c3055459"
   },
   "outputs": [],
   "source": [
    "increase_age(age_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can have multiple arguments. The arguments are separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def summarize(who, how_old):\n",
    "    later_age = how_old + 3\n",
    "    print(\"Participant \" + str(who) + \" \" + \"is \" + str(how_old) + \" years old, and will be \" + str(later_age) + \" \" + \"in three years.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "summarize(Response_ID, age_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are also able to produce *results* when they are called. This is done using the \"return\" keyword, and the result can be saved to a variable. To continue the button analogy, think of this as \"when you press the button, something comes out\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def celsius_to_fahrenheit(celsius_temp):\n",
    "    return (9 / 5) * celsius_temp + 32\n",
    "\n",
    "todays_temperature_C = 32\n",
    "# the result returned by celsius_to_fahrenheit can be saved to a variable\n",
    "todays_temperature_F = celsius_to_fahrenheit(todays_temperature_C)\n",
    "# we can now use this variable in our code, like any other variable\n",
    "print(\"Today's temperature is \" + str(todays_temperature_C) + \" in celsius, which is \" + str(todays_temperature_F) + \" in fahrenheit\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions that return results are very useful when there are calculations that you expect to do multiple times, such as unit conversion like in the example above. By writing the math only once and saving it in a function, you don't need to write the full calculation every time you need it, you just need to call the function, which is much neater."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "n4tVTGDMkTMX"
   },
   "source": [
    "In the previous examples we created our own functions, but there are many already built in functions. \n",
    "\n",
    "We have already used a few: *print(), int(), float(), type()*.\n",
    "\n",
    "Let's use three other examples of built-in functions: *max()*, *min()*, and *round()*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cP_3YjIzIB1B"
   },
   "source": [
    "We can find the maximum value of an integer list with the function *max*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "KvP4hCFeIswk"
   },
   "outputs": [],
   "source": [
    "max(1, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "35MTeJ--0fEr"
   },
   "source": [
    "This function will work with string values too analyzing them in alphabetical order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5G84EPdY0R1F"
   },
   "outputs": [],
   "source": [
    "min('a', 'b', 'c')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1XM0WORgIs6R"
   },
   "source": [
    "The built-in function *round()* will round a floating number to the number of decimals of your choosing. \n",
    "\n",
    "This specification of how many decimals the function must round up to is called a *parameter*.\n",
    "\n",
    "Parameters are included in the parenthesis after the function name and are separated by comas:\n",
    "\n",
    "*function(parameter, parameter)*\n",
    "\n",
    "To round the floating number 5.389 to 1 decimal, we will do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qevf1tWeJQRm"
   },
   "outputs": [],
   "source": [
    "round(5.389, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Pehg7tcYFy0P"
   },
   "source": [
    "There are also special functions that *belong to* an object, known as **methods**. You can think of a method as \"something that the object can do\". Different types of objects have different methods. For example, string objects have a method called \"upper\" which tells the string to turn itself into uppercase. By contrast, integer objects do not have this method, because integers cannot turn themselves into uppercase.\n",
    "\n",
    "Methods are called by adding a dot *.* after a variable or value, then typing the method name. So for example, if we have a string variable and want to call the \"upper\" method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "YazL03LnGpDR",
    "outputId": "e4c18d38-2396-4ed4-9d7a-d904c4d3ad00"
   },
   "outputs": [],
   "source": [
    "first_name = 'sam'\n",
    "first_name_uppercase = first_name.upper() # call the \"upper\" method of the string variable \"first_name\"\n",
    "print(first_name_uppercase)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sWeWDdExHR6j"
   },
   "source": [
    "This method can be used on any string value, not just variables. For example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "KvAQBufAHkOh",
    "outputId": "6499ca8b-7215-465b-de1d-69979f3ed6f5"
   },
   "outputs": [],
   "source": [
    "'Sam'.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MTABKV2qJXSx"
   },
   "source": [
    "You can find out what a method does by using the function *help*.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "7Ab_j3xKJlEF",
    "outputId": "2c523663-6dd4-4859-bf2b-8c074f0bd234"
   },
   "outputs": [],
   "source": [
    "help(str.upper)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yeCbIPQHHm5F"
   },
   "source": [
    "Find our what these other methods do:\n",
    "\n",
    "*str.replace*\n",
    "\n",
    "*str.find*\n",
    "\n",
    "*str.lower*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9FNTqEH9IBsA"
   },
   "outputs": [],
   "source": [
    "help(str.replace)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ffS_q0ipJrxj"
   },
   "source": [
    "Great job. Questions so far?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5fCEDCU_qrC0"
   },
   "source": [
    "\n",
    "\n",
    "<h1>Lists</h1>\n",
    "\n",
    "Learning Objectives:\n",
    "- Understand how to create and modify a list, and what a list can and can't do\n",
    "- Become familiar with common list methods\n",
    "\n",
    "A list is an ordered, indexable collection of data. Lets say you're doing a study on the following hometowns: Brooklyn, Atlanta, Hampton, Brentwood, and Lexington.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GJBs_flRovLc"
   },
   "source": [
    "You could put that data into a list.\n",
    "\n",
    "To create a list, put your desired values inside square brackets [...],\n",
    "where each value is separated by a comma ,."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gJr_9dXGpJ05",
    "outputId": "72e082ca-fd8d-4714-a579-d4e5f2e9f5e6"
   },
   "outputs": [],
   "source": [
    "Hometown_list = [\"Brooklyn\", \"Atlanta\", \"Hampton\", \"Brentwood\", \"Lexington\"]\n",
    "type(Hometown_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lSrWNr3MuFUS"
   },
   "source": [
    "\n",
    "<h1>Use an item’s index to fetch it from a list.</h1>\n",
    "\n",
    "- Each value in a list is stored in a particular location.\n",
    "- Locations are numbered from 0 rather than 1.\n",
    "- Use the location’s index in square brackets to access the value it contains.\n",
    "\n",
    "[\"Brooklyn\", \"Atlanta\", \"Hampton\", \"Brentwood\", \"Lexington\"]\n",
    "\n",
    "index: 0             1          2          3          4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "C4HZx7Gndbrh",
    "outputId": "d1ea8af2-70e7-474f-ea67-9db0eb4f31a1"
   },
   "outputs": [],
   "source": [
    "print('the first item is:', Hometown_list[0])\n",
    "print('the fourth item is:', Hometown_list[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4_kCnsPUqS6o"
   },
   "source": [
    "Lists can be indexed from the back using a negative index.\n",
    "\n",
    "[\"Brooklyn\", \"Atlanta\", \"Hampton\", \"Brentwood\", \"Lexington\"]\n",
    "\n",
    "index: -5 -4 -3 -2 -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NY2If6rU5eEm",
    "outputId": "262b8508-239d-44a7-86f5-e434fd1903ce"
   },
   "outputs": [],
   "source": [
    "print(Hometown_list[-1])\n",
    "print(Hometown_list[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OwuxHmxllTwN"
   },
   "source": [
    "## \"Slice\" a list using [ : ]\n",
    "\n",
    "- We can get multiple items from a list using slicing\n",
    "- Note that the first index is included, while the second is excluded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "EFe-Mu9C5p7s",
    "outputId": "3342254e-7b4b-4aa9-f4a4-6f73c200c66f"
   },
   "outputs": [],
   "source": [
    "print(Hometown_list[1:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Yeox4FGM5r0p"
   },
   "source": [
    "You can leave the first index blank if you want to start from the beginning of the list. Likewise, you can leave the second index blank if you want to end with the last item in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "8195YIO-5sVT",
    "outputId": "ac9c09a5-daec-4469-d618-117b3007ca84"
   },
   "outputs": [],
   "source": [
    "print(Hometown_list[:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3_mWASNg5td4",
    "outputId": "a96d0a91-53bf-4fe1-92a1-bba8de15a35a"
   },
   "outputs": [],
   "source": [
    "print(Hometown_list[2:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HhLA1gdOAuYq"
   },
   "source": [
    "## Use index in a string\n",
    "\n",
    "The same indexing and slicing syntax can also be used to access individual letters in a string!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "V1al0C09FAi6",
    "outputId": "6a6efc12-7a86-4970-c857-31e0b6edf8c0"
   },
   "outputs": [],
   "source": [
    "Hometown = \"New York\"\n",
    "Hometown[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CG1tgs9FFA4t"
   },
   "source": [
    "Lets get the first eight letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "Hr5qV_QMFHy5",
    "outputId": "6f4bb6b1-2888-4d33-806f-02d3cedb1606"
   },
   "outputs": [],
   "source": [
    "Hometown[0:8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3CXkwqME5vn5"
   },
   "source": [
    "# Changing values in a list\n",
    "Lists’ values can be replaced by assigning to specific indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "LML6-aXn54o4",
    "outputId": "a0d47823-e4ff-42c2-8c21-12db9129b30b"
   },
   "outputs": [],
   "source": [
    "Hometown_list[0] = \"New York\"\n",
    "print('Hometown List is now:', Hometown_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "g-kPtGGm6B7c"
   },
   "source": [
    "Note, however, that the same does not apply to strings - you cannot change characters in a string with the same syntax. We will explain this more in a later workshop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 184
    },
    "id": "9809TvS_6LYk",
    "outputId": "dd659d67-ea3f-4010-bbcc-a092513e40bb"
   },
   "outputs": [],
   "source": [
    "Hometown = \"New York\"\n",
    "Hometown[0] = 'C'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6RSjL4I96nsF"
   },
   "source": [
    "## Lists have Methods\n",
    "- Just like strings have methods, lists do too.\n",
    "- IPython lets us do tab completion after a dot ('.') to see what an object has to offer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XOZ8bQJY6xtc"
   },
   "outputs": [],
   "source": [
    "Hometown_list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "d_NCLyfY6zJz"
   },
   "source": [
    "If you want to append items to the end of a list, use the append method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "CwbZTnQJ60Wo",
    "outputId": "afe4acd4-8260-4c4e-d1fb-fafd34015283"
   },
   "outputs": [],
   "source": [
    "Hometown_list.append(\"Seattle\")\n",
    "print(Hometown_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mTvHWklz61gC"
   },
   "source": [
    "## Use del to remove items from a list entirely.\n",
    "- del list_name[index] removes an item from a list and shortens the list.\n",
    "- Not a function or a method, but a statement in the language."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "pRni7PK365Ew",
    "outputId": "b6685a12-b432-44b0-b00a-4af5fc51161a"
   },
   "outputs": [],
   "source": [
    "print(\"original list was:\", Hometown_list)\n",
    "del Hometown_list[3]\n",
    "print(\"the list is now:\", Hometown_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VpejLTyf7HjD"
   },
   "source": [
    "## Challenge 1: Slice It"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "an3JtI7n7LRE"
   },
   "source": [
    "Try it yourself! Using the list \"Answers\" in the cell below, use indexing and slicing to fetch the following:\n",
    "- The fifth item in the list\n",
    "- The second to last item in the list\n",
    "- The first 4 items in the list\n",
    "- The last 6 items in the list\n",
    "- A slice containing only ['Kentwood', 'Washington']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "0G0mhUx57KFw",
    "outputId": "aceb103b-f328-4e1b-e766-fd91c1465676"
   },
   "outputs": [],
   "source": [
    "Answers = [1,3,8.75,20,6, 'Kentwood', 'Washington', 200, 2, 'Tulsa']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IRwQNs9k7buw"
   },
   "source": [
    "## Challenge 2: Index\n",
    "I've created a (long) list for you below. Use the .index() method to find out what the index number is for Waldo.\n",
    "\n",
    "Remember, to get help on how to use a method, use the \"help\" function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4Mo4klPn7g6t"
   },
   "outputs": [],
   "source": [
    "Wheres_Waldo = [\"Anna\", \"Shad\", \"Rachel\", \"Maura\", \"Jason\", \"Matt\", \"Konrad\", \"Justine\", \"Sarah\", \"Laura\", \\\n",
    "                \"Chelsea\", \"Nina\", \"Dierdre\", \"Julian\", \"Waldo\", \"Naniette\", \"Melissa\", \"Biz\", \"Elsa\", \"Demetria\",\\\n",
    "                \"Liz\", \"Olivia\", \"Will\", \"Ogi\", \"Melanie\", \"Jessica\"]\n",
    "waldo_index = _________________ # fill in the blank\n",
    "print(waldo_index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Vcw8nsC77jzd"
   },
   "source": [
    "## Challenge 3: Join\n",
    "Read the help file (or the Python documentation) for join(), a string method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "68_9co5H7m3g"
   },
   "outputs": [],
   "source": [
    "help(str.join)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "drl6Jz9l7oZG"
   },
   "source": [
    "Using the join method, concatenate all the values in this list into one string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "VMHjXta07pfb"
   },
   "outputs": [],
   "source": [
    "letters = ['N', 'a', 's', 'h', 'v', 'i', 'l', 'l', 'e']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "5MlgjB0L7qvx",
    "outputId": "44f62255-da33-4ba7-e208-89b05d815231"
   },
   "outputs": [],
   "source": [
    "result = ______________ # fill in the blank\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vlp5jArxEvW4"
   },
   "source": [
    "Great Job! Next, we will look into Dictionaries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EPacNDzcZ3w4"
   },
   "source": [
    "## Dictionaries\n",
    "Learning Objectives:\n",
    "\n",
    "\n",
    "* What is a dictionary?\n",
    "\n",
    "* What are the advantages of dictionaries?\n",
    "\n",
    "* How do I use the content of a dictionary?\n",
    "\n",
    "* Examining\n",
    "\n",
    "* Modifying\n",
    "\n",
    "* Iterating\n",
    "\n",
    "* Methods\n",
    "\n",
    "\n",
    "**What is a dictionary?** \n",
    "\n",
    "A dictionary is a collection of organized elements in pairs of keys:values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DOvUkNX1aRAx"
   },
   "outputs": [],
   "source": [
    "subjects_dict = {\"Name\": \"Forough Farrokhzad\", \n",
    "            \"Age\": 21,  \n",
    "            \"Response_ID\": \"1\", \n",
    "            \"Self_Confidence\": \"Agree Slightly\", \n",
    "            \"surveys\": [\"DevContext\",\"UseOfSpace\",\"BrainInContext\",\"SocialNutrition\"]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PakWTFrgaVe6"
   },
   "source": [
    "for this reason, dictionaries are also called key-value pairs.\n",
    "\n",
    "In this example,\n",
    "\n",
    "the **keys** are **name, age, response_ID, Self_Confidencee** and **surveys**, and everything after the colon are the *values* assigned to that key: *Forough Farrokhzad, 21, 1, Agree Slightly, and [\"DevContext\",\"UseOfSpace\",\"BrainInContext\",\"SocialNutrition\"]**\n",
    "\n",
    "Dictionaries are defined with curly brackets holding the key-value pairs, written in the forman key:value and separated by comas.\n",
    "\n",
    "**When should I use dictionaries and when should I use lists?**\n",
    "\n",
    "If the data you are storing is complex and hierarchical, the dictionary's key / value structure is very helpful. This is the advantage of dictionaries.\n",
    "\n",
    "Keys must be unique (there cannot be duplicates of the dictionary with the same key) and they cannot be changed.\n",
    "\n",
    "Values, on the other hand, can be anything, including strings, intergers, booleans, lists of them or even other dictionaries.\n",
    "\n",
    "Let's see an example with different data types: strings, booleans, integers and lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "fsGoBWZGaj85"
   },
   "outputs": [],
   "source": [
    "Developmental_Context = {\n",
    "  \"City\": \"Ithaca\",\n",
    "  \"Urban\": False,\n",
    "  \"Year\": 2021,\n",
    "  \"Colleges\": [\"Cornell University\", \"Ithaca College\"]\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YAgXkHoKampA"
   },
   "source": [
    "Here is another example of a dictionary called *valid_dict* containing two other dictionaries *dict_nums* and *dict_ints.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "wLCW5W-ka2_j"
   },
   "outputs": [],
   "source": [
    "valid_dict = {'dict_nums':{1:'one', 2:'two', 3:'three'},\n",
    "             'dict_ints':{'one':1, 'two':2, 'three':3}}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZBRN9VC9a3vw"
   },
   "source": [
    "In this case *'dict_nums'* and *'dict_ints'* are both values of a dictionary, and a dictionary themselves.\n",
    "\n",
    "While dictionaries can be values in other dictionaries, they cannot be keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 184
    },
    "id": "_p6vRSU2a_P6",
    "outputId": "5f04f943-10b8-461c-fc66-4da515a7d85a"
   },
   "outputs": [],
   "source": [
    "invalid_dict = {{1:'one', 2:'two', 3:'three'}:'dict_nums',\n",
    "             {'one':1, 'two':2, 'three':3}:'dict_ints'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mAFk0WrBbABD"
   },
   "source": [
    "**Examining a Dictionary**\n",
    "\n",
    "You can use the function *print* and the methods *.values* and *.keys* to see the content of your dictionary.\n",
    "\n",
    "Let's use this on our first example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "yQFGyDQnbILA",
    "outputId": "709560aa-18d6-44cf-fbd2-52a2b43b490d"
   },
   "outputs": [],
   "source": [
    "print(subjects_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "QAmqdoqcbPQe",
    "outputId": "3a826a4c-cbe1-4b85-ce7a-69407191d3a2"
   },
   "outputs": [],
   "source": [
    "print(subjects_dict.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "MGHuoTmibTQ9",
    "outputId": "5cd81694-fa06-43d7-ad35-8f525fcf0c10"
   },
   "outputs": [],
   "source": [
    "print(subjects_dict.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "J5d4uMBsbVE2"
   },
   "source": [
    "You may want your notebook to show you a specific element from your dictionary. You can use the indexing syntax (square brackets) to look up what value goes with a specific key, like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "-Lu59cIzbX-Y",
    "outputId": "4997b6c5-7576-482f-959c-62f51adfe0d2"
   },
   "outputs": [],
   "source": [
    "subjects_dict[\"Self_Confidence\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "69ZiZv9LgFj8"
   },
   "source": [
    "**Other methods and functions for Dictionaries**\n",
    "\n",
    "The method .items can come in handy with dictionaries. What do you think it does?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "zvK6ME_rgIV5",
    "outputId": "4e49a19e-e158-4bac-910c-0239aaa8ce25"
   },
   "outputs": [],
   "source": [
    "subjects_dict.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "a3-X73ENgJ2K"
   },
   "source": [
    "If you want to know how many pairs there are in a dictionary, use len:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "aOREC5bIgMal",
    "outputId": "00cd99fd-2822-457f-cc53-d1e6abb077f1"
   },
   "outputs": [],
   "source": [
    "print(len(subjects_dict))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ViGGbAgz84BL"
   },
   "source": [
    "# Loops and Conditions\n",
    "Time\n",
    "\n",
    "Teaching: 10 min\n",
    "Exercises: 15 min\n",
    "\n",
    "Learning Objectives:\n",
    "\n",
    "- Explain what loops are normally used for.\n",
    "- Trace the execution of a simple (unnested) loop and correctly state the values of variables in each iteration.\n",
    "- Write for loops that use the Accumulator pattern to aggregate values.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ennTRx6Z9GzZ"
   },
   "source": [
    "## A for loop executes commands once for each value in a collection.\n",
    "\n",
    "Suppose we wanted to print three hometowns: Atlanta, Kentwood, Cincinnatti. We could do this by writing three print statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "pYxStx5n8mMc",
    "outputId": "97581b6e-14fb-4a41-8712-ac3bac4454b8"
   },
   "outputs": [],
   "source": [
    "print('Atlanta')\n",
    "print('Kentwood')\n",
    "print('Cincinnatti')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "A7NuSwlH9K1X"
   },
   "source": [
    "But a better way to do this is by using a for loop over a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "xiVmnQrh9W2r",
    "outputId": "1c904ed0-e096-4c22-8e72-7b6a3f99adce"
   },
   "outputs": [],
   "source": [
    "for hometown in ['Atlanta', 'Kentwood', 'Cincinnatti']:\n",
    "    print(hometown)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Q7SjqjWr9Yaq"
   },
   "source": [
    "## The first line of the for loop must end with a colon, and the body must be indented.\n",
    "- The colon at the end of the first line signals the start of a block of statements.\n",
    "- Python uses indentation rather than {} or begin/end to show nesting.\n",
    "- Any consistent indentation is legal, but almost everyone uses four spaces."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CDhPnzau9hvB"
   },
   "source": [
    "## A for loop is made up of a collection, a loop variable, and a body."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "f2hqqUYajE0s",
    "outputId": "1c904ed0-e096-4c22-8e72-7b6a3f99adce"
   },
   "outputs": [],
   "source": [
    "for hometown in ['Atlanta', 'Kentwood', 'Cincinnatti']:\n",
    "    print(hometown)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f_ooNy1k9lxu"
   },
   "source": [
    "- The collection, ['Atlanta', 'Kentwood', 'Cincinnatti'], is what the loop is being run on.\n",
    "- The body, print(hometown), specifies what to do for each value in the collection.\n",
    "- The loop variable, hometown, is what changes for each iteration of the loop, the \"current thing\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LHM6p_2_9-lN"
   },
   "source": [
    "## The Accumulator pattern turns many values into one.\n",
    "A common use of loops is to perform some computation on each item in a collection, and then save and/or combine the results in a new variable. This can be achieved using the *accumulator pattern*:\n",
    " - Initialize an accumulator variable to zero, the empty string, or the empty list.\n",
    " - Use a loop over a collection to perform computations on each value in the collection.\n",
    " - In the loop body, update the accumulator variable with the results of the computation.\n",
    " \n",
    "In the below example, we have a list of ages collected in a survey three years ago. We use the accumulator pattern to create a new list representing the subjects' current ages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "cF8FjfKP-YTP",
    "outputId": "18ac1627-a75e-4b90-ff3a-8043fb85e34e"
   },
   "outputs": [],
   "source": [
    "survey_ages = [18, 21, 34, 40, 18, 19, 20]\n",
    "\n",
    "present_ages = []\n",
    "for age in survey_ages:\n",
    "    present_ages.append(age+3)\n",
    "\n",
    "print(present_ages)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7qPPSudK-im8"
   },
   "source": [
    "## Challenge: Mean age\n",
    "Below, we have another list of ages. Write code to compute the mean age.\n",
    "\n",
    "HINT: Try using the accumulator pattern to compute the sum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "SetCwUld-lI4",
    "outputId": "d327b491-b5fe-4b83-9261-713527fd767a"
   },
   "outputs": [],
   "source": [
    "ages = [34, 52, 21, 42, 18, 36]\n",
    "\n",
    "# fill in the blanks\n",
    "accumulator = ______ # use this accumulator to hold the sum of ages. what should be its starting value?\n",
    "for ________________:\n",
    "    accumulator = ___________ # HINT: update the accumulator by adding the current age to the running sum\n",
    "    \n",
    "# remember that the mean is the sum divided by the total number of items.\n",
    "# accumulator now contains the sum, so what's the last thing we need to do?\n",
    "mean = ______________\n",
    "print(mean)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tVpHMtCD-lw0"
   },
   "source": [
    "# Conditionals\n",
    "Learning Objectives:\n",
    "\n",
    "- Being more specific with your data: \n",
    "\n",
    "  * Correctly write programs that use if and else statements and simple Boolean expressions (without logical operators).\n",
    "  * Trace the execution of unnested conditionals and conditionals inside loops.\n",
    "\n",
    "Keypoints:\n",
    " - Use if statements to control whether or not a block of code is executed.\n",
    " - Conditionals are often used inside loops.\n",
    " - Use else to execute a block of code when an if condition is not true.\n",
    " - Use elif to specify additional tests.\n",
    " - Conditions are tested once, in order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bnWvpdkq_B5O"
   },
   "source": [
    "## Use if statements to control whether or not a block of code is executed.\n",
    "- An if statement (more properly called a conditional statement) controls whether some block of code is executed or not.\n",
    "- Structure is similar to a for statement:\n",
    " - First line opens with if, contains a Boolean variable or expression, and ends with a colon\n",
    " - Body containing one or more statements is indented (usually by 4 spaces)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "-RhW_gft_IDd",
    "outputId": "87e3656a-0fed-47eb-995b-f545e2fc16ef"
   },
   "outputs": [],
   "source": [
    "age_1 = 23\n",
    "if age > 21\n",
    "    print('Being ' + str(age_1) + ', participant 1 is of age.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "EdGrlQW0_DS8",
    "outputId": "2da58c39-9d1d-4be2-fac7-6e8c1a6417e8"
   },
   "outputs": [],
   "source": [
    "age_2 = 18\n",
    "if age_2 < 21:\n",
    "    print ('Being ' + str(age_2) + ', participant 2 is under age.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "X5D7YW1I_JmM"
   },
   "source": [
    "# Conditionals are often used inside loops.\n",
    "- Not much point using a conditional when we know the value (as above).\n",
    "- But useful when we have a collection to process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "7e43_8a1_NxM",
    "outputId": "01c18cba-f84c-4df7-b16a-b83f6cc8adf4"
   },
   "outputs": [],
   "source": [
    "# select values that are underage\n",
    "\n",
    "ages = [21, 19, 18, 21, 20]\n",
    "for age in ages:\n",
    "    if age < 21:\n",
    "        print(age, 'is in underage group')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7MrLiZRJ_PN6"
   },
   "source": [
    "## Use else to execute a block of code when an if condition is not true.\n",
    "- else is always attached to if.\n",
    "- Allows us to specify an alternative to execute when the if branch isn't taken."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "UREUklD9_TZ_",
    "outputId": "4a9b18c2-734a-49e0-b21d-63d628b4a6ed"
   },
   "outputs": [],
   "source": [
    "ages = [21, 19, 18, 21, 20]\n",
    "for age in ages:\n",
    "    if age < 21:\n",
    "        print(age, 'is in underage group')\n",
    "    else:\n",
    "        print(age, 'is not in underage group')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PyIp1NX7_WVJ"
   },
   "source": [
    "# Use elif to specify additional tests.\n",
    "- May want to provide several alternative choices, each with its own test.\n",
    "- Use elif (short for \"else if\") and a condition to specify these.\n",
    "- Always associated with an if.\n",
    "- Must come before the else (which is the \"catch all\")."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "xac0YQwx_afB",
    "outputId": "b37fae37-46aa-4dc0-d210-3f17caedb8cd"
   },
   "outputs": [],
   "source": [
    "ages = [18, 88, 23, 97, 34]\n",
    "for age in ages:\n",
    "    if age > 65:\n",
    "        print(age, 'is in elders group')\n",
    "    elif age > 21:\n",
    "        print(age, 'is in adult group')\n",
    "    else:\n",
    "        print(age, 'is in teenagers group')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WcotsX2Q_cjH"
   },
   "source": [
    "## Challenge 1: Recoding the variable\n",
    "In the previous example, we just printed out the name of the group. Try using the accumulator pattern instead to create a new list containing the age groups. (This is known in social science as *recoding* and is commonly used to turn numerical data into categorical data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "LLtWQccI_e9a",
    "outputId": "885b651a-2571-42d5-eb52-0a2d4f18298d"
   },
   "outputs": [],
   "source": [
    "ages = [18, 88, 23, 97, 34]\n",
    "result = ___________\n",
    "for age in ages:\n",
    "    if age > 65:\n",
    "        _____________________\n",
    "    elif age > 21:\n",
    "        _____________________\n",
    "    else:\n",
    "        _____________________\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ROa5xIqj_hTL"
   },
   "source": [
    "# Challenge 2: String Conditionals\n",
    "Sometimes we have to separate first names from last names. Let's pick out last names starting with B."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HCiwuW3vl_WL"
   },
   "source": [
    "To grab the last name, you can use the split method to seperate a string into a list of strings based on spaces. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hacs8vuJErkc",
    "outputId": "1182e554-b917-4b14-a453-5d1d06d3bfac"
   },
   "outputs": [],
   "source": [
    "president=\"Franklin D. Roosevelt\"\n",
    "name_split=president.split()\n",
    "print(name_split)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "CQ2TjRdE_k-v",
    "outputId": "b1f8f5d0-f0fd-426f-ad6c-695ba59e49e2"
   },
   "outputs": [],
   "source": [
    "presidents_full = [\"George Washington\", \"John Adams\", \"Thomas Jefferson\", \"James Madison\", \"James Monroe\", \\\n",
    "        \"John Quincy Adams\", \"Andrew Jackson\", \"Martin Van Buren\", \"William Henry Harrison\", \"John Tyler\", \\\n",
    "        \"James K. Polk\", \"Zachary Taylor\", \"Millard Fillmore\", \"Franklin Pierce\", \"James Buchanan\", \\\n",
    "        \"Abraham Lincoln\", \"Andrew Johnson\", \"Ulysses S. Grant\", \"Rutherford B. Hayes\", \"James A. Garfield\", \\\n",
    "        \"Chester A. Arthur\", \"Grover Cleveland\", \"Benjamin Harrison\", \"Grover Cleveland\", \"William McKinley\", \\\n",
    "        \"Theodore Roosevelt\", \"William Howard Taft\", \"Woodrow Wilson\", \"Warren G. Harding\", \"Calvin Coolidge\", \\\n",
    "        \"Herbert Hoover\", \"Franklin D. Roosevelt\", \"Harry S. Truman\", \"Dwight D. Eisenhower\", \"John F. Kennedy\", \\\n",
    "        \"Lyndon B. Johnson\", \"Richard Nixon\", \"Gerald Ford\", \"Jimmy Carter\", \"Ronald Reagan\", \"George H. W. Bush\", \\\n",
    "        \"Bill Clinton\", \"George W. Bush\", \"Barack Obama\"]\n",
    "\n",
    "result = []\n",
    "for president in presidents_full:\n",
    "    name_split = _____________ # first, split the name like we demonstrated above\n",
    "    last_name = _____________  # next, use list indexing to get the last name \n",
    "    start_letter = ___________ # use string indexing to get the first letter of the last name\n",
    "    if _____________:          # fill in the conditional of the if statement to check if start_letter is \"B\"\n",
    "        ______________         # add the last name to the accumulator list\n",
    "        \n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U2bTdxqUf7TT"
   },
   "source": [
    "**Iterating with Dictionaries**\n",
    "\n",
    "When you need to do several changes in your dictionary, loops can help.\n",
    "\n",
    "For example, you could use a look to have your notebook print not just one but all the keys aong with their values in your dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "HmXl3xbOgBOY",
    "outputId": "7dfca2a2-89e9-4758-c7a5-e25953b15cd2"
   },
   "outputs": [],
   "source": [
    "#printpairs\n",
    "d = {'Response_ID_1': 21, 'Response_ID_2': 19, 'Response_ID_3': 24, 'Response_ID_4': 20}\n",
    "\n",
    "for key in d.keys():\n",
    "    print(key, d[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CdlerQUOgB55"
   },
   "source": [
    "Imagine these are the ages of different respondants in your survey. Now let's say you wish you correct all ages in this list by adding 2 years to each:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Bg6dwWc_gEEA",
    "outputId": "b926ce0e-9dc4-41b0-996a-fc481b865f04"
   },
   "outputs": [],
   "source": [
    "#add2years\n",
    "d = {'Response_ID_1': 21, 'Response_ID_2': 19, 'Response_ID_3': 24, 'Response_ID_4': 20}\n",
    "\n",
    "for key in d.keys():\n",
    "    d[key] = (2 + d[key])\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dwKE8aD-gN5O"
   },
   "source": [
    "The in operator works both for lists and dictionaries.\n",
    "\n",
    "It will allow you to check if an element is contained within a list or a dictionary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MZRvKaTjgPk7"
   },
   "source": [
    "## Challenge\n",
    "\n",
    "Using the dictionary below and a for loop, calculate how much it'll cost you to buy 2 pieces of each fruit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "OJqzf25MgTXl"
   },
   "outputs": [],
   "source": [
    "d = {'apples': 0.49, 'oranges': 0.99, 'pears': 1.49, 'bananas': 0.32}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "wwdpbcDmgVgw"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WVw9vYz9Ggg_"
   },
   "source": [
    "# Files\n",
    "Learning Objectives:\n",
    "\n",
    "* \"Learn the Python way of reading in files.\"\n",
    "* \"Understand how to read/write text files and csv files.\"\n",
    "\n",
    "Example file:\n",
    "\n",
    "* We are going to use an example dataset retrieved from a lab in Cornell University.\n",
    "\n",
    "\n",
    "Up until now, we have been creating variables directly in our code to represent our data. In actual social science research, however, you will most often be working with data that either you or someone else collected, which has been saved in a *file*, for example a text file or an excel spreadsheet.\n",
    "\n",
    "In fact, most of the variables we have been talking about come from a real database collected in the College of Human Ecology in Cornell University.\n",
    "\n",
    "It belongs to a social neuroscience project that looks at the relationship between social affordances and brain function, including risk/reward sensitivity and executive control.\n",
    "\n",
    "We have created a file containing a subset of this data base for you with the following columns:\n",
    "* Year\n",
    "* Month\n",
    "* Response_ID\n",
    "* Hunger_Experience\n",
    "* Moving_Times\n",
    "* Self_Confidence\n",
    "* Hometown\n",
    "* Age\n",
    "* Parental_Income\n",
    "* Race_Ethnicity\n",
    "* School_Year\n",
    "* Transfer_Student\n",
    "* College\n",
    "* Gender_Identity\n",
    "* Sex\n",
    "* Living_Location\n",
    "\n",
    "We will now use this file to demonstrate how to work with files in Python. Before we get started, it might be helpful to understand the actual survey questions that were used to create this data.\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "\n",
    "The first three items (year, month and Response_ID) are filled in automatically. Here are the prompts for the rest of the questions in this survey and their choices:\n",
    "\n",
    "* **Hunger_Experience:** In the last 12 months, were you ever hungry but didn't eat because there wasn't enough money for food?\n",
    "\n",
    "> -No\n",
    "\n",
    "> -Yes\n",
    "\n",
    "> -I don't know\n",
    "\n",
    "\n",
    "* **Moving_Times:** How many times did you move before you turned 18? Please respond with a numeral. Do not include moving for college.\n",
    "\n",
    "* **Self_Confidence:** When things don't go according to my plans, my motto is, \"Where there's a will, there's a way.\"\n",
    "\n",
    ">-Don't Know/Not Applicable\n",
    "\n",
    ">-Disagree strongy\n",
    "\n",
    ">-Disagree somewhat\n",
    "\n",
    ">-Disagree slightly\n",
    "\n",
    ">-Agree slightly\n",
    "\n",
    ">-Agree somewhat\n",
    "\n",
    ">-Agree Strongly\n",
    "\n",
    "\n",
    "* **Hometown:** What is the name of your hometown (including city, state/province and zip/postal code)? For example, Ithaca, New York 14850. \n",
    "\n",
    "* **Age:** What is your age? (Enter a number)\n",
    "\n",
    "* **Parental_Income:** What is your parents' income?\n",
    "\n",
    ">-Below $40,000\n",
    "\n",
    ">-$40,000 - $59,999\n",
    "\n",
    ">-$60,000 - $99,999\n",
    "\n",
    ">-$100,000 - $174,000\n",
    "\n",
    ">-$175,000 - $299,999\n",
    "\n",
    ">-$300,000 - $499,999\n",
    "\n",
    ">-$500,000 - $749,999\n",
    "\n",
    ">-More than $750,000\n",
    "\n",
    "\n",
    "* **Race_Ethnicity:**  What is your race/ethnicity?\n",
    "\n",
    ">-White (of European Descent)\n",
    "\n",
    ">-Black\n",
    "\n",
    ">-Hispanic\n",
    "\n",
    ">-Asian\n",
    "\n",
    ">-Pacific Islander\n",
    "\n",
    ">-Middle Eastern\n",
    "\n",
    ">-Mixed Race\n",
    "\n",
    ">-Unknown\n",
    "\n",
    "\n",
    "* **School_Year:** What is your year in school?\n",
    "\n",
    ">-1st year undergraduate\n",
    "\n",
    ">-2nd year undergraduate\n",
    "\n",
    ">-3rd year undergraduate\n",
    "\n",
    ">-4th year undergraduate\n",
    "\n",
    ">-Graduate\n",
    "\n",
    "\n",
    "* **Transfer_Student:** Are you a transfer student?\n",
    "\n",
    ">-Yes\n",
    "\n",
    ">-No\n",
    "\n",
    "\n",
    "* **College:** Which College at Cornell are you in?\n",
    "\n",
    ">-College of Agriculture and Life Sciences\n",
    "\n",
    ">-College of Architecture, Art and Planning\n",
    "\n",
    ">-College of Art and Sciences\n",
    "\n",
    ">-SC Johnson College of Business\n",
    "\n",
    ">-College of Engineering\n",
    "\n",
    ">-College of Human Ecology\n",
    "\n",
    ">-School of Industrial and Labor Relations\n",
    "\n",
    ">-Faculty of Computing and Information Science\n",
    "\n",
    ">-Cornell Law School\n",
    "\n",
    ">-College of Veterinary Medicine\n",
    "\n",
    ">-Weill Cornell Medicine\n",
    "\n",
    "\n",
    "* **Gender_Identity:** What is your gender identity?\n",
    "\n",
    ">-Man\n",
    "\n",
    ">-Woman\n",
    "\n",
    ">-Gender non conforming\n",
    "\n",
    "* Sex: What is your sex?\n",
    "\n",
    ">-Female\n",
    "\n",
    ">-Male\n",
    "\n",
    ">-Intersex\n",
    "\n",
    "\n",
    "* **Living_Location:** Where do you live?\n",
    "\n",
    ">-Off Campus\n",
    "\n",
    ">-On Campus\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FMjqqrh4gXte",
    "tags": []
   },
   "source": [
    "\n",
    "# Reading from a file\n",
    "Reading a file requires three steps:\n",
    "\n",
    "1. Opening the file: open function\n",
    "2. Reading the file: read function\n",
    "3. Closing the file: close function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "tjqtWTYcgkcm",
    "outputId": "3161f0f1-0c3d-45ad-f016-80f1667d3717"
   },
   "outputs": [],
   "source": [
    "my_file = open('data/survey_responses_small.csv', \"r\") # open takes two arguments: the location of the file to open, and the mode (see below for details)\n",
    "text = my_file.read()\n",
    "my_file.close()\n",
    "\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yai00FXfglDm"
   },
   "source": [
    "However, use the with open syntax and this will automatically close files for you.\n",
    "The 'r' indicates that you are reading the file, as opposed to, say, writing to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "zUamQxhWgnNE",
    "outputId": "c5fc781c-5cd7-4092-de89-c2e2cd7d3aec"
   },
   "outputs": [],
   "source": [
    "# better code\n",
    "with open('data/survey_responses_small.csv', 'r') as my_file:\n",
    "    text = my_file.read()\n",
    "    \n",
    "print(text)\n",
    "\n",
    "#note that we are also reading the column names as the first line and we will deal with this issue later"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ckh-dxCbgo9U"
   },
   "source": [
    "# Reading a file as a list\n",
    "\n",
    "Very often we want to read in a file line by line, storing those lines as a list.\n",
    "\n",
    "To do that, we can use a for loop over the file object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "HKuhyt9dgxaq"
   },
   "outputs": [],
   "source": [
    "stored = []\n",
    "with open('data/survey_responses_small.csv', 'r') as my_file:\n",
    "    for line in my_file:\n",
    "        stored.append(line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "2A1ZAgXrgzJj",
    "outputId": "f717d655-f690-431a-c942-24f805088710"
   },
   "outputs": [],
   "source": [
    "stored"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f9mWa8iXgsyv"
   },
   "source": [
    "Remember that the variable name can be anything. It does not have to be \"line\". Files are simply always read line by line.\n",
    "\n",
    "# Line breaks\n",
    "\n",
    "The list we have just created looks pretty good, but there is something strange about it. You might notice that each string in the list ends with '\\n'. Why is this happening? The answer is that '\\n' is a special character, a *line break*, to indicate the ending of each line in a file.\n",
    "\n",
    "We can use the strip method to get rid of those line breaks at the end.\n",
    "\n",
    "The strip() method returns a copy of the string by removing both the leading and the trailing empty characters, such as spaces and line breaks (based on the string argument passed). Here are some demonstrations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 131
    },
    "id": "j6McAmPchAxA",
    "outputId": "82e97e3d-258a-4652-8ba7-04b1f93d7703"
   },
   "outputs": [],
   "source": [
    "string = '  White (of European descent)   '\n",
    "print(string.strip()) # no more extra spaces!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "pKjesOljhBm6",
    "outputId": "5146c1a3-faf4-486a-ece3-43e10436f49c"
   },
   "outputs": [],
   "source": [
    "string = 'White (of European descent)\\n'\n",
    "print(string.strip()) # no more line break!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So if we want to get rid of the line breaks, we simply need to call strip() before adding each line to the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "uBHKNHAihBce"
   },
   "outputs": [],
   "source": [
    "stored = []\n",
    "with open('data/survey_responses_small.csv', 'r') as my_file:\n",
    "    for line in my_file:\n",
    "        stored.append(line.strip())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "sJfphkPnhBOU",
    "outputId": "012b6be6-ea26-44a2-d532-c8410b80e68d"
   },
   "outputs": [],
   "source": [
    "stored"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pDa8DWCJhGyy"
   },
   "source": [
    "# Read certain lines in file\n",
    "\n",
    "* We can pick certain lines to read using the enumerate function\n",
    "\n",
    "* We can use this method to drop the title line\n",
    "\n",
    "* The enumerate function adds a counter to an iterable and returns it in a form of enumerating object. This enumerated object can then be used directly for loops or converted into a list of tuples using the list() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KoDviffFhMwj",
    "outputId": "50165f0d-3cc1-485f-c695-f25d882671ac"
   },
   "outputs": [],
   "source": [
    "list1 = [\"Time_Stamp\",\"Year\",\"Month\"]\n",
    "\n",
    "for ele in enumerate(list1):\n",
    "    print (ele)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WBNylLRBhORn"
   },
   "outputs": [],
   "source": [
    "stored = []\n",
    "with open('data/survey_responses_small.csv', 'r') as my_file:\n",
    "    for i, line in enumerate(my_file):  # use enumerate to count which line we are on\n",
    "        if i>0:\n",
    "            stored.append(line.strip())\n",
    "        else:\n",
    "            continue # do nothing when identify the first line (i==1), i.e. do not read the first line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "JnezJ_KvhN2b",
    "outputId": "817615e1-b5b0-4ced-ba28-9f0ef11c0f73"
   },
   "outputs": [],
   "source": [
    "stored # now the title line has been removed!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1LrXK47ehS20"
   },
   "source": [
    "# Excercise\n",
    "\n",
    "Read from line 7 to line 20 (including both line 7 and line 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "gRIvN_jXhXns"
   },
   "outputs": [],
   "source": [
    "stored = []\n",
    "with open('data/survey_responses_small.csv', 'r') as my_file:  \n",
    "    for i, line in enumerate(my_file):\n",
    "        if _______________: # fill in the blank\n",
    "            stored.append(line.strip())\n",
    "        else:\n",
    "            continue "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oZkZL9BvAL-S",
    "outputId": "4b30c91c-aaed-4810-92a9-a9922be2de06"
   },
   "outputs": [],
   "source": [
    "print(stored)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-6lWtko1hYhR"
   },
   "source": [
    "# Writing to a file\n",
    "\n",
    "We can use the with open syntax for writing files as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rG435zDBhdhT"
   },
   "outputs": [],
   "source": [
    "hometowns = ['Pasadena', 'Pensacola', 'Panama']\n",
    "with open('output.csv', 'w') as new_file:\n",
    "    for i in hometowns:\n",
    "        new_file.write(i + '\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aXxr3WDzhhac"
   },
   "source": [
    "If you look in the file browser, you'll see that the new file has been created! Let's take a look at the file."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "iO4uA8eZLMyX",
    "HwvJhgrnKdMz",
    "JJ55li0sKlMS",
    "AQkEYkbRLdXz",
    "1kZfwelLLyod",
    "jSzPvmP2Llgl",
    "iTDyOix-MWam",
    "hCDsmIg8XOUk",
    "OwuxHmxllTwN",
    "3CXkwqME5vn5",
    "6RSjL4I96nsF",
    "mTvHWklz61gC",
    "VpejLTyf7HjD",
    "IRwQNs9k7buw",
    "Vcw8nsC77jzd",
    "ViGGbAgz84BL",
    "ennTRx6Z9GzZ",
    "Q7SjqjWr9Yaq",
    "CDhPnzau9hvB",
    "LHM6p_2_9-lN",
    "7qPPSudK-im8",
    "tVpHMtCD-lw0",
    "bnWvpdkq_B5O",
    "X5D7YW1I_JmM",
    "7MrLiZRJ_PN6",
    "PyIp1NX7_WVJ",
    "WcotsX2Q_cjH",
    "Ckh-dxCbgo9U",
    "f9mWa8iXgsyv",
    "pDa8DWCJhGyy",
    "1LrXK47ehS20",
    "-6lWtko1hYhR",
    "aXxr3WDzhhac"
   ],
   "name": "Intro to Python Bootcamp.ipynb",
   "provenance": []
  },
  "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}