Copy_of_02_programming_grammar_katina.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of 02_programming_grammar-katina.ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [],
      "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/kmcarranza/Pre-Bootcamp/blob/main/Copy_of_02_programming_grammar_katina.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"
      },
      "source": [
        "**Programming Grammar**\n",
        "\n",
        "_Ada Build - Intro to Python - Lesson 2_"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5bWRMZSwX6-2"
      },
      "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"
      },
      "source": [
        "# Notes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "avOzPJaSgRId"
      },
      "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"
      },
      "source": [
        "## Comments\n",
        "\n",
        "Comments allow us to leave notes along with our code. These notes will help us when we return to our code later, as well as anyone else that looks at our code. Beginning a line using the `#` character is a comment. Comments are not executed and are ignored when running our program. Following Python style guidelines, it is good practice to enter a space following `#`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B0U9fpTVY_s6"
      },
      "source": [
        "### Example"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K6hYdLjLZBqa"
      },
      "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"
      },
      "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"
      },
      "source": [
        "### Determining the type\n",
        "\n",
        "To determine the type of an object, we use the function `type`. We 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"
      },
      "source": [
        "type(1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6C8UAwNbc0Ke"
      },
      "source": [
        "x = 1\n",
        "type(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q4PcrpRjdNwO"
      },
      "source": [
        "type(\"hello\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lEvyZDVMc35K"
      },
      "source": [
        "word = \"hello\"\n",
        "type(word)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Alyb5Q-seijp"
      },
      "source": [
        "### What is a class?\n",
        "\n",
        "Run the code below that uses `print` to show the output."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UH1mo4sveczn"
      },
      "source": [
        "print(type(1))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nndfXazzer17"
      },
      "source": [
        "Note now that the output is not just `int`, but instead: `<class 'int'>`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W0YZ6sr16K58"
      },
      "source": [
        "**What is a class?**\n",
        "\n",
        "- Briefly, _classes_ are data along with the operations we can do to that data.\n",
        "- _Objects_ are _instances_ of a _class_. For example:\n",
        "    - 1, 2, and 3 are instances of the class `int`, and the operations we can do are math operations.\n",
        "    - `\"hello\"`, `\"good bye\"`, and `\"see ya\"` are instances of the class `str`, and the operations we can do include capitalization and concatenation.\n",
        "- Almost all data in Python is saved as _objects_.\n",
        "\n",
        "_Much more about objects and classes is covered in the Core Curriculum._"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rrbrjcHCf4sw"
      },
      "source": [
        "### Exercise: Comments\n",
        "\n",
        "Now that we've run the code blocks above that output the data types, let's 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"
      },
      "source": [
        "## [Mathematical operations](https://docs.python.org/3/tutorial/introduction.html#numbers)\n",
        "\n",
        "| Operation | Python 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"
      },
      "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"
      },
      "source": [
        "### Precedence\n",
        "\n",
        "Also commonly called order-of-operations, _precedence_ 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, <br /> greater than or equal to, not equal to, <br /> 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"
      },
      "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"
      },
      "source": [
        "2 / 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4HlFkcG2Wzet"
      },
      "source": [
        "2 // 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TSkGVl6Rem1b"
      },
      "source": [
        "10 % 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PsIPre4WhfNB"
      },
      "source": [
        "2 * 3 + 5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qcidv7FfgL2V"
      },
      "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",
        "We can also read the values left to right like \"set the variable x to 5\" or \"set x to 5\".\n",
        "\n",
        "We 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"
      },
      "source": [
        "### Exercise: Assignment Statements\n",
        "\n",
        "As we 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"
      },
      "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"
      },
      "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"
      },
      "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"
      },
      "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"
      },
      "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 we can use `+=`, to subtract and assign we can use `-=`, to divide and assign we can use `/=` (or `//=`) and to multiply and assign we can use `*=`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "APYzmNVehkLZ"
      },
      "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 effect of each operation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WJNVdD8iXznY"
      },
      "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"
      },
      "source": [
        "## [Strings](https://docs.python.org/3/tutorial/introduction.html#strings)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sJymSsLO-ssw"
      },
      "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. We 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 `()`. If we have a variable that contains an object instance, we can call methods on that instance as `instance_var.operation_name()`, where `instance_var` is the variable holding an instance, and `operation_name` is the name of the method we want to use. The `()` are required to tell Python to run the operation, and is used to provide any needed arguments.\n",
        "\n",
        "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"
      },
      "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"
      },
      "source": [
        "Here is a second example that uses another string method `isdigit`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rnNBgO-m8106"
      },
      "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 isdigit 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"
      },
      "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"
      },
      "source": [
        "#### Exercise: Numbers Problem\n",
        "\n",
        "Using _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 our code should be `25 + 20 = 45`.\n",
        "\n",
        "_You can click on the link for [a livecode video solution](https://adaacademy.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=6381fadb-917b-4a94-a617-acaf017fe9fb)._\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sfckRi6b0j5z"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dAoCdnqJefv_"
      },
      "source": [
        "# assign values to 3 variables\n",
        "x1 = 30\n",
        "x2 = 40\n",
        "x3 = 50\n",
        "\n",
        "# print the equations\n",
        "\n",
        "print(f'{x1} + 20 = {x1+20}')\n",
        "print(f'{x2} + 20 = {x2+20}')\n",
        "print(f'{x3} + 20 = {x3+20}')\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yOUO4wr_-nAD"
      },
      "source": [
        "### Common Escape Sequences\n",
        "\n",
        "The escape character `\\` allows us 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",
        " | `\\` | At the end of a line, this allows a string<br />to wrap to the next line (the new line does<br /> _not_ become part of the string) |\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"
      },
      "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"
      },
      "source": [
        "### String Concatenation and Duplication\n",
        "\n",
        "* When combining strings, we 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"
      },
      "source": [
        "word_1 = \"home\"\n",
        "word_2 = \"work\"\n",
        "concatenated_words = word_1 + word_2  # concatentation\n",
        "\n",
        "print(f\"You can combine the words {word_1} and {word_2} \\\n",
        "to make the word {concatenated_words}.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ml_qp9D2W7lY"
      },
      "source": [
        "concatenated_words = word_1 + word_2 + ' '  # concatentation\n",
        "duplicated_words = 3 * concatenated_words  # duplication\n",
        "\n",
        "print(f\"These days, all I seem to do is {duplicated_words}.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3FK2HHn7Y32E"
      },
      "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 us to split a string into smaller pieces. \n",
        "\n",
        "To take a slice of a string, we can pass one, two, or three values. \n",
        "- `string[i]` will provide 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 when we are indexing a string as in `string[i]`, if we provide an index greater than the length of the string, an `IndexError` will occur. We'll leave it to you to investigate what happens when you provide an index greater than the length when slicing a string.\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"
      },
      "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"
      },
      "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"
      },
      "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 our code. It is one of the most important skills you will develop as a software developer."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9zIeuEEPlnAf"
      },
      "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 our 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"
      },
      "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 us out by identifying syntax errors.\n",
        "\n",
        "_You can click on the link for [a video lesson of the debugging exercise](https://adaacademy.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=34fb0c22-7a32-4360-98e9-acaf017fe9d3)._"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YDfi_BXlnoY5"
      },
      "source": [
        "# code block 1\n",
        "print('hello world!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3AGWJ42rn3vV"
      },
      "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"
      },
      "source": [
        "# code block 3\n",
        "print(\"hello world!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z8Sb4uMospO5"
      },
      "source": [
        "#### Solutions\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o8iC219kyVPi"
      },
      "source": [
        "##### Code Block 1\n",
        "\n",
        "**EOL** stands for **End of Line**. This means that Python hit an error at the end of the line when evaluating the string. That is why we 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"
      },
      "source": [
        "print('hello world!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_W3RE_REwWJG"
      },
      "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"
      },
      "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"
      },
      "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"
      },
      "source": [
        "print('hello world!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yeyJmIr-liHy"
      },
      "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"
      },
      "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",
        "# Guess: \n",
        "print(zz)\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"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NPtnZeCQl5Hr"
      },
      "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"
      },
      "source": [
        "# 10 + 5.0 = 15.0\n",
        "# 2 + 3 = 5\n",
        "# 11 + 3 = 14\n",
        "# 10 - 2 = 8\n",
        "# 11 - 5 = 6\n",
        "# (3-1.5) - 2 = -0.5\n",
        "# (10-2) + 5.0 = 13\n",
        "# 10 * 2 = 20\n",
        "# 11 * 1.5 = 16.5\n",
        "# 2 * 11.0 = 22.0\n",
        "# 10 / 2 = 5\n",
        "# 10 / 5.0 = 2\n",
        "# 5.0 / 2 = 2.5\n",
        "# (11.0 * 2)/2 = 11\n",
        "# (10/2) * 5.0 = 4\n",
        "# 21 / 5 = 4.2\n",
        "# 14/5 = 2.8\n",
        "# 10%3 = 1\n",
        "# 4 % 5 = 1\n",
        "# 8 % 1 = 0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QYbkiM5gmGco"
      },
      "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"
      },
      "source": [
        "# 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",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}