Mastering Python iteration: Loops and the magic of list comprehensions
Tags: beginners, python, lists, loops
Published: 2024-04-08 09:11:24


![An image illustrating loops in python](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/m254epjtf69mpbbowzbj.jpeg)
**<h2>What are loops?</h2>** ➰
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!💌