python01_instructor.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 01\n",
    "Notes based on [The Carpentries](https://carpentries.org/) material.\n",
    "\n",
    "# Lesson 01 - Running Python and Using Jupyter Notebooks\n",
    "- Running and Quitting\n",
    "- Variables and Assignment\n",
    "- Data Types and Type Conversion\n",
    "- Built-in Functions and Help\n",
    "- Libraries\n",
    "- Conditionals\n",
    "- Lists\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questions:\n",
    "- How can I run Python programs? \n",
    "\n",
    "## Objectives:  \n",
    "- Log into OSU's Tiger Research Compute Cloud\n",
    "- Launch a Jupyter notebook.\n",
    "- Explain the difference between a Python script and a Jupyter notebook.\n",
    "- Create Markdown cells in a notebook.\n",
    "- Create and run Python cells in a notebook.\n",
    "\n",
    "## Running a Pythong Program\n",
    "- Python scripts are plain-text files.\n",
    "- Files usually end with `.py` extenstion.\n",
    "- Scripts require a Python interpreter to run.\n",
    "- You have lots of options when creating a Python script: integrated developer environments (IDE's), various text editors, and Jupyter notebooks.\n",
    "\n",
    "## Jupyter Notebooks\n",
    "- We will use a Jupyter Notebook for running and editing Python commands.\n",
    "- Notebooks are intended to imitate the feel of a lab notebook and are designed for presenting output.\n",
    "- Content is broken into three types of blocks: Markdown, code blocks, and output/results.\n",
    "- Notebooks can be saved as `.ipynb` files that you can share with collaborators.\n",
    "- Notebooks are separate from the Python interpreter.\n",
    "- Jupyter notebooks can be run in the cloud or locally on your computer.\n",
    "- If you decide to run notebooks locally on your computer, we recommend using the [Anaconda Python](https://www.anaconda.com/products/individual) distribution.\n",
    "\n",
    "## Using Jupyter Notebooks\n",
    "- There are two modes:\n",
    "  - Edit mode\n",
    "  - Command mode\n",
    "- After clicking on a cell, type <kbd>Esc</kbd> to enter command mode and <kbd>Return</kbd> to enter edit mode.\n",
    "- Command mode allows you to take change the cell type to either Markdown (<kbd>m</kbd>) or Python code (<kbd>y</kbd>).\n",
    "- To execute the content of a cell type <kbd>Shift</kbd>+<kbd>Return</kbd>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Markdown\n",
    "- Markdown is a markup language used to format text.\n",
    "- Designed for bloggers to format text without needing to learn HTML.\n",
    "- Jupyter notebooks employ Markdown to allow us to explain code blocks and content within our notebook.\n",
    "- These notes employ markdown. Double click this text to see how I entered it in edit mode.\n",
    "- Here is a [Markdown cheat sheet](https://www.markdownguide.org/cheat-sheet) for further reference."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Key Markdown Conventions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Headings\n",
    "\n",
    "# Level 1\n",
    "## Level 2\n",
    "### Level 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "* Asterisks\n",
    "- and dashes\n",
    "- create unordered lists "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Numbers\n",
    "3. off any\n",
    "1. order create\n",
    "2. ordered lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- This convention is helpful for updating documentation later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. First step\n",
    "1. then add\n",
    "1. a step"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. First step\n",
    "1. then add\n",
    "1. then add\n",
    "1. a step"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Adding spaces in front \n",
    "  - of a line\n",
    "    - creates\n",
    "    1. sublists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Markdown supports $LaTeX$ notation between `$`'s, so you write equations in your notebook:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\zeta (s)=\\sum _{n=1}^{\\infty }{\\frac {1}{n^{s}}}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lesson 02 - Variables and Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questions:\n",
    "- How can I store data in programs?\n",
    "\n",
    "## Objectives\n",
    "- Write programs that assign values to variables and perform calculations with those values.\n",
    "- Correctly trace value changes in programs that use variable assignment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables Store Values\n",
    "- *Variables* are names used to store values.\n",
    "- The `=` symbol assigns the object on the right to the name on the left."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 42\n",
    "first_name = 'Ahmed'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variable Naming Conventions\n",
    "- Names can only contain letters, digits, and underscores (`_`).\n",
    "- Names cannot start with a digit.\n",
    "- Names are case sensitive (`Age` and `age` are different variables in Python).\n",
    "- Names that start with underscores have special meaning in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use Print to Display Values\n",
    "- Python uses the built-in function `print()` to display objects within variables.\n",
    "- Put the items that you want to print in a comma-separated list within the function's parenthesis to display their content.\n",
    "  - Values passed to a function are called *arguments*.\n",
    "- You can include *strings* (text characters) in the list by wrapping the string in quotes.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(first_name, 'is', age, 'years old.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Print automatically manages formatting issues like spaces between words and line wrapping."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables Must be Created Before they are Used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(last_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Be Aware of Hidden-State Errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(myval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myval = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- If we execute `print(myval)` again, it will work because `myval` has now been assigned `1`.\n",
    "- Jupyter is running separatly from the Python kernal.\n",
    "- These *hidden state* errors often occur when re-running old cells after reusing data or variables in recent work.\n",
    "- Sometimes it is helpful to use \"Kernal\", \"Restart and Run All\" to reset your environment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Variables in Calculations\n",
    "- You can use variables to stand in for the objects they store in calculations.\n",
    "- We assigned `42` to `age` above. Let's use it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "age = age + 3\n",
    "print('Age in three years:', age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using an Index to get Characters from String\n",
    "- Each letter in a string occupies a position that can be referenced, or indexed.\n",
    "- Counting starts with `0` in Python.\n",
    "- To access a specific letter, use it's *index*.\n",
    "- Brackets (`[position]`) after a variable's name index the item at that position.\n",
    "\n",
    "![](http://swcarpentry.github.io/python-novice-gapminder/fig/2_indexing.svg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "atom_name = 'helium'\n",
    "print(atom_name[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using a Slice to get a Substring\n",
    "- An item within a list of items is called an *element*.\n",
    "- A string's elements are individual characters.\n",
    "- We can index multiple elements by using the following index notation: `[start:stop]`.\n",
    "- This notation returns all the elements starting with the `start` item and up to (but not including) the `stop` item.\n",
    "- Grabbing multiple elements from a list of items is called taking a *slice*.\n",
    "- Taking a slice does not change the original string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "atom_name = 'sodium'\n",
    "print(atom_name[0:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use `len()` to Find the Length of a String\n",
    "- The built-in function `len()` returns the length of a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(len('helium'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can nest functions.\n",
    "- Functions are executed from the inside out, like mathematics."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use Meaningful Variable Names\n",
    "- Be kind to potential collaborators (and your future self) by using descriptive variable names.\n",
    "- Python will still execute your code without problems as long as names are consistent, but you might not know what is going on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "flabadab = 42\n",
    "ewr_422_yY = 'Ahmed'\n",
    "print(ewr_422_yY, 'is', flabadab, 'years old.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "**What do you expect to get when running the following code? Paste it into a cell below and try it out**\n",
    "\n",
    "```python\n",
    "a = 123\n",
    "print(a[1])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 123\n",
    "print(a[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `a` is not a string; it's an integer.\n",
    "- Every object in Python has a type with its own set of behaviors.\n",
    "- You cannot index integers like you index strings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lesson 03 - Data Types and Type Conversion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questions\n",
    "- What kind of data types does Python provide?\n",
    "- How can I convert one type to another?\n",
    "\n",
    "## Objectives\n",
    "- Distinguish key differences between integers and floating point numbers.\n",
    "- Distinguish key differences between numbers and character strings.\n",
    "- Use built-in functions to cnovert between integers, floating-point numbers, and strings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Every Object has a Type\n",
    "- Every object in your Python workspace has a type.\n",
    "- A type determines an object's behavior and what you can do with that object.\n",
    "- The integer (`int`) type represents positive and negative whole numbers.\n",
    "- Strings (`str`) hold text.\n",
    "  - Strings must be contained within quotation marks (matching double or single), why?\n",
    "- Float (`float`) represents numbers with a decimal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use `type()` to Find an Object's Type\n",
    "- The built-in function `type()` returns an object's data type.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(type(52))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "fitness = 'average'\n",
    "print(type(fitness))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Types Control Valid Operations for an Object\n",
    "-  An object's type determines what you can do with it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(5 - 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('hello' - 'h')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings can be Added and Multiplied\n",
    "- The string type allows you to add and multiply with strings.\n",
    "- What behavior to you expect in the following two cells?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "full_name = 'Ahmed' + ' ' + 'Walsh'\n",
    "print(full_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "separator = '=' * 10\n",
    "print(separator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings have a Length\n",
    "- But numbers don't ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(len(full_name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(52))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Converting Between Types\n",
    "- We cannot add numbers and strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1 + '2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Python doesn't know how to convert types since the answer could be either `3` or `'12'`.\n",
    "- You can convert some types by using the type name as a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(1 + int('2'))\n",
    "print(str(1) + '2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Integers and Floats Mix Freely\n",
    "- You can mix integers and floats freely in operations and Python knows what to do."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print('Half is', 1 / 2.0)\n",
    "print('Three squared is', 3.0 ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Python automatically does floating-point division."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(3/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Use `//` to compute integer division."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(3//2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Changing a Variable's Value\n",
    "- Variables only change when you assign a new value to them.\n",
    "- While spreadsheets automatically update dependent cells, Python only updates variables when they are explicitly changed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "first = 1\n",
    "second = 5 * first\n",
    "first = 2\n",
    "print('First is', first, 'and second is', second)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `second` did not automatically update when we updated `first`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**When reasonable, `float()` will convert a string to a number, and `int()` will convert a floating-point number to an integer. What do you expect to get when running the following code blocks? Try it out.**\n",
    "\n",
    "- String to number, and float to integer:\n",
    "\n",
    "```python\n",
    "print('String to float:', float('3.4'))\n",
    "print('Float to integer:', int(3.4))\n",
    "```\n",
    "\n",
    "- Another string to number:\n",
    "\n",
    "```python\n",
    "print('String to float:', float('Hellow world!))\n",
    "```\n",
    "\n",
    "**Given this information, what do you expect this code to do?**\n",
    "\n",
    "```python\n",
    "int('3.4')\n",
    "```\n",
    "\n",
    "**How do we fix it?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print('String to float:', float('3.4'))\n",
    "print('Float to integer:', int(3.4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('String to float:', float('Hello world!'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int('3.4')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int(float('3.4'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Knowing what you know now, how do we index the second digit from `a = 123`?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "a = 123\n",
    "a_string = str(a)\n",
    "print(int(a_string[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lesson 04 - Built-In Functions and Help"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questions\n",
    "- How can I find out what built-in functions do?\n",
    "- What kind of errors can occur in a program?\n",
    "\n",
    "## Objectives\n",
    "- Explain the purpose of functions.\n",
    "- Call built-in Python functions.\n",
    "- Use help to display documentation for built-in functions.\n",
    "- Describe situations in which `SyntaxError`s and `NameError`s occur."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A Quick Note on Comments\n",
    "- Be sure to use descriptive comments to document your code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This sentence isn't executed by Python\n",
    "adjustment = 0.5 # Neither is this - anything after `#` is ignored."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calling Functions\n",
    "- An *argument* is a value that is *passed* to a function.\n",
    "- Functions may take zero or more arguments.\n",
    "- `len()` takes exactly one argument.\n",
    "- `int()`, `str()`, and `float()` create new values from an existing one.\n",
    "- What arguments a function takes depends on how it has been defined.\n",
    "- They key to remember is a function takes zero or more arguments (inputs) and produces some output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Even when a function takes zero parameters, you must use parenthesis so Python knows you are calling a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print('before')\n",
    "print()             # Print with no arguments prints a blank line\n",
    "print('after')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some Common Built-In Functions\n",
    "- `max()` returns the larges value of one or more values.\n",
    "- `min()` returns the smallest.\n",
    "- Both work on character strings as well.\n",
    "  - Both use 0-9, A-Z, and a-z to decide what is large and what is small."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(max(1, 2, 3))\n",
    "print(min('a', 'A', '0'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mixing Arguments\n",
    "- Functions might only work for certain combinations of arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(max(1, 'a'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Default Values\n",
    "- Some functions have pre-defined default values.\n",
    "- `round()` defaults to zero decimal places, but you can specify more explicitly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "round(3.712)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "round(3.712, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting Help\n",
    "- Each function comes with built-in documentation.\n",
    "- Use `help()` to look up how to use a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "help(round)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Jupyter notebooks also support clicking on the function and holding <kbd>Shift</kbd>+<kbd>Tab</kbd>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Syntax Errors\n",
    "- If code is typed incorrectly, Python reports a `SytaxError`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Forgot to close the quote marks around the string\n",
    "name = 'Feng"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# An extra `=` in the assignment\n",
    "age = = 52"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('hello world'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Python tries to point out the source of the error with the `^`.\n",
    "- Often the most important part of the error message is the last line.\n",
    "- Do not forget you can Google if an error doesn't make sense."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Runtime Errors\n",
    "- Runtime errors (like `NameError`) occur when something goes wrong while the program is running."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 53\n",
    "remaining = 100 - aege  # Spelled 'age' wrong"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Every Function Returns Something"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Python requires every function to return something.\n",
    "- If a function doesn't return something, Python forces it to return the special datatype `None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "result = print('example')\n",
    "print('The result of print is', result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "**Why don't `max` and `min` return `None` when they are not given arguments? What error message do you get when you try it out?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Both `max()` and `min()` require at least one argument.\n",
    "- This design means the function throws an error immediately instead of getting an unexpected `None`.\n",
    "- Having an unexpected `None` in a variable may create a runtime error later and be harder to fix."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lesson 05 - Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questions:\n",
    "- How can I use software that other people have written?\n",
    "- How can I find out what that software does?\n",
    "\n",
    "## Objectives\n",
    "- Explain what software libraries are and why programmers create and use them.\n",
    "- Write programs that import and use modules from Python's standard library.\n",
    "- Find and read documentation for the standard library interactively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Expanding Python's Capabilities\n",
    "- A *library* is a collection of code that we can import into our environment to expand Python's base functionalities.\n",
    "- Libraries contain functions and constants that will save us time coding from scratch.\n",
    "- The contents of a library should be related, but there is no way to enforce this convention.\n",
    "- Python already comes with the [standard library](https://docs.python.org/3/library/) which gives it a lot of functionality.\n",
    "- Single files within a library are called *modules*.\n",
    "- We typically load only the modules we need for our program.\n",
    "- Other libraries/modules like [NumPy](https://numpy.org/), [math](https://docs.python.org/3/library/math.html) (part of the standard library), and [Pandas](https://pandas.pydata.org/) give us extra tools for working with math functions and data.\n",
    "- You can find many other libraries at the [Python Package Index (PyPI)](https://pypi.org/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing a Module\n",
    "- Use `import` to load a module into your program.\n",
    "- Python uses dot notation (`.`) to indicate something belongs to something else.\n",
    "- To use functions in the module, type `module_name.function_name`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "print('Pi is', math.pi)\n",
    "print('cos(pi) is', math.cos(math.pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting Help\n",
    "- You can use `help()` to learn about the contents of a module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "help(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module Shorthand Conventions\n",
    "- We can import specific items from a module.\n",
    "- This way we don't need to always type the module name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from math import cos, pi\n",
    "\n",
    "print('cos(pi) is', cos(pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- You can also create an alias for a module name and then use that shorthand in your code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import math as m\n",
    "\n",
    "print('cos(pi) is', m.cos(m.pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Different library communities often come to consensus on an agreed shorthand.\n",
    "- An example of this is the convention used by the Pandas community.\n",
    "\n",
    "```python\n",
    "import pandas as pd\n",
    "```\n",
    "\n",
    "- If a given alias is convention it is probably harmless, but do not forget that aliases can cause your code to be difficult to understand."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "**When a colleague types `help(math)`, they get the following error:**\n",
    "\n",
    "```python\n",
    "NameError: name 'math' is not defined\n",
    "```\n",
    "\n",
    "**What did they forget to do?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import math\n",
    "help(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**You want to select a random character from a string:**\n",
    "\n",
    "```python\n",
    "bases = 'ACTTGCTTGAC'\n",
    "```\n",
    "\n",
    "**1. Which [Standard Library](https://docs.python.org/3/library/) module might help? Click the link and look through the modules.**\n",
    "\n",
    "**2. Which function from the module might help?**\n",
    "\n",
    "**3. Write code that uses that function.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1. Which [Standard Library](https://docs.python.org/3/library/) module might help?**\n",
    "\n",
    "- Since we want to randomly select a character, [`random`](https://docs.python.org/3/library/random.html) might help us."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2. Which function from the module might help?**\n",
    "\n",
    "- We can look at the list of function in the [online documentation](https://docs.python.org/3/library/random.html) for `random` to find a function that might apply.\n",
    "- We can also use `help()` to get a list of functions.\n",
    "\n",
    "*Hint: Look for the list under the title `FUNCTIONS` in the documentation.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import random\n",
    "help(random)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The function `choice()` looks promising."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "help(random.choice)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. Write code that uses that function. Run it several times to see if it is truly random.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "bases = 'ACTTGCTTGAC'\n",
    "random.choice(bases)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lesson 06 - Making Decisions (Conditionals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questions\n",
    "- How do I make my program change based on different conditions?\n",
    "\n",
    "## Objectives\n",
    "- Write code that makes decisions using `if` and `else` statements and boolean expressions.\n",
    "- Trace the execution of conditionals.\n",
    "- Change our program based on a user's input."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `if` Statements\n",
    "- `if` statements control whether or not a block of code is executed.\n",
    "- Anatomy of an `if` statement:\n",
    "  - Begin with `if`\n",
    "  - Follow `if` with a logical condition (e.g. `mass > 3.0`)\n",
    "  - End line with a colon `:` and type <kbd>Return</kbd>\n",
    "  - The body of the if statement must be indented (convention is 4 spaces)\n",
    "    - Jupyter Notebooks will do this for you automatically when you type <kbd>Return</kbd>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "mass = 3.54\n",
    "if mass > 3.0:\n",
    "    print(mass, 'is large')\n",
    "\n",
    "mass = 2.07\n",
    "if mass > 3.0:\n",
    "    print(mass, 'is large')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `if` statements make use of boolean expressions (things that evaluate to either `True` or `False`).\n",
    "- Below are a some commonly used boolean expressions:\n",
    "\n",
    "| Expression | Meaning |\n",
    "|    :---:     |   :---   |\n",
    "| <          | Less than |\n",
    "| >          | Greater than |\n",
    "| <=         | Less than or equal to |\n",
    "| >=         | Greater than or equal to |\n",
    "| ==         | Is equal to |\n",
    "| !=         | Is not equal to |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `else` Statement\n",
    "- Use the `else` statement to execute a different code block if the `if` statement is not true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Test several numbers\n",
    "# Call them large if they are greater than 3.0\n",
    "# Call them small if they are less than or equal to 3.0\n",
    "\n",
    "m = 3.54\n",
    "if m > 3.0:\n",
    "    print(m, 'is large')\n",
    "else:\n",
    "    print(m, 'is small')\n",
    "\n",
    "m = 2.07\n",
    "if m > 3.0:\n",
    "    print(m, 'is large')\n",
    "else:\n",
    "    print(m, 'is small')\n",
    "\n",
    "m = 9.22\n",
    "if m > 3.0:\n",
    "    print(m, 'is large')\n",
    "else:\n",
    "    print(m, 'is small')\n",
    "\n",
    "m = 1.86\n",
    "if m > 3.0:\n",
    "    print(m, 'is large')\n",
    "else:\n",
    "    print(m, 'is small')\n",
    "\n",
    "m = 1.71\n",
    "if m > 3.0:\n",
    "    print(m, 'is large')\n",
    "else:\n",
    "    print(m, 'is small')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `elif` Statement\n",
    "- `elif` allows you to create several options for a given decision.\n",
    "- `elif` must come after `if` and before `else`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "m = 3.54\n",
    "if m > 9.0:\n",
    "    print(m, 'is Huge')\n",
    "elif m > 3.0:\n",
    "    print(m, 'is large')\n",
    "else:\n",
    "    print(m, 'is small')\n",
    "\n",
    "m = 2.07\n",
    "if m > 9.0:\n",
    "    print(m, 'is Huge')\n",
    "elif m > 3.0:\n",
    "    print(m, 'is large')\n",
    "else:\n",
    "    print(m, 'is small')\n",
    "\n",
    "m = 9.22\n",
    "if m > 9.0:\n",
    "    print(m, 'is Huge')\n",
    "elif m > 3.0:\n",
    "    print(m, 'is large')\n",
    "else:\n",
    "    print(m, 'is small')\n",
    "\n",
    "m = 1.86\n",
    "if m > 9.0:\n",
    "    print(m, 'is Huge')\n",
    "elif m > 3.0:\n",
    "    print(m, 'is large')\n",
    "else:\n",
    "    print(m, 'is small')\n",
    "\n",
    "m = 1.71\n",
    "if m > 9.0:\n",
    "    print(m, 'is Huge')\n",
    "elif m > 3.0:\n",
    "    print(m, 'is large')\n",
    "else:\n",
    "    print(m, 'is small')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Python moves through `elif` statements in order and stops once it executes a true statement.\n",
    "- This means order of statements matters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "grade = 85\n",
    "if grade >= 70:\n",
    "    print('Grade is C')\n",
    "elif grade >= 80:\n",
    "    print('Grade is B')\n",
    "elif grade >= 90:\n",
    "    print('Grade is A')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**How can we fix this?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "grade = 85\n",
    "if grade >= 90:\n",
    "    print('Grade is A')\n",
    "elif grade >= 80:\n",
    "    print('Grade is B')\n",
    "elif grade >= 70:\n",
    "    print('Grade is C')\n",
    "else:\n",
    "    print('Grade is D')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Conditionals do no re-evaluate automatically if a value is updated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "velocity = 10.0\n",
    "if velocity > 20.0:\n",
    "    print('Moving too fast')\n",
    "else:\n",
    "    print('Adjusting velocity')\n",
    "    velocity = 50.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Python supports compound boolean expressions.\n",
    "- `(expression) and (expression)` requires the expression on the left and right to be true in order for the whole statement to be true.\n",
    "- `(expression) or (expression)` requires allows either expression on the right or left to be true in order for the whole statement to be true.\n",
    "- Be sure to use parenthesis around your expressions so that everything is tested in the correct order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The `input()` function prints a prompt and allows the user to enter values into the program.\n",
    "- Even if we enter numbers into the prompt, they are recorded as strings, so we need to do a type conversion when assigning the input value to a variable.\n",
    "- Try out the following code with different values. See if you can hit all the cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Get user input for mass and velocity\n",
    "mass = float(input('Enter a mass:'))\n",
    "velocity = float(input('Enter a velocity:'))\n",
    "\n",
    "# What kind of traffic is it?\n",
    "if mass > 5 and velocity > 20:\n",
    "    print('Fast heavy object.  Duck!')\n",
    "elif (mass > 2 and mass <= 5 ) and velocity <= 20:\n",
    "    print('Normal traffic.')\n",
    "elif mass <= 2 and velocity <= 20:\n",
    "    print('Slow light object.  Ignore it.')\n",
    "else:\n",
    "    print('Whoa!  Something is up with the data.  Please check it.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**How can we add parenthesis to the above code to make it safer? Go ahead and make those changes.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "**What does this code print? Determine the answer before running the code, then run it to check your answer.**\n",
    "\n",
    "```python\n",
    "pressure = 71.9\n",
    "if pressure > 50.0:\n",
    "    pressure = 25.0\n",
    "elif pressure <= 50.0:\n",
    "    pressure = 0.0\n",
    "print(pressure)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pressure = 71.9\n",
    "if pressure > 50.0:\n",
    "    pressure = 25.0\n",
    "elif pressure <= 50.0:\n",
    "    pressure = 0.0\n",
    "print(pressure)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Execution ends once a condition is met. Execution does not run again for updated values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lesson 07 - Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questions:\n",
    "- How can I store multiple values?\n",
    "\n",
    "## Objectives:\n",
    "- Explain why programs need collections of values.\n",
    "- Write code that creates lists and does the following operations on them:\n",
    "  - Indexing\n",
    "  - Slicing\n",
    "  - Modifying through assignment\n",
    "  - Modifying through a method call"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Storing Many Values\n",
    "- Working with thousands of values can be cumbersome.\n",
    "- List store multiple values as one entity and make it easier for us to work with them in bulk.\n",
    "- To store objects in a list, type a comma-delimited list between brackets: `[item01, item02, item03]`.\n",
    "- The `len()` function tells you how many items are in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pressures = [0.273, 0.275, 0.277, 0.275, 0.276]\n",
    "print('Pressures:', pressures)\n",
    "print('Length:', len(pressures))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing Items\n",
    "- You can index items from a list just like strings.\n",
    "- Things to remember:\n",
    "  - Index (access) objects by using bracket notation: `list_name[position]`.\n",
    "  - Counting starts at 0.\n",
    "  - Slices start with the first index and go up to, but not including, the last index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print('Zeroth item of pressures:', pressures[0])\n",
    "print('Fourth item of pressures:', pressures[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Changing List Values\n",
    "- You can use bracket notation on the left side of an assignement expression to replace a specific item in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print('Pressures is', pressures[0])\n",
    "pressures[0] = 0.265\n",
    "print('Pressures is now', pressures[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Different Datatypes\n",
    "- One list can contain multiple data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "goals = [1, 'Create lists.', 2, 'Extract items from lists.', 3, 'Modify lists.']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Appending Items to a List\n",
    "- `list_name.append()` adds items to the end of a list.\n",
    "- `append()` is a method (a function that belongs to an object).\n",
    "- You can use methods to change objects or take action with them.\n",
    "- Methods use the dot (`.`) notation just like modules and libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "primes = [2, 3, 5]\n",
    "print('`primes` is initially', primes)\n",
    "primes.append(7)\n",
    "print('`primes` has become', primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Lists also have the `extend()` method. Can you tell the difference between `append()` and `extend()`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "teen_primes = [11, 13, 17, 19]\n",
    "middle_aged_primes = [37, 41, 43, 47]\n",
    "print('`primes` is currently', primes)\n",
    "primes.extend(teen_primes)\n",
    "print('`primes` has now become', primes)\n",
    "primes.append(middle_aged_primes)\n",
    "print('`primes` has finally become', primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Lists can contain multiple datatypes, even other lists!\n",
    "- `extend()` maintains the flat list structure while `append()` takes whatever you give it and places it in the next spot.\n",
    "- After running the above code, the last item in the list is an entire list: `[37, 41, 43, 47]]`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Removing Items\n",
    "- `del` deletes items from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "primes = [2, 3, 5, 7, 9]\n",
    "print('`primes` before removing last item:', primes)\n",
    "del primes[4]\n",
    "print('`primes` after removing last item:', primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Empty Lists\n",
    "- Use `[]` to designate a list with no values.\n",
    "- This is helpful when building new lists from scratch."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing Strings\n",
    "- Recall that we can index characters from a string just like lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "element = 'carbon'\n",
    "print('Zeroth character:', element[0])\n",
    "print('Third character:', element[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings are Immutable\n",
    "- Python recognized two types of collections: mutable and immutable.\n",
    "- *Mutable* collections can be changed in place.\n",
    "- *Immutable* collections cannot be changed. The only way to change them is to re-assign their variable.\n",
    "- Lists are mutable while strings are immutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "element[0] = 'C'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing Errors\n",
    "- Python reports an `IndexError` when we try to reference a value that does not exist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('99th element of element is:', element[99])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "**If both `low` and `high` are non-negative integers, how long is the list `values[low:high]`?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The list `values[low:high]` has `high - low` elements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Try out the following code.**\n",
    "\n",
    "```python\n",
    "print('String to list:', list('tin'))\n",
    "print('List to string:', ''.join(['g', 'o', 'l', 'd']))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print('String to list:', list('tin'))\n",
    "print('List to string:', ''.join(['g', 'o', 'l', 'd']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Given this, what does `list('some string')` and `'-'.join(['x', 'y', 'z'])` do?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(list('some string'))\n",
    "print('-'.join(['x', 'y', 'z']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What will the following code do? Try it out.**\n",
    "\n",
    "```python\n",
    "element = 'helium'\n",
    "print(element[-1])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "element = 'helium'\n",
    "print(element[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}