Mastering Python iteration: Loops and the magic of list comprehensions

What are loops?

➰
They can be termed simply as a way to repeatedly execute some code➿.

For example:

planets= ['mercury','venus','earth','mars','jupyter','saturn','uranus','neptune']
for planet in planets:
print(planet,end='')

# The end='' overrides the \n behavior and instead adds a space ('') after each planet name

output: Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune 

The for loop specifies:

The variable names to use in this case, ‘planet’
The set of values to loop over ‘planets’
You use the word ‘in’ to link them together.

NB :The object right to the ‘in’ can be thought of as a set of a group of things you can probably loop over.

We can also iterate over elements in a tuple. Difference between lists and tuples is that tuple elements are put inside parenthesis and they are immutable i.e. cannot be assigned new values to them once assigned.

multiplicands=(2,2,2,3,3,5)
product = 1
for mult in multiplicands:
product=product*mult

product

Output:360

Multiplicands holds the values to be multiplied together. The ‘product=1’ initializes the variable product that will be used to store the final multiplication answer. ‘for mult in multiplicands’ is a for loop that iterates over each number represented by variable ‘mult’ in the multiplicands tuple.
‘product = product * mult’ is a line executed for each iteration on the loop.

• Retrieves the current value of the product variable.
• Multiplies it with the current mult value from the tuple.
• Assigns the result back to the product variable, updating it with the new product.
• The code effectively multiplies together all the numbers in the multiplicands tuple, resulting in 2 x 2 x 2 x 3 x 3 x 5 = 360. You can even loop through each character in a string:

s = 'steganograpHy is the practicE of conceaLing a file, message, image, or video within another fiLe, message, image, Or video.'
msg = ''
# print all the uppercase letters in s, one at a time

for char in s:
if char.isupper():
print(char)

output: HELLO

Range()
A function that returns a sequence of numbers and is very useful in writing loops. For instance, if we want to repeat some action 5 times:

for i in range(5):
print('Doing important work.i=',i)
Output:
Doing important work. i = 0
Doing important work. i = 1
Doing important work. i = 2
Doing important work. i = 3
Doing important work. i = 4

In this case the loop variable is named i and range(5) generates a sequence of numbers from 0 to 5.In each iteration, the value of i is inserted into the string using string formatting. So the printing is done 5 times equivalent to the sequence range.

While loops➰
Iterate until some condition is met.

i=0
while i<10:
print(i)
i+= 1 #increase the value of i by 1
output: 0 1 2 3 4 5 6 7 8 9 

List Comprehensions
Are one of python’s most beloved features. The easiest way of understanding them is to probably look at examples.

squares= [n**2 for n in range(10)]
squares

Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Here’s how we would do the same thing without a list comprehension:

squares=[]
for n in range(10):
squares.append(n**2)
squares

Output:[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

We can also add an ‘if’ condition

short_planets = [planet for planet in planets if len(planet) < 6]
short_planets

Output: ['Venus', 'Earth', 'Mars']

(If you’re familiar with SQL, you might think of this as being like a “WHERE” clause)

Here’s an example for filtering with an ‘if’ condition and applying some transformations to the loop variable:

# str.upper() returns all-caps version of a string
loud_short_planets=[planet.upper() + '!' for planet in planets if len(planet)<6]
loud_short_planets

Output:['VENUS!', 'EARTH!', 'MARS!']

People usually write these on a single line, but you might find the structure clearer when split into 3 lines:

[
planet.upper()+'!'
for planet in planets
if len(planet)<6
]
Output: ['VENUS!', 'EARTH!', 'MARS!']

Continuing in the SQL analogy, you could think of these 3 lines as SELECT, FROM and WHERE.

List comprehensions combined with functions like min, max and sum can lead to impressive one-line solutions for problems that would otherwise require several lines of code.

For example compare the following two cells of code that do the same thing:

def count_negatives(nums):
"""Return the number of negative numbers in the given list.
>>> count_negatives([5, -1, -2, 0, 3])
    2
    """
n_negative=0
for num in nums:
if num<0:
n_negative=n_negative + 1
return n_negative

Here is a code using list comprehension instead:

def count_negatives(nums):
return len([num for num in nums if num<0])

Much better right? Especially in terms of lines of code.

Solving a problem with less code is always nice, but it’s worth keeping in mind the following lines from The Zen of Python:

Readability counts
Explicit is better than implicit
So use tools that make compact readable programs. But when you have to choose, favor code that is easy for others to understand.

A special thanks to the Kaggle community for their contributions to open-source data and code. This article benefitted greatly from the resources available on their platform: https://www.kaggle.com/.

Thank you!💌