{ "cells": [ { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "# for loops\n", "\n", "In the previous section we introduced *{term}`lists `* in Python, one form of a collection of values that can be represented by a single variable. In this lesson we will learn how to use *{term}`loops `*. Loops allow parts of code to be repeated some number of times, such as iterating over all of the items in a Python list and performing a calculation using each item. " ] }, { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "## A (bad) example\n", "\n", "Let’s consider an example using the `list` below:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "european_cities = [\"Helsinki\", \"Paris\", \"Barcelona\", \"Uppsala\"]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Suppose we want to print out the name of each city in our list. We could use the index value for each city and do the following:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "But this is a bad idea. Why? Well there are two reasons.\n", "First, it does not scale nicely for long lists and will take forever to type in.\n", "Second, it won’t work if the length of the list has fewer than 4 cities (or more than 4 cities for that matter...).\n", "Let's see an example with a new `list`." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "european_cities = [\"Riga\", \"Rome\", \"Athens\"]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": { "tags": [ "raises-exception" ] }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "## Introducing the for loop\n", "\n", "In situations like those above, it is far more efficient to use a `for` loop. Let's see an example." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "european_cities = [\"Amsterdam\", \"Brussels\", \"Lisbon\", \"Reykjavik\"]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Not only is this shorter, but it is also more flexible.\n", "Try printing out a different list of cities such as `['Detroit', 'Chicago', 'Denver', 'Boston', 'Portland', 'San Francisco', 'Houston', 'Orlando']`.\n", "Still works, right?" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "us_cities = [\n", " \"Detroit\",\n", " \"Chicago\",\n", " \"Denver\",\n", " \"Boston\",\n", " \"Portland\",\n", " \"San Francisco\",\n", " \"Houston\",\n", " \"Orlando\",\n", "]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "### for loop format\n", "\n", "`for` loops in Python have the general form below.\n", "\n", "```python\n", "for variable in collection:\n", " do things with variable\n", "```\n", "\n", "Let's break down the code above to see some essential aspect of `for` loops:\n", "\n", "- The `variable` can be any valid variable name you like.\n", "- The statement of the `for` loop must end with a `:`\n", "- The code that should be executed as part of the loop must be indented beneath the `for` statement. The recommended indentation is 4 spaces.\n", "- There is no additional special word needed to end the loop, you simply change the indentation back to normal.\n", "\n", "In summary, `for` loops are useful to repeat some part of the code a finite number of times." ] }, { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "### Your daily for loop\n", "\n", "![_**Figure 2.3**. A cat's daily routine as an example loop. Original comic from ._](../img/2009-11-03-Cats-Eye.jpg)\n", "\n", "_**Figure 2.3**. A cat's daily routine as an example loop. Original comic from ._\n", "\n", "Like many other programming concepts, the idea of looping through actions is something that is already perhaps more familiar to you than you think. Consider your actions during a given weekday. Many people have certain routines they follow each weekday, such as waking up, taking a shower, eating breakfast, and brushing their teeth. In Python code, we might represent such actions as follows:" ] }, { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "```python\n", "for day in my_week:\n", " wake_up()\n", " take_shower()\n", " eat_breakfast()\n", " brush_teeth()\n", " ...\n", "```\n", " \n", "Note that `my_week` would be a list of the days of the week, and the actions you take are represented as functions, such as `wake_up()`.\n", "Furthermore, by following this kind of list of repeating actions we're able to start the day effectively even before the first cup of coffee :)." ] }, { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "### for loop variables\n", "\n", "Note that the variable used in a `for` loop is just a normal variable. This its value still exists after the loop has been run. Let's loop over a list of weather conditions and print them to the screen. " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "weather_conditions = [\n", " \"rain\",\n", " \"sleet\",\n", " \"snow\",\n", " \"freezing fog\",\n", " \"sunny\",\n", " \"cloudy\",\n", " \"ice pellets\",\n", "]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "What is its value of `weather` after the `for` loop has completed?" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "## For loops using the range function\n", "\n", "A loop can be used to iterate over any list of values in Python. So far we have considered only iterating over lists, but we could also write a loop that performs a calculation a specified number of times by using the `range()` function. Let's consider an example where we use a `for` loop with `value` as the loop variable and `range(5)` as the collection. Let's see what happens if we print `value` at each iteration." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this case, we use a special function called `range()` to give us a list of 5 numbers `[0, 1, 2, 3, 4]` and then we print a number in the list to the screen during each iteration.\n", "When given an integer (whole number) as an argument, `range()` will produce a list of numbers with a length equal to the specified `number`.\n", "The list starts at `0` and ends with `number - 1`.\n", "You can learn a bit more about range by typing `help(range)`.\n", "\n", "```python\n", "In [1]: help(range)\n", "```\n", "\n", "```\n", "Help on class range in module builtins:\n", "\n", "class range(object)\n", " | range(stop) -> range object\n", " | range(start, stop[, step]) -> range object\n", " | \n", " | Return an object that produces a sequence of integers from start (inclusive)\n", " | to stop (exclusive) by step. range(i, j) produces i, i+1, i+2, ..., j-1.\n", "... (output truncated)\n", "```" ] }, { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [ "question" ] }, "source": [ "#### Question 2.7\n", "\n", "The program below will print numbers to the screen using the `range()` function.\n", "\n", "```python\n", "for i in range(...):\n", " print(i)\n", "```\n", "\n", "Using the documentation that is produced when you run `help(range)`, what values would you replace the `...` in the parentheses of the `range()` function with to have the following output printed to the screen? Try to first think about the function without running any code.\n", "\n", "```python\n", "2\n", "5\n", "8\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [ "remove_cell" ] }, "outputs": [], "source": [ "# You can use this cell to enter your solution.\n" ] }, { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "## Looping over lists using index values\n", "\n", "Since we already know how to find the length of a list using the `len()` function, we can now take advantage of this knowledge to make our `for` loops more flexible. Let's start by doing something we have done earlier, printing out city names using a `for` loop. However, this time we will also use the `range()` function to print the cities." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "african_cities = [\"Dakar\", \"Addis Ababa\", \"Nairobi\", \"Cairo\", \"Rabat\", \"Kampala\"]" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "There are several important things to observe in this `for` loop:\n", "\n", "1. You can see that because we are using the `range()` function, the value assigned to the loop variable `i` starts with `0` and increases by `1` each time through the loop. \n", "2. In order to access individual cities in the `african_cities` list, we need to include the index value (e.g., `african_cities[i]`. Here, the variable `i` will be replaced by the current value assigned from the `range()` function.\n", "\n", "The variable `i` is commonly used to denote the index variable in loops. Loops can sometimes occur with another loop (referred to as nested loops), in which case other index variables such as `j` or `k` may be used." ] }, { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "## Why use index value to loop over a list?\n", "\n", "Good question. There are two common case where you might need to loop using index values:\n", "\n", "1. If you want to update individual values in a list you're likely going to need a loop that includes the index values. To update a list value, you need to refer to both the list and index, which means looping using the list values directly will not work. There are functions such as `enumerate()` that can help, but their use can be somewhat confusing for new programmers.\n", "2. In cases where you have multiple lists that are related to one another, it can be handy to use a loop with the index values to be able to access corresponding locations in each list. For this, let's consider an example with the two lists below." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "cities = [\"Helsinki\", \"Stockholm\", \"Oslo\", \"Reykjavik\", \"Copenhagen\"]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "countries = [\"Finland\", \"Sweden\", \"Norway\", \"Iceland\", \"Denmark\"]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As you can see we have 5 cities and 5 corresponding countries. Let's print out each pair using a single `for` loop." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Cool. So as you can see, the index `i` is used in this case to access each item in the two lists of cities and countries and allow us to print out the city/country pairs. In the example above, we used the length of the list `cities` in the `range()` function. We could just as easily used the list `countries` to define the values of `i` since both lists are the same length." ] }, { "cell_type": "markdown", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [ "question" ] }, "source": [ "#### Question 2.8\n", "\n", "What output would the following program produce? Try to first think about the loop without running any code.\n", "\n", "```python\n", "odd_numbers = [1, 3, 5, 7, 9]\n", "even_numbers = [10, 4, 6, 8, 2]\n", "for i in range(len(odd_numbers)):\n", " print(odd_numbers[i] + even_numbers[i])\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [ "remove_cell" ] }, "outputs": [], "source": [ "# Use this cell to enter your solution.\n" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.6" } }, "nbformat": 4, "nbformat_minor": 4 }