Sequences: Lists, Tuples, Strings, and Ranges

When it comes to iterating oversequence data types like lists, tuples, strings, and ranges, the iteration happens in the same order that the items appear in thesequence. Consider the following example where you iterate over the numbers in a list:

>>>numbers=[1,2,3,4]>>>fornumberinnumbers:...print(number)...1234

In this example, the iteration goes through the list in the definition order, starting with1 and ending with4. Note that to iterate over a sequence in Python, you don’t need to be aware of the index of each item as in other languages where loops often rely on indices.

Often, you use plural nouns to name lists. This naming practice allows you to use singular nouns as the loop variable, making your code descriptive and readable.

You’ll note the same behavior with other built-in sequences:

>>>person=("Jane",25,"Python Dev","Canada")>>>forfieldinperson:...print(field)...Jane25Python DevCanada>>>text="abcde">>>forcharacterintext:...print(character)...abcde>>>forindexinrange(5):...print(index)...01234

In these examples, you iterate over a tuple, string, and numeric range. Again, the loop traverses the sequence in the order of definition.

Tuples are often used to represent rows of data. In the example above, theperson tuple holds data about a person. You can iterate over each field using a readable loop.

When it comes to iterating over string objects, thefor loop lets you process the string on a character-by-character basis. Finally, iterating over a numeric range is sometimes a requirement, especially when you need toiterate a given number of times and need control over the consecutive index.

Collections: Dictionaries and Sets

When traversing dictionaries with afor loop, you’ll find that you can iterate over the keys, values, and items of thedictionary at hand.

You’ll have two different ways to iterate over the keys of a dictionary. You can either use:

1. The dictionary directly
2. The.keys()method

The following examples show how to use these two approaches:

>>>students={..."Alice":89.5,..."Bob":76.0,..."Charlie":92.3,..."Diana":84.7,..."Ethan":88.9,...}>>>forstudentinstudents:...print(student)...AliceBobCharlieDianaEthan>>>forstudentinstudents.keys():...print(student)...AliceBobCharlieDianaEthan

In these examples, you first iterate over the keys of a dictionary using the dictionary directly in the loop header. In the second loop, you use the.keys() method to iterate over the keys. While both approaches are equivalent, the first one is more commonly used, whereas the second might be more readable and explicit.

In both loops, you can access the dictionary values using the keys:

>>>forstudentinstudents:...print(student,"->",students[student])...Alice -> 89.5Bob -> 76.0Charlie -> 92.3Diana -> 84.7Ethan -> 88.9

To access the values in this type of iteration, you can use the original dictionary and a key lookup operation, as shown in the highlighted line.

You can use the.values() method to feed thefor loop when you need to iterate over the values of a dictionary:

>>>teams={..."Colorado":"Rockies",..."Chicago":"White Sox",..."Boston":"Red Sox",..."Minnesota":"Twins",..."Milwaukee":"Brewers",..."Seattle":"Mariners",...}>>>forteaminteams.values():...print(team)...RockiesWhite SoxRed SoxTwinsBrewersMariners

The.values() method lets you traverse the values in the target dictionary. In this example, you iterate over team names one by one. Note that when you use the.values() method, you can’t access the dictionary keys.

Finally, iterating over both keys and values in a Python dictionary is a common requirement. In this case, the recommended and most Pythonic approach is to use the.items() method in afor loop like the following:

>>>forplace,teaminteams.items():...print(place,"->",team)...Colorado -> RockiesChicago -> White SoxBoston -> Red SoxMinnesota -> TwinsMilwaukee -> BrewersSeattle -> Mariners

When iterating over keys and values this way, you typically use a tuple of loop variables. The first variable will get the key, while the second will get the associated value. In this example, you have theplace andteam variables, which make the code clear and readable.

When it comes to iterating oversets, you only have to keep in mind that sets are unordered data types. This means that looping in order isn’t guaranteed:

>>>tools={"Django","Flask","pandas","NumPy"}>>>fortoolintools:...print(tool)...NumPyFlaskpandasDjango

As you can see, the loop goes through the elements of your set in a different order than they were inserted. So, you can’t rely on the order of the elements when traversing sets in Python.

Thebreak Statement

Thebreak statement immediately exits the loop and jumps to the first statement after the loop. For example, say that you want to write a loop to determine whether a number is in a list. To avoid unnecessary work, the loop should terminate once it finds the target value. You can do this with thebreak statement:

>>>numbers=[1,3,5,7,9]>>>target=5>>>fornumberinnumbers:...print(f"Processing{number}...")...ifnumber==target:...print(f"Target found{target}!")...break...Processing 1...Processing 3...Processing 5...Target found 5!

In this example, thebreak statement jumps out of the loop as soon as the target number is found. The remaining values,7 and9, aren’t processed. You can think of thebreak statement as a way to short-circuit the loop execution once you’ve gotten the desired result.

It’s important to note that it makes little sense to havebreak statements outside conditionals. Suppose you include abreak statement directly in the loop body without wrapping it in a conditional. In that case, the loop will terminate in the first iteration, potentially without running the entire loop body.

Thecontinue Statement

Thecontinue statement terminates the current iteration and proceeds to the next one. For example, if you have a list of numbers and only want to process the even ones, you can use acontinue statement to skip the odd numbers:

>>>numbers=[1,2,3,4,5,6]>>>fornumberinnumbers:...print(f"{number= }")...ifnumber%2!=0:...continue...print(f"{number} is even!")...number = 1number = 22 is even!number = 3number = 44 is even!number = 5number = 66 is even!

In this example, the code that processes the numbers is only reached if the number is even. Otherwise, thecontinue statement skips that code and jumps right into the next iteration.

Again, it doesn’t make much sense to have acontinue statement without wrapping it in a conditional. If you do so, the code after the statement will be unreachable and never run.

Theelse Clause

In Python,for loops can have anelse clause at the end. Theelse clause will only run if the loop terminates because of the exhaustion of the input iterable. This feature is useful when you have abreak statement that can terminate the loop in certain situations. If the loop doesn’t break, then you can run additional code in theelse clause.

To illustrate, say that you want to continue improving the loop that determines whether a number is in a list. You’d like to explicitly inform the user if the number isn’t in the list. You can do this with theelse clause:

>>>numbers=[1,3,5,7,9]>>>target=42>>>fornumberinnumbers:...print(f"Processing{number}...")...ifnumber==target:...print(f"Target found{target}!")...break...else:...print(f"Target not found{target}")...Processing 1...Processing 3...Processing 5...Processing 7...Processing 9...Target not found 42

Theelse clause won’t run if the loop breaks out with thebreak statement. It only runs if the loop terminates normally, allowing you to inform the user that the target number wasn’t found.

It doesn’t make sense to have anelse clause in a loop that doesn’t have abreak statement. In that case, placing theelse block’s content after the loop—withoutindentation—will work the same and be cleaner.

Nestedfor Loops

You can also have nestedfor loops. In the example below, you create a multiplication table that shows the products of all combinations of integers up to ten usingnested loops. The outer loop iterates over the numbers between1 and10, and the inner loop calculates and prints the products:

>>>fornumberinrange(1,11):...forproductinrange(number,number*11,number):...print(f"{product:>4d}",end="")...print()...   1   2   3   4   5   6   7   8   9  10   2   4   6   8  10  12  14  16  18  20   3   6   9  12  15  18  21  24  27  30   4   8  12  16  20  24  28  32  36  40   5  10  15  20  25  30  35  40  45  50   6  12  18  24  30  36  42  48  54  60   7  14  21  28  35  42  49  56  63  70   8  16  24  32  40  48  56  64  72  80   9  18  27  36  45  54  63  72  81  90  10  20  30  40  50  60  70  80  90 100

In this example, you use two nested loops. Together, they create a two-dimensional multiplication table. First, you loop over the numbers from one up to and including ten. These represent the rows in the table, and you can see those numbers at the beginning of each row.

In the inner loop, you calculate the products for the currentnumber by iterating from thenumber itself up to its tenth multiple. Then, you format each product using the:>4dformat specifier. This ensures the table is nicely aligned. By settingend to an empty string, you skip the newline until the products on the current row are printed. After printing all products for a row, you useprint() withoutarguments to move to the next row.

Iterating With Indices: The Pythonic Way

Sometimes, you need to use the indices of items when you iterate over a sequence with a Pythonfor loop. Up to this point, you’ve seen examples where you can access the items but don’t know their corresponding indices.

To get both the item and its index, you can end up writing a loop like the one shown in the following example:

>>>fruits=["orange","apple","mango","lemon"]>>>forindexinrange(len(fruits)):...fruit=fruits[index]...print(index,fruit)...0 orange1 apple2 mango3 lemon

This loop gets the job done, but it’s not as clean or readable as you’d expect from Python code. Fortunately, there’s a better way—the built-inenumerate() function:

>>>forindex,fruitinenumerate(fruits):...print(index,fruit)...0 orange1 apple2 mango3 lemon

Theenumerate()function takes an iterable as an argument and generates tuples of the form(index, item). Note that the loop reads almost like plain English, which makes your code way more Pythonic than the previous version usingrange().

Theenumerate() function also takes an optional argument calledstart that lets you tweak the initial value. This feature is useful when you need to create counts. Consider the following example that mimics an option menu for a command-line application:

>>>defdisplay_menu(options):...print("Main Menu:")...forposition,optioninenumerate(options,start=1):...print(f"{position}.{option}")...>>>display_menu(["Open","Save","Settings","Quit"])Main Menu:1. Open2. Save3. Settings4. Quit

In this example, instead of usingenumerate() to produce zero-based indices, you start the count at1. From the end user’s perspective, starting the menu at1 is the natural way to go.

Looping Over Several Iterables in Parallel

Looping through two or more iterables in parallel may be another common task you encounter in Python programming. To do this, you can use the built-inzip() function, which takes two or more iterables andyields tuples that combine items from each iterable.

Consider the following toy example:

>>>numbers=[1,2,3]>>>letters=["a","b","c"]>>>fornumber,letterinzip(numbers,letters):...print(number,"->",letter)...1 -> a2 -> b3 -> c

In this example, you usezip(numbers, letters) to create an iterator that produces tuples of the form(number, letter). In this case, thenumber values are taken fromnumbers, and theletter values are taken fromletters.

Iterating Over Multiple Iterables Sequentially

There may be times when you need to iterate over multiple iterables sequentially in a single loop. In such cases, you can use thechain() function from Python’sitertoolsmodule.

For example, say that you have several lists of numbers and want to calculate the square of each number in all lists. You can usechain() as follows:

>>>fromitertoolsimportchain>>>first=[7,6,1]>>>second=[4,1]>>>third=[8,0,6]>>>forvalueinchain(first,second,third):...print(value**2)...4936116164036

This loops over all three lists in sequence and prints the square of each value. You can also usechain() to work through a list of lists. Say that you, again, need to process each value in a sequence and calculate its square:

>>>matrix=[...[9,3,8],...[4,5,2],...[6,4,3],...]>>>forvalueinchain(*matrix):...print(value**2)...819641625436169

In this example, you usechain() to iterate over the rows of the matrix. To feed the rows intochain(), you use the unpacking operator (*). Inside the loop, you calculate and print the square of each value.

Usingchain(), like in this example, essentiallyflattens the matrix into a single iterable, helping you avoid anested loop, which can be difficult to read and understand in some contexts.

Repeating Actions a Predefined Number of Times

Iteration is all about repeating some fragment of code multiple times. As you’ve learned so far,for loops are designed to repeat a given set of actions on the items of an iterable. However, you can also use this type of loop to quickly iterate a specific number of times. This is useful when you need to repeat a bunch of statements, but they don’t operate on the items of an iterable.

Here’s a fun example aboutPenny andSheldon to illustrate this:

>>>for_inrange(3):...print("Knock, knock, knock")...print("Penny!")...Knock, knock, knockPenny!Knock, knock, knockPenny!Knock, knock, knockPenny!

This loop runs three times and repeats a series of statements that don’t operate on any iterable. Note that the loop variable is a singleunderscore character in this example. This variable name communicates that you don’t need to use the loop variable inside the loop. It’s a throwaway variable.

With this looping construct that takes advantage ofrange(), you have full control over the number of times your code runs.

Iterating Over Reversed and Sorted Iterables

Iterating over the items of an iterable in reverse or sorted order is also a common requirement in programming. To achieve this, you can combine afor loop with the built-inreversed() orsorted() function, respectively.

For example, say that you’re working on a text editor and want to implement a basicUndo option. You can implement it with thereversed() function and a loop like the following:

>>>actions=["Type text","Select text","Cut text","Paste text"]>>>foractioninreversed(actions):...print(f"Undo:{action}")...Undo: Paste textUndo: Cut textUndo: Select textUndo: Type text

In this example, you have a list of hypothetical user actions in a text editor. The actions are stored in a list from oldest to newest. To implement theUndo operation, you need to reverse the actions, which you do withreversed().

To iterate in sorted order, say that you have a dictionary that maps student names to their corresponding average grades. You need to create a quick report and want to sort the data from highest to lowest grades. For this, you can do something like the following:

>>>students={..."Alice":89.5,..."Bob":76.0,..."Charlie":92.3,..."Diana":84.7,..."Ethan":88.9,..."Fiona":95.6,..."George":73.4,..."Hannah":81.2,...}>>>sorted_students=sorted(...students.items(),key=lambdaitem:item[1],reverse=True...)>>>forname,gradeinsorted_students:...print(f"{name}'s average grade:{grade:->{20-len(name)}.1f}")...Fiona's average grade: -----------95.6Charlie's average grade: ---------92.3Alice's average grade: -----------89.5Ethan's average grade: -----------88.9Diana's average grade: -----------84.7Hannah's average grade: ----------81.2Bob's average grade: -------------76.0George's average grade: ----------73.4

Thesorted() function returns a list of sorted values. In this example, you sort the dictionary by its values in ascending order. To do this, you use alambda function that takes a two-value tuple as an argument and returns the second item, which has an index of1. You also set thereverse argument toTrue so that the grades are ordered in descending order.

Thefor loop iterates over the sorted data and generates a nicely formatted report using anf-string with a customformat specifier.

Modifying the Loop Collection

Python hasmutable collections, such as lists and dictionaries, that you can modify in place. You may want to change a list while looping over it. In this situation, you need to distinguish betweensafe andunsafe changes.

For example, say that you have a list of names and want to convert them into uppercase. You may think of doing something like the following:

>>>names=["Alice","Bob","John","Jane"]>>>forindex,nameinenumerate(names):...names[index]=name.upper()...>>>names['ALICE', 'BOB', 'JOHN', 'JANE']

In this example, you only change the existing items in the list without adding or removing any. This operation is safe. However, modifying a mutable iterable like a list while iterating over it always raises a warning.

Issues may appear when you add or remove items from a list while iterating over it. To understand why this is best avoided, say that you want to remove all the even numbers from a list. You might write the following code:

>>>numbers=[2,4,6,8]>>>fornumberinnumbers:...ifnumber%2==0:...numbers.remove(number)...>>>numbers[4, 8]

After running the loop, some even numbers remain, even though you expected the list to be empty.

On the first iteration,2 is removed, and the list shifts left, becoming[4, 6, 8]. The loop then jumps to the next item, skipping4 and processing6 instead. Then6 is removed, and the list shifts again, becoming[4, 8]. The iteration ends before reaching8.

When you need to resize a list during iteration like in the example above, it’s recommended to create a copy of the list:

>>>numbers=[2,4,6,8]>>>fornumberinnumbers[:]:...ifnumber%2==0:...numbers.remove(number)...>>>numbers[]

The slicing operator ([:]) with no indices creates a copy of the original list for iteration purposes. The loop traverses the copy while removing values from the original list.

In some cases, creating a copy of the input list isn’t enough. Say that on top of removing even numbers, you want to calculate the square of odd numbers. You might modify the previous loop as shown in the following code:

>>>numbers=[2,1,4,6,5,8]>>>forindex,numberinenumerate(numbers[:]):...ifnumber%2==0:...numbers.remove(number)...else:...numbers[index]=number**2...Traceback (most recent call last):...ValueError:list.remove(x): x not in list

This time, you useenumerate() to generate index-item pairs. Then, you think of using the index to update the value of a given item. However, the code fails with aValueError exception. Creating a copy of the input list isn’t enough in this case. You’d have to make a separate list to store the result:

>>>numbers=[2,1,4,6,5,8]>>>processed_numbers=[]>>>fornumberinnumbers:...ifnumber%2!=0:...processed_numbers.append(number**2)...>>>processed_numbers[1, 25]

In this new loop implementation, you’re using a new list to store the result. Because of this, you don’t have to remove items anymore. You add the square values to the end of the new list using the.append() method.

Python doesn’t allow you to add or remove items from a dictionary while you’re iterating through it:

>>>values={"one":1,"two":2,"three":3,"four":4}>>>forvalueinvalues:...values["five"]=5# Attempt to add an item...Traceback (most recent call last):...RuntimeError:dictionary changed size during iteration>>>forvalueinvalues:...delvalues[value]# Attempt to remove an item...Traceback (most recent call last):...RuntimeError:dictionary changed size during iteration

If you try to expand or shrink a dictionary during iteration, you get aRuntimeError exception. Again, you can work around this by creating a copy of the dictionary using the.copy() method or by building a new dictionary with the resulting data.

Changing the Loop Variable

Changing the loop variable in the loop body doesn’t have an effect on the original data:

>>>names=["Alice","Bob","John","Jane"]>>>fornameinnames:...name=name.upper()...print(name)...ALICEBOBJOHNJANE>>>names['Alice', 'Bob', 'John', 'Jane']

In this example, the highlighted line changes the loop variable,name. This change doesn’t affect the original data in your list of names. The loop variable is just a temporary reference to the current item in the iterable, and reassigning it doesn’t affect the loop iterable.

Ignoring Possible Exceptions

If an exception occurs in a loop body and isn’t handled, the loop will terminate prematurely, skipping subsequent iterations. This result can generate unexpected issues, especially when you rely on the loop to process data, performlogging, or run cleanup actions in each iteration.

As an example, say that you want to process some text files in a loop:

>>>files=["file1.txt","file2.txt","file3.txt"]>>>forfileinfiles:...withopen(file,"r")asf:...print(f"Contents of{file}:")...print(f.read())...Traceback (most recent call last):...FileNotFoundError:[Errno 2] No such file or directory: 'file1.txt'

In this example, none of the files exist in your working directory. The loop tries to process the first file and fails with aFileNotFoundError exception. Because the exception wasn’t handled properly, the loop terminates in the first iteration, skipping the rest of the files in the list.

To avoid this behavior, you need to catch and handle the exception:

>>>files=["file1.txt","file2.txt","file3.txt"]>>>forfileinfiles:...try:...withopen(file,"r")asf:...print(f"Contents of{file}:")...print(f.read())...exceptFileNotFoundError:...print(f"Error:{file} not found. Skipping.")...Error: file1.txt not found. Skipping.Error: file2.txt not found. Skipping.Error: file3.txt not found. Skipping.

In this new implementation, the loop catches anyFileNotFoundError exception and prints an error message to the screen. The loop runs entirely without abrupt interruptions.