What are loops?
➰
They can be termed simply as a way to repeatedly execute some code➿.
For example:
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.
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:
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:
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.
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
Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Here’s how we would do the same thing without a list comprehension:
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
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:
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:
“””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:
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!💌
