intro-to-python/02_programming_grammar.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "02_programming_grammar.ipynb",
      "provenance": [],
      "private_outputs": true,
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Ada-Developers-Academy/ada-build/blob/master/intro-to-python/02_programming_grammar.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BEhGh3j7X_ai",
        "colab_type": "text"
      },
      "source": [
        "**Programming Grammar**\n",
        "\n",
        "_Ada Build - Intro to Python - Lesson 2_"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5bWRMZSwX6-2",
        "colab_type": "text"
      },
      "source": [
        "# Learning Goals\n",
        "By the end of this lesson we will be able to:\n",
        "* Understand and identify different data types (string, integer, float).\n",
        "* Assign data to variables.\n",
        "* Use the `print` function.\n",
        "* Understand and use string  concatenation and string interpolation.\n",
        "* Identify and debug simple syntax errors.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8vNe319OYQvw",
        "colab_type": "text"
      },
      "source": [
        "# Notes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "avOzPJaSgRId",
        "colab_type": "text"
      },
      "source": [
        "## Copy to Drive\n",
        "Before you get started, remember to copy this Colab notebook to your Google Drive so that you can save your work."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w1FcybABY3es",
        "colab_type": "text"
      },
      "source": [
        "## Comments\n",
        "\n",
        "Comments allow you to leave notes along with your code. These notes will help you when you return to your code later, as well as anyone else that looks at your code. Beginning a line using the `#` character is a comment. Comments are not executed and are ignored when running your program. Following Python style guidelines, it is good practice to enter a space following `#`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B0U9fpTVY_s6",
        "colab_type": "text"
      },
      "source": [
        "### Example"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K6hYdLjLZBqa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# I'm a code comment. Python knows this is for people and not computers\n",
        "# Also, it is always taco time.\n",
        "taco_time = \"Always\"\n",
        "\n",
        "# This is a comment too.\n",
        "print(\"But this isn't.\") # comments can be on the same line as code\n",
        "\n",
        "#This comment is not following good Python style practices because it does not have space after the #"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DZRvYeRXZwwY",
        "colab_type": "text"
      },
      "source": [
        "## Data types\n",
        "\n",
        "| Data Type | Description | Example |\n",
        "| :--- | :--- | :--- |\n",
        "| string / str | A collection of characters within single or double quotes | `\"hello\"`, `'hello'` |\n",
        "| integer / int | A number with no decimal | `1`, `0`, `-7` |\n",
        "| float | Real value (decimal) | `0.5` |\n",
        "| list | A collection of data of one or more types within square brackets | `[\"hello\", 0, 1.5]` |\n",
        "| dictionary / dict | A set of key, value pairs | `{ A: 2, B: 3, C: 1}` |\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3iVHFv-CbwXl",
        "colab_type": "text"
      },
      "source": [
        "### Determining the type\n",
        "\n",
        "To determine the type of an object you can use the function `type`. You can call the function `type` on a _literal_ value such as the integer `3` or string `\"hello\"`, or a variable that holds a value such as `x` or `word` as shown below. \n",
        "\n",
        "Run the code blocks to see example output from the function `type`.\n",
        "\n",
        "Notice that the result is printed to the screen even though we did not use the `print` function. In `Colab`, the result from the last line of a code block is printed to the screen.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2Dpwq1klb_ib",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "type(1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6C8UAwNbc0Ke",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = 1\n",
        "type(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q4PcrpRjdNwO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "type(\"hello\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lEvyZDVMc35K",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "word = \"hello\"\n",
        "type(word)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Alyb5Q-seijp",
        "colab_type": "text"
      },
      "source": [
        "### What is a class?\n",
        "\n",
        "Run the code below that uses `print` to show the output."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UH1mo4sveczn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(type(1))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nndfXazzer17",
        "colab_type": "text"
      },
      "source": [
        "Note now that the output is not just `int`, but instead: `<class 'int'>`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W0YZ6sr16K58",
        "colab_type": "text"
      },
      "source": [
        "**What is a class?**\n",
        "\n",
        "- Almost all data in Python is saved as _objects_.\n",
        "- _Objects_ are instances of a _Class_.\n",
        "- _Classes_ usually provide some functionality that allow for different operations on the data in the objects.\n",
        "\n",
        "_Much more about objects and classes is covered in the Core Curriculum._"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rrbrjcHCf4sw",
        "colab_type": "text"
      },
      "source": [
        "### Exercise: Comments\n",
        "\n",
        "Now that you've run the code blocks above that output the data types, practice writing comments by adding comments to the code blocks that describe the output.\n",
        "\n",
        "For instance:\n",
        "\n",
        "- ```type(1.5) # float```\n",
        "- ```type(\"ada\") # string```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ce6gfJM7eBRf",
        "colab_type": "text"
      },
      "source": [
        "## [Mathematical operations](https://docs.python.org/3/tutorial/introduction.html#numbers)\n",
        "\n",
        "| Operation | Ruby symbol | Example |\n",
        "| :--- | :--- | :--- |\n",
        "| addition |  `+` | `2 + 3` |\n",
        "| subtraction | `-` | `4 - 5` |\n",
        "| multiplication | `*` | `7 * 8` |\n",
        "| division | `/` | `1 / 2` |\n",
        "| truncating division | `//` | `1 // 2` |\n",
        "| remainder (modulus) | `%` | `15 % 5` |"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5RwTuRvIeCp6",
        "colab_type": "text"
      },
      "source": [
        "### Important notes\n",
        "\n",
        "#### Division\n",
        "Python has two types of division.  The first is \"regular\" division (`/`) where `1 / 2` is `0.5`.  The other is \"truncating\" division (`//`) where `1 // 2` is `0`.  \n",
        "\n",
        "In some languages \"integer division\" (division involving only integers) is always truncating. This was the case in old and unsupported versions of Python, however now (in Python 3) `/` always results in a `Float` and `//` always results in an integer.\n",
        "\n",
        "#### Modulus\n",
        "Modulus (or \"mod\", for short) returns the remainder of dividing one number by another number. e.g. `15 % 10` will return `5`.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VPsKx8u6gFLr",
        "colab_type": "text"
      },
      "source": [
        "### Precedence\n",
        "\n",
        "Also commonly called order-of-operations, is the order in which operations are completed.\n",
        "\n",
        "| __Priority__ | __Operation__ | __Symbol__\n",
        "| :--- | :--- |:---|\n",
        "| 1 | parens | `()` |\n",
        "| 2 | unary operations | `-x,+x` |\n",
        "| 3 | multiplication, division, modulus | `*,/,%`|\n",
        "| 4 | addition, subtraction, string concatenation | `+,-` |\n",
        "| 5 | less than, less than or equal to, greater than,  |`<,<=,>,>=,!=` |\n",
        "|   | greater than or equal to, equal to, not equal to | |\n",
        "| 6 | not | `not` |\n",
        "| 7 | and | `and` |\n",
        "| 8 | or | `or` |\n",
        "\n",
        "We will discuss compound operators (and, or) and comparators (less than, greater than, equal, etc.) later in the Build curriculum."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MG1F8Mqlg8e7",
        "colab_type": "text"
      },
      "source": [
        "### Exercise: Mathematical Operations and Precedence\n",
        "\n",
        "- Study the expressions below and determine the output.\n",
        "- Run the code below to check your work."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qh0TFAh-eMPN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "2 / 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4HlFkcG2Wzet",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "2 // 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TSkGVl6Rem1b",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "10 % 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PsIPre4WhfNB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "2 * 3 + 5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qcidv7FfgL2V",
        "colab_type": "text"
      },
      "source": [
        "## Assignment Statements\n",
        "\n",
        "In programming, we often need to store values. We may want to refer to the values later, or only have to do a calculation once. Another motivator for storing a value is to give a complex calculation a name for clarity, or to communicate intent.\n",
        "\n",
        "Variables have a name and a value. We assign a value to a variable using an assignment statement. \n",
        "\n",
        "It can be helpful to read assignment statements right to left like \"assign the value 5 to x\" or \"assign 5 to x\" .\n",
        "You can also read the values left to right like \"set the variable x to 5\" or \"set x to 5\".\n",
        "\n",
        "You should make sure to avoid saying things like \"equal\" or \"equals\" here though, as those mean something different when it comes to Python."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ymePs6OYgV4B",
        "colab_type": "text"
      },
      "source": [
        "### Exercise: Assignment Statements\n",
        "\n",
        "As you go through the examples below, read the comments to understand how to talk in programming terms. Before you run the code, make a guess at what will be printed to the screen.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jmy2wRM7gP4N",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# the value of 5 is assigned to the variable named x\n",
        "x = 5\n",
        "# the current value of x (5) is added to 1\n",
        "# that sum is then assigned to the variable named x\n",
        "x = x + 1\n",
        "\n",
        "print(\"x =\", x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TEY-R5oUgm_0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# the value of 1 is assigned to the variable named x\n",
        "x = 1\n",
        "# the value stored in x is assigned to y\n",
        "# note: this does not mean that x and y will always\n",
        "# store the same value\n",
        "y = x\n",
        "# the value of 3 is assigned to the variable named x\n",
        "x = 3\n",
        "# note: y still holds the value of 1\n",
        "print(\"x =\", x)\n",
        "print(\"y =\", y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SVI5uXLVhKXM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# the value of \"Rosa\" is assigned to the variable named dog_name\n",
        "dog_name = \"Rosa\"\n",
        "# the value of \"Raquel\" is assigned to the variable named cat_name\n",
        "cat_name = \"Raquel\"\n",
        "# the value of 7 is assigned to the variable named dog_age\n",
        "dog_age  = 7\n",
        "# the value of 11 is assigned to the variable named cat_age\n",
        "cat_age  = 11\n",
        "\n",
        "print(\"The dog named\", dog_name, \"is\", dog_age, \"years old\")\n",
        "print(\"The cat named\", cat_name, \"is\", cat_age, \"years old\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fmM5o3pKdzvl",
        "colab_type": "text"
      },
      "source": [
        "### Printing multiple values\n",
        "\n",
        "Did you notice that the print statements in the previous examples output string labels and variable values in a single line by providing them to the print function as a list, separated with a comma? The print function can accept multiple values in a single use, and in fact has many other advanced ways that it can be called. For now, just notice that sometimes functions can be used in multiple ways, and you may need to refer to language documentation to become familiar with them all.\n",
        "\n",
        "In just a moment, we will also introduce another method of combining strings and variable values called string interpolation, so stay tuned!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "orktS-YKhjN3",
        "colab_type": "text"
      },
      "source": [
        "## Compound assignment statements\n",
        "\n",
        "It is possible to perform an operation and assign a value all in the same step. To add and assign you can use `+=`, to subtract and assign you can use `-=`, to divide and assign you can use `/=` (or `//=`) and to multiply and assign you can use `*=`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "APYzmNVehkLZ",
        "colab_type": "text"
      },
      "source": [
        "### Exercise: Compound Assignment Statements\n",
        "\n",
        "* `x += 3`  assigns the value of `x + 3` to the variable `x`  \n",
        "* `x += y + 3` assigns the value of `x + (y + 3)` to the variable `x`  \n",
        "* `x -= 2`  assigns the value of `x – 2` to the variable `x`  \n",
        "* `x -= y – 5`  assigns the value of `x – (y – 5)` to the variable `x`  \n",
        "* `x /= 3`  assigns the value of `x / 3` to the variable `x`  \n",
        "* `x //= 3` assigns the value of `x // 3` to the variable `x`\n",
        "* `x *= y`  assigns the value of `x * y` to the variable `x`  \n",
        "* `x %= y`  assigns the value of `x % y` to the variable `x`\n",
        "\n",
        "*Try some of these expressions in the code block below.* \n",
        "- Uncomment one expression by removing the `#` and run the code block to see the affect the operation has on `x` and/or `y`. \n",
        "- Recomment that expression by adding the `#` back and uncomment the next expression.\n",
        "- Continue until you've examined the affect of each operation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WJNVdD8iXznY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = 2\n",
        "y = 5\n",
        "\n",
        "# x += 3 \n",
        "# x += y + 3\n",
        "# x -= 2\n",
        "# x -= y - 5\n",
        "# x /= 3\n",
        "# x //= 3\n",
        "# x *= y\n",
        "# x %= y\n",
        "\n",
        "print(\"x =\", x)\n",
        "print(\"y =\", y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x69GGuwo6yla",
        "colab_type": "text"
      },
      "source": [
        "## [Strings](https://docs.python.org/3/tutorial/introduction.html#strings)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sJymSsLO-ssw",
        "colab_type": "text"
      },
      "source": [
        "### Strings Interpolation and [Methods](https://docs.python.org/3/library/stdtypes.html#string-methods)\n",
        "\n",
        "Strings in Python are objects that hold a sequence of characters. You can create a string by surrounding the sequence of characters with double or single quotes; both `\"hello\"` and `'hello'` are strings.\n",
        "\n",
        "Below is an example of using the string method `capitalize` and _string interpolation_.\n",
        "\n",
        "_Methods_ are _functions_ that can be called on instances of a class. They are a more specific name for a _function_ and are called using parentheses `()`. We'll learn more about _methods_, _functions_, and _classes_ later in the Build curriculum.\n",
        "\n",
        "_String interpolation_ is the process of substituting values of variables into placeholders in a string..  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OkQtvdhB7le9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# store the name of a state in the variable state_name\n",
        "state_name = \"washington\"\n",
        "\n",
        "# use string interpolation and the method capitalize to output the state_name in a different string\n",
        "print(f\"{state_name.capitalize()} is a nice place to live!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TeX0NMiL82ne",
        "colab_type": "text"
      },
      "source": [
        "Here is a second example that uses another string method `isdigit`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rnNBgO-m8106",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# store a value in the variables value_1 and value_2\n",
        "value_1 = \"2\"\n",
        "value_2 = \"hello\"\n",
        "\n",
        "# use string interpolation and the method capitalize to output whether or not the values are digits.\n",
        "print(f\"True or False? The value {value_1} is a digit: {value_1.isdigit()}\")\n",
        "print(f'True or False? The value {value_2} is a digit: {value_2.isdigit()}')\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GOIXfMSB94lt",
        "colab_type": "text"
      },
      "source": [
        "Notice that the string with interpolation can be contained in single or double quotes. The value to be interpolated is placed within curly braces `{}`, and the character `f` is written in front of the string. \n",
        "\n",
        "Note: The `f` in string interpolation is short for \"format\"."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tzZs7QiAeAFH",
        "colab_type": "text"
      },
      "source": [
        "#### Exercise: Numbers Problem \n",
        "\n",
        "\n",
        "Using _compound assignment statements_ and _string interpolation_, complete the following problem in the code block below.\n",
        "\n",
        "- Assign values to three variables `x1`, `x2`, and `x3`. \n",
        "\n",
        "- Print three number equations that show the result of adding `20` to each of the variables. \n",
        "\n",
        "- For instance, if `x1 = 25`, the ouput of your code should be `25 + 20 = 45`.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dAoCdnqJefv_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# assign values to 3 variables\n",
        "x1 = \n",
        "x2 = \n",
        "x3 = \n",
        "\n",
        "# print the equations\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yOUO4wr_-nAD",
        "colab_type": "text"
      },
      "source": [
        "### Common Escape Sequences\n",
        "\n",
        "The escape character `\\` allows you to invoke a different meaning for the following character than the one standardly used in the programming language. The below table describes a few uses of the escape `\\` character. \n",
        "\n",
        " | Escape Sequence | Description |\n",
        " | :--- | :--- |\n",
        " | `\\n` | A new line (moves down to the next line)\n",
        " | `\\\\` | A single backslash |\n",
        " | `\\\"` | A double quote |\n",
        " | `\\'` | A single quote |\n",
        "\n",
        "In Python, the escape character can be used with strings in single or double quotes.\n",
        "\n",
        "Run the code examples below to see it in use."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GexFdLvE8wu8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# double quotes.\n",
        "phrase = \"\\\"We're so glad you're here!\\\" they said.\\n\"\n",
        "print(phrase) \n",
        " \n",
        "# new line\n",
        "phrase = 'hello \\nscholar!\\n'\n",
        "print(phrase) \n",
        "\n",
        "# single backslash\n",
        "phrase = \"ada\\\\lovelace\"\n",
        "print(phrase)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "co1ucigoBWqf",
        "colab_type": "text"
      },
      "source": [
        "### String Concatenation and Duplication\n",
        "\n",
        "* When combining strings, you can use the `+` and `*` operator.\n",
        "\n",
        "Run the code below to see examples of string concatenation and duplication."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CrTtG6CH8ZvL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "word_1 = \"home\"\n",
        "word_2 = \"work\"\n",
        "\n",
        "print(f\"You can combine the words {word_1} and {word_2} \\\n",
        "to make the word {word_1+word_2}.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ml_qp9D2W7lY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(f\"These days, all I seem to do is {3*(word_1+word_2+' ')}.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3FK2HHn7Y32E",
        "colab_type": "text"
      },
      "source": [
        "### Indexing/Slicing\n",
        "\n",
        "Indexing refers to retrieving a single value from a group, in this case a string of characters, by its position in that group. Alternatively, it can refer to the way in which we label those positions.\n",
        "\n",
        "Slicing a string allows you to split a string into smaller pieces. \n",
        "\n",
        "To take a slice of a string, you can pass one, two, or three values. \n",
        "- `string[i]` will provide give a single character\n",
        "- `string[i:j]` will provide a section of characters from index `i` up to, but not including index `j`\n",
        "- `string[i:j:k]` will provide a section of characters from index `i` up to, but not including index `j`, stepping by the interval `k`\n",
        "\n",
        "Note that if you provide an index greater than the length of the string, an `IndexError` will occur. \n",
        "\n",
        "It is important to note that in Python, indexing starts at the value `0`. So the first character in the string is at index 0.\n",
        "\n",
        "Python also uses negative indexing. The `-1` index is the last character in the string, the `-2` index is the second to last character in the string, and so on.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T0T18esOZ2PR",
        "colab_type": "text"
      },
      "source": [
        "#### Exercise: Slicing\n",
        "\n",
        "- Uncomment and recomment each of the expressions below to see how they slice the string."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Uteluhp7ZeRg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "name = \"Ada Lovelace\"\n",
        "# name[5] # \"o\"\n",
        "# name[20] # IndexError\n",
        "# name[0:3] # \"Ada\"\n",
        "# name[0:8] # \"Ada Love\"\n",
        "# name[0:8:2] # \"AaLv\"\n",
        "# name[-1] #e"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "muQdFzLUkRdr",
        "colab_type": "text"
      },
      "source": [
        "## Debugging\n",
        "\n",
        "You have probably already found that one doesn't always write code correctly the first time. **Debugging** is the process of identifying and fixing errors in your code. It is one of the most important skills you will develop as a software developer."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9zIeuEEPlnAf",
        "colab_type": "text"
      },
      "source": [
        "### Syntax Errors\n",
        "\n",
        "The first type of error we'll look at are syntax errors. Syntax errors are mistakes in the language of your code. The error could be a misplaced comma or parenthesis, a mispelled variable, an invalid operation, or any number of small mistakes.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BkrwJPxJndok",
        "colab_type": "text"
      },
      "source": [
        "#### Exercise: Debugging syntax errors\n",
        "\n",
        "Run the code cell below and read the error messages. Try to fix the error. \n",
        "\n",
        "Note the red underline. Like most other programming environments, Colab often helps you out by identifying syntax errors."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YDfi_BXlnoY5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# code block 1\n",
        "print('hello world!)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3AGWJ42rn3vV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# code block 2\n",
        "a = 3\n",
        "b = 4\n",
        "c = a*a + b***b\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TxGsPpfDoc-X",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# code block 3\n",
        "prnt(\"hello world!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z8Sb4uMospO5",
        "colab_type": "text"
      },
      "source": [
        "#### Solutions\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o8iC219kyVPi",
        "colab_type": "text"
      },
      "source": [
        "##### Code Block 1\n",
        "\n",
        "**EOL** stands for **End of Line**. This means that Python hit and error at the end of the line when evaluating the string. That is why you see the carat `^` at the end of the line. The error here is a missing quotation mark.\n",
        "\n",
        "\n",
        "```python\n",
        "print('hello world!)\n",
        "```\n",
        "\n",
        "![missing_quote](https://drive.google.com/uc?id=1F0zv2K0DM65WJ31Ak8jxEqj3zmAJoDbd)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7CzdguEGwLjn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print('hello world!)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_W3RE_REwWJG",
        "colab_type": "text"
      },
      "source": [
        "##### Code Block 2\n",
        "\n",
        "Python reports invalid syntax and there is a carat `^` pointing to the third `*`.\n",
        "\n",
        "```python\n",
        "a = 3\n",
        "b = 4\n",
        "c = a*a + b***b\n",
        "print(c)\n",
        "```\n",
        "\n",
        "![invalid_operation](https://drive.google.com/uc?id=198FvNX3GJXEFM8jvwWxbxMBVUTkmE6gY)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KKhkvYp1wFkN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = 3\n",
        "b = 4\n",
        "c = a*a + b**b\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CMNULWGYwWqw",
        "colab_type": "text"
      },
      "source": [
        "##### Code Block 3\n",
        "\n",
        "Python reports a `NameError` and identifies that `prnt` is not defined.\n",
        "\n",
        "```python\n",
        "prnt(\"hello world!\")\n",
        "```\n",
        "\n",
        "\n",
        "![mispelled_function](https://drive.google.com/uc?id=1Fjn3qzdFCOfV61H6bnX5x38oh0YgW65S)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RibS_V_7wSlO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print('hello world!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yeyJmIr-liHy",
        "colab_type": "text"
      },
      "source": [
        "# Practice Problems\n",
        "\n",
        "Complete each section by hand, then check your answers by running the code in a code block below."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UHOZzRIwlL7W",
        "colab_type": "text"
      },
      "source": [
        "## 1. Variables and Assignment\n",
        "\n",
        "```python\n",
        "# problem 1.1\n",
        "x = 5\n",
        "# what value does x now hold?\n",
        "\n",
        "# problem 1.2\n",
        "z = \"Hello\"\n",
        "# what value does z now hold?\n",
        "\n",
        "# problem 1.3\n",
        "a = 5\n",
        "b = 3.2\n",
        "c = a + b\n",
        "# what values does c now hold?\n",
        "\n",
        "# problem 1.4\n",
        "var1 = \"lawl\"\n",
        "var2 = \"brb\"\n",
        "# what value does var2 now hold?\n",
        "\n",
        "# problem 1.5\n",
        "e = 6 + 3\n",
        "# what values does e now hold?\n",
        "\n",
        "# problem 1.6\n",
        "f = 3.5\n",
        "f = f + 2\n",
        "# what value does f now hold?\n",
        "\n",
        "# problem 1.7\n",
        "poodle = 4\n",
        "pitbull = 3\n",
        "# what value does boxer now hold?\n",
        "\n",
        "# problem 1.8\n",
        "h = 5\n",
        "h = h + h\n",
        "# what values does h now hold?\n",
        "\n",
        "# problem 1.9\n",
        "j = 1\n",
        "k = 2\n",
        "m = 3\n",
        "n = j + k + m\n",
        "# what value does n now hold?\n",
        "\n",
        "# problem 1.10\n",
        "l = \"moo\"\n",
        "q = \"quack\"\n",
        "l  = q\n",
        "# what value does l now hold?\n",
        "\n",
        "# problem 1.11\n",
        "r = \"moo\"\n",
        "s = \"quack\"\n",
        "t = \"woof\"\n",
        "r = t\n",
        "# what value does r now hold?\n",
        "\n",
        "# problem 1.12\n",
        "u = 5\n",
        "u = u * 2\n",
        "u = u * 2\n",
        "u = u * 2\n",
        "# what value does u now hold?\n",
        "\n",
        "# problem 1.13\n",
        "v = \"b\"\n",
        "z = \"a\"\n",
        "# what value does v now hold?\n",
        "\n",
        "# problem 1.14\n",
        "aa = 3234\n",
        "bb = 2398\n",
        "cc = 0\n",
        "dd = (aa + bb) / cc\n",
        "# what value does dd now hold?\n",
        "\n",
        "# problem 1.15\n",
        "yy = 7\n",
        "zz = yy % 2\n",
        "# what value does zz now hold?\n",
        "\n",
        "# problem 1.16\n",
        "ee = 12\n",
        "ff = ee % 4\n",
        "# what value does ff now hold?\n",
        "\n",
        "# problem 1.17\n",
        "zz = 17\n",
        "hh = zz % 3\n",
        "# what value does hh now hold?\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IdW2J0FNhHRG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NPtnZeCQl5Hr",
        "colab_type": "text"
      },
      "source": [
        "## 2. Operators\n",
        "\n",
        "Consider the following variable assignments and then fill in the table.\n",
        "\n",
        "```python\n",
        "d = 10\n",
        "e = 5.0\n",
        "f = 2\n",
        "g = 11.0\n",
        "h = 3\n",
        "i = 1.5\n",
        "```\n",
        "\n",
        "| Problem | Operation | Result | Data type of result |\n",
        "| :---: | :---: | :---:| :---: |\n",
        "| 1 | `d + e` | | |\n",
        "| 2 | `f + h` | | |\n",
        "| 3 | `g + h` | | |\n",
        "| 4 | `d - f` | | |\n",
        "| 5 | `g - e` | | |\n",
        "| 6 | `(h + i) - f` | | |\n",
        "| 7 | `(d - f) + e` | | |\n",
        "| 8 | `d * f` | | | |\n",
        "| 9 | `g * i` | | | |\n",
        "| 10 | `f * g` | | | |\n",
        "| 11 | `d / f` | | | |\n",
        "| 12 | `d / e` | | | |\n",
        "| 13 | `e / f` | | | |\n",
        "| 14 | `(g * f) / f` | | | |\n",
        "| 15 | `(d / f) * e` | | | |\n",
        "| 16 | `21 / 5` | | | |\n",
        "| 17 | 14 / 5 | | | |\n",
        "| 18 | 10 % 3 | | | |\n",
        "| 19 | 20 % 2 | | | |\n",
        "| 20 | 4 % 5 | | | |\n",
        "| 21 | 8 % 1 | | | |"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QEW43asXl9g6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QYbkiM5gmGco",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "## 3. Strings\n",
        "\n",
        "Determine the results for each of the following problems on your own and then check your answer using the code block below.\n",
        "\n",
        "```python\n",
        "# problem 3.1\n",
        "my_string = \"I love Seattle\"\n",
        "my_string[7]\n",
        "\n",
        "# problem 3.2\n",
        "my_string = \"I love Seattle\"\n",
        "my_string[2:4]\n",
        "\n",
        "# problem 3.3\n",
        "my_string = \"Ada\"\n",
        "my_string += \" Lovelace\"\n",
        "\n",
        "# problem 3.4\n",
        "my_string = \"Ada\"\n",
        "my_string += \" codes\" + \" it!\"\n",
        "\n",
        "# problem 3.5\n",
        "my_string = \"Ada\"\n",
        "(my_string + \" likes to code\")[4:9]\n",
        "\n",
        "# problem 3.6\n",
        "my_string = \"Hello world\"\n",
        "\"Goodbye \" + my_string[6:11] + \"!\"\n",
        "\n",
        "# problem 3.7\n",
        "my_string = \"Hello world!\"\n",
        "my_string[0:5] + \", goodbye!\"\n",
        "\n",
        "# problem 3.8\n",
        "my_string = \"Hello world!\"\n",
        "my_string[:1] + \"i\" + \"!\"\n",
        "\n",
        "# problem 3.9\n",
        "my_string = \"I love Python\"\n",
        "my_string[7:13] + my_string[2:6] + my_string[0]\n",
        "\n",
        "# problem 3.10\n",
        "my_string = \"I love Python\"\n",
        "\"P\" + my_string[8:13] + \" rocks!\"\n",
        "\n",
        "# problem 3.11\n",
        "my_string = \"I love Python\"\n",
        "my_string[2:6] + my_string[7:13] + my_string[2:6]\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_bMJxzYYilbA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}