Intro__Python_jrg363.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, 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": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "EDAPh8XS0MHK",
    "outputId": "23dc5e22-7a61-4ad8-e3dc-6c7515c9855c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "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": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "lpl39CP0GbOj",
    "outputId": "ba0689f8-d5f3-4cb4-f78d-a69cc2b8588a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "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": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "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": 6,
   "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": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29\n"
     ]
    }
   ],
   "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": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "XbkPIGcF_uCa",
    "outputId": "71b5be28-8173-4058-abb2-026b10c90186"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Participant 1 is 34 years old.\n"
     ]
    }
   ],
   "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": 9,
   "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": "DHk7IMk4zOEs"
   },
   "source": [
    "You can use the function *type* to have the notebook tell you what type a variable is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "QUwvs5bh5etf",
    "outputId": "8f796e58-bf61-4305-b78c-ff11d5dd77f8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "O6IAsODy5tBS",
    "outputId": "b1b522bb-2314-44f0-f3bc-ad15cf18b7f8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "UASqRUXxv0kO",
    "outputId": "6377f343-b564-415d-b2f2-a53237cc425b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37\n"
     ]
    }
   ],
   "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": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "574zZCMyNVLQ",
    "outputId": "d9561f41-98ed-428c-a9c5-35b81931e3fc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "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": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "D11UEPKQN2yt",
    "outputId": "7db14961-ce35-42f0-beda-cd51198d785c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.5\n"
     ]
    }
   ],
   "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": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "BxgbYFrb0RPp",
    "outputId": "532d58b6-6b34-4420-e1cc-f8b0ab45d26c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "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": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "P-XYILiI6val",
    "outputId": "fc4593aa-a4d6-4ec5-9371-2fe2b1bd6979"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SaintLouis\n"
     ]
    }
   ],
   "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": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "jOmphwxBNgGs",
    "outputId": "98c1c5e4-2540-45bd-d05f-dc695c3a94d0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "A5DN9gASPU7g",
    "outputId": "73428236-ee5c-495c-b283-9a64004890a0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saint Louis\n"
     ]
    }
   ],
   "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": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "T_4ZhhrmVRG4",
    "outputId": "176dc838-3cb8-4b14-b423-cc0f96546f94"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Participat 1 is 34\n"
     ]
    }
   ],
   "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": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 184
    },
    "id": "eALLi07-Uc0Z",
    "outputId": "d34dd4ec-784c-42c9-cea7-06659492b3e1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "participant1\n"
     ]
    }
   ],
   "source": [
    "e='participant'+ str(1)\n",
    "print(e)"
   ]
  },
  {
   "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": 21,
   "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": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "SvomqfVCjfuS",
    "outputId": "e53878c4-e5fb-4827-c17f-7042c3055459"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The age after 3 years will be 37\n"
     ]
    }
   ],
   "source": [
    "increase_age(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": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today's temperature is 32 in celsius, which is 89.6 in fahrenheit\n"
     ]
    }
   ],
   "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": {},
   "source": [
    "Exercise: Create user-defined function to convert cm to inches. When running function display result of total inches from cm. Convert the 3 following cm values to inches: 150, 1000, 99"
   ]
  },
  {
   "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": "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": "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": "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": "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": 24,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "tjqtWTYcgkcm",
    "outputId": "3161f0f1-0c3d-45ad-f016-80f1667d3717"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ï»¿Time_Stamp,Year,Month,Response_ID,Hunger_Experience,Moving_Times,Self_Confidence,Hometown,Age,Parental_Income,Race_Ethnicity,School_Year,Transfer_Student,College,Gender_Identity,Sex,Living_Location,\n",
      "4/14/2021 19:43,2021,April,1,No,1,Agree slightly,\"Coconut Grove, Florida 33133\",20,\"More than $750,000\",White (of European descent),2nd year undergraduate,No,College of Human Ecology,Woman,Female,Off campus,\n",
      "4/15/2021 11:30,2021,April,2,No,1,Agree slightly,\"Brooklyn, New York 11225\",20,\"Below $40,000\",Black,3rd year undergraduate,No,College of Human Ecology,Woman,Female,Off campus,\n",
      "4/15/2021 13:00,2021,April,3,No,5,Agree somewhat,\"Roslyn Heights, New York 11577\",21,\"More than $750,000\",Asian,3rd year undergraduate,No,College of Agriculture and Life Sciences,Woman,Female,Off campus,\n",
      "4/15/2021 14:01,2021,April,4,No,1,Agree slightly,\"Rye Brook, New York 10573\",19,\"More than $750,000\",White (of European descent),2nd year undergraduate,No,College of Human Ecology,Woman,Female,On campus,\n",
      "4/15/2021 14:31,2021,April,5,No,0,Agree somewhat,\"San Antonio, Texas 78218\",21,\"$100,000 - $174,999\",\"White (of European descent),Hispanic\",4th year undergraduate,No,College of Arts and Sciences,Woman,Female,Off campus,\n",
      "4/15/2021 14:30,2021,April,6,No,2,Agree strongly,Shanghai (China) 200127,18,\"$175,000 - $299,999\",Asian,1st year undergraduate,No,College of Engineering,Woman,Female,Off campus,\n",
      "4/15/2021 15:18,2021,April,7,No,0,Agree slightly,\"New York, New York 10075\",21,\"$100,000 - $174,999\",White (of European descent),4th year undergraduate,No,College of Agriculture and Life Sciences,Woman,Female,Off campus,\n",
      "4/15/2021 15:25,2021,April,8,Don't know,0,Don't know / not applicable,cupertino,20,\"More than $750,000\",Asian,3rd year undergraduate,No,College of Engineering,Woman,Female,Off campus,\n",
      "4/15/2021 15:42,2021,April,9,No,5,Agree slightly,\"Santa Rosa, California, 95405\",22,\"$175,000 - $299,999\",Asian,4th year undergraduate,No,School of Industrial and Labor Relations,Woman,Female,Off campus,\n",
      "4/15/2021 17:34,2021,April,10,No,2,Don't know / not applicable,\"Atlanta, Georgia 30327\",21,\"More than $750,000\",White (of European descent),3rd year undergraduate,No,College of Engineering,Woman,Female,Off campus,\n",
      "4/15/2021 18:02,2021,April,11,No,3,Agree somewhat,\"Long Island, NY\",23,\"$300,000 - $499,999\",Asian,4th year undergraduate,No,College of Agriculture and Life Sciences,Man,Male,Off campus,\n",
      "4/15/2021 20:43,2021,April,12,No,1,Agree slightly,\"La Jolla, CA 92037\",20,\"$500,000 - $749,999\",\"American Indian or Alaskan Native,White (of European descent)\",3rd year undergraduate,No,College of Arts and Sciences,Man,Male,Off campus,\n",
      "4/16/2021 10:49,2021,April,13,No,0,Agree somewhat,\"Cambridge, MA 02139\",21,\"$40,000 - $59,999\",Middle Eastern,4th year undergraduate,Yes,College of Arts and Sciences,Woman,Female,Off campus,\n",
      "4/16/2021 10:58,2021,April,14,No,1,Disagree slightly,\"Horseheads, NY 14845\",19,\"$100,000 - $174,999\",\"White (of European descent),Black\",1st year undergraduate,No,College of Human Ecology,Woman,Female,On campus,\n",
      "4/16/2021 17:52,2021,April,15,No,2,Agree slightly,No,19,\"$40,000 - $59,999\",White (of European descent),2nd year undergraduate,No,School of Industrial and Labor Relations,Man,Male,On campus,\n",
      "4/17/2021 14:10,2021,April,16,No,0,Agree strongly,\"Hampton, NH 03842\",20,\"$100,000 - $174,999\",White (of European descent),3rd year undergraduate,Yes,College of Human Ecology,Woman,Female,Off campus,\n",
      "4/18/2021 18:41,2021,April,17,No,3,Disagree slightly,\"Tambo, Paranaque City, Manila, Philippines\",22,\"$40,000 - $59,999\",Asian,4th year undergraduate,Yes,College of Human Ecology,Woman,Female,Off campus,\n",
      "4/19/2021 14:53,2021,April,18,No,3,Agree somewhat,\"New York, NY, 10021\",20,\"More than $750,000\",\"White (of European descent),Hispanic\",2nd year undergraduate,No,College of Agriculture and Life Sciences,Woman,Female,Off campus,\n",
      "4/19/2021 20:37,2021,April,19,No,1,Agree slightly,\"Roslyn, NY 11577\",19,\"$300,000 - $499,999\",White (of European descent),2nd year undergraduate,No,College of Engineering,Woman,Female,On campus,\n",
      "4/20/2021 18:04,2021,April,20,No,1,Agree slightly,\"Brentwood, California 94513\",21,\"$175,000 - $299,999\",White (of European descent),3rd year undergraduate,No,College of Agriculture and Life Sciences,Woman,Female,Off campus,\n",
      "\n"
     ]
    }
   ],
   "source": [
    "my_file = open('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": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "zUamQxhWgnNE",
    "outputId": "c5fc781c-5cd7-4092-de89-c2e2cd7d3aec"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ï»¿Time_Stamp,Year,Month,Response_ID,Hunger_Experience,Moving_Times,Self_Confidence,Hometown,Age,Parental_Income,Race_Ethnicity,School_Year,Transfer_Student,College,Gender_Identity,Sex,Living_Location,\n",
      "4/14/2021 19:43,2021,April,1,No,1,Agree slightly,\"Coconut Grove, Florida 33133\",20,\"More than $750,000\",White (of European descent),2nd year undergraduate,No,College of Human Ecology,Woman,Female,Off campus,\n",
      "4/15/2021 11:30,2021,April,2,No,1,Agree slightly,\"Brooklyn, New York 11225\",20,\"Below $40,000\",Black,3rd year undergraduate,No,College of Human Ecology,Woman,Female,Off campus,\n",
      "4/15/2021 13:00,2021,April,3,No,5,Agree somewhat,\"Roslyn Heights, New York 11577\",21,\"More than $750,000\",Asian,3rd year undergraduate,No,College of Agriculture and Life Sciences,Woman,Female,Off campus,\n",
      "4/15/2021 14:01,2021,April,4,No,1,Agree slightly,\"Rye Brook, New York 10573\",19,\"More than $750,000\",White (of European descent),2nd year undergraduate,No,College of Human Ecology,Woman,Female,On campus,\n",
      "4/15/2021 14:31,2021,April,5,No,0,Agree somewhat,\"San Antonio, Texas 78218\",21,\"$100,000 - $174,999\",\"White (of European descent),Hispanic\",4th year undergraduate,No,College of Arts and Sciences,Woman,Female,Off campus,\n",
      "4/15/2021 14:30,2021,April,6,No,2,Agree strongly,Shanghai (China) 200127,18,\"$175,000 - $299,999\",Asian,1st year undergraduate,No,College of Engineering,Woman,Female,Off campus,\n",
      "4/15/2021 15:18,2021,April,7,No,0,Agree slightly,\"New York, New York 10075\",21,\"$100,000 - $174,999\",White (of European descent),4th year undergraduate,No,College of Agriculture and Life Sciences,Woman,Female,Off campus,\n",
      "4/15/2021 15:25,2021,April,8,Don't know,0,Don't know / not applicable,cupertino,20,\"More than $750,000\",Asian,3rd year undergraduate,No,College of Engineering,Woman,Female,Off campus,\n",
      "4/15/2021 15:42,2021,April,9,No,5,Agree slightly,\"Santa Rosa, California, 95405\",22,\"$175,000 - $299,999\",Asian,4th year undergraduate,No,School of Industrial and Labor Relations,Woman,Female,Off campus,\n",
      "4/15/2021 17:34,2021,April,10,No,2,Don't know / not applicable,\"Atlanta, Georgia 30327\",21,\"More than $750,000\",White (of European descent),3rd year undergraduate,No,College of Engineering,Woman,Female,Off campus,\n",
      "4/15/2021 18:02,2021,April,11,No,3,Agree somewhat,\"Long Island, NY\",23,\"$300,000 - $499,999\",Asian,4th year undergraduate,No,College of Agriculture and Life Sciences,Man,Male,Off campus,\n",
      "4/15/2021 20:43,2021,April,12,No,1,Agree slightly,\"La Jolla, CA 92037\",20,\"$500,000 - $749,999\",\"American Indian or Alaskan Native,White (of European descent)\",3rd year undergraduate,No,College of Arts and Sciences,Man,Male,Off campus,\n",
      "4/16/2021 10:49,2021,April,13,No,0,Agree somewhat,\"Cambridge, MA 02139\",21,\"$40,000 - $59,999\",Middle Eastern,4th year undergraduate,Yes,College of Arts and Sciences,Woman,Female,Off campus,\n",
      "4/16/2021 10:58,2021,April,14,No,1,Disagree slightly,\"Horseheads, NY 14845\",19,\"$100,000 - $174,999\",\"White (of European descent),Black\",1st year undergraduate,No,College of Human Ecology,Woman,Female,On campus,\n",
      "4/16/2021 17:52,2021,April,15,No,2,Agree slightly,No,19,\"$40,000 - $59,999\",White (of European descent),2nd year undergraduate,No,School of Industrial and Labor Relations,Man,Male,On campus,\n",
      "4/17/2021 14:10,2021,April,16,No,0,Agree strongly,\"Hampton, NH 03842\",20,\"$100,000 - $174,999\",White (of European descent),3rd year undergraduate,Yes,College of Human Ecology,Woman,Female,Off campus,\n",
      "4/18/2021 18:41,2021,April,17,No,3,Disagree slightly,\"Tambo, Paranaque City, Manila, Philippines\",22,\"$40,000 - $59,999\",Asian,4th year undergraduate,Yes,College of Human Ecology,Woman,Female,Off campus,\n",
      "4/19/2021 14:53,2021,April,18,No,3,Agree somewhat,\"New York, NY, 10021\",20,\"More than $750,000\",\"White (of European descent),Hispanic\",2nd year undergraduate,No,College of Agriculture and Life Sciences,Woman,Female,Off campus,\n",
      "4/19/2021 20:37,2021,April,19,No,1,Agree slightly,\"Roslyn, NY 11577\",19,\"$300,000 - $499,999\",White (of European descent),2nd year undergraduate,No,College of Engineering,Woman,Female,On campus,\n",
      "4/20/2021 18:04,2021,April,20,No,1,Agree slightly,\"Brentwood, California 94513\",21,\"$175,000 - $299,999\",White (of European descent),3rd year undergraduate,No,College of Agriculture and Life Sciences,Woman,Female,Off campus,\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# better code\n",
    "with open('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": 27,
   "metadata": {
    "id": "HKuhyt9dgxaq"
   },
   "outputs": [],
   "source": [
    "stored = []\n",
    "with open('survey_responses_small.csv', 'r') as my_file:\n",
    "    for line in my_file:\n",
    "        stored.append(line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "2A1ZAgXrgzJj",
    "outputId": "f717d655-f690-431a-c942-24f805088710"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ï»¿Time_Stamp,Year,Month,Response_ID,Hunger_Experience,Moving_Times,Self_Confidence,Hometown,Age,Parental_Income,Race_Ethnicity,School_Year,Transfer_Student,College,Gender_Identity,Sex,Living_Location,\\n',\n",
       " '4/14/2021 19:43,2021,April,1,No,1,Agree slightly,\"Coconut Grove, Florida 33133\",20,\"More than $750,000\",White (of European descent),2nd year undergraduate,No,College of Human Ecology,Woman,Female,Off campus,\\n',\n",
       " '4/15/2021 11:30,2021,April,2,No,1,Agree slightly,\"Brooklyn, New York 11225\",20,\"Below $40,000\",Black,3rd year undergraduate,No,College of Human Ecology,Woman,Female,Off campus,\\n',\n",
       " '4/15/2021 13:00,2021,April,3,No,5,Agree somewhat,\"Roslyn Heights, New York 11577\",21,\"More than $750,000\",Asian,3rd year undergraduate,No,College of Agriculture and Life Sciences,Woman,Female,Off campus,\\n',\n",
       " '4/15/2021 14:01,2021,April,4,No,1,Agree slightly,\"Rye Brook, New York 10573\",19,\"More than $750,000\",White (of European descent),2nd year undergraduate,No,College of Human Ecology,Woman,Female,On campus,\\n',\n",
       " '4/15/2021 14:31,2021,April,5,No,0,Agree somewhat,\"San Antonio, Texas 78218\",21,\"$100,000 - $174,999\",\"White (of European descent),Hispanic\",4th year undergraduate,No,College of Arts and Sciences,Woman,Female,Off campus,\\n',\n",
       " '4/15/2021 14:30,2021,April,6,No,2,Agree strongly,Shanghai (China) 200127,18,\"$175,000 - $299,999\",Asian,1st year undergraduate,No,College of Engineering,Woman,Female,Off campus,\\n',\n",
       " '4/15/2021 15:18,2021,April,7,No,0,Agree slightly,\"New York, New York 10075\",21,\"$100,000 - $174,999\",White (of European descent),4th year undergraduate,No,College of Agriculture and Life Sciences,Woman,Female,Off campus,\\n',\n",
       " '4/15/2021 15:25,2021,April,8,Don\\'t know,0,Don\\'t know / not applicable,cupertino,20,\"More than $750,000\",Asian,3rd year undergraduate,No,College of Engineering,Woman,Female,Off campus,\\n',\n",
       " '4/15/2021 15:42,2021,April,9,No,5,Agree slightly,\"Santa Rosa, California, 95405\",22,\"$175,000 - $299,999\",Asian,4th year undergraduate,No,School of Industrial and Labor Relations,Woman,Female,Off campus,\\n',\n",
       " '4/15/2021 17:34,2021,April,10,No,2,Don\\'t know / not applicable,\"Atlanta, Georgia 30327\",21,\"More than $750,000\",White (of European descent),3rd year undergraduate,No,College of Engineering,Woman,Female,Off campus,\\n',\n",
       " '4/15/2021 18:02,2021,April,11,No,3,Agree somewhat,\"Long Island, NY\",23,\"$300,000 - $499,999\",Asian,4th year undergraduate,No,College of Agriculture and Life Sciences,Man,Male,Off campus,\\n',\n",
       " '4/15/2021 20:43,2021,April,12,No,1,Agree slightly,\"La Jolla, CA 92037\",20,\"$500,000 - $749,999\",\"American Indian or Alaskan Native,White (of European descent)\",3rd year undergraduate,No,College of Arts and Sciences,Man,Male,Off campus,\\n',\n",
       " '4/16/2021 10:49,2021,April,13,No,0,Agree somewhat,\"Cambridge, MA 02139\",21,\"$40,000 - $59,999\",Middle Eastern,4th year undergraduate,Yes,College of Arts and Sciences,Woman,Female,Off campus,\\n',\n",
       " '4/16/2021 10:58,2021,April,14,No,1,Disagree slightly,\"Horseheads, NY 14845\",19,\"$100,000 - $174,999\",\"White (of European descent),Black\",1st year undergraduate,No,College of Human Ecology,Woman,Female,On campus,\\n',\n",
       " '4/16/2021 17:52,2021,April,15,No,2,Agree slightly,No,19,\"$40,000 - $59,999\",White (of European descent),2nd year undergraduate,No,School of Industrial and Labor Relations,Man,Male,On campus,\\n',\n",
       " '4/17/2021 14:10,2021,April,16,No,0,Agree strongly,\"Hampton, NH 03842\",20,\"$100,000 - $174,999\",White (of European descent),3rd year undergraduate,Yes,College of Human Ecology,Woman,Female,Off campus,\\n',\n",
       " '4/18/2021 18:41,2021,April,17,No,3,Disagree slightly,\"Tambo, Paranaque City, Manila, Philippines\",22,\"$40,000 - $59,999\",Asian,4th year undergraduate,Yes,College of Human Ecology,Woman,Female,Off campus,\\n',\n",
       " '4/19/2021 14:53,2021,April,18,No,3,Agree somewhat,\"New York, NY, 10021\",20,\"More than $750,000\",\"White (of European descent),Hispanic\",2nd year undergraduate,No,College of Agriculture and Life Sciences,Woman,Female,Off campus,\\n',\n",
       " '4/19/2021 20:37,2021,April,19,No,1,Agree slightly,\"Roslyn, NY 11577\",19,\"$300,000 - $499,999\",White (of European descent),2nd year undergraduate,No,College of Engineering,Woman,Female,On campus,\\n',\n",
       " '4/20/2021 18:04,2021,April,20,No,1,Agree slightly,\"Brentwood, California 94513\",21,\"$175,000 - $299,999\",White (of European descent),3rd year undergraduate,No,College of Agriculture and Life Sciences,Woman,Female,Off campus,\\n']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "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": 29,
   "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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Markdown\n",
    "\n",
    "Helpful Link:\n",
    "https://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/Working%20With%20Markdown%20Cells.html"
   ]
  }
 ],
 "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 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}