Chapter 4: Working with Lists

Looping is important because it’s one of the most common ways a computer automates repetitive tasks. For example, in a simple loop like we used in magicians.py, Python initially reads the first line of the loop:

This line tells Python to retrieve the first value from the list magicians and associate it with the variable magician. This first value is 'alice'. Python then reads the next line:

Python prints the current value of magician, which is still 'alice'. Because the list contains more values, Python returns to the first line of the loop, retrieves the next name 'david', and associates that value with the variable magician. Python then executes the print() call again. Python repeats the entire loop once more with the last value in the list, 'carolina'. Because no more values are in the list, Python moves on to the next line in the program. In this case nothing comes after the for loop, so the program ends.

When you’re using loops for the first time, keep in mind that the set of steps is repeated once for each item in the list, no matter how many items are in the list. If you have a million items in your list, Python repeats these steps a million times — and usually very quickly.

Also keep in mind when writing your own for loops that you can choose any name you want for the temporary variable that will be associated with each value in the list. However, it’s helpful to choose a meaningful name that represents a single item from the list. For example, here’s a good way to start a for loop for a list of cats, a list of dogs, and a general list of items:

These naming conventions can help you follow the action being done on each item within a for loop. Using singular and plural names can help you identify whether a section of code is working with a single element from the list or the entire list.

You can do just about anything with each item in a for loop. Let’s build on the previous example by printing a message to each magician, telling them that they performed a great trick:

The only difference in this code is where we compose a message to each magician, starting with that magician’s name. The first time through the loop the value of magician is 'alice', so Python starts the first message with the name 'Alice'. The second time through, the message will begin with 'David', and the third time through, the message will begin with 'Carolina'.

The output shows a personalized message for each magician in the list:

You can also write as many lines of code as you like in the for loop. Every indented line following the line for magician in magicians is considered inside the loop, and each indented line is executed once for each value in the list. Therefore, you can do as much work as you like with each value in the list.

Let’s add a second line to our message, telling each magician that we’re looking forward to their next trick:

Because we have indented both calls to print(), each line will be executed once for every magician in the list. The newline "\n" in the second print() call inserts a blank line after each pass through the loop. This creates a set of messages that are neatly grouped for each person in the list:

You can use as many lines as you like in your for loops. In practice, you’ll often find it useful to do a number of different operations with each item in a list when you use a for loop.

What happens once a for loop has finished executing? Usually, you’ll want to summarize a block of output or move on to other work that your program must accomplish.

Any lines of code after the for loop that are not indented are executed once without repetition. Let’s write a thank you to the group of magicians as a whole, thanking them for putting on an excellent show. To display this group message after all of the individual messages have been printed, we place the thank you message after the for loop, without indentation:

The first two calls to print() are repeated once for each magician in the list, as you saw earlier. However, because the last line is not indented, it’s printed only once:

When you’re processing data using a for loop, you’ll find that this is a good way to summarize an operation that was performed on an entire dataset. For example, you might use a for loop to initialize a game by running through a list of characters and displaying each character on the screen. You might then write some additional code after this loop that displays a Play Now button after all the characters have been drawn to the screen.

Always indent the line after the for statement in a loop. If you forget, Python will remind you:

When Python expects an indented block and doesn’t find one, it lets you know which line it had a problem with:

You can usually resolve this kind of indentation error by indenting the line or lines immediately after the for statement.

Sometimes your loop will run without any errors but won’t produce the expected result. This can happen when you’re trying to do several tasks in a loop and you forget to indent some of its lines.

For example, this is what happens when we forget to indent the second line in the loop that tells each magician we’re looking forward to their next trick:

Because Python finds at least one indented line after the for statement, it doesn’t report an error. As a result, the first print() call is executed once for each name in the list because it is indented. The second print() call is not indented, so it is executed only once after the loop has finished running. Because the final value associated with magician is 'carolina', she is the only one who receives the "looking forward to the next trick" message:

This is a logical error. The syntax is valid Python code, but the code does not produce the desired result because a problem occurs in its logic. If you expect to see a certain action repeated once for each item in a list and it’s executed only once, determine whether you need to simply indent a line or a group of lines.

If you accidentally indent a line that doesn’t need to be indented, Python informs you about the unexpected indent:

We don’t need to indent the print() call, because it isn’t part of a loop; hence, Python reports that error:

You can avoid unexpected indentation errors by indenting only when you have a specific reason to do so. In the programs you’re writing at this point, the only lines you should indent are the actions you want to repeat for each item in a for loop.

If you accidentally indent code that should run after a loop has finished, that code will be repeated once for each item in the list. Sometimes this prompts Python to report an error, but often this will result in a logical error.

For example, let’s see what happens when we accidentally indent the line that thanked the magicians as a group for putting on a good show:

This is another logical error, similar to the one in Forgetting to Indent Additional Lines. Because Python doesn’t know what you’re trying to accomplish with your code, it will run all code that is written in valid syntax. If an action is repeated many times when it should be executed only once, you probably need to unindent the code for that action.

The colon at the end of a for statement tells Python to interpret the next line as the start of a loop.

Python doesn’t know if you simply forgot the colon, or if you meant to write additional code to set up a more complex loop. If the interpreter can identify a possible fix it will suggest one, as it does here with expected ':'. Some errors have easy, obvious fixes thanks to the suggestions in Python’s tracebacks. Some errors are much harder to resolve, even when the eventual fix only involves a single character. Don’t feel bad when a small fix takes a long time to find — you are absolutely not alone in this experience.

4-1. Pizzas: Think of at least three kinds of your favorite pizza. Store these pizza names in a list, and then use a for loop to print the name of each pizza. Modify your for loop to print a sentence using the name of the pizza instead of printing just the name of the pizza. For each pizza, you should have one line of output containing a simple statement like I like pepperoni pizza. Add a line at the end of your program, outside the for loop, that states how much you like pizza. The output should consist of three or more lines about the kinds of pizza you like and then an additional sentence, such as I really love pizza!

4-2. Animals: Think of at least three different animals that have a common characteristic. Store the names of these animals in a list, and then use a for loop to print out the name of each animal. Modify your program to print a statement about each animal, such as A dog would make a great pet. Add a line at the end of your program, stating what these animals have in common. You could print a sentence, such as Any of these animals would make a great pet!

Python’s range() function makes it easy to generate a series of numbers. For example, you can use the range() function to print a series of numbers like this:

Although this code looks like it should print the numbers from 1 to 5, it doesn’t print the number 5:

In this example, range() prints only the numbers 1 through 4. This is another result of the off-by-one behavior you’ll see often in programming languages. The range() function causes Python to start counting at the first value you give it, and it stops when it reaches the second value you provide. Because it stops at that second value, the output never contains the end value, which would have been 5 in this case.

To print the numbers from 1 to 5, you would use range(1, 6):

This time the output starts at 1 and ends at 5:

If your output is different from what you expect when you’re using range(), try adjusting your end value by 1.

You can also pass range() only one argument, and it will start the sequence of numbers at 0. For example, range(6) would return the numbers from 0 through 5.

If you want to make a list of numbers, you can convert the results of range() directly into a list using the list() function. When you wrap list() around a call to the range() function, the output will be a list of numbers.

In the example in the previous section, we simply printed out a series of numbers. We can use list() to convert that same set of numbers into a list:

We can also use the range() function to tell Python to skip numbers in a given range. If you pass a third argument to range(), Python uses that value as a step size when generating numbers.

For example, here’s how to list the even numbers between 1 and 10:

In this example, the range() function starts with the value 2 and then adds 2 to that value repeatedly until it reaches or passes the end value, 11:

You can create almost any set of numbers you want to using the range() function. For example, consider how you might make a list of the first 10 square numbers (that is, the square of each integer from 1 through 10). In Python, two asterisks (**) represent exponents. Here’s how you might put the first 10 square numbers into a list:

Finally, when the loop has finished running, the list of squares is printed:

To write this code more concisely, omit the temporary variable square and append each new value directly to the list:

This line does the same work as the lines inside the for loop in the previous listing. Each value in the loop is raised to the second power and then immediately appended to the list of squares.

You can use either of these approaches when you’re making more complex lists. Sometimes using a temporary variable makes your code easier to read; other times it makes the code unnecessarily long. Focus first on writing code that you understand clearly, and does what you want it to do. Then look for more efficient approaches as you review your code.

A few Python functions are helpful when working with lists of numbers. For example, you can easily find the minimum, maximum, and sum of a list of numbers:

The approach described earlier for generating the list squares consisted of using three or four lines of code. A list comprehension allows you to generate this same list in just one line of code. A list comprehension combines the for loop and the creation of new elements into one line, and automatically appends each new element. List comprehensions are not always presented to beginners, but I’ve included them here because you’ll most likely see them as soon as you start looking at other people’s code.

The following example builds the same list of square numbers you saw earlier but uses a list comprehension:

To use this syntax, begin with a descriptive name for the list, such as squares. Next, open a set of square brackets and define the expression for the values you want to store in the new list. In this example the expression is value2, which raises the value to the second power. Then, write a for loop to generate the numbers you want to feed into the expression, and close the square brackets. The for loop in this example is for value in range(1, 11), which feeds the values 1 through 10 into the expression value2. Note that no colon is used at the end of the for statement.

The result is the same list of square numbers you saw earlier:

It takes practice to write your own list comprehensions, but you’ll find them worthwhile once you become comfortable creating ordinary lists. When you’re writing three or four lines of code to generate lists and it begins to feel repetitive, consider writing your own list comprehensions.

4-3. Counting to Twenty: Use a for loop to print the numbers from 1 to 20, inclusive.

4-4. One Million: Make a list of the numbers from one to one million, and then use a for loop to print the numbers. (If the output is taking too long, stop it by pressing Ctrl+C or by closing the output window.)

4-5. Summing a Million: Make a list of the numbers from one to one million, and then use min() and max() to make sure your list actually starts at one and ends at one million. Also, use the sum() function to see how quickly Python can add a million numbers.

4-6. Odd Numbers: Use the third argument of the range() function to make a list of the odd numbers from 1 to 20. Use a for loop to print each number.

4-7. Threes: Make a list of the multiples of 3, from 3 to 30. Use a for loop to print the numbers in your list.

4-8. Cubes: A number raised to the third power is called a cube. For example, the cube of 2 is written as 2**3 in Python. Make a list of the first 10 cubes (that is, the cube of each integer from 1 through 10), and use a for loop to print out the value of each cube.

4-9. Cube Comprehension: Use a list comprehension to generate a list of the first 10 cubes.

To make a slice, you specify the index of the first and last elements you want to work with. As with the range() function, Python stops one item before the second index you specify. To output the first three elements in a list, you would request indices 0 through 3, which would return elements 0, 1, and 2.

The following example involves a list of players on a team:

This code prints a slice of the list. The output retains the structure of the list, and includes the first three players in the list:

You can generate any subset of a list. For example, if you want the second, third, and fourth items in a list, you would start the slice at index 1 and end it at index 4:

This time the slice starts with 'martina' and ends with 'florence':

If you omit the first index in a slice, Python automatically starts your slice at the beginning of the list:

A similar syntax works if you want a slice that includes the end of a list. For example, if you want all items from the third item through the last item, you can start with index 2 and omit the second index:

Python returns all items from the third item through the end of the list:

This syntax allows you to output all of the elements from any point in your list to the end, regardless of the length of the list. Recall that a negative index returns an element a certain distance from the end of a list; therefore, you can output any slice from the end of a list. For example, if we want to output the last three players on the roster, we can use the slice players[-3:]:

This prints the names of the last three players and will continue to work as the list of players changes in size.

You can use a slice in a for loop if you want to loop through a subset of the elements in a list. In the next example, we loop through the first three players and print their names as part of a simple roster:

Slices are very useful in a number of situations. For instance, when you’re creating a game, you could add a player’s final score to a list every time that player finishes playing. You could then get a player’s top three scores by sorting the list in decreasing order and taking a slice that includes just the first three scores. When you’re working with data, you can use slices to process your data in chunks of a specific size. Or, when you’re building a web application, you could use slices to display information in a series of pages with an appropriate amount of information on each page.

Often, you’ll want to start with an existing list and make an entirely new list based on the first one. To copy a list, you can make a slice that includes the entire original list by omitting the first index and the second index ([:]). This tells Python to make a slice that starts at the first item and ends with the last item, producing a copy of the entire list.

For example, imagine we have a list of our favorite foods and want to make a separate list of foods that a friend likes. This friend likes everything in our list so far, so we can create their list by copying ours:

When we print each list, we see that they both contain the same foods:

To prove that we actually have two separate lists, we’ll add a new food to each list and show that each list keeps track of the appropriate person’s favorite foods:

The output shows that 'cannoli' now appears in our list of favorite foods but 'ice cream' does not, and vice versa for our friend’s list.

If we had simply set friend_foods equal to my_foods, we would not produce two separate lists. For example, here’s what happens when you try to copy a list without using a slice:

Instead of assigning a copy of my_foods to friend_foods, we set friend_foods equal to my_foods. This syntax actually tells Python to associate the new variable friend_foods with the list that is already associated with my_foods, so now both variables point to the same list. As a result, when we add 'cannoli' to my_foods, it will also appear in friend_foods. The output shows that both lists are now the same, which is not what we wanted:

4-10. Slices: Using one of the programs you wrote in this chapter, add several lines to the end of the program that do the following: print the message The first three items in the list are:, then use a slice to print the first three items from that program’s list. Print the message Three items from the middle of the list are:, then use a slice to print three items from the middle of the list. Print the message The last three items in the list are:, then use a slice to print the last three items in the list.

4-11. My Pizzas, Your Pizzas: Start with your program from Exercise 4-1. Make a copy of the list of pizzas, and call it friend_pizzas. Then add a new pizza to the original list, add a different pizza to the list friend_pizzas, and prove that you have two separate lists. Print the message My favorite pizzas are:, and then use a for loop to print the first list. Print the message My friend’s favorite pizzas are:, and then use a for loop to print the second list. Make sure each new pizza is stored in the appropriate list.

4-12. More Loops: All versions of foods.py in this section have avoided using for loops when printing, to save space. Choose a version of foods.py, and write two for loops to print each list of foods.

A tuple looks just like a list, except you use parentheses instead of square brackets. Once you define a tuple, you can access individual elements by using each item’s index, just as you would for a list.

For example, if we have a rectangle that should always be a certain size, we can ensure that its size doesn’t change by putting the dimensions into a tuple:

We define the tuple dimensions using parentheses instead of square brackets. Then we print each element in the tuple individually:

Let’s see what happens if we try to change one of the items in the tuple dimensions:

This code tries to change the value of the first dimension, but Python returns a type error:

This is beneficial because we want Python to raise an error when a line of code tries to change the dimensions of the rectangle.

You can loop over all the values in a tuple using a for loop, just as you did with a list:

Python returns all the elements in the tuple:

Although you can’t modify a tuple, you can assign a new value to a variable that represents a tuple. For example, if we wanted to change the dimensions of this rectangle, we could redefine the entire tuple:

The first four lines define the original tuple and print the initial dimensions. We then associate a new tuple with the variable dimensions, and print the new values. Python doesn’t raise any errors this time, because reassigning a variable is valid:

When compared with lists, tuples are simple data structures. Use them when you want to store a set of values that should not be changed throughout the life of a program.

4-13. Buffet: A buffet-style restaurant offers only five basic foods. Think of five simple foods, and store them in a tuple. Use a for loop to print each food the restaurant offers. Try to modify one of the items, and make sure that Python rejects the change. The restaurant changes its menu, replacing two of the items with different foods. Add a line that rewrites the tuple, and then use a for loop to print each of the items on the revised menu.

When someone wants to make a change to the Python language, they write a Python Enhancement Proposal (PEP). One of the oldest PEPs is PEP 8, which instructs Python programmers on how to style their code. PEP 8 is fairly lengthy, but much of it relates to more complex coding structures than what you’ve seen so far.

The Python style guide was written with the understanding that code is read more often than it is written. You’ll write your code once and then start reading it as you begin debugging. When you add features to a program, you’ll spend more time reading your code. When you share your code with other programmers, they’ll read your code as well.

Given the choice between writing code that’s easier to write or code that’s easier to read, Python programmers will almost always encourage you to write code that’s easier to read. The following guidelines will help you write clear code from the start.

PEP 8 recommends that you use four spaces per indentation level. Using four spaces improves readability while leaving room for multiple levels of indentation on each line.

In a word processing document, people often use tabs rather than spaces to indent. This works well for word processing documents, but the Python interpreter gets confused when tabs are mixed with spaces. Every text editor provides a setting that lets you use the Tab key but then converts each tab to a set number of spaces. You should definitely use your Tab key, but also make sure your editor is set to insert spaces rather than tabs into your document.

Mixing tabs and spaces in your file can cause problems that are very difficult to diagnose. If you think you have a mix of tabs and spaces, you can convert all tabs in a file to spaces in most editors.

Many Python programmers recommend that each line should be less than 80 characters. Historically, this guideline developed because most computers could fit only 79 characters on a single line in a terminal window. Currently, people can fit much longer lines on their screens, but other reasons exist to adhere to the 79-character standard line length.

Professional programmers often have several files open on the same screen, and using the standard line length allows them to see entire lines in two or three files that are open side by side onscreen. PEP 8 also recommends that you limit all of your comments to 72 characters per line, because some of the tools that generate automatic documentation for larger projects add formatting characters at the beginning of each commented line.

The PEP 8 guidelines for line length are not set in stone, and some teams prefer a 99-character limit. Don’t worry too much about line length in your code as you’re learning, but be aware that people who are working collaboratively almost always follow the PEP 8 guidelines. Most editors allow you to set up a visual cue, usually a vertical line on your screen, that shows you where these limits are.

To group parts of your program visually, use blank lines. You should use blank lines to organize your files, but don’t do so excessively. By following the examples provided in this book, you should strike the right balance. For example, if you have five lines of code that build a list and then another three lines that do something with that list, it’s appropriate to place a blank line between the two sections. However, you should not place three or four blank lines between the two sections.

Blank lines won’t affect how your code runs, but they will affect the readability of your code. The Python interpreter uses horizontal indentation to interpret the meaning of your code, but it disregards vertical spacing.

PEP 8 has many additional styling recommendations, but most of the guidelines refer to more complex programs than what you’re writing at this point. As you learn more complex Python structures, I’ll share the relevant parts of the PEP 8 guidelines.

4-14. PEP 8: Look through the original PEP 8 style guide at python.org/dev/peps/pep-0008. You won’t use much of it now, but it might be interesting to skim through it.

4-15. Code Review: Choose three of the programs you’ve written in this chapter and modify each one to comply with PEP 8. Use four spaces for each indentation level. Set your text editor to insert four spaces every time you press the Tab key, if you haven’t already done so (see Appendix B for instructions). Use less than 80 characters on each line, and set your editor to show a vertical guideline at the 80th character position. Don’t use blank lines excessively in your program files.

D4-1. Node Loop: Create a list of all your Domus Digitalis node hostnames (hypervisors, routers, k3s master, FreeIPA, Vault, ISE homelab, NAS). Use a for loop to print a status message for each, such as Checking health: kvm-01. After the loop, print a summary line like Health check complete for all nodes.

D4-2. VLAN Range: Your VLAN IDs are not contiguous. Use range() and a step to generate a list of VLAN IDs from 10 to 40, stepping by 10 (DATA, VOICE, GUEST, IoT). Print each one with a label like VLAN 10 — DATA.

D4-3. Square Latency: Create a list of simulated round-trip latency values in milliseconds — the squares of integers from 1 through 8 — using a list comprehension. Print the list. Then use min(), max(), and sum() to print the minimum, maximum, and total latency values.

D4-4. Stack Slice: Define a list of your full Domus Digitalis software stack in the order services start (VyOS, FreeIPA, Vault, Bind, k3s, Wazuh, Gitea, MinIO). Use slices to print the first three services (core networking layer), the middle two (PKI and DNS), and the last three (workload layer). Add a label before each slice.

D4-5. Immutable VLAN Core: Define a tuple called core_vlans containing the IDs and names of your three most critical VLANs as strings (e.g., 'VLAN 100 — INFRA'). Loop through the tuple and print each entry. Then try to modify one entry and confirm Python rejects it. Finally, redefine the entire tuple with an updated set of core VLANs and loop through it again.

C4-1. Policy Loop: Create a list of ISE policy set names. Use a for loop to print a message for each, such as Evaluating policy set: 802.1X Wired. After the loop, print a line like All policy sets evaluated.

C4-2. Syslog Source Range: Your Monad pipeline ingests syslog from multiple sources numbered 1 through 6 (e.g., ISE nodes, FTD, Wazuh). Use range(1, 7) and a for loop to print a message for each source number like Connecting to syslog source 3.

C4-3. Log Volume Math: Use a list comprehension to generate a list representing estimated daily log volumes (in thousands) for each of 7 days, calculated as day ** 2 * 5. Print the list, then print the min(), max(), and sum().

C4-4. Pipeline Slice: Define a list representing the stages of your Monad → Sentinel pipeline in order (e.g., ingest, normalize, enrich, route, store-hot, store-cold, alert). Use slices to print the first two stages (ingestion), the middle three (processing), and the last two (output). Label each slice clearly.

C4-5. Immutable Node Tuple: Define a tuple called ise_nodes containing the hostnames of your production ISE nodes. Loop through the tuple to print each hostname. Try to add a node by index assignment and confirm Python rejects it. Then redefine the tuple to simulate adding a new node and loop through it again.

L4-1. Service Loop: Create a list of systemd services you manage on Rocky Linux. Use a for loop to print Starting: <service> for each. After the loop, print All services started.

L4-2. Port Range: Use range() to generate a list of common privileged ports: 22, 80, 443, 8080, 8443 (use a hand-crafted list if range() doesn’t fit cleanly). Loop through them and print Checking port: <port>.

L4-3. Filesystem Math: Use a list comprehension to build a list of simulated filesystem usage percentages: the square root approximation value * 7 % 100 for values 1 through 10 (use integer math). Print the list, then print min(), max(), and sum().

L4-4. Log Slice: Define a list of 10 recent syslog event descriptions in chronological order. Use slices to print the first three (oldest events), three from the middle, and the last three (most recent events). Label each group.

L4-5. Immutable Nameservers: Define a tuple called nameservers containing your three DNS server IPs. Loop through the tuple and print each one with a label like Nameserver: 10.100.0.1. Try to change one value by index and confirm Python rejects it. Then redefine the tuple to simulate a nameserver change.

E4-1. Vocabulary Loop: Create a list of at least six Spanish words from your current Don Quijote reading. Use a for loop to print each word. After the loop, print Repaso completo.

E4-2. Chapter Range: Use range(1, 31) to represent the chapters of Don Quijote you’ve read so far. Use a for loop to print Capítulo <N> — leído. for the first five chapters only, using a slice.

E4-3. Study Session Math: Use a list comprehension to generate a list of cumulative study minutes for 7 days, calculated as day * 25. Print the list. Use sum() to print total minutes studied, and max() to print your longest session.

E4-4. Verb Conjugation Slice: Define a list of at least eight conjugated forms of a Spanish verb (e.g., all forms of ser or ir across tenses). Use slices to print the first three (present tense), three from the middle (past tense), and the last two (future/conditional). Label each group by tense.

E4-5. Immutable DELE Levels: Define a tuple called dele_levels containing all DELE proficiency levels in order from A1 to C2. Loop through the tuple and print each level. Try to reassign one level by index and confirm Python rejects it. Then redefine the tuple to include an unofficial C2+ level and loop through the updated tuple.