Loop for in Python: understanding and using it

“[An iterable is] an object capable of returning its members one at a time”/ Source: docs.python.org/3/glossary.html

Translation: “[An iterable is] an object whose values ​​can be traversed one by one” (translated by IONOS)

An iterable object has two properties:

1. It groups several elements to form a collection
2. It gives access to its elements via an interface called “iterator”

Together, this means that iterables are collections whose content can be iterated over. An iterable specifically has an ‘__iter__()’ method that returns an iterator. The iterator is an object that supplies the next element of the iterable on command . Additionally, an iterator recalls the position of the last element returned in the collection.

An iterator returns to the next element when calling the __next__() method. If all elements of the collection have been delivered , the iterator is exhausted. Another call to __next__() raises a ‘StopIteration’ exception.

Let’s consider how an iterator works using an example . We create a range() object that represents consecutive numbers 21 to 23. Then we create an iterator using the iter() function and we output successive elements using the next() function. On the last call, the exception is thrown because the iterator is exhausted:

<spannumbers = range(21, 24)
<spannumber = iter(numbers)
<spannext(number)
<span# returns '21'
<spannext(number)
<span# returns '22'
<spannext(number)
<span# returns '23'
<spannext(number)
<span"># raises 'StopIteration' exception

An iterator provides access to individual elements of a collection. Python also knows the similar concept of “generator”. The difference is that a builder only creates individual items at access time . Above all, this saves memory during the execution of the program, which is why we also speak of “lazy generation”.

A generator in Python is based on a function that uses the Yield statement. This returns an object in the same way as the return statement and terminates the function call . On a new call, however, the generator function does not start again from the beginning, but continues after the last yield statement.

The following example illustrates this point. We write our own version of the range() function . We use the yield statement in a while loop to generate continuous numbers:

<spandef my_range(start, stop):
<span    if stop < start:
<span        return None
<span    current = start
<span    while current < stop:
<span        yield current
<span        current += 1
<span# test
<spanassert list(my_range(7, 9)) == list(range(7, 9))

Skipping and undoing a pass of the for loop in Python

In practice, it is sometimes necessary to skip a single pass of the loop. Like many other languages, Python contains the “continue” statement. When calling continue in the loop body, the current iteration is terminated . The loop then immediately begins the next iteration.

A continue statement can be used similarly to early-return when calling a function . For example, we skip an iteration as soon as we find that a dataset does not have the required quality:

<spandef process_data(data):
<span    for data_set in data:
<span        data_set.validate()
<span        # early continue after cheap check fails
<span        if not data_set.quality_ok():
<span            continue
<span        # expensive operation guarded by early continue
<span        data_set.process()

Another example: we take a text and skip every other letter :

text = 'Skipping every second letter'
for index, letter in enumerate(text):
    if index % 2 != 0 and letter != ' ':
        continue
    print(letter)

In addition to the continue statement to skip a passage of the loop, there is the break statement. A call to break inside the loop body immediately breaks further execution of the loop . Thus, break has a similar function for loops as the return statement for functions.

The break statement is often used to implement search algorithms. If a searched element is found in a loop, there is no need to continue iterating. In the same way as for the any() function, we check the presence of a single True value in a list. With break, we stop as soon as we have found something:

bool_list = [False, False, True, False]
for index, boolean in enumerate(bool_list):
    if boolean:
        print(f"Value at position {index + 1} is True")
        print(f"Aborting inspection of remaining {len(bool_list) - index - 1} item(s)")
        break

Related to the break statement, a for loop in Python can have an optional else body. The code it contains is executed when the loop ends without a break statement having been executed:

def find_element(target, collection):
    for element in collection:
        if element == target:
            print("Found what you’re looking for")
            break
    else:
        print("Didn’t find what you were looking for")
# test
find_element('a', 'Python')
find_element('o', 'Python')

For loops are often used in Python inside function bodies. In this case, it is common to use a return statement instead of a break statement . Our search algorithm rephrases without using break and else:

def find_element(target, collection):
    for element in collection:
        if element == target:
            print("Found what you’re looking for")
            # returning breaks us out of the loop
            return element
    # we made it here without returning
    print("Didn’t find what you were looking for")
    return None
# test
print(find_element('a', 'Python'))
print(find_element('o', 'Python'))

word = 'Python'
for i in range(len(word)):
    print(word[i])

word = 'Python'
for letter in word:
    print(letter)

names = ["Jim", "Jack", "John"]
for index, name in enumerate(names):
    print(f"{index + 1}. {name}")

people = ('Jim', 'Jack', 'John')
ages = (42, 69, 13)
# ascertain both collections are same length
assert len(people) == len(ages)
# iterate over tuples of (person, age)
for person, age in zip(people, ages):
    print(f"{person} is {age} years old")

for counter in range(10):
    print(counter)

'a' in 'Python'
'y' in 'Python'

word = 'Python'
letters = []
for letter in word:
    letters.append(letter)

assert list(word) == letters

list(range(10))

alphabet = set('Python is not hyped')
assert 'a' not in alphabet

[ operation(element) for element in collection ]

[ operation(element) for element in collection if condition(element) ]

numbers = [2, 3, 5, 9, 17]

squares = []
for number in numbers:
    squares.append(number ** 2)

squares_comp = [number ** 2 for number in numbers]

assert squares == squares_comp

word = list("PyThoN")

lowers = []
for letter in word:
    if letter.islower():
        lowers.append(letter)

lowers_comp = [ letter for letter in word if letter.islower() ]

assert lowers == lowers_comp