01-Introduction-to-Python-ALICE.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A link to the worksheet corresponding to this notebook can be found *[here](https://docs.google.com/document/d/1VhkS4cKEBcvHQZMc8jodwdXXRx0VOeBJiVcAc-YDYJg/edit?usp=sharing).*\n",
    "\n",
    "This notebook and worksheet were developed by Alice Hsu for UEA Python PPDs 2024. Last updated: 14/11/2024."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Table of Contents\n",
    "1. **Variables**\n",
    "2. **Data Types**\n",
    "    <ol type=\"a\">\n",
    "  <li><b>Integers and Floats</li>\n",
    "  <li><b>Strings</b></li>\n",
    "    </ol>\n",
    "3. **Data Structures**\n",
    "    <ol type=\"a\">\n",
    "  <li><b>Lists</b></li>\n",
    "    <ol type=\"a\">\n",
    "        <li>Creating a list</li>\n",
    "        <li>Accessing items in a list</li>\n",
    "        <ol type=\"a\">\n",
    "            <li>Indexing and Slicing</li>\n",
    "            </ol>\n",
    "        <li>Changing items in a list</li>\n",
    "        <li>List Methods</li>\n",
    "    </ol>\n",
    "  <li>Tuples</li>\n",
    "   <li>Dictionaries</li>\n",
    "    </ol>\n",
    "4. **Control Flow**\n",
    "<ol type=\"a\">\n",
    "  <li>Booleans</li>\n",
    "  <li><b>Conditional (if-elif-else) statements</b></li>\n",
    "   <li><b>Loops</b></li>\n",
    "        <ol type=\"a\">\n",
    "            <li>For loops</li>\n",
    "            <li>While loops</li>\n",
    "            </ol>\n",
    "    </ol>\n",
    "5. **Coding Challenges**\n",
    "5. **Functions**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. <u>Variables</u>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Variable assignment** is one of the fundamental building blocks of coding.\n",
    "\n",
    "**Variable assignment** just means setting some variable name equal to some data or value.\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myvar1 = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable naming rules:\n",
    "* Variables are case-sensitive.\n",
    "    * ```myvar``` is not the same as ```myVar```\n",
    "* Your variable name cannot start with a number.\n",
    "    * E.g., 2nd_number = 10\n",
    "* Your variable name can only include letters, numbers, and underscores.\n",
    "* Your variable name should not be the same thing as a built-in Python function.\n",
    "    * While this is not technically forbidden, you may overwrite important functions which you will then be unable to use later.\n",
    "    * E.g., ```list```, ```int```, ```str``` ... and also:\n",
    "    * ``and, as, assert, break, class, continue, def, del, elif, else, except, exec, finally, for, from, global, if, import, in, is, lambda, not, or, pass, print, raise, return, try, with, while, yield.``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### iPYNB EX1\n",
    "In the cell below, do the following:\n",
    "* Create a variable named after your initials.\n",
    "* Assign it a value equivalent to your birth year."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *A quick aside about displaying variables*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will notice that by default, Python will not print a result to the screen unless you ask it to with the ``print()`` command, or putting the variable by itself in a cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print function\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Printing your variable(s) (via the ``print()`` function or using the variable name) is useful for **checking the value of variables**. It is also useful for if you forget whether you have used a variable name **(\"Have I used `myvar` as a variable name yet?\")** or if you forgot what value you assigned to a certain variable **(\"What did I set ``a`` equal to again?\")**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You must be careful you **do not accidentally overwrite variables** (if you aren't doing so on purpose) - if you set the same variable name equal to different values, it will take on the last value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"hello world\"\n",
    "x = 4\n",
    "x = 3.73"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What will the following cell output?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. <u> Data Types </u>\n",
    "\n",
    "In Python, every variable has a **type**. Different data types have different properties, and the type also determines what operations can be performed on that variable. Some common data types include:\n",
    "\n",
    "| Type        | Example        | Description                                                  |\n",
    "|-------------|----------------|--------------------------------------------------------------|\n",
    "| ``int``     | ``x = 1``      | integers (i.e., whole numbers)                               |\n",
    "| ``float``   | ``x = 1.0``    | floating-point numbers (i.e., real numbers)                  |\n",
    "| ``bool``    | ``x = True``   | Boolean: True/False values                                   |\n",
    "| ``str``     | ``x = 'abc'``  | String: characters or text                                   |\n",
    "| ``complex`` | ``x = 1 + 2j`` | Complex numbers (i.e., numbers with real and imaginary part) |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use the built-in function **```type()```** to **check the data type of variables you have created**. This can be useful to check what sorts of operations can be performed on your variables. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Integers and Floats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Integers and floats represent numbers. You can do **basic mathematical operations** with them. Basic maths are supported in Python - no need to download any special packages to do:\n",
    "\n",
    "| Operator     | Name           | Description                                            |\n",
    "|--------------|----------------|--------------------------------------------------------|\n",
    "| ``a + b``    | Addition       | Sum of ``a`` and ``b``                                 |\n",
    "| ``a - b``    | Subtraction    | Difference of ``a`` and ``b``                          |\n",
    "| ``a * b``    | Multiplication | Product of ``a`` and ``b``                             |\n",
    "| ``a / b``    | True division  | Quotient of ``a`` and ``b``                            |\n",
    "| ``a // b``   | Floor division | Quotient of ``a`` and ``b``, removing fractional parts |\n",
    "| ``a % b``    | Modulus        | Integer remainder after division of ``a`` by ``b``     |\n",
    "| ``a ** b``   | Exponentiation | ``a`` raised to the power of ``b``                     |\n",
    "| ``-a``       | Negation       | The negative of ``a``                                  |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### iPYNB EX2\n",
    "\n",
    "Write the following code in the cell below.\n",
    "* Create a variable called **x** that stores the value **3.1415**. \n",
    "* Create a variable called **y** that stores the value of **4**. \n",
    "* Create a variable called **z** that is equal to the **product of x and y**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WKSH EX 2\n",
    "You can change between different data types using their names as functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3.141\n",
    "a = int(a)\n",
    "\n",
    "b = 2\n",
    "b = float(b)\n",
    "\n",
    "c = 2024\n",
    "c = str(c)\n",
    "\n",
    "d = 0\n",
    "d = bool(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the variables above here:\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WKSH EX3\n",
    "\n",
    "Check the type of `x`, `y`, and `z` from iPYNB EX 2 using the `type()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WKSH EX4\n",
    "\n",
    "Add together `a` and `b` from WKSH EX2 and use the `type()` function to check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "\n",
    "**Strings** in Python are created with **single** or **double quotes**. Generally, they are used to represent **text**.\n",
    "\n",
    "You can use just about any characters on your keyboard in a string. For example:\n",
    "```\n",
    "name = 'alice v\n",
    "bday = '213'\n",
    "pwd = “plsd0n’th@ckm3!”```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has many extremely useful functions and methods you can use on strings. **A full list of string methods** can be found at this **[link](https://www.w3schools.com/python/python_ref_string.asp)**.\n",
    "\n",
    "| Method       | Syntax           | Description                                  |\n",
    "|--------------|------------------|----------------------------------------------|\n",
    "| ``upper()``  | ``myStr.upper()``    | Capitalizes all characters in ``myStr``         |\n",
    "| ``lower()``  | ``myStr.lower()``    | Lower cases all characters in ``myStr``         |\n",
    "| ``replace()``| ``myStr.replace(old,new)`` | In ``myStr``, replaces the <br>characters specified in ``old`` by the<br>characters specified in ``new``           |\n",
    "| ``split()``  | ``myStr.split(dtr)``  | Splits the characters of ``myStr``<br>by the delimiter specified by ``dtr``|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will demonstrate examples of the above methods using the strings in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "phrase = 'Welcome to python class.'\n",
    "ans = \"I mean, I just thought there'd be more snakes :(\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before running the lines of code below, see if you can guess what the output will be!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "phrase.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "phrase.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "phrase.replace('python','r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "phrase.split(' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "phrase+ans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### iPYNB EX3\n",
    "\n",
    "Using the variables ```name = 'alice v'``` and ```last = 'hsu'```, we want to create a new variable called ```fullname``` that is equal to ```'Alice V Hsu'```.\n",
    "1. First, **concatenate** the first and last names - but don’t forget to **add a space** between the first and last names (i.e., after the ```v``` in ```alice v```).\n",
    "2. Click this link to the [online table of string methods](https://www.w3schools.com/python/python_ref_string.asp).\n",
    "3. Using the table, scroll through and **find the string method** that is used to **capitalize every word in a string**.\n",
    "4. Read the documentation on this method and then use it to capitalize your string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'alice v'\n",
    "last = 'hsu'\n",
    "\n",
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that different data types may not be compatible with each other. You can only perform **certain operations** on **certain data types**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WKSH EX5\n",
    "Why doesn't the following line of code work? Put the following code into a cell in your Jupyter notebook and see what happens when you try to run it.\n",
    "\n",
    "```mycalc = '4' + 3```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How would you modify the above line of code so that it works?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **iPYNB EX5**\n",
    "\n",
    "A. Create a variable called ``filename`` that is a string that includes the model, model number, country, date, and file type. Separate the model, model number, country, and date with a dash ```'-'```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = 'MetMod'\n",
    "model_no = 3\n",
    "country = \"USA\"\n",
    "date = 19970213\n",
    "filetype = '.csv'\n",
    "\n",
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "B. Now say we wanted to split apart ```filename```. Choose the appropriate method from the table above and then write the code in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge Warm Up: Temperature Converter\n",
    "**<u>Concepts covered</u>**\n",
    "* Basic maths\n",
    "* Strings and string methods\n",
    "* Data type conversion\n",
    "\n",
    "**<u> Instructions </u>**\n",
    "\n",
    "In this exercise, you will write some code that converts a temperature from Celsius to Fahrenheit and outputs it nicely as a string.\n",
    "\n",
    "The formula for converting from Celsius to Fahrenheit is:\n",
    "\n",
    "<center> $F = \\frac{9}{5}*C + 32$ </center>\n",
    "\n",
    "where F is the temperature in Fahrenheit and C is the temperature in Celsius.\n",
    "\n",
    "**<u>Pseudocode</u>**\n",
    "* **Create a variable called `C`** that represents the temperature that you'd like to convert to Fahrenheit.\n",
    "* Using the formula provided above, **create a variable called `F`** that is equal to the temperature specified by `C` converted into Fahrenheit.\n",
    "    * Note that `F` should change automatically if you change what you set `C` equal to.\n",
    "* **Create two strings** that tell you what the temperature is in Celsius and Fahrenheit. For example:\n",
    "    * Create one string that is equal to `'Temperature in Celsius: 0 degrees'`, where the `0` is whatever you set `C` equal to.\n",
    "    * Create one string that is equal to `'Temperature in Fahrenheit: 32 degrees'`, where the `32` is calculated based on what you set `C` equal to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. <u>Data Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Type Name | Example                   |Description                            |\n",
    "|-----------|---------------------------|---------------------------------------|\n",
    "| ``list``  | ``[1, 2, 3]``             | Ordered collection                    |\n",
    "| ``tuple`` | ``(1, 2, 3)``             | Immutable ordered collection          |\n",
    "| ``dict``  | ``{'a':1, 'b':2, 'c':3}`` | Ordered (key,value) mapping         |\n",
    "| ``set``   | ``{1, 2, 3}``             | Unordered collection of unique values |\n",
    "\n",
    "**NOTE**: round ( ), square [ ], and curly { } brackets have distinct meanings - you can't use them interchangeably."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lists\n",
    "Lists are the basic *ordered* and *mutable* data collection type in Python.\n",
    "\n",
    "**Ordered**: the elements in the list have an order.\n",
    "\n",
    "**Mutable**: the order or value of the elements within a list can be changed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <u> Creating a List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = ['apple','banana','cherry','durian']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <u> Accessing items in a lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing\n",
    "You can access a single item in a list using its **index**. An index represents the **position of an item** in a collection. Note that in Python, **indexing starts at 0**. This means that the first item in a list would have the index of 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access an item in a list, take the name of your list followed by the index in square brackets. For example, to access the first item in `my_list` from above, you would write:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also access items in a list using a **negative index**. A negative index represents **the position of an item, but starting from the back**. This means the last item has an index of -1, second to last -2, etc.\n",
    "\n",
    "| Index |0|1|2|3|\n",
    "|-------|-------|----|-------|---------|\n",
    "|`my_list`|`'apple'`|`'banana'`|`'cherry'`|`'durian'`|\n",
    "|**Negative Index**|**-4**|**-3**|**-2**|**-1**|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that you can also index the **characters within strings**. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'hello'\n",
    "x[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### WKSH EX6: Accessing items in a list\n",
    "\n",
    "Feel free to check you answers in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_list = [1, 1, '2', 'hello?', 583, 'llama', [2,4,6], 3.14159]\n",
    "\n",
    "# Your code here\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also **access multiple items**, or **slices**, of your list by using a colon (`:`) along with the index. The colon specifies the **range of the items** in your last that you want.\n",
    "\n",
    "To access a slice in a list, you specify the **starting and ending indices of the items you want, with a colon in between**. However, note that when you use the colon to specify a range, **this range is not inclusive of the number specified on the right side**.\n",
    "\n",
    "For example, see what the following cell outputs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = ['apple','banana','cherry','durian']\n",
    "\n",
    "my_list[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also omit either the starting or ending index if you would like to access all items to or from the start or end of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[2:]\n",
    "my_list[:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, you can also **slice characters within strings**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'hello'\n",
    "x[0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <u> Changing items in a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To change an item in a list, you first need to **access the item in the list via its index**, and then **set it equal to what you would like to change it to**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[0] = 1234"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WKSH EX 7\n",
    "\n",
    "Implement your written code here to check if it is correct."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_list = [1, 1, '2', 'hello?',583, 'llama', [2,4,6], 3.14159]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(A) What code would you write to change the first element of `some_list` to a string representing your name?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code for A\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(B) What code would you write to change the third element of `some_list` to the integer 2?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code for B\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <u> List Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Lists have a number of useful properties and methods available to them.\n",
    "\n",
    "| Method |Description                            |\n",
    "|----------|---------------------------------------|\n",
    "| ``my_list.append()``|**Add an item to the end of a list.**<br>You’ll need to specify the item you are appending to the list.|\n",
    "| ``my_list.insert()``|**Insert an item into a specific position in the list.**<br>You’ll need to specify the item you are inserting as well as<br>the position you’d like to insert it into.|\n",
    "| ``my_list.remove()``|**Remove an item from a list.**<br>You’ll need to specify the item you are removing.<br>If there are duplicates in your list, it will only remove the first occurrence of that item.|\n",
    "| ``my_list.pop()``  |**Remove an item from a list by index.**<br>This differs from remove() because you specify the **index** of the item<br>you are removing, instead of specifying the item itself.|\n",
    "| ``my_list.sort()``  |**Sort the list.**<br>If the items in your list are all numbers, it will sort it by ascending numbers.<br>If your items are all strings, it will alphabetize your list.<br>If your list contains a mix of strings and numbers, you may run into an error.<br>You can specify ways to sort. Read documentation for more info.|\n",
    "| ``my_list.reverse()``  |**Reverse the order of the items in your list.**<br>You don’t need to specify anything in this method.|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at how the following methods can be used on the example `some_list` below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use as RESET cell if needed\n",
    "some_list = [1, 1, '2', 'hello?', 583, 'llama', [2,4,6], 3.14159]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the `len()` function tells us how many items are in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Length of a list\n",
    "len(some_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now onto the methods.\n",
    "\n",
    "Note that each of these methods modify `some_list` **in place**. This means that will **keep all of the previous changes** you make to it. For example, if you run `some_list.append(11)` twice, some_list will have two 11s at the end.\n",
    "\n",
    "If you need reset some_list, simply run the cell above to redefine `some_list`.\n",
    "\n",
    "Predict what `some_list` will look like before executing the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Append a value to the end\n",
    "some_list.append(11)\n",
    "some_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Insert the item 'information' into the position with index 3\n",
    "some_list.insert(3,'information')\n",
    "some_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove the item 1 from the list\n",
    "some_list.remove(1)\n",
    "some_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove an item in position 0 in the list\n",
    "some_list.pop(0)\n",
    "some_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sort the list\n",
    "some_list.sort()\n",
    "some_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reverse the order of the list\n",
    "some_list.reverse()\n",
    "some_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WKSH EX8\n",
    "\n",
    "Check the answers to the exercise here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_list = [1, 1, '2', 'hello?', 583, 'llama', [2,4,6], 3.14159]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(A) What code would you write if you wanted to add the number 314 after the item `“llama”` in `some_list`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(B) How would `some_list` change if you ran the following line of code?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_list.pop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(C) How would `some_list` change if you ran the following line of code?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_list.append()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### iPYNB EX6\n",
    "Say we have a list containing the names of several CSV files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "filenames = ['Mod-3-USA-19970101.csv','Mod-3-AUS-19970102.csv',\n",
    "             'Mod-3-BRA-19970103.csv','Mod-3-CAN-19970204.csv',\n",
    "             'Mod-3-ENG-19970105.csv']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(A)** You notice that the fourth file, `Mod-3-USA-19970204.csv`, has the wrong month in the date - it should be `19970104` instead of `19970204`. How would you correct this file name in `filenames`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(B)** You want to extract the **day** within the date of the **last file** in `filenames`. That is, you want to extract the substring `'05'` from the `'19970105'` within `'Mod-3-ENG-19970105.csv'`.\n",
    "\n",
    "What code could you write to do that?\n",
    "\n",
    "**Tip - do this in two steps:**\n",
    "\n",
    "   1) Extract the file name from `filenames`.\n",
    "   \n",
    "   2) Extract the day from the file name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filenames = ['Mod-3-USA-19970101.csv',\n",
    "             'Mod-3-AUS-19970102.csv',\n",
    "             'Mod-3-BRA-19970103.csv',\n",
    "             'Mod-3-CAN-19970204.csv',\n",
    "             'Mod-3-ENG-19970105.csv']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "A tuple is a data structure in Python where values are **ordered** but **unchangeable (“immutable”)**. Like a list, the **items are accessed through an index**. However, you **cannot add, delete, or change items** in a tuple after it is created. Tuples are useful if you want to store pieces of information with a specific order that you don’t want to accidentally change - for example, an RGB code or a phone number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "blue = (0,0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "blue[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The difference is that tuples are *immutable* so cannot be changed in any way "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "blue[0] = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This may seem like a limitation but is in fact very useful if you don't want to accidently change something, like a list of constants. Tuples  are faster than lists and can be used in dictionaries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "A **dictionary** is a data structure in Python where **values are accessed by keys** instead of indices. Each item in a dictionary is a **key:value** pair.\n",
    "\n",
    "Dictionaries are useful if you want to store pieces of information that are unique to that key - for example, a person (key) and their phone number (value), a country (key) and an abbreviation you’d like to assign to it (value), a color (key) and its RGB code (value)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = {'blue':(0,0,1), 'red':(1,0,0), 'green':(0,1,0)}\n",
    "# or\n",
    "colors = dict(blue = (0,0,1), red = (1,0,0), green = (0,1,0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Items are accessed using the key you set when you make the dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Access a value via the key\n",
    "colors['blue']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "New items can be added to the dictionary using similar syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set a new key:value pair\n",
    "colors['purple'] = (1,1,0)\n",
    "print(colors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**iPYNB EX 7:** Create a dictionary called `constants` that holds the values of the following scientific constants:\n",
    "\n",
    "|`pi`|`R`|`g`|\n",
    "|--|--|--|\n",
    "|`3.141`|`8.314`|`9.807`|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add a key value pair for `phi`, which is equal to `1.618`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Control Flow\n",
    "* Without *Control flow*, a program is simply a list of statements that are sequentially executed.\n",
    "* With control flow, you can execute certain code blocks conditionally and/or repeatedly.\n",
    "* Basic building blocks are:\n",
    "    - *conditional statements* (including \"``if``\", \"``elif``\", and \"``else``\")\n",
    "    - *loop statements* (including \"``for``\" and \"``while``\" and the accompanying \"``break``\", \"``continue``\", and \"``pass``\")."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Booleans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Booleans**, or the ``bool`` data type, can take on only values of `True` or `False`. **Booleans are the basis for writing conditional conditional if statements**. (You can also use bools for indexing data, but we will not cover this until the data analysis section)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Booleans are the results of **logical operators**. The following are common logical operators:\n",
    "\n",
    "|Less than|Greater than|Less than or equal to|Greater than or equal to|Equal to|Not equal to\n",
    "|:-:|:-:|:-:|:-:|:-:|:-:|\n",
    "| `<`|`>`|`<=`|`>=`|`==`|`!=`|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the **boolean equal to “==” is different from “=”**, which is used to assign values to variables (eg, x = 3)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can **combine boolean operators** to create more multi-conditional statements **using `and`/`or`**.\n",
    "\n",
    "|And|Or|\n",
    "|:-:|:-:|\n",
    "| `and` or `&`|`or` or `\\|`|\n",
    "\n",
    "Some examples of boolean statements in action:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = 30 > 10\n",
    "print(test)\n",
    "\n",
    "Test = True\n",
    "Test2 = False\n",
    "print(Test & Test2)\n",
    "\n",
    "A = 3\n",
    "B = 1\n",
    "print(A>B | A<0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WKSH EX9\n",
    "\n",
    "You can check your exercises in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code for (A) here\n",
    "\n",
    "\n",
    "# Your code for (B) here\n",
    "\n",
    "\n",
    "# Your code for (C) here\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional Statements: ``if``-``elif``-``else``:\n",
    "The **if statement** directs Python to **execute certain lines of code depending on whether a <u>certain condition is satisfied**. That condition is specified using a **boolean statement**.\n",
    "    \n",
    "The output of a boolean statement must always be `True` or `False` (i.e., a bool), or convertible to a bool (i.e., implicit booleaness; you can Google this term to learn more about it)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "if x>0:\n",
    "    print('x is positive')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the first condition is not true (i.e., the boolean statement returns False), then you may specify any number of **additional boolean statements** using **else ifs (`elif`)**. Lastly, you have the option to specify an **`else`**, which will execute **if neither the first if or any of the following `elif` boolean statements are true**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3\n",
    "if x > 0:\n",
    "    print('x is positive')\n",
    "elif x < 0:\n",
    "    print('x is negative')\n",
    "else:\n",
    "    print('x is zero')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WKSH EX10\n",
    "\n",
    "You can check your exercises in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A\n",
    "x = \n",
    "if x >= 2:\n",
    "    y = x+2\n",
    "else:\n",
    "    y = x-2\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# B\n",
    "T = \n",
    "P = \n",
    "if (T >= 0) or (P < 10):\n",
    "    z = 1000\n",
    "elif (T < 0) and (P > 1):\n",
    "    z = 500\n",
    "\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# C\n",
    "T = 20\n",
    "if # Your code here:\n",
    "    instruction = 'Danger'\n",
    "elif # Your code here:\n",
    "     instruction = 'Optimal'\n",
    "# Your code here:\n",
    "     instruction = 'Acceptable'\n",
    "\n",
    "print(instruction)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### iPYNB EX 8\n",
    "\n",
    "Write a sequence of `if`-`elif` statements that outputs a student’s grade based on the table below:\n",
    "\n",
    "|A|B|C|D|F|\n",
    "|:-:|:-:|:-:|:-:|:-:|\n",
    "|90 ≥ grade|80 ≤ grade < 90|70 ≤ grade < 80|60 ≤ grade < 70|grade < 60|\n",
    "\n",
    "**Tip**: define a variable called `score` at the top that is used in the **condition**. `score` will represent the score that you are checking the grade for - you can change the value you set it to the check whether your code is working. Then, create a variable called `grade` that is defined in the **executable**.\n",
    "\n",
    "**Hint**: To compound multiple conditions, you will need to use `and` or `or`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ``for`` loops\n",
    "A **for loop** is used to execute some code for a **predetermined number of iterations**, normally determined by the size of your data set. The for loop is useful when you know how many iterations you need.\n",
    "\n",
    "A basic ``for`` loop generally has 3 components:\n",
    "\n",
    "1. The **indexing variable**, which takes on the value of every item in the iterable\n",
    "2. The **iterable**, the collection of *things* you are iterating through\n",
    "3. The **executable**, the code you are executing on each iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A simple example of a for loop\n",
    "for j in [0,1,2,3]:\n",
    "    print(j+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The built-in function `range()` is commonly used to create an iterable of sequential numbers from a starting point until stopping point in increments of a step you can specify:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(0,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of how to use `range()` in a for loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,1,0.2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WKSH EX12\n",
    "Feel free to use the cells below to check over your answers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here for (A)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here for (B)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WKSH EX13: Calculating the BMI of patients\n",
    "\n",
    "Type the code you've written in your worksheet here to check it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H = [176,162,181,153,170,168]\n",
    "W = [75,65,83,54,91,62]\n",
    "\n",
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common Uses of For Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loops are incredibly useful for generating and processing datasets. Some functions that are frequently used in loops are **appending** and **counters**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Appending"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall `.append()`, a `list` method that we can use to add an item to an end of a list.\n",
    "\n",
    "For example, if `my_list = [1,2,3,4]`, then `my_list.append('hello')` would turn `my_list` into `[1,2,3,4,'hello']`.\n",
    "\n",
    "The `.append()` method is very useful for when we want to perform an operation on every item in a list to create a new output. An example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# List of first names\n",
    "list1 = ['alice','tvetene','minerva','aparna','clara']\n",
    "# List of last names\n",
    "list2 = ['hsu','carlson','teli','reghunathan','kubler']\n",
    "\n",
    "# The new list we want to fill with full names\n",
    "new_list = []\n",
    "\n",
    "# Iterate as many times as there are names in the list\n",
    "for i in range(len(list1)):\n",
    "    \n",
    "    # Concatenate first and last names\n",
    "    full_name = list1[i]+list2[i]\n",
    "    \n",
    "    # Add the full_name to the new list\n",
    "    new_list.append(full_name)\n",
    "    \n",
    "print(new_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Counters\n",
    "\n",
    "**Counters** are a really useful way to debug code. The idea behind the counter is that it **counts the number of iterations** you have done. Below is a simple implementation of a counter.\n",
    "\n",
    "Note that your **counter's variable name** needs to be **different from the indexing variable**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize the counter\n",
    "j = 0\n",
    "\n",
    "for i in range(0,1000,20):\n",
    "    \n",
    "    # Increment the counter\n",
    "    j = j+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because counters **count the number of iterations** you have done, it is very useful for debugging code. This is because if your code runs into an error in your loop, the **counter will tell us which iteration it was on when the error occurred**.\n",
    "\n",
    "In this example, we will implement a counter to tell us which row has an error in it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of counter\n",
    "dataset = [[1,2,3],[3,1,'error'],[2,1,1],[3,2,2],[2,1,2]]\n",
    "\n",
    "# Initialize the counter\n",
    "i = 0\n",
    "\n",
    "# For loop to interate through each row in dataset\n",
    "for row in dataset:\n",
    "    \n",
    "    # Calculate the mean of the row\n",
    "    row_mean = sum(row)/len(row)\n",
    "    \n",
    "    # Increment the counter\n",
    "    i+=1\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Coding Challenges"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Coding Challenge 1: Usernames\n",
    "\n",
    "**<u>Concepts covered</u>**\n",
    "* Strings and string methods\n",
    "* Data type conversion\n",
    "* Lists and indexing\n",
    "* List methods\n",
    "* `for` loops\n",
    "\n",
    "**<u>Instructions</u>**\n",
    "\n",
    "In this exercise, you have a list of names, `names`, that you need to generate usernames for. Each username must contain the name of the person plus their ID number, stored in `IDs`. For example, the first username would be `'alice142'`. Write a loop that combines creates a username for each item in `names` and `IDs`, and saves each username into the list `usernames`. For example, `usernames` should have a length of 5 and its first element would be `'alice142'`.\n",
    "\n",
    "**<u>Pseudocode</u>**\n",
    "* Use an iterable that represents an index on each iteration (such as in EX12).\n",
    "    * Hint: recall how to access items in a list using their indices. You may find either the `range()` function or a counter useful for this.\n",
    "* On each iteration, convert the element in ID into a string.\n",
    "* On each iteration, concatenate (add together) the string in names and the number in ID to create the username for that person. For example, `'alice' + '142'` would return `'alice142'`.\n",
    "* On each iteration, append the username you just created to the list `usernames`.\n",
    "    * You will need the list method `.append()` for this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['alice','clara','alfie','matthew','abdullah','ingo']\n",
    "IDs = [142,753,243,457,503,294]\n",
    "usernames = []\n",
    "\n",
    "# Your code here\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Coding Challenge 2: Experiment Files\n",
    "\n",
    "**<u>Concepts covered</u>**\n",
    "* Strings and string methods\n",
    "* Lists and indexing\n",
    "* List methods\n",
    "* `for` loops\n",
    "* `if-elif-else` statements\n",
    "\n",
    "**<u>Instructions</u>**\n",
    "\n",
    "In this exercise, you have a list of files from different experiments you’ve conducted, `exp_files`. For each file, we want to extract the date, but only if it is for a file corresponding to experiment A (`expA`). Write a loop that extracts the dates for all the `expA` files only and saves them in a new list called `expA_dates`.\n",
    "\n",
    "`expA_dates` should return `['20221024','20230814','20210203','20230523']` at the end of your code.\n",
    "\n",
    "**<u>Pseudocode</u>**\n",
    "* Use `exp_files` as the iterable.\n",
    "* Your code should first check whether the file name has `'expA'` in it using an if statement.\n",
    "    * Google “check if substring in string Python” and look at some of the Stack Overflow recommendations for going about this.\n",
    "* On each iteration (that passes the condition above), extract the date from the file name.\n",
    "    * You might find the string method `.split()` useful.\n",
    "* On each iteration (that passes the condition above), append the extracted date to `expA_dates`.\n",
    "    * You will need the list method `.append()` for this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exp_files = ['20221024_expA.xlsx','20231006_expB.csv','20230910_expC.csv',\n",
    "              '20230814_expA.csv','20220405_expB.xlsx','20211201_expC.xlsx'\n",
    "             '20210203_expA.xlsx','20220505_expB.csv','20211102_expC.xlsx'\n",
    "             '20230523_expA.xlsx','20230611_expB.csv','20211102_expC.xlsx']\n",
    "\n",
    "expA_dates = []\n",
    "# Your code here\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Coding Challenge 3: A Fancier Temperature Converter\n",
    "\n",
    "**<u>Concepts covered</u>**\n",
    "* Basic maths\n",
    "* Strings\n",
    "* Lists and indexing\n",
    "* List methods\n",
    "* `for` loops\n",
    "* `if-elif-else` statements\n",
    "\n",
    "**<u>Instructions</u>**\n",
    "\n",
    "In this exercise, you will write some code that converts a series of temperature measurements into Celsius. You have a series of temperature measurements stored in a list called `T`. The corresponding unit of each of the measurements is stored in a separate list called `units`. Your goal is to convert all of the measurements in `T` into Celsius, and store them to a list called `T_C`.\n",
    "\n",
    "The formulae for converting from Fahrenheit and Kelvin are:\n",
    "\n",
    "<center> $C = \\frac{5}{9}*(F - 32)$ </center>\n",
    "<center> $C = K - 273.15$ </center>\n",
    "\n",
    "**<u>Pseudocode</u>**\n",
    "* Use an iterable in your `for` loop that represents an index on each iteration (such as in EX12).\n",
    "    * *Hint: recall how to access items in a list using their indices.*\n",
    "    * You may find either the `range()` function or a counter useful for this.\n",
    "* On each iteration, you should have a series of `if` statements that check the unit of that measurement in `units`.\n",
    "    * Based on the unit, apply the correct temperature conversion formula.\n",
    "* After applying the correct temperature conversion, save the converted value into `T_C`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "T = [30,280,14,85,58,317,251,305,5,69,301]\n",
    "units = ['C','K','C','F','F','K','K','K','C','F','K']\n",
    "\n",
    "T_C = []\n",
    "\n",
    "# Your code here\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Functions** generally take inputs (called **parameters**) and return one or more outputs. Functions are useful because they are reusable - you can run the same code on different variables without having to rewrite all the code every time.\n",
    "\n",
    "Some examples of some functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    y = x+1\n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def g(x,y):\n",
    "    z = x**2+**2\n",
    "    return z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the syntax for defining a function.\n",
    "\n",
    "* You must use the `def` keyword, followed by your **function name**, the **inputs** you would like to use in **parentheses**, and followed by a **colon**.\n",
    "* The operations that you perform within your function must be **indented to the right of the `def` line** with your function name and inputs.\n",
    "* You must **specify the outputs** you would like your function to compute using the **return** keyword."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WKSH EX15\n",
    "\n",
    "Complete the exercises in the worksheet and then run the cell below to check your answers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_max(list1,list2):\n",
    "\n",
    "    list1_max = max(list1)\n",
    "    list2_max = max(list2)\n",
    "\n",
    "    list1_2_max = list1_max + list2_max\n",
    "\n",
    "    return list1_2_max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WKSH EX16\n",
    "\n",
    "**(A)** Write a function called parabola that takes an input `x` and outputs a point on the `parabola` y = x$^2$+2x+1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(B)** Write a function called `circles` that takes a radius of a circle as input and returns\n",
    "* the circumference\n",
    "* the area of that circle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### iPYNB EX9\n",
    "\n",
    "In iPYNB EX8, you wrote a sequence of `if-elif` statements that outputs a student’s grade based on their score in the table below.\n",
    "\n",
    "|A|B|C|D|F|\n",
    "|:-:|:-:|:-:|:-:|:-:|\n",
    "|90 ≥ grade|80 ≤ grade < 90|70 ≤ grade < 80|60 ≤ grade < 70|grade < 60|\n",
    "\n",
    "Using your code from this exercise, create a function called `my_grade()` that takes `score` as an input and outputs the grade as a string (e.g., `'A'`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What did you think?\n",
    "\n",
    "**Please take a few moments to leave your [course feedback here!](https://forms.office.com/Pages/DesignPageV2.aspx?subpage=design&FormId=lYdfxj26UUOKBwhl5djwkFtIujJ9lCFMouysTWFV3rRURU9JM0wxVlhQTTFPOE9XR01BT0UwQllJVy4u&Token=05c54230d6544ef2a07129e4ac8da068)**\n",
    "\n",
    "This is the first time this version of the Introduction to Python Course has been run. I am very eager for your feedback on what worked for your and what could be improved :)\n",
    "\n",
    "Cheers,\n",
    "\n",
    "Alice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.12"
  },
  "vscode": {
   "interpreter": {
    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}