Day_2_Control_Flow.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Control_Flow.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ehvmN7Yq2_j2",
        "colab_type": "text"
      },
      "source": [
        "# **Control Flow:**\n",
        "Welcome to this lesson on Control Flow! Control flow is the sequence in which your code is run helping you in decision making. Here, we'll learn about several tools in Python we can use to affect our code's control flow:\n",
        "\n",
        "* Conditional Statements\n",
        "* Boolean Expressions\n",
        "* For and While Loops\n",
        "* Break and Continue\n",
        "* Zip and Enumerate\n",
        "* List Comprehensions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ih5lvgbH7_bF",
        "colab_type": "text"
      },
      "source": [
        "## **Conditional If Statements:**\n",
        "\n",
        "Sometimes we need to run a line of code only if a particular condition is true.\n",
        "For example suppose that you have subscribed to a sharebike rental service.\n",
        "\n",
        "Lets look at its pay as you use billing system. The app contains a credit balance which then the user can use to rent the bikes.\n",
        "\n",
        "The customer can then setup a link to their bank account so that if their phone credit balance goes below a particular threshold amountm, in this case Rs.100, then Rs.500 in credit is then added from their bank account.\n",
        "\n",
        "this can be represented as in below:\n",
        "\n",
        "```\n",
        "if bikeapp_balance < 100:\n",
        "  bikeapp_balance += 500\n",
        "  bank_balance -= 500\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ynX7uFME4aq_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "c97cb77e-0bc3-49f5-b70a-ed697396b587"
      },
      "source": [
        "bikeapp_balance = 99\n",
        "bank_balance = 1000\n",
        "\n",
        "print(bikeapp_balance, bank_balance)\n",
        "\n",
        "if(bikeapp_balance<100):\n",
        "  bikeapp_balance += 500\n",
        "  bank_balance -= 500\n",
        "\n",
        "print(bikeapp_balance, bank_balance)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "99 1000\n",
            "599 500\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DP_isfUUtHw3",
        "colab_type": "text"
      },
      "source": [
        "- An *if* statement starts with the *if* keyword, followed by the condition to be checked, in this case *bikeapp_balance* < 100, and then a colon. The condition is specified in a boolean expression that evaluates to either *True* or *False*.\n",
        "\n",
        "- After this line is an indented block of code to be executed if that condition is true. Here, the lines that increment *bikeapp_balance* and decrement *bank_balance* only execute if it is true that *bikeapp_balance* is less than 100. If not, the code in this if block is simply skipped."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8SoDevOntowm",
        "colab_type": "text"
      },
      "source": [
        "> You have learned about Python's comparison operators (e.g. == and !=) and how they are different from assignment operators (e.g. =). In conditional statements, you want to use comparison operators. For example, you'd want to use if x == 5 rather than if x = 5. If your conditional statement is causing a syntax error or doing something unexpected, check whether you have written == or =!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N7kP8ymfuZs0",
        "colab_type": "text"
      },
      "source": [
        "## **Conditional If Else Statements:**\n",
        "\n",
        "Else helps us to execute a diffrent block of code when a particular condition is not true or even for multiple other conditions diffrent from the *if()* condition.\n",
        "\n",
        "Lets see it in action using an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S-CVWAwWtAvB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a96af217-0f30-49cc-a626-11c2bfeee982"
      },
      "source": [
        "n=4\n",
        "\n",
        "if (n%2 == 0):\n",
        "  print(\"Number \" + str(n) + \" is even.\")\n",
        "else:\n",
        "  print(\"Number \" + str(n) + \" is odd.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number 4 is even.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X6edLDaNzBuz",
        "colab_type": "text"
      },
      "source": [
        "> if you have more than 2 possible cases then you can also use *elif()*. Lets look at an example:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sMucuIQdv8YW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d518a2a3-46b3-4f5a-e992-3542c2d55de9"
      },
      "source": [
        "season = 'fall'\n",
        "\n",
        "if season == 'spring':\n",
        "    print('plant the garden!')\n",
        "elif season == 'summer':\n",
        "    print('water the garden!')\n",
        "elif season == 'fall':\n",
        "    print('harvest the garden!')\n",
        "elif season == 'winter':\n",
        "    print('stay indoors!')\n",
        "else:\n",
        "    print('unrecognized season')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "harvest the garden!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vgGEoCCIzesU",
        "colab_type": "text"
      },
      "source": [
        "### **Summarize If, Elif, Else:**\n",
        "\n",
        "1. **if:** An *if* statement must always start with an *if* clause, which contains the first condition that is checked. If this evaluates to *True*, Python runs the code indented in this *if* block and then skips to the rest of the code after the *if* statement.\n",
        "\n",
        "2. **elif:** *elif* is short for \"else if.\" An *elif* clause is used to check for an additional condition if the conditions in the previous clauses in the *if* statement evaluate to *False*. As you can see in the example, you can have multiple *elif* blocks to handle different situations.\n",
        "\n",
        "3. **else:** Last is the *else* clause, which must come at the end of an *if* statement if used. This clause doesn't require a condition. The code in an else block is run if all conditions above that in the *if* statement evaluate to *False*."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z1pisLR01GNq",
        "colab_type": "text"
      },
      "source": [
        "## **Ouestion**:\n",
        "\n",
        "Write an if statement that lets a student know which of these grades they got based on the number they got in exams, which is stored in the integer variable *marks*.\n",
        "\n",
        "Marks -> Grade\n",
        "\n",
        "100-90 -> A+\n",
        "\n",
        "90-80 -> A\n",
        "\n",
        "80-70 -> B\n",
        "\n",
        "70-60 -> C\n",
        "\n",
        "60-50 -> D\n",
        "\n",
        "50-40 -> E\n",
        "\n",
        "<40 -> F\n",
        "\n",
        "> All of the lower and upper bounds here are inclusive, and marks can only take on positive integer values up to 100.\n",
        "\n",
        "In your if statement, assign the result variable to a string holding the appropriate message based on the value of marks.\n",
        "\n",
        "\"you have scored *[Grade]* Grade.\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2wdJN8S3zVMh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "marks = 60  # use this input to make your submission\n",
        "\n",
        "# write your if statement here\n",
        "\n",
        "\n",
        "print(result)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ugIlhL7m3zXD",
        "colab_type": "text"
      },
      "source": [
        "## **Question:**\n",
        "\n",
        "Depending on where an individual is from we need to tax them appropriately. The states of CA, MN, and NY have taxes of 7.5%, 9.5%, and 8.9% respectively. Use this information to take the amount of a purchase and the corresponding state to assure that they are taxed by the right amount."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1mGkeGw536hm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "state = #Either CA, MN, or NY\n",
        "purchase_amount = #amount of purchase\n",
        "\n",
        "if #provide conditional for checking state is CA\n",
        "    tax_amount = .075\n",
        "    total_cost = purchase_amount*(1+tax_amount)\n",
        "    result = \"Since you're from {}, your total cost is {}.\".format(state, total_cost)\n",
        "\n",
        "elif #provide conditional for checking state is MN\n",
        "    tax_amount = .095\n",
        "    total_cost = purchase_amount*(1+tax_amount)\n",
        "    result = \"Since you're from {}, your total cost is {}.\".format(state, total_cost)\n",
        "\n",
        "elif #provide conditional for checking state is NY\n",
        "    tax_amount = .089\n",
        "    total_cost = purchase_amount*(1+tax_amount)\n",
        "    result = \"Since you're from {}, your total cost is {}.\".format(state, total_cost)\n",
        "\n",
        "print(result)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x6l-cZP84fJq",
        "colab_type": "text"
      },
      "source": [
        "## **Complex Boolean Expressions:**\n",
        "\n",
        "*If* statements sometimes use more complicated boolean expressions for their conditions. They may contain multiple comparisons operators, logical operators, and even calculations. Examples:\n",
        "\n",
        "```\n",
        "if 18.5 <= (weight / height**2) < 25:\n",
        "    print(\"BMI is considered 'normal'\")\n",
        "\n",
        "if is_raining and is_sunny:\n",
        "    print(\"Is there a rainbow?\")\n",
        "\n",
        "if (not unsubscribed) and (location == \"USA\" or location == \"IND\"):\n",
        "    print(\"send email\")\n",
        "```\n",
        "\n",
        "For really complicated conditions you might need to combine some *ands*, *ors* and *nots* together. Use parentheses if you need to make the combinations clear.\n",
        "\n",
        "However simple or complex, the condition in an *if* statement must be a boolean expression that evaluates to either *True* or *False* and it is this value that decides whether the indented block in an *if* statement executes or not."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x0jp6rHk6tAd",
        "colab_type": "text"
      },
      "source": [
        "## **Good and Bad Examples:**\n",
        "\n",
        "Here are some things to keep in mind while writing boolean expressions for your *if* statements.\n",
        "\n",
        "### **1. Don't use True or False as conditions:**\n",
        "While \"*True*\" is a valid boolean expression, it's not useful as a condition since it always evaluates to *True*, so the indented code will always get run. Similarly, *if False* is not a condition you should use either - the statement following this *if* statement would never be executed.\n",
        "\n",
        "```\n",
        "# Bad example\n",
        "if True:\n",
        "    print(\"This indented code will always get run.\")\n",
        "```\n",
        "\n",
        "Similarly, it's useless to use any condition that you know will always evaluate to *True*, like this example above. A boolean variable can only be *True* or *False*, so either *is_cold* or *not is_cold* is always *True*, and the indented code will always be run.\n",
        "\n",
        "```\n",
        "# Another bad example\n",
        "if is_cold or not is_cold:\n",
        "    print(\"This indented code will always get run.\")\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jLPGtgTs9Eh2",
        "colab_type": "text"
      },
      "source": [
        "### **2. Be careful writing expressions that use logical operators:**\n",
        "\n",
        "Logical operators *and*, *or* and *not* have specific meanings that aren't quite the same as their meanings in plain English. Make sure your boolean expressions are being evaluated the way you expect them to.\n",
        "```\n",
        "# Bad example\n",
        "if weather == \"snow\" or \"rain\":\n",
        "    print(\"Wear boots!\")\n",
        "```\n",
        "This code is valid in Python, but it is not a boolean expression, although it reads like one. The reason is that the expression to the right of the or operator, \"rain\", is not a boolean expression - it's a string! Later we'll discuss what happens when you use non-boolean-type objects in place of booleans."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GvEplz5N9Zdb",
        "colab_type": "text"
      },
      "source": [
        "### **3. Don't compare a boolean variable with == True or == False:**\n",
        "This comparison isn’t necessary, since the boolean variable itself is a boolean expression.\n",
        "```\n",
        "# Bad example\n",
        "if is_cold == True:\n",
        "    print(\"The weather is cold!\")\n",
        "```\n",
        "This is a valid condition, but we can make the code more readable by using the variable itself as the condition instead, as below.\n",
        "```\n",
        "# Good example\n",
        "if is_cold:\n",
        "    print(\"The weather is cold!\")\n",
        "```\n",
        "> If you want to check whether a boolean is False, you can use the not operator."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f-e4vBjswgri",
        "colab_type": "text"
      },
      "source": [
        "## **Truth Value Testing:**\n",
        "\n",
        "If we use a non-boolean object as a condition in an *if* statement in place of the boolean expression, Like in the 2nd example above, Python will check for its truth value and use that to decide whether or not to run the indented code. By default, the truth value of an object in Python is considered True unless specified as False in the documentation.\n",
        "\n",
        "Here are most of the built-in objects that are considered False in Python:\n",
        "\n",
        "- constants defined to be false: *None* and *False*\n",
        "- zero of any numeric type: *0, 0.0, 0j, Decimal(0), Fraction(0, 1)*\n",
        "- empty sequences and collections: *'' , \"\", (), [], {}, set(), range(0)*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UXoUXQw85N0_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "979c593f-d14a-482f-c7cc-2195ad7324ab"
      },
      "source": [
        "errors = 3\n",
        "if errors:\n",
        "    print(\"You have {} errors to fix!\".format(errors))\n",
        "else:\n",
        "    print(\"No errors to fix!\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "You have 3 errors to fix!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KUrZxBi8xMNQ",
        "colab_type": "text"
      },
      "source": [
        "> In this code, errors has the truth value True because it's a non-zero number, so the error message is printed. This is a nice, succinct way of writing an if statement."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CialzRUUycYa",
        "colab_type": "text"
      },
      "source": [
        "### **Ouestion:**\n",
        "Imagine an air traffic control program that tracks three variables, *altitude*, *speed*, and *propulsion* which for a particular airplane have the values specified below.\n",
        "```\n",
        "altitude = 10000\n",
        "speed = 250\n",
        "propulsion = \"Propeller\"\n",
        "```\n",
        "For each of the following boolean expressions, work out whether it evaluates to True or False and match the correct value.\n",
        "\n",
        "-  altitude < 1000 and speed > 100\n",
        "- (propulsion == \"Jet\" or propulsion == \"Turboprop\") and speed < 300 and altitude > 20000\n",
        "- not (speed > 400 and propulsion == \"Propeller\")\n",
        "- (altitude > 500 and speed > 100) or not propulsion == \"Propeller\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PnyTpu2VxGRo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "altitude = 10000\n",
        "speed = 250\n",
        "propulsion = \"Propeller\"\n",
        "\n",
        "# write your code here"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qYBnISVTzrcg",
        "colab_type": "text"
      },
      "source": [
        "## **For Loops:**\n",
        "\n",
        "Python has two kinds of loops - for loops and while loops. A for loop is used to \"iterate\", or do something repeatedly, over an iterable.\n",
        "\n",
        "An iterable is an object that can return one of its elements at a time. This can include sequence types, such as strings, lists, and tuples, as well as non-sequence types, such as dictionaries and files.\n",
        "\n",
        "Example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Uklx-pvdG90s",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "34869d0c-e095-48e7-827e-3c77eada7cc2"
      },
      "source": [
        "cities = ['new york city', 'mountain view', 'chicago', 'los angeles']\n",
        "for city in cities:\n",
        "    print(city)\n",
        "print(\"Done!\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "new york city\n",
            "mountain view\n",
            "chicago\n",
            "los angeles\n",
            "Done!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "quErSmRaHEol",
        "colab_type": "text"
      },
      "source": [
        "### **Components of a for Loop:**\n",
        "1. The first line of the loop starts with the *for* keyword, which signals that this is a *for* loop\n",
        "2. Following that is *city in cities*, indicating *city* is the iteration variable, and *cities* is the iterable being looped over. In the first iteration of the loop, *city* gets the value of the first element in *cities*, which is “new york city”.\n",
        "3. The *for* loop heading line always ends with a colon *:*\n",
        "4. Following the *for* loop heading is an indented block of code, the body of the loop, to be executed in each iteration of this loop. There is only one line in the body of this loop - *print(city)*.\n",
        "5. After the body of the loop has executed, we don't move on to the next line yet; we go back to the for heading line, where the iteration variable takes the value of the next element of the iterable. In the second iteration of the loop above, *city* takes the value of the next element in *cities*, which is \"mountain view\".\n",
        "6. This process repeats until the loop has iterated through all the elements of the iterable. Then, we move on to the line that follows the body of the loop - in this case, *print(\"Done!\")*. We can tell what the next line after the body of the loop is because it is unindented. Here is another reason why paying attention to your indentation is very important in Python!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LkPeOdqhHt-S",
        "colab_type": "text"
      },
      "source": [
        "> You can name iteration variables however you like. A common pattern is to give the iteration variable and iterable the same names, except the singular and plural versions respectively (e.g., 'city' and 'cities')."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EzjgTy3oJo9U",
        "colab_type": "text"
      },
      "source": [
        "## **Using the *range()* Function with for Loops:**\n",
        "*range()* is a built-in function used to create an iterable sequence of numbers. You will frequently use *range()* with a for loop to repeat an action a certain number of times, as in this example:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZufzUKnLG_49",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "20eff6c2-c891-4538-f26f-cfab5835800b"
      },
      "source": [
        "for i in range(3):\n",
        "    print(\"Hello!\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello!\n",
            "Hello!\n",
            "Hello!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bAycHJdLM2fZ",
        "colab_type": "text"
      },
      "source": [
        "## **range(start=0, stop, step=1)**\n",
        "The range() function takes three integer arguments, the first and third of which are optional:\n",
        "\n",
        "- The 'start' argument is the first number of the sequence. If unspecified, 'start' defaults to 0.\n",
        "- The 'stop' argument is 1 more than the last number of the sequence. This argument must be specified.\n",
        "- The 'step' argument is the difference between each number in the sequence. If unspecified, 'step' defaults to 1.\n",
        "\n",
        "\n",
        "Notes on using range():\n",
        "\n",
        "- If you specify one integer inside the parentheses withrange(), it's used as the value for 'stop,' and the defaults are used for the other two. Example-"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bCyOEET0LKEV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "82bfe7c1-03ec-4463-8659-a7a85e1f9caa"
      },
      "source": [
        "for i in range(4):\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "seR1RsifQoiu",
        "colab_type": "text"
      },
      "source": [
        "- If you specify two integers inside the parentheses withrange(), they're used for 'start' and 'stop,' and the default is used for 'step.' Example-"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MNzooFSsQVMb",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "42aca6cc-acea-4bcb-80c9-6439337cad4c"
      },
      "source": [
        "for i in range(2, 6):\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kEKyJFNZQtxM",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "- Or you can specify all three integers for 'start', 'stop', and 'step.' Example-"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l2Aztu8AQcue",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "19fc3eab-52ce-4c59-916a-de56b387cf9b"
      },
      "source": [
        "for i in range(1, 10, 2):\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "3\n",
            "5\n",
            "7\n",
            "9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8zOw8WP4RC7B",
        "colab_type": "text"
      },
      "source": [
        "## **Creating and Modifying Lists:**\n",
        "In addition to extracting information from lists, as we did in the first example above, you can also create and modify lists with *for* loops. You can **create** a list by appending to a new list at each iteration of the for loop like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p2zsBeOwQidy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Creating a new list\n",
        "cities = ['new york city', 'mountain view', 'chicago', 'los angeles']\n",
        "capitalized_cities = []\n",
        "\n",
        "for city in cities:\n",
        "    capitalized_cities.append(city.title())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M0m3k0-HRwAT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "806c0da9-3767-472f-e8f2-165aa3097c3d"
      },
      "source": [
        "for cap_city in capitalized_cities:\n",
        "  print(cap_city)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "New York City\n",
            "Mountain View\n",
            "Chicago\n",
            "Los Angeles\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dw6_HNA_Sfc2",
        "colab_type": "text"
      },
      "source": [
        "**Modifying** a list is a bit more involved, and requires the use of the *range()* function.\n",
        "\n",
        "We can use the *range()* function to generate the indices for each value in the cities list. This lets us access the elements of the list with *cities[index]* so that we can modify the values in the cities list in place."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aVjmwdt_R54p",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "cities = ['new york city', 'mountain view', 'chicago', 'los angeles']\n",
        "\n",
        "for index in range(len(cities)):\n",
        "    cities[index] = cities[index].title()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kwh9PYVsSxIJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "309bbc2f-d27a-4536-90bc-b4e9d5de2158"
      },
      "source": [
        "for city in cities:\n",
        "    print(city)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "New York City\n",
            "Mountain View\n",
            "Chicago\n",
            "Los Angeles\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cux22zs5VB60",
        "colab_type": "text"
      },
      "source": [
        "### **Question:**\n",
        "Write a for loop below that will print out every whole number that is a multiple of 5 and less than or equal to 30."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tsrVr6kKTMuD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        },
        "outputId": "24f47265-5bce-489f-c601-73407b7971f8"
      },
      "source": [
        "# Write a for loop using range() to print out multiples of 5 up to 30 inclusive\n",
        "\n",
        "for i in range(5, 35, 5):\n",
        "    print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5\n",
            "10\n",
            "15\n",
            "20\n",
            "25\n",
            "30\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "grakoICBGtDU",
        "colab_type": "text"
      },
      "source": [
        "### **Question:**\n",
        "Write a for loop that iterates over the names list to create a usernames list. To create a username for each name, make everything lowercase and replace spaces with underscores. Running your for loop over the list:\n",
        "```\n",
        "names = [\"Joey Tribbiani\", \"Monica Geller\", \"Chandler Bing\", \"Phoebe Buffay\"]\n",
        "```\n",
        "should create the list:\n",
        "\n",
        "```\n",
        "usernames = [\"joey_tribbiani\", \"monica_geller\", \"chandler_bing\", \"phoebe_buffay\"]\n",
        "```\n",
        "\n",
        "> HINT: Use the *.replace()* method to replace the spaces with underscores. Check out how to use this method in this [Stack Overflow answer](https://stackoverflow.com/questions/12723751/replacing-instances-of-a-character-in-a-string/12723785#12723785)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zkGdiF3AVNKf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "names = [\"Joey Tribbiani\", \"Monica Geller\", \"Chandler Bing\", \"Phoebe Buffay\"]\n",
        "usernames = []\n",
        "\n",
        "# write your for loop here\n",
        "\n",
        "\n",
        "print(usernames)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8gQCnzE_HUBx",
        "colab_type": "text"
      },
      "source": [
        "### **Question:**\n",
        "Write a for loop that iterates over a list of strings, tokens, and counts how many of them are XML tags. \n",
        "\n",
        "> XML is a data language similar to HTML. You can tell if a string is an XML tag if it begins with a left angle bracket \"<\" and ends with a right angle bracket \">\". \n",
        "\n",
        "Keep track of the number of tags using the variable count.\n",
        "\n",
        "You can assume that the list of strings will not contain empty strings."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ukZhXoydHnkw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "tokens = ['<greeting>', 'Hello World!', '</greeting>']\n",
        "count = 0\n",
        "\n",
        "# write your for loop here\n",
        "\n",
        "\n",
        "print(count)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hts0b-6HHsap",
        "colab_type": "text"
      },
      "source": [
        "### **Question:**\n",
        "Write some code, including a for loop, that iterates over a list of strings and creates a single string, html_str, which is an HTML list. For example, if the list is items = ['first string', 'second string'], printing html_str should output:\n",
        "```\n",
        "<ul>\n",
        "<li>first string</li>\n",
        "<li>second string</li>\n",
        "</ul>\n",
        "```\n",
        "That is, the string's first line should be the opening tag ```<ul>```. Following that is one line per element in the source list, surrounded by ```<li>``` and ```</li>``` tags. The final line of the string should be the closing tag ```</ul>```."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AOKRbOG1H_JP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "items = ['first string', 'second string']\n",
        "html_str = \"<ul>\\n\"  # \"\\ n\" is the character that marks the end of the line, it does\n",
        "                     # the characters that are after it in html_str are on the next line\n",
        "\n",
        "# write your code here\n",
        "\n",
        "\n",
        "print(html_str)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y46BP9WUIOMg",
        "colab_type": "text"
      },
      "source": [
        "## **Iterating Through Dictionaries with For Loops:**\n",
        "When you iterate through a dictionary using a for loop, doing it the normal way (for n in some_dict) will only give you access to the keys in the dictionary - which is what you'd want in some situations. \n",
        "\n",
        "In other cases, you'd want to iterate through both the keys and values in the dictionary. Let's see how this is done in an example. Consider this dictionary that uses names of actors as keys and their characters as values.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QYBoBC2fIYtt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "cast = {\n",
        "           \"Joey Tribbiani\": \"Joey Tribbiani\",\n",
        "           \"Monica Geller\": \"Chandler Bing\",\n",
        "           \"Phoebe Buffay\": \"Mike Hannigan\",\n",
        "           \"Ross Geller\": \"Rachel Green\"\n",
        "       }"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4d97pJSCJGDt",
        "colab_type": "text"
      },
      "source": [
        "Iterating through it in the usual way with a for loop would give you just the keys, as shown below:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qGashuUvJHdu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "be7fdeb5-cd7d-47da-f235-bfe648efa81a"
      },
      "source": [
        "for key in cast:\n",
        "    print(key)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Joey Tribbiani\n",
            "Monica Geller\n",
            "Phoebe Buffay\n",
            "Ross Geller\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y6NPJ50UJO0I",
        "colab_type": "text"
      },
      "source": [
        "If you wish to iterate through both keys and values, you can use the built-in method items like this:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ovRnghC3JNwQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "6283877e-7f74-4263-cd6f-4cf27c12f257"
      },
      "source": [
        "for key, value in cast.items():\n",
        "    print(\"Partner 1: {}    Partner 2: {}\".format(key, value))"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Partner 1: Joey Tribbiani    Partner 2: Joey Tribbiani\n",
            "Partner 1: Monica Geller    Partner 2: Chandler Bing\n",
            "Partner 1: Phoebe Buffay    Partner 2: Mike Hannigan\n",
            "Partner 1: Ross Geller    Partner 2: Rachel Green\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8T7sbVuHJbRx",
        "colab_type": "text"
      },
      "source": [
        "> items is an awesome method that returns tuples of key, value pairs, which you can use to iterate over dictionaries in for loops.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bMwu5B1RJrof",
        "colab_type": "text"
      },
      "source": [
        "### **Ouestion:**\n",
        "You would like to count the number of fruits in your basket. In order to do this, you have the following dictionary and list of fruits. Use the dictionary and list to count the total number of fruits, but you do not want to count the other items in your basket."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P54P9OkiJW2v",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "result = 0\n",
        "basket_items = {'apples': 4, 'oranges': 19, 'kites': 3, 'sandwiches': 8}\n",
        "fruits = ['apples', 'oranges', 'pears', 'peaches', 'grapes', 'bananas']\n",
        "\n",
        "#Iterate through the dictionary\n",
        "\n",
        "#if the key is in the list of fruits, add the value (number of fruits) to result\n",
        "\n",
        "\n",
        "print(result)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L77tOmpwKFc9",
        "colab_type": "text"
      },
      "source": [
        "## **While Loops:**\n",
        "For loops are an example of definite iteration, meaning that the loops body is run a predefined no of times. A for loop over a list executes the body for each element in the list, a for loop using the range function will execute a no of times specified by the range function.\n",
        "This deffer from indefinite iteration ie. when a loop repeats an unknown no of times, and ends when some condition is met.\n",
        "While loop is an example of indefinite iteration. Here is an example:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "It81d8ZoLSni",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "card_deck = [4, 11, 8, 5, 13, 2, 8, 10]\n",
        "hand = []\n",
        "\n",
        "# adds the last element of the card_deck list to the hand list\n",
        "# until the values in hand add up to 17 or more\n",
        "while sum(hand)  < 17:\n",
        "    hand.append(card_deck.pop())"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9KkqkudbLU6g",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "185d97e2-3fbc-4ea5-89ca-3fb4ca63be56"
      },
      "source": [
        "for card in hand:\n",
        "  print(card)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n",
            "8\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JwnTD36ZLqMs",
        "colab_type": "text"
      },
      "source": [
        "This example features two new functions. sum returns the sum of the elements in a list, and pop is a list method that removes the last element from a list and returns it."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4jDhRwT2Lr-l",
        "colab_type": "text"
      },
      "source": [
        "### **Components of a While Loop:**\n",
        "1. The first line starts with the while keyword, indicating this is a while loop.\n",
        "2. Following that is a condition to be checked. In this example, that's sum(hand) <= 17.\n",
        "3. The while loop heading always ends with a colon :.\n",
        "4. Indented after this heading is the body of the while loop. If the condition for the while loop is true, the code lines in the loop's body will be executed.\n",
        "5. We then go back to the while heading line, and the condition is evaluated again. This process of checking the condition and then executing the loop repeats until the condition becomes false.\n",
        "6. When the condition becomes false, we move on to the line following the body of the loop, which will be unindented.\n",
        "\n",
        "The indented body of the loop should modify at least one variable in the test condition. If the value of the test condition never changes, the result is an infinite loop!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r_a96I8tMgJV",
        "colab_type": "text"
      },
      "source": [
        "### **Question:**\n",
        "Find the factorial of a number using a while loop.\n",
        "\n",
        "A factorial of a whole number is that number multiplied by every whole number between itself and 1. For example, 6 factorial (written \"6!\") equals 6 x 5 x 4 x 3 x 2 x 1 = 720. So 6! = 720.\n",
        "\n",
        "We can write a while loop to take any given number and figure out what its factorial is.\n",
        "\n",
        "Example: If number is 6, your code should compute and print the product, 720."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r5ngmqZ0LjKu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# number to find the factorial of\n",
        "number = 6   \n",
        "\n",
        "# start with our product equal to one\n",
        "product = 1\n",
        "\n",
        "# track the current number being multiplied\n",
        "current = 1\n",
        "\n",
        "# write your while loop here\n",
        "\n",
        "    # multiply the product so far by the current number\n",
        "    \n",
        "    \n",
        "    # increment current with each iteration until it reaches number\n",
        "\n",
        "\n",
        "\n",
        "# print the factorial of number\n",
        "print(product)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0ovry-I1Mw8u",
        "colab_type": "text"
      },
      "source": [
        "### **Question:**\n",
        "Now use a for loop to find the factorial!\n",
        "\n",
        "It will now be great practice for you to try to revise the code you wrote above to find the factorial of a number, but this time, using a for loop. Try it in the code editor below!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Su8VaSb5M1pH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# number to find the factorial of\n",
        "number = 6   \n",
        "\n",
        "# start with our product equal to one\n",
        "product = 1\n",
        "\n",
        "# write your for loop here\n",
        "\n",
        "\n",
        "\n",
        "# print the factorial of number\n",
        "print(product)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mMEMlamnODYu",
        "colab_type": "text"
      },
      "source": [
        "## **Question:**\n",
        "Suppose you want to count from some number start_num by another number count_by until you hit a final number end_num. Use break_num as the variable that you'll change each time through the loop. For simplicity, assume that end_num is always larger than start_num and count_by is always positive.\n",
        "<br>\n",
        "<br>\n",
        "\n",
        "Before the loop, what do you want to set break_num equal to? How do you want to change break_num each time through the loop? What condition will you use to see when it's time to stop looping?\n",
        "<br>\n",
        "<br>\n",
        "After the loop is done, print out break_num, showing the value that indicated it was time to stop looping. It is the case that break_num should be a number that is the first number larger than end_num.\n",
        "<br>\n",
        "<br>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SIB04lNqOKUy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "start_num = 5\n",
        "end_num = 30\n",
        "count_by = 3\n",
        "\n",
        "# write a while loop that uses break_num as the ongoing number to \n",
        "#   check against end_num\n",
        "\n",
        "\n",
        "print(break_num)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xn6OcbHqOsG2",
        "colab_type": "text"
      },
      "source": [
        "## **Break and Continue:**\n",
        "For Loop iterate over every element in a sequence, while loops iterate over every element untill stopping condition is met.\n",
        "\n",
        "This is sufficient for most purposes, but sometimes we need more precise control over when we need to end a loop.\n",
        "\n",
        "In these cases we use the *break* keyword.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YgKrCyZmRzee",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "manifest = [(\"bananas\", 15), (\"mattresses\", 24), (\"dog kennels\", 42), \n",
        "            (\"machine\", 120), (\"cheeses\", 5)]\n",
        "\n",
        "weight = 0\n",
        "items = []"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sj-BgklORzHd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "manifest = [(\"bananas\", 15), (\"mattresses\", 24), (\"dog kennels\", 42), \n",
        "            (\"machine\", 120), (\"cheeses\", 5)]\n",
        "\n",
        "weight = 0\n",
        "items = []"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JD4oemELR1jK",
        "colab_type": "text"
      },
      "source": [
        "This brings us to our next statement sometimes there will be conditions where instead of breaking the loop we will like to skip one iteration of the loop. In this case we will use the continue keyword.\n",
        "\n",
        "> break and continue keywords, which can be used in both for and while loops.\n",
        "- break terminates a loop\n",
        "- continue skips one iteration of a loop"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2ibOEVxLSwjo",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "67c9a24a-f049-4d26-c792-b224bd9b3492"
      },
      "source": [
        "fruits= [\"orange\", \"strawberry\", \"apple\"]\n",
        "foods = [\"apple\", \"apple\", \"burger\", \"toast\"]\n",
        "\n",
        "fruit_count = 0\n",
        "for food in foods:\n",
        "  if food not in fruits:\n",
        "    print(\"Not a fruit\")\n",
        "    continue\n",
        "  fruit_count += 1\n",
        "  print(\"Found a fruit!!\")\n",
        "\n",
        "print(\"Total fruits: \", fruit_count)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Found a fruit!!\n",
            "Found a fruit!!\n",
            "Not a fruit\n",
            "Not a fruit\n",
            "Total fruits:  2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ERamEo0rQcbX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 510
        },
        "outputId": "fd21e714-a889-4bc8-d3dc-9f7e35700b83"
      },
      "source": [
        "manifest = [(\"bananas\", 15), (\"mattresses\", 24), (\"dog kennels\", 42), \n",
        "            (\"machine\", 120), (\"cheeses\", 5)]\n",
        "\n",
        "# skips an iteration when adding an item would exceed the limit\n",
        "# breaks the loop if weight is exactly the value of the limit\n",
        "\n",
        "weight = 0\n",
        "items = []\n"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "METHOD 1\n",
            "current weight: 0\n",
            "  adding bananas (15)\n",
            "current weight: 15\n",
            "  adding mattresses (24)\n",
            "current weight: 39\n",
            "  adding dog kennels (42)\n",
            "current weight: 81\n",
            "  adding machine (120)\n",
            "current weight: 201\n",
            "  breaking loop now!\n",
            "\n",
            "Final Weight: 201\n",
            "Final Items: ['bananas', 'mattresses', 'dog kennels', 'machine']\n",
            "\n",
            "METHOD 2\n",
            "current weight: 0\n",
            "  adding bananas (15)\n",
            "current weight: 15\n",
            "  adding mattresses (24)\n",
            "current weight: 39\n",
            "  adding dog kennels (42)\n",
            "current weight: 81\n",
            "  skipping machine (120)\n",
            "current weight: 81\n",
            "  adding cheeses (5)\n",
            "\n",
            "Final Weight: 86\n",
            "Final Items: ['bananas', 'mattresses', 'dog kennels', 'cheeses']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "otmYN5IOTwgU",
        "colab_type": "text"
      },
      "source": [
        "### **Question:**\n",
        "\n",
        "Write a loop with a break statement to create a string, news_ticker, that is exactly 140 characters long. You should create the news ticker by adding headlines from the headlines list, inserting a space in between each headline. If necessary, truncate the last headline in the middle so that news_ticker is exactly 140 characters long.\n",
        "\n",
        "> Remember that break works in both for and while loops. Use whichever loop seems most appropriate. Consider adding print statements to your code to help you resolve bugs."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9e-iNtDjQkX4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "headlines = [\"Local Bear Eaten by Man\",\n",
        "             \"Legislature Announces New Laws\",\n",
        "             \"Peasant Discovers Violence Inherent in System\",\n",
        "             \"Cat Rescues Fireman Stuck in Tree\",\n",
        "             \"Brave Knight Runs Away\",\n",
        "             \"Papperbok Review: Totally Triffic\"]\n",
        "\n",
        "news_ticker = \"\"\n",
        "# write your loop here\n",
        "\n",
        "\n",
        "print(news_ticker)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "baBSZNdeUIkk",
        "colab_type": "text"
      },
      "source": [
        "## **Zip and Enumerate:**\n",
        "zip and enumerate are useful built-in functions that can come in handy when dealing with loops.\n",
        "\n",
        "## **Zip:**\n",
        "zip returns an iterator that combines multiple iterables into one sequence of tuples. Each tuple contains the elements in that position from all the iterables. For example, printing\n",
        "\n",
        "```\n",
        "manifest = [(\"bananas\", 15), (\"mattresses\", 24), (\"dog kennels\", 42), \n",
        "            (\"machine\", 120), (\"cheeses\", 5)]\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CvI2ARw7UZ3Q",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "8cd91920-df3f-4a3b-f86b-195e13eef8fa"
      },
      "source": [
        "items = ['bananas', 'mattresses', 'dog kennels', 'machine', 'cheeses']\n",
        "\n",
        "weights = [15, 24, 42, 120, 5]\n",
        "\n",
        "print(list(zip(items, weights)))"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[('bananas', 15), ('mattresses', 24), ('dog kennels', 42), ('machine', 120), ('cheeses', 5)]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PLhgh95XWHCQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "8a55051e-d8ca-4cfd-9e5e-251e34fce4ee"
      },
      "source": [
        "for item, weight in zip(items, weights):\n",
        "    print(\"{}: {}\".format(item, weight))"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "bananas: 15\n",
            "mattresses: 24\n",
            "dog kennels: 42\n",
            "machine: 120\n",
            "cheeses: 5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4uGD7MD7VI-L",
        "colab_type": "text"
      },
      "source": [
        "In addition to zipping two lists together, you can also unzip a list into tuples using an asterisk."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dHg_F7rTU-Eo",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "213e156b-5add-4606-baaa-bb3b7af91bb8"
      },
      "source": [
        "manifest = [(\"bananas\", 15), (\"mattresses\", 24), (\"dog kennels\", 42), \n",
        "            (\"machine\", 120), (\"cheeses\", 5)]\n",
        "\n",
        "items, weights = zip(*manifest)\n",
        "\n",
        "print(items)\n",
        "print(weights)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "('bananas', 'mattresses', 'dog kennels', 'machine', 'cheeses')\n",
            "(15, 24, 42, 120, 5)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YleWcdd3VizQ",
        "colab_type": "text"
      },
      "source": [
        "This would create the same letters and nums tuples we saw earlier."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JaA0PEZHWVFh",
        "colab_type": "text"
      },
      "source": [
        "## **Enumerate:**\n",
        "enumerate is a built in function that returns an iterator of tuples containing indices and values of a list. You'll often use this when you want the index along with each element of an iterable in a loop."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NHUepFAuVibt",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "0fb0c71a-1381-4647-a856-1698a2ac441c"
      },
      "source": [
        "items = ['bananas', 'mattresses', 'dog kennels', 'machine', 'cheeses']\n",
        "\n",
        "for i, item in zip(range(len(items)), items):\n",
        "  print(i, item)"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 bananas\n",
            "1 mattresses\n",
            "2 dog kennels\n",
            "3 machine\n",
            "4 cheeses\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4DJATkVnVYSO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "7e396dbe-5de7-485d-a593-b722feca0ea7"
      },
      "source": [
        "items = ['bananas', 'mattresses', 'dog kennels', 'machine', 'cheeses']\n",
        "\n",
        "for i, item in enumerate(items):\n",
        "  print(i, item)"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 bananas\n",
            "1 mattresses\n",
            "2 dog kennels\n",
            "3 machine\n",
            "4 cheeses\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "92PJy7_rXGYV",
        "colab_type": "text"
      },
      "source": [
        "### **Question:**\n",
        "\n",
        "Use zip to write a for loop that creates a string specifying the label and coordinates of each point and appends it to the list points. Each string should be formatted as ``` label: x, y, z ``` . For example, the string for the first coordinate should be ```F: 23, 677, 4```."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DI28k3bcXAS1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x_coord = [23, 53, 2, -12, 95, 103, 14, -5]\n",
        "y_coord = [677, 233, 405, 433, 905, 376, 432, 445]\n",
        "z_coord = [4, 16, -6, -42, 3, -6, 23, -1]\n",
        "labels = [\"F\", \"J\", \"A\", \"Q\", \"Y\", \"B\", \"W\", \"X\"]\n",
        "\n",
        "points = []\n",
        "# write your for loop here\n",
        "\n",
        "\n",
        "for point in points:\n",
        "    print(point)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tVYaOI-PYXIi",
        "colab_type": "text"
      },
      "source": [
        "## **Question:**\n",
        "Use zip to create a dictionary cast that uses names as keys and heights as values.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X8VB9r6lYjgn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "cast_names = [\"Joey Tribbiani\", \"Monica Geller\", \"Chandler Bing\", \n",
        "              ,\"Ross Geller\", \"Phoebe Buffay\"]\n",
        "\n",
        "cast_heights = [172, 168, 172, 166, 170]\n",
        "\n",
        "cast = # replace with your code\n",
        "print(cast)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4nXbwD4bY0qn",
        "colab_type": "text"
      },
      "source": [
        "## **Question:**\n",
        "Use zip to transpose data from a 4-by-3 matrix to a 3-by-4 matrix. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TNOuyi3eY6jh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "data = ((0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11))\n",
        "\n",
        "data_transpose = # replace with your code\n",
        "print(data_transpose)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k3LD-7ReY_hc",
        "colab_type": "text"
      },
      "source": [
        "## **Question:**\n",
        "Use enumerate to modify the cast list so that each element contains the name followed by the character's corresponding income in $ 1000. For example, the first element of cast should change from \"Barney Stinson\" to \"Barney Stinson 150\"."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Yz5KAaVxZO4y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "cast = [\"Barney Stinson\", \"Robin Scherbatsky\", \"Ted Mosby\", \n",
        "        \"Lily Aldrin\", \"Marshall Eriksen\"]\n",
        "heights = [150, 100, 40, 0, 80]\n",
        "\n",
        "# write your for loop here\n",
        "\n",
        "\n",
        "print(cast)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QDgp2aaFZalY",
        "colab_type": "text"
      },
      "source": [
        "## **List Comprehensions:**\n",
        "In Python you can create lists very quickly and consisely with a cool tool called as list comprehension. For exampls from earlier:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ih37N8jGa_Nu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "92b2ca7e-c6a5-44a1-f81b-0b0724ad1cfb"
      },
      "source": [
        "cities = ['new york city', 'mountain view', \n",
        "                      'chicago', 'los angeles']\n",
        "capitalized_cities = []\n",
        "\n",
        "for city in cities:\n",
        "    capitalized_cities.append(city.title())\n",
        "\n",
        "print(capitalized_cities)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['New York City', 'Mountain View', 'Chicago', 'Los Angeles']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i7ek39QWbbTl",
        "colab_type": "text"
      },
      "source": [
        "With the help of list comprehension this can be reduced to:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6dNrPANObBU-",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "742a3c44-76a5-4551-cc9f-b8ac864dcff3"
      },
      "source": [
        "capitalized_cities = [city.title() for city in cities]\n",
        "\n",
        "print(capitalized_cities)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['New York City', 'Mountain View', 'Chicago', 'Los Angeles']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PFYkA6q-bpFJ",
        "colab_type": "text"
      },
      "source": [
        "List comprehensions allow us to create a list using a for loop in one step.\n",
        "\n",
        "You create a list comprehension with brackets [], including an expression to evaluate for each element in an iterable. This list comprehension above calls city.title() for each element city in cities, to create each element in the new list, capitalized_cities."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GHwo95c_cQTq",
        "colab_type": "text"
      },
      "source": [
        "## **Conditionals in List Comprehensions:**\n",
        "You can also add conditionals to list comprehensions (listcomps). \n",
        "\n",
        "Lets look at an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3dBmqynjbhMw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "3daeccb2-91fb-4104-f82a-930804ca7614"
      },
      "source": [
        "squares = []\n",
        "\n",
        "for x in range(9):\n",
        "  squares.append(x**2)\n",
        "\n",
        "print(squares)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 4, 9, 16, 25, 36, 49, 64]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "moGS7Ruacp5K",
        "colab_type": "text"
      },
      "source": [
        "writing the same as a list comprehension will be like:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4mKNK5MtclQK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "feac3c8e-50bb-49a6-fbe9-1675a146f713"
      },
      "source": [
        "squares = [x**2 for x in range(9)]\n",
        "\n",
        "print(squares)"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 4, 9, 16, 25, 36, 49, 64]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lYwMMvDIdX54",
        "colab_type": "text"
      },
      "source": [
        "Now if we want only those numbers that are multiple of 2:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ly-zmKbadb8h",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "26fc5436-6e24-4f28-9408-84f19c5f6524"
      },
      "source": [
        "squares = [x**2 for x in range(9) if x % 2 == 0]\n",
        "print(squares)"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 4, 16, 36, 64]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GYfWe8kydlxg",
        "colab_type": "text"
      },
      "source": [
        "The code above sets squares equal to the list [0, 4, 16, 36, 64], as x to the power of 2 is only evaluated if x is even. If you want to add an else, you will get a syntax error doing this."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SCKNfhaEdeFf",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 130
        },
        "outputId": "9e1b0744-2c02-4bd7-8ddb-38d50b6bf5b5"
      },
      "source": [
        "squares = [x**2 for x in range(9) if x % 2 == 0 else x + 3]"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-30-0d53fcb29c35>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    squares = [x**2 for x in range(9) if x % 2 == 0 else x + 3]\u001b[0m\n\u001b[0m                                                       ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p_a9CKS_duRo",
        "colab_type": "text"
      },
      "source": [
        "If you would like to add else, you have to move the conditionals to the beginning of the listcomp, right after the expression, like this."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "srvbtvFVdrG4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "squares = [x**2 if x % 2 == 0 else x + 3 for x in range(9)]"
      ],
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8MfbXBqHdzld",
        "colab_type": "text"
      },
      "source": [
        "> List comprehensions are not found in other languages, but are very common in Python."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jc3k9Rbbd5kM",
        "colab_type": "text"
      },
      "source": [
        "### **Question:**\n",
        "Use a list comprehension to create a new list first_names containing just the first names in names in lowercase."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OL7SIKyFdxPP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "names = [\"Barney Stinson\", \"Robin Scherbatsky\", \"Ted Mosby\", \n",
        "        \"Lily Aldrin\", \"Marshall Eriksen\"]\n",
        "\n",
        "first_names = # write your list comprehension here\n",
        "print(first_names)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qQ84Hi0peE4U",
        "colab_type": "text"
      },
      "source": [
        "### **Question:**\n",
        "Use a list comprehension to create a list multiples_3 containing the first 20 multiples of 3.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VS0_4QnteNt7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "multiples_3 = # write your list comprehension here\n",
        "print(multiples_3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3euEzM19eQbe",
        "colab_type": "text"
      },
      "source": [
        "### **Question:**\n",
        "Use a list comprehension to create a list of names passed that only include those that scored at least 65."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GP9dY8jLeWJD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "scores = {\n",
        "             \"Deku\": 70,\n",
        "             \"Bakugo\": 35,\n",
        "             \"Tenya\": 82,\n",
        "             \"Shoto\": 23,\n",
        "             \"All Might\": 98\n",
        "          }\n",
        "\n",
        "passed = # write your list comprehension here\n",
        "print(passed)"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}