Repeated Iterations (Loops)

Repeating Code

numbers = [2, 3, 5]

squared = list()

squared.append(numbers[0] ** 2)
squared.append(numbers[1] ** 2)
squared.append(numbers[2] ** 2)
squared

[4, 9, 25]

There are times while coding where we may want to repeat the same action multiple times.

Let’s say we want to add the square of every number in a list to a new list.

We could write code that looked something like this, but it’s problematic for numerous reasons.

squared = list()

squared.append(numbers[0] ** 2)
squared.append(numbers[1] ** 2)
squared.append(numbers[2] ** 2)
squared

[4, 9, 25]

This kind of coding exhibits bad programming practices such as :

• Difficult to scale

• Difficult to modify

• Clarity

This kind of coding exhibits bad programming practices such as :

• Difficult to scale: This only works for a list with 3 elements. If we want to do this for a list of a different length, we would need to add or remove code.

• Difficult to modify: If we want to change this code’s functionality, we need to change 3 very similar lines of code.

• Clarity: It is hard to understand what it does just by looking at it.

Don’t Repeat Yourself (DRY Principle)

The DRY in the DRY principle stands for “Don’t Repeat Yourself”. It is the principle of avoiding redundancy within code.

squared = list()

squared.append(numbers[0] ** 2)
squared.append(numbers[1] ** 2)
squared.append(numbers[2] ** 2)
squared

[4, 9, 25]

Just like how we try to reduce, reuse, and recycle waste, coding likes to borrow a similar principle aimed at reducing repetitive code.

This motion is called the DRY principle, otherwise known as the “Don’t Repeat Yourself” principle.

The premise of this principle to avoid redundancy within code.

The code we discussed here is a violation of this principle (known as a WET Solution (“write every time”)).

There is a much more efficient method to obtain the same output that avoids typing out multiple iterations of similar code.

Loops

numbers = [2, 3, 5]

squared = list()

squared.append(numbers[0] ** 2)
squared.append(numbers[1] ** 2)
squared.append(numbers[2] ** 2)
squared

[4, 9, 25]

squared = list()
for number in numbers: 
    squared.append(number ** 2)
squared

[4, 9, 25]

Our example from before takes 3 lines of code to add all the squared values to squared and violates the DRY principle in the process.

Instead, we can add to the list named squared by using something called a loop to repeat the .append() action over the multiple elements.

This only took 2 lines of code, but if the number of elements in the list numbers increased, the code would remain the same. Think how much code writing we would avoid if the list numbers had a length of 1000?!

For (Each) Loop

squared = list()
for number in numbers: 
    squared.append(number ** 2)
squared

[4, 9, 25]

This specific type of loop is called a For loop and can be iterated over any type of collection/sequence (these are lists, tuples, and strings).

In this example, it’s over the values in a list.

Every line of code that is indented is executed for each value in the list (hence the name “for” loops, sometimes also called “for each” loops).

Here we only have one line that is indented and repetitively executed for each element.

The loop ends after the variable has iterated over all the values in the collection/sequence.

Before entering the loop, we make an empty list named squared.

squared = list()
numbers = [ 2, 3, 5]

for number in numbers: 
    squared.append(number ** 2)

squared

[4, 9, 25]

squared = list()
numbers = [ 2, 3, 5]

for thingamajig in numbers: 
    squared.append(thingamajig ** 2)

squared

[4, 9, 25]

Our loop begins with the keyword for, and we make a new variable named number.

This refers to an element in the list numbers.

We could name this new variable anything so long as we reference the same name later on in the loop.

Here we can change number to the name thingamajig so long as we change the object name in both the construction of the loop as well as in .append().

squared = list()

for number in numbers: 
    squared.append(number ** 2)

squared

[4, 9, 25]

Loops have a similar structure to conditions in that the first line must end with a colon (:), and everything within the loop must have a 4-space indentation to differentiate it from code outside the loop.

We first start with the first number in the list numbers, which is 2.

We then calculate the square of 2 as 4 and append it to the empty list called squared.

When we have finished all the code for the first element, we move to the second element in numbers which has a value of 3.

We calculate the square of 3 as 9 and append it to the existing list squared.

We then move onto the last element, which has a value of 5.

We square the number 5, which results in 25 and append it to the existing list squared.

This is where the loop ends since there are no more values in the list numbers and so it executes the next line of code, which is displaying object squared.

Here we can see exactly what steps are happening altogether.

The first element, 2, gets squared and added to the new list squared.

Then element 3, followed by the last element 5 where the loop stops and displays the new list squared.

Let’s apply what we learned!