1-Python-Reference.ipynb

{
  "cells": [
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Introduction to Python\n\nSince its first release in 1991, Python has risen to become not just a popular general-purpose programming language, but a preeminent computer language for data science. This notebook is designed to accompany the Microsoft Reactors introduction to data science workshop, and it will use Python as the primary means of illustrating data-science tools and resources.\n\nSeveral examples in this notebook draw from the [python.org introductory tutorial](https://docs.python.org/3.5/tutorial/introduction.html) and examples given in the [Python 3 documentation](https://docs.python.org/3/) (with edits and amendments). This introduction to Python is written for Python 3.6.7 but is generally applicable to other Python 3.x versions. \n\nOriginal material from python.org is Copyright (c) 2001-2019 Python Software Foundation.\n\nThis course makes extensive use of Jupyter Notebooks hosted on Microsoft Azure. Azure-hosted Jupyter Notebooks provide an easy way for you to experiment with programming concepts in an interactive fashion that requires no installation of software by students on local computers.\n\nJupyter Notebooks are divided into cells. Each cell contains either text written in the Markdown markup language or a space in which to write and execute computer code. Because all the code resides inside code cells, you can run each code cell inline rather than using a separate Python interactive window.\n\n> **Note**: This notebook is designed to have you run code cells one by one, and several code cells contain deliberate errors for demonstration purposes. As a result, if you use the **Cell** > **Run All** command, some code cells past the error won't be run. To resume running the code in each case, use **Cell** > **Run All Below** from the cell after the error."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Comments\n\nMany of the examples in this notebook include comments. Comments in Python start with the hash character (`#`) and extend to the end of the physical line. A comment may appear at the start of a line or following white space or code, but not within a string literal. A hash character within a string literal is just a hash character. Because comments are there to clarify code and are not interpreted by Python, they may be omitted when typing in examples. For example:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# this is the first comment\nspam = 1  # and this is the second comment\n          # ... and now a third!\ntext = \"# This is not a comment because it's inside quotes.\"\nprint(text)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Python basics\n\nThis section will provide you with a foundational understanding of Python syntax and data types."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Arithmetic and numeric types\n\n> **Learning goal:** By the end of this subsection, you should be comfortable with using numeric types in Python arithmetic.\n\nPython is an interpreted language, which means that you can interactively use the interpreter to get immediate results. You can see this by using the Python interpreter as a simple calculator: type an expression, and you can see the output immediately.\n\nHow can you see the results? The Python interpreter runs inside this notebook. To run the code inside a cell, either click the **Run Cell** button at the top of the window or press **Ctrl**+**Enter**. Try running the contents of the cell below. (Don't worry, we'll cover what the syntax of the Python code means later on in this section.)"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(\"Hello, world.\")",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### Python numeric operators\n\nExpression syntax is straightforward: the operators `+`, `-`, `*`, and `/` work just like in most other programming languages (such as Java or C). For example:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "2 + 3",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The order of operations also works as in other programming languages (and in math class):"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "30 - 4 * 5",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Note what happens when you use division:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "7 / 5",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Division (`/`) always returns a floating-point number, which brings up a good point. Python (like other programming languages) has different numeric types. Integer numbers (such as `1`, `3`, and `20`) have type [`int`](https://docs.python.org/3.6/library/functions.html#int). Numbers with a fractional component (such as `3.0` or `1.6`) have type [`float`](https://docs.python.org/3.5/library/functions.html#float).\n\nYou can mix numeric types in calculations:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "3 * 3.5",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "7.0 / 5",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "You can perform a type of division that returns an integer: [floor division](https://docs.python.org/3.6/glossary.html#term-floor-division). Floor division uses the `//` operator, discards any remainders, and just returns an `int`."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "7 // 5",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "To calculate the remainder, you can use the modulo operator, `%`:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "7 % 5",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "For exponents, use the `**` operator. For example, you can write $5^2$ as:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "5 ** 2",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Conversely, $2^5$ would be:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "2 ** 5",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Note that `**` has higher precedence in the order of operations than the negative sign, `-`. This means that $-5^2$ is actually the same thing as $-\\left(5^2\\right)$:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "-5 ** 2",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "In order to assert the order of precedence that you want, use parentheses, `()`:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "(-5) ** 2",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Parentheses can supersede the order of operations in any calculation you need to run:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "(30 - 4) * 5",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Variables\n\nAs in other programming languages, it is often essential to save values for later using variables in Python. Python assigns values to variables using the equals sign (`=`):"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "length = 15\nwidth = 3 * 5\nlength * width",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "If you come from a programming background in another programming language (such as Java), you might have noticed that we never specified the variable type when we declared our variables `length` and `width`. Python does not require this, and you can change variable types as you wish:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "length = 15\nlength",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "length = 15.0\nlength",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "length = 'fifteen'\nlength",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Note that, for all the flexibility of variables in Python, you do have to define them. If you try to use an undefined variable, it will produce an error:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "n",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "In Python's interactive mode and in Jupyter Notebooks, you can use the built-in variable `_`, which automatically takes the value of the last printed expression. For example:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "tax = 11.3 / 100\nprice = 19.95\nprice * tax",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "price + _",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Note that you should always treat the `_` variable as read-only. Explicitly assigning a value to it will create an independent local variable with the same name and will mask the built-in variable (and its behavior).\n\nOur previous output was kind of a mess, however; we generally use only two or fewer decimal points when working with prices. In order to clean this up, we can use a built-in function, `round()`."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "round(_, 2)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We will cover some of the other functions built into Python later in this section and cover user-defined functions in Section 2.\n\nYou do not have to define variables one at a time. You can define multiple variables on a single line, like so:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "a, b, c, = 3.2, 1, 6\na, b, c",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "You can also augment variable assignments. This will be particularly useful when we tackle loops in the next section."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = 5\nx = x + 1  # Un-pythonic variable augmentation\nx += 1  # Pythonic variable augmentation\nx",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Note that augmented assignment doesn’t have to be by 1 or even just addition. Beyond +=, augmented assignment statements in Python include -=, \\*=, /=, %=, and \\**=. Try playing around with different augmentation assignments until this concept makes sense.\n\nPython supports other types of numbers beyond `int` and `float`, such as [`Decimal`](https://docs.python.org/3.6/library/decimal.html#decimal.Decimal) and [`Fraction`](https://docs.python.org/3.6/library/fractions.html#fractions.Fraction). Python also has built-in support for [complex numbers](https://docs.python.org/3.6/library/stdtypes.html#typesnumeric), which are all beyond the scope of this course."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Expressions\n\nAs with other programming languages, expressions are critical for decision making controlling the logical flow of Python programs. The most fundamental way of doing this in Python is with a comparison operator, such as \"`<`\":"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "2 < 5",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Python supplies serveral comparison operators:"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "<center>**Python Comparison Operators**</center>"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "| Operator |      Description      | Sample Input | Sample Output |\n|:--------:|:---------------------:|:------------:|:-------------:|\n| `<`      | Less than             | `2 < 5`      | `True`        |\n| `>`      | Greater than          | `2 > 5`      | `False`       |\n| `<=`     | Less than or equal    | `2 <= 5`     | `True`        |\n|          |                       | `2 <= 2`     | `True`        |\n| `>=`     | Greater than or equal | `2 >= 5`     | `False`       |\n| `==`     | Equality              | `2 == 2`     | `True`        |\n|          |                       | `2 == 5`     | `False`       |\n| `!=`     | Inequality            | `2 != 5`     | `True`        |\n|          |                       | `2 != 2`     | `False`       |"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Python does not restrict you to comparing just two operands at a time. For example:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "a, b, c = 1, 2, 3\na < b < c",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "This entire expression is `True` because `1 < 2` is `True` and `2 < 3` is `True`.\n\nYou can also use built-in functions in Python for comparing data. For example:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "min(3, 2.4, 5)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "max(3, 2.4, 5)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "You can also combine comparison operators into compound expressions. For example:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "1 < 2 and 2 < 3",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "This compound expression returned `True` because **both** `1 < 2` is true and `2 < 3` is true. (Note that this is equivalent to `1 < 2 < 3`.)\n\n### Exercise:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Now flip around one of the simple expressions and see if the output matches your expectations:\n1 < 2 and 3 < 2",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Python also provides the `or` Boolean operator, which requires that only one simple expression in a compound expression be true in order to return `True`. For example:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "1 < 2 or 1 > 2",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Finally, `not` inverts the truth evaluation of an expression, such as in:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "not (2 < 3)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Exercise:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Play around with compound expressions.\n# Set i to different values to see what results this complex compound expression returns:\ni = 7\n(i == 2) or not (i % 2 != 0 and 1 < i < 5)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "> **Takeaway:** Arithmetic operations on numeric data form the foundation of data science work in Python. Even sophisticated numeric operations are predicated on these basics, so mastering them is essential to doing data science."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Strings\n\n> **Learning goal:** By the end of this subsection, you should be comfortable working with strings at a basic level in Python.\n\nBesides numbers, Python can also manipulate strings. Strings can be enclosed in single quotes (`'...'`) or double quotes (`\"...\"`) with the same result. Use `\\` to escape quotes; that is, use `\\` in order to use quotation marks within the string itself:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "'spam eggs'  # Single quotes.",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "'doesn\\'t'  # Use \\' to escape the single quote...",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "\"doesn't\"  # ...or use double quotes instead.",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "In the interactive interpreter and Jupyter Notebooks, the output string is enclosed in quotes and special characters are escaped with backslashes. Although this output sometimes looks different from the input (the enclosing quotes could change), the two strings are equivalent. The string is enclosed in double quotes if the string contains a single quote and no double quotes; otherwise, it’s enclosed in single quotes. The [`print()`](https://docs.python.org/3.6/library/functions.html#print) function produces a more readable output by omitting the enclosing quotes and by printing escaped and special characters:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "'\"Isn\\'t,\" she said.'",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print('\"Isn\\'t,\" she said.')",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "If you don't want escaped characters (prefaced by `\\`) to be interpreted as special characters, use *raw strings* by adding an `r` before the first quote:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print('C:\\some\\name')  # Here \\n means newline!",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(r'C:\\some\\name')  # Note the r before the quote.",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### String literals\n\nString literals can span multiple lines and are delineated by triple-quotes: `\"\"\"...\"\"\"` or `'''...'''`.\n\nBecause Python doesn't provide a means for creating multi-line comments, developers often just use triple quotes for this purpose. In a Jupyter notebook, however, such quotes define a string literal that appears as the output of a code cell:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "\"\"\"\nEverything between the first three quotes, including new lines,\nis part of the multi-line comment. Technically, the Python interpreter\nsimply sees the comment as a string, and because it's not otherwise\nused in code, the string is ignored. Convenient, eh?\n\"\"\"",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "For this reason, it's best in notebooks to use the # comment character at the beginning of each line, or better still, just use a Markdown cell outside of a code cell in a Jupyter notebook!\n\nStrings can be *concatenated* (glued together) with the + operator, and repeated with *:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# 3 times 'un', followed by 'ium'\n3 * 'un' + 'ium'",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The order of operations applies to operators when they are used with strings as well as numeric types. Try experimenting with different combinations and orders of operators and strings to see what happens."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Concatenating strings\n\nTwo or more *string literals* placed next to each other are automatically concatenated:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "'Py' 'thon'",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "However, to concatenate variables or a variable and a literal, use `+`:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "prefix = 'Py'\nprefix + 'thon'",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### String indexes\n\nStrings can be *indexed* (subscripted), with the first character having index 0. There is no separate character type; a character is simply a string of size one:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word = 'Python'\nword[0]  # Character in position 0.",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[5]  # Character in position 5.",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Indices may also be negative numbers, which means to start counting from the end of the string. Note that because -0 is the same as 0, negative indices start from -1:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[-1]  # Last character.",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[-2]  # Second-last character.",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[-6]",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Slicing strings\n\nIn addition to indexing, which extracts individual characters, Python also supports *slicing*, which extracts a substring. To slice, you indicate a *range* in the format `start:end`, where the start position is included but the end position is excluded:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[0:2]  # Characters from position 0 (included) to 2 (excluded).",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[2:5]  # Characters from position 2 (included) to 5 (excluded).",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "If you omit either position, the default start position is 0 and the default end is the length of the string:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[:2]   # Character from the beginning to position 2 (excluded).",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[4:]  # Characters from position 4 (included) to the end.",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[-2:] # Characters from the second-last (included) to the end.",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "This characteristic means that `s[:i] + s[i:]` is always equal to `s`:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[:2] + word[2:]",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[:4] + word[4:]",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "One way to remember how slices work is to think of the indices as pointing between characters, with the left edge of the first character numbered 0. Then the right edge of the last character of a string of *n* characters has index *n*. For example:"
    },
    {
      "metadata": {},
      "cell_type": "raw",
      "source": " +---+---+---+---+---+---+\n | P | y | t | h | o | n |\n +---+---+---+---+---+---+\n 0   1   2   3   4   5   6\n-6  -5  -4  -3  -2  -1"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The first row of numbers gives the position of the indices 0–6 in the string; the second row gives the corresponding negative indices. The slice from *i* to *j* consists of all characters between the edges labeled *i* and *j*, respectively.\n\nFor non-negative indices, the length of a slice is the difference of the indices, if both are within bounds. For example, the length of `word[1:3]` is 2.\n\nAttempting to use an index that is too large results in an error:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[42]  # The word only has 6 characters.",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "However, when used in a range, an index that's too large defaults to the size of the string and does not give an error. This characteristic is useful when you always want to slice at a particular index regardless of the length of a string:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[4:42]",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[42:]",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Python strings are [immutable](https://docs.python.org/3.6/glossary.html#term-immutable), which means they cannot be changed. Therefore, assigning a value to an indexed position in a string results in an error:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[0] = 'J'",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The following cell also produces an error:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[2:] = 'py'",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "A slice is itself a value that you can concatenate with other values using `+`:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "'J' + word[1:]",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[:2] + 'Py'",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "A slice, however, is not a string literal, and it cannot be used with automatic concatenation. The following code produces an error:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "word[:2] 'Py'    # Slice is not a literal; produces an error",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Oftentimes, while working with strings, it can be useful to evaluate the length of a string. The built-in function [`len()`](https://docs.python.org/3.5/library/functions.html#len) returns the length of a string:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "s = 'supercalifragilisticexpialidocious'\nlen(s)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Another useful built-in function for working with strings is [`str()`](https://docs.python.org/3.6/library/stdtypes.html#str). This function takes any object and returns a printable string version of that object. For example:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "str(2)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "str(2.5)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "> **Takeaway:** Operations on string data form the other fundamental task you will do in data science in Python. Becoming comfortable with strings now will pay large dividends to you later as you work with increasingly complex data."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Other data types\n\n> **Learning goal:** By the end of this subsection, you should have a basic understanding of the remaining fundamental data types in Python and an idea of how and when to use them.\n\nThe string and numeric data types that we have looked at so far are common to many programming languages. The other data types that we will now look at--lists, tuples, and dictionaries--set Python apart from C++ or Java by providing powerful and easy-to-use built-in data structures."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Lists\n\nPython knows a number of compound data types, which are used to group together other values. The most versatile is the [*list*](https://docs.python.org/3.5/library/stdtypes.html#typesseq-list), which can be written as a sequence of comma-separated values (items) between square brackets. Lists might contain items of different types, but usually the items all have the same type."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "squares = [1, 4, 9, 16, 25]\nsquares",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Like strings (and all other built-in [sequence](https://docs.python.org/3.5/glossary.html#term-sequence) types), lists can be indexed and sliced:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "squares[0]  # Indexing returns the item.",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "squares[-1]",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "squares[-3:]  # Slicing returns a new list.",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "All slice operations return a new list containing the requested elements. This means that the following slice returns a new (shallow) copy of the list:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "squares[:]",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Lists also support concatenation with the `+` operator:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "squares + [36, 49, 64, 81, 100]",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Unlike strings, which are [immutable](https://docs.python.org/3.5/glossary.html#term-immutable), lists are a [mutable](https://docs.python.org/3.5/glossary.html#term-mutable) type, which means you can change any value in the list:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "cubes = [1, 8, 27, 65, 125]  # Something's wrong here ...\n4 ** 3  # the cube of 4 is 64, not 65!",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "cubes[3] = 64  # Replace the wrong value.\ncubes",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "You can assign to slices, which can change the size of the list or clear it entirely:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\nletters",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Replace some values.\nletters[2:5] = ['C', 'D', 'E']\nletters",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Now remove them.\nletters[2:5] = []\nletters",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Clear the list by replacing all the elements with an empty list.\nletters[:] = []\nletters",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The built-in [`len()`](https://docs.python.org/3.6/library/functions.html#len) function also applies to lists for getting their lengths:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "letters = ['a', 'b', 'c', 'd']\nlen(letters)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "You can nest lists, which means to create lists that contain other lists. For example:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "a = ['a', 'b', 'c']\nn = [1, 2, 3]\nx = [a, n]\nx",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "`x` is a list of lists, and you can access its constituent lists through the same indexing you use with simpler lists:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x[0]",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "And by using additional index numbers, you can directly access elements within those sub-lists:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x[0][0]",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Exercise:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Nested lists come up a lot in programming, so it pays to practice.\n# Which indices would you include after x to get ‘c’?\n# How about to get 3?\n",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### List object methods\n\nPython includes a number of handy functions that are available to all lists.\n\nFor example, [`append()`](https://docs.python.org/3.6/tutorial/datastructures.html) and [`extend()`](https://docs.python.org/3.6/tutorial/datastructures.html) enable you to add to the end of a list, much like the `+=` operator:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "beatles = ['John', 'Paul']\nbeatles.append('George')\nbeatles",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Notice that you did not actually pass a list to `append()`; passing a list to `append()` results in this behavior:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "beatles2 = ['John', 'Paul', 'George']\nbeatles2.append(['Stuart', 'Pete'])\nbeatles2",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "To tack a list on the end of an existing list, use `extend()` instead:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "beatles.extend(['Stuart', 'Pete'])\nbeatles",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "[`index()`](https://docs.python.org/3.6/tutorial/datastructures.html) returns the index of the first matching item in a list (if present):"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "beatles.index('George')",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The [`count()`](https://docs.python.org/3.6/tutorial/datastructures.html) method returns the number of items in a list that match objects you pass in:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "beatles.count('John')",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "There are two methods for removing items from a list. The first is [`remove()`](https://docs.python.org/3.6/tutorial/datastructures.html), which locates the first occurrence of an item in the list and removes it (if present):"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "beatles.remove('Stuart')\nbeatles",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The other method for removing items from lists is the [`pop()`](https://docs.python.org/3.6/tutorial/datastructures.html) method. If you supply `pop()` with an index number, it will remove the item from that location in the list and return it; otherwise, `pop()` removes the last item in a list and returns that:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "beatles.pop()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The [`insert()`](https://docs.python.org/3.6/tutorial/datastructures.html) method enables you to add an item to a specific location in a list:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "beatles.insert(1, 'Ringo')\nbeatles",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Unsurprisingly, the [`reverse()`](https://docs.python.org/3.6/tutorial/datastructures.html) method reverses the order of items in a list:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "beatles.reverse()\nbeatles",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Finally, the [`sort()`](https://docs.python.org/3.6/tutorial/datastructures.html) method orders the items in a list:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "beatles.sort()\nbeatles",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Exercise:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# What happens if you run beatles.extend(beatles)?\n# How about beatles.append(beatles)?\n",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Note that you can supply your own *lambda function* to `sort()` for use in comparing items in a list. We will cover lambda functions in Section 2."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Tuples\n\nAnother immutable data type in Python are *tuples*. It can be useful at times to create a data structure that won't be altered later in a program, such as to protect constant data from being overwritten on accident or to improve performance for iterating over data. This is where tuples come in. You create tuples much as you do lists, only using parentheses instead of brackets."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "t = (1, 2, 3)\nt",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Because tuples are immutable, you cannot change elements within them:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "t[1] = 2.0",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "However, you can refer to elements within them:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "t[1]",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "You can also slice tuples:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "t[:2]",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "You can also create tuples from lists:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "l = ['baked', 'beans', 'spam']\nl = tuple(l)\nl",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Or you can create lists from tuples:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "l = list(l)\nl",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Membership testing\n\nAs your Python programming grows more complex, you will want to test lists and tuples for the membership of specific data. The `in` operator enables you to do that."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "tup = ('a', 'b', 'c')\n'b' in tup",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "You can also test to see if something is not in a list or tuple using `not in`:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "lis = ['a', 'b', 'c']\n'a' not in lis",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Exercise:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# What happens if you run lis in lis?\n# Is that the behavior you expected?\n# If not, think back to the nested lists we’ve already encountered.\n",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Dictionaries\n\nDictionaries in Python provide a means of mapping information between unique keys and values. You create dictionaries by listing zero or more key-value pairs inside of braces, like this:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "capitals = {'France': ('Paris', 2140526)}",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Keys for dictionaries can be three things: strings, numbers, or tuples (that contain only strings, numbers, or other tuples). The important thing is that dictionary keys be immutable, so lists cannot be used for keys in dictionaries, for example.\n\nYou add to dictionaries like this:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "capitals['Nigeria'] = ('Lagos', 6048430)\ncapitals",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Exercise:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Now try adding another country (or something else) to the capitals dictionary",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "You reference entries much like you do as through an index number for a string, list, or tuple, but instead of an index, use a key:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "capitals['France']",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "collapsed": true
      },
      "cell_type": "markdown",
      "source": "You can also update entries in the dictionary:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "capitals['Nigeria'] = ('Abuja', 1235880)\ncapitals",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "collapsed": true
      },
      "cell_type": "markdown",
      "source": "When used on a dictionary, the `len()` method returns the number of keys in a dictionary:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "len(capitals)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "collapsed": true
      },
      "cell_type": "markdown",
      "source": "Similar to the `pop()` method for lists, the `popitem()` method randomly removes a key from the dictionary, along with its associated value:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "capitals.popitem()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "capitals",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "> **Takeaway:** Regardless of how complex and voluminous the data you will work with, these basic data structures will repeatedly be your means for handling and manipulating it. Comfort with these basic data structures is essential to being able to understand and use Python code written by others."
    },
    {
      "metadata": {
        "collapsed": true
      },
      "cell_type": "markdown",
      "source": "## Control Flow, Functions, and Libraries\n\nYou will have a foundational understanding of Python control flows, functions, and libraries after completing this section."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Control flow in Python\n\n> **Learning goal:** By the end of this subsection, you should be comfortable using basic control flows in Python.\n\nNow that you have a working understanding of the fundamental data types and structures in Python, we can move on to actual programming using Python.\n\n#### If-statements\n\n`If` statements in Python are similar to those in other programming languages like Java, and they form the backbone of the logical flow of most programs."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "y = 6\nif y % 2 == 0:\n    print('Even')",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Exercise:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# What behavior do you experience if you change y to be odd?",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Did you notice the indentation for print under the if statement? That indentation is important because that is how Python demarks the scope of a control flow--what is contingently run or looped over--as opposed to the braces ({}) used in other languages.\n\nTo cover more contingencies without having to construct a follow-on `if` statement, you can add an `else` statement:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "y = 7\nif y % 2 == 0:\n    print('Even')\nelse:\n    print('Odd')",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "`elif` enables you to insert an additional logical test to an `if` statement:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "y = 1\nif y % 2 == 0:\n    print('Even')\nelif y == 1:\n    print('One')\nelse:\n    print('Odd')",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Notice that, in the previous example, the `if` statement exited after finding the *first* logical test that was `true`. If `y = 1`, and while 1 is indeed odd, the `if` statement executed and exited after finding that `y == 1`, rather than continuing to the end of the statement."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Exercise:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Try changing the value of y in the snippet above.\n# Do you get the output that you expect?\n",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### For-loops\n\nIt is often necessary in programs to iterate over some set of items. This is where `for` loops prove useful. For example, they can provide a useful way to iterate over the items of a list:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "colors = ['red', 'yellow', 'blue']\nfor color in colors:\n    print(color)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Sometimes, you will want to iterate over a list using the list index rather than items from that list (say, when you want to access items from another list at the same time). In this case, you can combine list-object methods and for loops:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "comp_colors = ['green', 'purple', 'orange']\nfor i in range(len(comp_colors)):\n    print(colors[i], comp_colors[i])",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We've met `len()` before, but [`range()`](https://docs.python.org/3/library/functions.html#func-range) is new to us. That function produces a sequence of integers from 0 to 1 less than the number passed into it. Hence:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for j in range(5):\n    print(j)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "In addition to `range(`*`stop`*`)`, the range function can take up to three parameters: `range(`*`start`*, *`stop`*`[, `*step*`])`. This odd-looking notation just means that if you pass a single argument to `range()`, it will take that to be the stop value; two arguments will be the start and stop values; and three values are `start`, `stop`, and `step`.\n\n### Exercise:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# How would you use range and a for loop to print the sequence of numbers\n# from 10 to 20? How about counting by threes from 17 to 41?\n",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "It can also be important to break out of a loop. Python uses the `break` statement borrowed from C to do this. To see this in action, consider two nested for loops:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for n in range(2, 10):\n    for x in range(2, n):\n        if n % x == 0:\n            print(n, 'equals', x, '*', n//x)\n            break\n    else:\n        print(n, 'is a prime number')",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Note that, in the example above, the `else` statement belongs to the `for` loop, not to the `if` statement.\n\n### Exercise:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Try changing the code snippet above after you remove the break statement.\n# What output does it now produce?\n",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "As part of the control flow of your program, you might want to continue to the next iteration of your loop. The `continue` statement (also borrowed from C) can help with that:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for num in range(2, 10):\n    if num % 2 == 0:\n        print(\"Found an even number:\", num)\n        continue\n    print(\"Found an odd number:\", num)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Exercise:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# What happens when you replace the continue statement above with a break?\n",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### While-loops\n\nIf we cross the functionality of the `if` statement with that of the `for` loop, we would get the `while` loop, a loop that iterates while some logical condition remains true. Consider this snippet of code to compute the initial sub-sequence of the Fibonacci sequence:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# In the Fibonacci series, the sum of two elements defines the next.\na, b = 0, 1\n\nwhile b < 100:    \n    print(b, end=', ')\n    a, b = b, a+b",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Go ahead and play with the number of iterations for the while loop. Notice that this snippet also uses multiple assignment for variables.\n\n> **Takeaway:** Control flows are what make programs programs, as opposed to a single sequence of operations. Mastering the logical flow of information in Python will enable you to automate tasks that would be impossibly complex or time-consuming to do manually."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Functions\n\n> **Learning goal:** By the end of this subsection, you should understand how to pass and receive data from functions.\n\nAs in other programming languages, it is often essential in Python to break down your program into reusable chunks. A primary means of doing that is through functions.\n\nFor example, we could rewrite the `while` loop code snippet above as a formal function:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "def fib(n):\n    \"\"\"Print a Fibonacci series up to n.\"\"\"\n    a, b = 0, 1\n    while a < n:\n        print(a, end=', ')\n        a, b = b, a+b",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Now we can call this function and compute the Fibonacci series up to some arbitrary point:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "fib(2000)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Python can also define new functions on the fly. These anonymous functions are called *lambda functions* because you define them with the `lambda` keyword. Lambda functions can contain any number of arguments but only one expression."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\nlist(filter(lambda x: x % 2 != 0, nums))",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "> **Takeaway:** You will constantly be using functions of all kind to perform data science in Python, so understanding how functions accept, work on, and return data is critical to further progress."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### List comprehensions\n\n> **Learning goal:** By the end of this subsection, you should understand how to economically and computationally create lists.\n\nSometimes, it makes more sense to generate a list algorithmically. Consider the last example. We really wanted just a list of numbers from 1 to 10. Rather than type those out, we can use a *list comprehension* to generate it:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "numbers = [x for x in range(1,11)] # Remember to create a range 1 more than the number you actually want.\nnumbers",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can also perform computation on the items generated for the list:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "squares = [x*x for x in range(1,11)]\nsquares",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can even perform logical tests on list items in the comprehension:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "odd_squares = [x*x for x in range(1,11) if x % 2 != 0]\nodd_squares",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Exercise:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Now use a list comprehension to generate a list of odd cubes\n# from 1 to 2,197\n",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "> **Takeaway:** List comprehensions are a popular tool in Python because they enable the rapid, programmatic generation of lists. The economy and ease of use therefore make them an essential tool for you (in addition to a necessary topic to understand as you try to understand Python code written by others)."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Importing modules\n\n> **Learning goal:** By the end of this subsection, you should be comfortable importing modules in Python.\n\nIf you quit from the Python interpreter and enter it again, the definitions you have made (your functions and variables) will be lost. Similarly, you might also want to use a handy function that you’ve written in several programs without copying its definition into each program.\n\nTo support this, Python has a way to put definitions in a file and use them in a script or in an interactive instance of the interpreter. Such a file is called a [*module*](https://docs.python.org/3/tutorial/modules.html). Definitions from a module can be imported into other programs or modules.\n\nFor example, the `factorial()` function is not one of the standard functions built into Python. It is part of the Python [`math`](https://docs.python.org/3/library/math.html) module. So, when we run `factorial()` before importing `math`, we get an error:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "factorial(5)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "However, the situation changes after we import the `math` module:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "import math\nmath.factorial(5)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Notice that we still have to prepend `math` to the front of the `factorial()` function. We can use a different method to import that specific function from the `math` module and use it as if it were defined in our program:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "from math import factorial\nfactorial(5)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "You can add more cells to your notebook by clicking the **insert cell below (+)** button at the top of the window. The Python [`math`](https://docs.python.org/3/library/math.html) module has many functions in it. Try importing some of the other math functions and playing around with them.\n\n> **Takeaway:** There are several Python modules that you will regularly use in conducting data science in Python, so understanding how to import them will be essential (especially in this training)."
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3",
      "language": "python"
    },
    "language_info": {
      "mimetype": "text/x-python",
      "nbconvert_exporter": "python",
      "name": "python",
      "pygments_lexer": "ipython3",
      "version": "3.5.4",
      "file_extension": ".py",
      "codemirror_mode": {
        "version": 3,
        "name": "ipython"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 1
}