Chapter 3.4 - For loops

Like while loops, for loops will execute an indented code block as long as a condition is met.

The useful aspect of for loops is that this logic does not need to be explicitly determined by the coder. And, you can avoid infinite loops!

Chapter 3.4.1 - Basic for loop syntax:¶

my_list = [1, 2, 3, 4, 5]

for i in my_list:
    print(i)
    # do something with i

Each for loop has 3 major components:

1. iterable: a data type that is able to interface with a for loop and has multiple values within it.
2. iteration: each step in the loop, where the iteration variable set by the programmer is modified based on values in the iterable.
3. iterator: the mechanism that works behind the scenes to set values and determine if the loop should continue

The preconditions for a for loop require an iterable data type. These types include (but are not limited to):

1. list
2. tuple
3. dict

Each of these composite data types are considered iterable, which is just a fancy way of saying that they contain multiple items and a for loop can automatically serve up each item that it contains. For example, an int is not an iterable because it is only one value, but a list of int variables within a list can be served to a for loop through the list that contains these variables.

Each step of the loop (i.e., each time the indented code block is executed) is called an iteration. During an iteration, the value served by the for loop changes in the order the values appear in the list.

For example, the following list (which is an iterable):

my_list = [1, 2, 3, 4]

Would serve to the for loop the value 1 during the first iteration. The second iteration would serve the value 2, and so on.

The iterator is the magic that occurs in the background of a for loop that does multiple things for you:

1. It checks to see if there are more items to visit in the iterable. If not, the loop ends

2. During each iteration, it accesses the values in the iterable at each index in the order in which they appear. The iterator then sets this value equal to a variable that is named by the programmer that can be used in the current iteration

Consider the above for loop:

my_list = [1, 2, 3, 4, 5]

for i in my_list:
    print(i)
    # do something with i

The equivalent process can be explicitly demonstrated by a while loop:

my_list = [1, 2, 3, 4, 5]

index = 0

while (index < len(my_list)):

    i = my_list[index]
    
    print(i)
    
    # do something with i
    
    index = index + 1

Notice the extra steps in the while loop:

1. setting an index variable to 0 to start at the beginning of the list
2. determining a condition (i.e., index < len(my_list) when the loop should stop
3. accessing each value in the list based on the index variable and setting it equal to i
4. incrementing the index by 1 to visit the next item in the list, or to cause the while loop condition to result in False and stop the loop.

Thus, for most cases, we would want to use a for loop to avoid all of the potential pitfalls and bugs that could pop up when using a while loop.

Examples of the for and while loops above.

while loop:

for loop equivalent

Chapter 3.4.2 - Iterators¶

There are multiple built-in iterators that are incredibly useful and very common in Python programs. These iterators typically encapsulate common use-cases for steping through iterables (e.g., a list).

range¶

One common iteration is to step through a sequence of numbers. For example, you may want to visit all numbers between 1 and 100. Using the code pattern associated with the for loop above, you might start writing the following code:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 .....]

You immediately recognize that would require typing many numbers. If you have any case where you need 1000, 10000, or 1000000000 number sequences, you can see where this approach would be limiting.

However, Python has a solution--the built-in range data type. This is a special type of list that contain a list of int values with attributes defined by the programmer. Specifically, the programmer can provide the start, end, and steps (i.e., spacing between numbers). This allows you to type as few as two numbers to produce a sequence of many int values.

The following pattern is associated with range:

for number in range(start, finish, step):
    print(number)
    # do stuff with number

Here is a working version below. Modify the start, finish, and step values by typing an int and pressing enter when prompted below:

Example: # iterate through a list of integers that go from 0 to 10

By default, python will treat using only one number as the “finish” number, and the first number will default to 0 and the step will default to one. The following iterator is equivalent to range(0, 11, 1)

that is much easier than this:

Example: iterate through a list of every 10th integer from 0 to 100

enumerate¶

Another common pattern is to keep track of how many times the loop has executed. For example, you might have a list of data from hours or days, and you want to print out that the data are from “Day 1” or “Day 2”.

enumerate will keep track of this information and provide the value during each iteration. This can also be useful for identifying the index associated with each value.

Here is the interactive example above, except with enumerate included and wrapped around range:

Chapter 3.4.3 - Stacks and queues¶

These are special types of list that are used for a specific purpose and various algorithms. This approach uses the pop() function to remove the last item that was added to the lift (last in, first out) and set it equal to a variable.

Stacks¶

The premise of a stack is Last In First Out (LIFO)

Rules of a stack:

1. allow values to be added at any time
2. the last value to be added will be the first to be removed when the stack is accessed

Queue¶

The same as a stack, except the premise of a queue is First in First Out (LIFO)

Rules of a queue:

1. allow values to be added at any time
2. the first value to be added will be the first to be removed when the queue is accessed (pop(0))

Chapter 3.4.5 - Dictionary iterators¶

These follow the same rules as the above examples, except they have different iterator keywords that need to be explicitly written out:

1. .keys(): iterate through only the keys in the dictionary
2. .values(): iterate only though the values and not the keys in the dictionary
3. .items(): iterate through BOTH the keys and values

Basic dictionary iterator example:¶

Example: A weather related use-case that iterates through both keys and values in a dictionary to print a message.

Chapter 3.4.6 - Practice¶

Create a dictionary of rock or cloud names, where each name has their affiliated descriptions and a date when you saw the rock or cloud.

Once you complete the dict, use the dict iterator to print a message similar to the following:

The cirrus cloud looks wispy and feathery and is usually high in the sky. I saw a cirrus cloud on 09/06/2025.
The obsidian rock is black and shiny and is formed by volcanoes. I saw an obsidian rock on 09/20/2025.