1. Introduction to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is Python?\n",
    "\n",
    "Python is an extremely common programming language that is becoming more and more popular with all types of programmers. It is especially strong in data handling, and is the language of choice for AI and data science applications including machine learning. \n",
    "\n",
    "Python was invented in 1990 by Guido van Rossum and was specifically designed for programmers (not computers). Thus it's one of the best programming languages to learn as a first language. \n",
    "\n",
    "> So I set out to come up with a language that made programmers more productive, and if that meant that the programs would run a bit slower, well, that was an acceptable trade-off - Van Rossum\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Zen of Python\n",
    "\n",
    "Python has a philosophy built into the language"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running the Python interperter\n",
    "\n",
    "If you are using the recommended Jupyter Lab, then you can easily access a terminal in the same window as this notebook\n",
    "\n",
    "We can start an interactive Python **interpreter** session by typing the following \n",
    "\n",
    "```bash\n",
    "#  the $ indicates the command is run in a shell\n",
    "$ python\n",
    "```\n",
    "\n",
    "We can see where this Python executable is located on our machine using the bash program `which`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  use ! to run bash/shell code in the notebook directly\n",
    "!which python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And what version of Python we are using by running Python with a command line argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  use ! to run bash/shell code in the notebook directly\n",
    "!python3 --version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python development environment\n",
    "\n",
    "## iPython\n",
    "\n",
    "IPython = Interactive Python \n",
    "- command shell for interactive computing\n",
    "- IPython is what runs in Jupyter\n",
    "\n",
    "In Python, we run code in 2 different ways: \n",
    "- iPython: lets you run small snippets of code directly\n",
    "- Python: script mode, runs entire programs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code editors and Integrated Development Environments (IDEs)\n",
    "\n",
    "This is where you develop your code.\n",
    "\n",
    "### Code editors\n",
    "\n",
    "Code editors are text editor programs specifically designed to edit code. They usually provide features such as syntax highlighting, auto-indentation, auto-completion, etc.\n",
    "\n",
    "Examples of Code editors:\n",
    "- Vim\n",
    "- Atom\n",
    "- Sublime Text\n",
    "\n",
    "### Integrated Development Environments (IDEs)\n",
    "\n",
    "IDEs combine several tools and functionalities to support software programming under one Graphical User Interface. They usually offer more built-in features, e.g. code editor, interpreter, debugger, deployment tools, etc.\n",
    "\n",
    "Examples of IDEs working nicely with Python:\n",
    "- PyCharm\n",
    "- Visual Studio Code\n",
    "- Psyder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Python\n",
    "Python works with (mainly) 2 different things at the lowest level:\n",
    "1. Data types\n",
    "2. Functions\n",
    "\n",
    "Data types store data. Functions act on or change those bits of data.\n",
    "We name different <i> instances </i> of those data types and save them as variables to make our code easier to read and work with. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Types - Numbers\n",
    "There are 2 different data types for holding numeric values in python - floats and integers.\n",
    "Python can be used just like a calculator to work on these numbers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(16.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the typical operators we know `(+, *, /, etc.) ` to perform math operations.\n",
    "\n",
    "NOTE: `=` in python is used to assign a variable to a name. It is NOT necessary for doing math operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "6 * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python will complete the operations based on correct order of operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "4 + 1 * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do exponentiation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "4 ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float(4) ** 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The modulo (`%`) operator gives us the remainder after division:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "20 % 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be used to check if a number is even:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "20 % 2 == 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Types - Booleans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many expressions in Python have a \"truth value\" and evaluate to one of the two boolean values.\n",
    "- values which are evaluated to `True` or `False`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool([1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool(None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Types: Strings\n",
    "\n",
    "String data types hold text data. If a number appears in a string, it isn't treated as a number (can't be added, multiplied, etc.).\n",
    "They can be written in multiple ways:\n",
    "\n",
    "Can use `\"`, `'` or `str()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"this is fine\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'so is this'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Files are just big lists of characters\n",
    "\n",
    "`\\n` in the newline character "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lines = \"First line \\nSecond line\"\n",
    "print(lines)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiple line strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lines_2 = \"\"\"First line,\n",
    "Second line\"\"\"\n",
    "print(lines_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# showing that the line break is read from the typed line break\n",
    "lines_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings next to each other are joined:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Py\" \"thon\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Py\" \"thon\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add strings together (called concatenation):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"ja\" + \"nein\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"ja\" + \" \" + \"nein\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And multiply them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"ja\" * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"ja \" * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens when we try to multiply this string?:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"2\" * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String formatting\n",
    "\n",
    "There are many formatting tricks in Python to control how strings appear. \n",
    "Most formatting commands involve the `{}` curly brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "day = \"Tuesday\"\n",
    "print(\"Today is {}\".format(day))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "day = \"Tuesday\"\n",
    "print(f\"Today is {day}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can control the formatting of decimal places"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1.00015\n",
    "f\"{x:.4f}, {x:.2f}, {x:.1f}, {x:.0f}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String stripping\n",
    "\n",
    "A common operation is removing whitespaces:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\" python is dynamically typed \""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To remove leading and trailing whitespaces in a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\" python is dynamically typed \".strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or to remove all whitespaces from the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"python is dynamically typed\".replace(\" \", \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `in`\n",
    "\n",
    "A way to check if an object exists in an iterable using `in`.  As strings are iterable, this syntax works with strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_string = \"Python\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"P\" in new_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"p\" in new_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Comparisons\n",
    "A double equals sign is used to compute comparisons in Python.\n",
    "\n",
    "An exclamation sign followed by an equals sign means \"is not equal to\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 == 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 == 3 + 2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 != 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logical operators\n",
    "\n",
    "`and`, `or`, `not`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True is not False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditionals\n",
    "Booleans can be used in conditional commands. \n",
    "Conditional commands work just like the \"IF..THEN..\" command you know from Microsoft Excel.\n",
    "\n",
    "\n",
    "Try changing the value of X in the example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if x <= 10:\n",
    "    print(\"X is less than or equal to 10\")\n",
    "else:\n",
    "    print(\"X is greater than 10\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add almost infinite layers to our conditional by adding `elif` to the conditional block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if x <= 10 or y <= 10: \n",
    "    print(\"X or Y is less than or equal to 10\")\n",
    "elif x > 20: \n",
    "    print(\"x is greater than 20\")\n",
    "else:\n",
    "    print(\"X is between 11 and 19\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Datatypes: List\n",
    "A list in python is a collection of datapoints. It is created with brackets `[]` or using `list()`. \n",
    "We can use **selectors** to select specific items within the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [1, 1.0, \"hi\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Selectors are called after the list using `[]`. Python starts counting at 0. To get the first element of the list then, we need to use 0 inside the selector. To get the second item, we would put a 1 inside the selector. \n",
    "\n",
    "We can also start from the back of the list, using -1. Then every positional element we want to get after the last one, we subtract one further. For example, if we want to get the 2nd-from-last element, we could select this element by putting -2 in the selector. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Selecting a range of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "weekdays = [\n",
    "    \"Monday\",\n",
    "    \"Tuesday\",\n",
    "    \"Wednesday\",\n",
    "    \"Thursday\",\n",
    "    \"Friday\",\n",
    "    \"Saturday\",\n",
    "    \"Sunday\"\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Select Thursday and Friday from the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# answer \n",
    "weekdays[3:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables & objects\n",
    "\n",
    "In Python (unlike other languages) there is a difference between **objects** and **variables**:\n",
    "- object = the actual data in memory\n",
    "- variable = a label that refers to an object\n",
    "\n",
    "Objects have an identity, type and value.  Only the value changes over time.\n",
    "\n",
    "In Python, variables **refer** to objects.  They are labels for objects - not the object themselves.\n",
    "- one object can have many labels\n",
    "- one label only refers to one object\n",
    "\n",
    "Below we create two objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "first = [2, 4, 8]\n",
    "second = [2, 4, 8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use two different operators to compare these variables.\n",
    "\n",
    "The `==` operator checks if the two objects have the same values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "second == first"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `is` operator checks whether both variables refer to the same object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "second is first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "third = first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "third is first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "fourth = first.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fourth is first"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Under the hood Python is comparing the object's `id` - a unique value for each object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(first)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(third)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(fourth)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(second)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loops\n",
    "In Python (and programming in general), we'll find many times when we want to do the same calculation over multiple values. This is what loops are for. They allow us to iterate through lists, or rows in a table of data. \n",
    "\n",
    "### `for`\n",
    "\n",
    "We can iterate through any object that has multiple smaller objects within it, like a list. \n",
    "A list contains multiple smaller elements within it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in first:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = [1, 5, 8, 12, 6]\n",
    "\n",
    "for i in p[:3]:\n",
    "    new_number = i + 5\n",
    "    print(\"old number: \", i)\n",
    "    print(\"new number: \", new_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Question: What will happen if we call `new_number` now?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How could we see all of the new_numbers?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = [1, 5, 8, 12, 6]\n",
    "\n",
    "# instantiating empty list to hold all new_numbers\n",
    "new_p = []\n",
    "for i in p[:3]:\n",
    "    new_number = i + 5\n",
    "    print(\"old number: \", i)\n",
    "    print(\"new number: \", new_number)\n",
    "    new_p.append(new_number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A useful tool in python exists for making increasing 'counting-style' lists. This is called `range`. With range, the programmer enters the value at which they want the list to start and stop, and the 'step' of the list. Normally this would be 1. Setting the step to 2 counts off by skipping the intermediary number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Range doesn't \"show\" the list, you have to convert it to a list to see this. However, it is still iterable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "setting starting point with range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# note that it now starts at 1, not 0.\n",
    "for i in range(1,10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "setting step size with range "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1, 10, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings are iterable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in \"python\":\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the builtin `len` to measure the number of characters in a string:\n",
    "\n",
    "(can also be used to measure length of a list, or any iterable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(\"python\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see some of the other functionality available on the `str` object using `dir`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "Write a program to print out:\n",
    "\n",
    "```\n",
    "*****                                                                  \n",
    "  *                                                                    \n",
    "  *                                                                    \n",
    "  *                                                                    \n",
    "  *                                                                    \n",
    "  *                                                                    \n",
    "  *  \n",
    "```\n",
    "\n",
    "It might be useful to know you can do\n",
    "\n",
    "`'*' * 2 = '**'`\n",
    "\n",
    "`'*' + ' ' = '* '`\n",
    "\n",
    "\n",
    "`'\\n'` makes a line break in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(6):\n",
    "    if i == 0:\n",
    "        print(5 * \"*\")\n",
    "    else:\n",
    "        print(\"  *\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program to print:\n",
    "```\n",
    "1\n",
    "22\n",
    "333\n",
    "4444\n",
    "55555\n",
    "666666\n",
    "7777777\n",
    "88888888\n",
    "999999999\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1, 10):\n",
    "    print(i * str(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Datatypes: Dictionary\n",
    "\n",
    "Dictionaries are a handy way to keep track of data in key-value pairs. \n",
    "`{key1: value1, key2: value2}`\n",
    "\n",
    "Let's make a list of dictionaries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [\n",
    "    {'author': 'F. SCOTT FITZGERALD', 'text': 'Action is character'},\n",
    "    {'author': 'RALPH WALDO EMERSON', 'text': 'Every man is my superior in some way. In that, I learn of him'},\n",
    "    {'author': 'RALPH WALDO EMERSON', 'text': 'The purpose of life is not to be happy. It is to be useful, to be honorable, to be compassionate, to have it make some difference that you have lived and lived well'},\n",
    "    {'author': 'Ralph Waldo Emerson', 'text': 'Every man alone is sincere.  At the entrance of a second persion, hypocrisy beings'},\n",
    "    {'author': 'Majjha Nikaya', 'text': 'This is, because that is.  This is not, because that is not.  This is like this, because this is like that'}\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can select our first quote dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data[0]['text']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can iterate over the keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1 = data[0]\n",
    "for key in dict1.keys():\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And the same for the values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for value in dict1.values():\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And both at the same time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for key, value in dict1.items():\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then use the dictionaries to make a DataFrame (more on this in the pandas class :) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a Python program to display the first and last colors from the following list.\n",
    "\n",
    "color_list = [\"Red\",\"Green\",\"White\" ,\"Black\"]\n",
    "\n",
    "Should display \"Red Black\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sum all the items in the following list:\n",
    "x = [1, 2, 3, 7, 12]\n",
    "\n",
    "(hint: no using built-in functions!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get the maximum number from a list: y = [-10, 6, 8, 14]\n",
    "\n",
    "(hint: no using built-in functions!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check if a list is empty or not.\n",
    "\n",
    "For list p = [ ], should print \"True\".\n",
    "\n",
    "For list q = [1, 2, 3, 4] should print \"False\". "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add the {key: value} pair `{\"Susan: 43}` to the dictionary `ages = {\"Joe\": 50, \"Gretchen\": 31}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python-classes",
   "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.11.0 | packaged by conda-forge | (main, Oct 25 2022, 06:21:25) [Clang 14.0.4 ]"
  },
  "vscode": {
   "interpreter": {
    "hash": "33e49de180f7b68adbe0b8c3da4cce2849e5189a09c8fdb059671b22301aa1fe"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}