Iterating Over Lists, Tuples, and Dictionaries

Iterating means going through each item in a collection one at a time. In Python, collections like lists, tuples, and dictionaries hold multiple pieces of data. To work with each piece individually, you use a for loop. This is the most common way to iterate in Python. The for loop gives you a temporary variable that takes the value of the current element, runs a block of code once for that element, then moves to the next element until every element has been processed.

Let’s start with a list. A list is an ordered, changeable collection written inside square brackets, like fruits = ['apple', 'banana', 'cherry']. To iterate over it:

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

The loop runs three times: first fruit = 'apple', then fruit = 'banana', then fruit = 'cherry'. It stops automatically. The variable name fruit is up to you — it holds a reference to the current element. The colon : starts the block of code that runs each iteration. The indented lines under the for statement define that block. Python uses indentation to group code, so every line that is indented at the same level belongs to the loop.

Tuples work almost identically. A tuple is written in parentheses, like coordinates = (10, 20, 30). Tuples are immutable — they cannot be changed after creation. The iteration is exactly the same:

coordinates = (10, 20, 30)
for coord in coordinates:
    print(coord)

Dictionaries are different. They store key-value pairs: each element has a unique key and an associated value. For example, student = {'name': 'Alice', 'age': 22, 'grade': 'A'}. To iterate over a dictionary, you can loop over its keys, values, or both. By default, iterating over a dictionary gives you the keys:

student = {'name': 'Alice', 'age': 22, 'grade': 'A'}
for key in student:
    print(key)  # prints name, age, grade

To get the values, use the .values() method:

for value in student.values():
    print(value)  # prints Alice, 22, A

To get both keys and values together as pairs, use the .items() method. This gives you a tuple of (key, value) for each iteration:

for key, value in student.items():
    print(f"{key}: {value}")

The f"" is an f-string, which lets you insert variables directly into the text. In this case, it prints "name: Alice", "age: 22", and so on.

Why does iteration exist? Before loops, you would have to write print(fruits[0]), print(fruits[1]), print(fruits[2]) for each element. That is fine for three fruits but impractical for a list of 10,000 customer names. Loops automate this repetition, making code shorter, easier to read, and less error-prone.

A critical rule: you cannot iterate over an integer or a floating-point number directly. Only sequences (like lists, tuples, strings) and mappings (dictionaries) support iteration. Attempting for x in 5: raises a TypeError.

Another important concept is the range() function. When you need to iterate a specific number of times, range() generates a sequence of numbers. For example, range(5) produces numbers 0, 1, 2, 3, 4. Combined with len(), you can iterate over a list by index:

fruits = ['apple', 'banana', 'cherry']
for i in range(len(fruits)):
    print(i, fruits[i])

This prints the index and the element. But using for fruit in fruits: is simpler and preferred unless you need the index.

You can also iterate over strings. A string is a sequence of characters. This loop prints each character:

word = 'hello'
for char in word:
    print(char)

Remember that dictionaries are unordered in older Python versions (before 3.7). In Python 3.7 and later, dictionaries preserve insertion order, but the exam may test that you must not rely on order if you are writing for compatibility. The PCEP-30-02 exam covers all these details.

Finally, you cannot modify a collection while iterating over it directly. If you try to delete an element from a list while you are iterating, you will skip elements or get errors. The safe way is to iterate over a copy (using [:] or list(original)) or collect items to remove and delete them after the loop.

Practice: write a loop that sums all numbers in a list [10, 20, 30]. You need an accumulator variable initialised to 0, then add each number inside the loop. This is a pattern you will use often.

Let’s summarise the types of iteration you will see in the exam:

Each of these is a common exam question. Know them by heart.

An IT professional working in e-commerce needs to generate a daily sales report. They have a list of sales amounts from yesterday, stored as a Python list: sales = [245.50, 189.99, 310.00, 150.75, 422.30]. They need to calculate the total revenue and identify which sales were above $200. Without iteration, they would have to manually add each number. With a loop, they write a few lines of code that automatically process all five (or five thousand) sales.

The process goes like this: first, the IT professional opens their Python script or Jupyter notebook. They define a variable total = 0 to hold the running total. Then they write a for loop:

for sale in sales:
    total += sale
    if sale > 200:
        print(f"Sale of ${sale:.2f} is above $200")

The += operator adds the current sale amount to the total. The if statement checks each sale. In one minute, the code produces the total and flags all high-value sales. This is vastly faster than doing it by hand.

Now imagine the company also stores product details in a dictionary: each product has a unique product ID as the key and its price as the value. The IT professional needs to apply a 10% discount to all products and output new prices. They can iterate over the dictionary items:

products = {'P001': 25.00, 'P002': 50.00, 'P003': 15.00}
for prod_id, price in products.items():
    discounted = price * 0.9
    print(f"{prod_id}: new price ${discounted:.2f}")

Notice that the original dictionary is not changed. If the professional needed to update the dictionary, they would need to write back into it carefully, because modifying a dictionary while iterating can cause errors. Instead, they might build a new dictionary.

Another real-world scenario: a system administrator has a list of server IP addresses stored as a tuple (because the list of servers should never change). They need to ping each server to check if it is online. The tuple servers = ('192.168.1.1', '192.168.1.2', '192.168.1.3') is iterated over, and each IP is passed to a ping function. If one server fails, the admin records it in a separate list. The immutability of the tuple guarantees that no code accidentally changes the server list.

What tools are used? - Python IDEs like PyCharm or VS Code for writing loops - Jupyter Notebooks for quick data analysis - time module to measure how long iteration takes (important for performance optimisation) - csv module to read files line by line, where each line is processed in a loop - pandas library for large-scale data manipulation (but the exam focuses on pure Python)

In practice, IT professionals often chain loops: first they iterate over a list of customer IDs, then inside that loop they iterate over a dictionary of orders for each customer. This is called nested iteration. For example, each customer ID from a list points to a dictionary of their orders, and the loop extracts the total per customer.

The step-by-step action in business:

This is how real code works. The loop is the engine that drives most data processing in Python.