4d. For-Loops

Introduction

A key feature of programming is its ability to automate repetitive tasks. A standard way to implement this is via for-loops. They allow you to execute the same block of code, treating each element of a list as a different input.

For-loops are delimited with the keywords for and end. To illustrate this syntax, consider the function println(a), which evaluates a and displays its output in the REPL. In case a is a string, println(a) will simply display the word stored in a. The following script repeatedly applies println to display each word in a list.

for x in ["hello","beautiful","world"]
    println(x)
end

Remark

The keyword in can be replaced by ∈ or =. [note] Recall that ∈ can be written through Tab Completion using the command \in Consequently, the following are all equivalent.

in ∈ =

for x in ["hello","beautiful","world"] 
    println(x)
end

for x ∈ ["hello","beautiful","world"] 
    println(x)
end

for x = ["hello","beautiful","world"] 
    println(x)
end

Furthermore, we can use any term to describe the iteration variable.

An Alternative Name For The Iteration Variable

for word in ["hello","beautiful","world"] 
    println(word)
end

Output in REPL

"hello" "beautiful" "world"

Based on this example, we can identify three components that characterize a for-loop:

The following sections will demonstrate how different objects can be employed as lists. We'll also show that for-loops can iterate over elements that may not be immediately apparent, such as functions.

Always Wrap For-Loops in Functions

At this stage of the website, we're still introducing fundamental concepts. Thus, the subjects are presented as simple as possible. This is why for-loops in particular will be written in the global scope.

However, you should always wrap for-loops in functions. Executing for-loops outside a function severely degrades performance, and is additionally subject to different rules regarding variable scoping. [note] In fact, older versions of Julia were restricting the use of for-loops in the global scope.

About High Performance

For-loops can negatively impact performance in certain languages (e.g., Matlab, Python, and R). These languages recommend instead using vectorized code, which operates over the whole vector rather than its individual elements. In Part II of this website, we'll see that such a recommendation has no bearing on Julia. Indeed, for-loops are as fast as vectorized code, and speeding up operations in Julia commonly rely on them.

Rules for Variable Scope in For-Loops

Similar to functions, for-loops create a new scope for variables. In fact, the scoping rules for both are similar, with one key difference: for-loops can modify global variables, whereas functions cannot.

Warning!

The rules of variable scope we present apply generally, with one exception that arises from following bad practices. Since this case is rare, we won't cover it.

Basically, the issue occurs when i) the for-loop is not wrapped in a function, ii) a local variable shares its name with a global variable, and iii) the script is run non-interactively (i.e., run by using the function include). [note] Recall that there are two methods to execute a script, as we saw here. The first method is the one we're using, where you work interactively with Julia. This includes running commands in the REPL's prompt julia>and the execution of a script through a code editor. The second method consists of executing a file that stores a script, through the function include.

Unless the three conditions hold simultaneously, you don't have to worry about this scenario. And even if this occurs, Julia will display a warning in the REPL indicating that there's a problem with your code.

To formalize the variable scope of for-loops, we'll refer to a variable x. The rules governing its scope are:

The following code snippets illustrate the first two rules, which exclusively refer to local variables. The second example is particularly noteworthy, as it highlights a common mistake made by beginners: running a for-loop that defines a local variable, and then trying to access this outside the for-loop.

x = 2

for x in ["hello"]          # this 'x' is local, not related to 'x = 2'
    println(x)
end

#no `x` outside the for-loop

for word in ["hello"]
    x = word                # `x` is local to the for-loop, not available outside it
end

Likewise, the following example demonstrates the consequences of last rule we mentioned. This refers to the consequences of variable scope for global variables.

x = [2, 4, 6]

for i in eachindex(x)
    x[i] * 10        # it refers to the `x` outside of the for-loop
end

x = [2, 4, 6]

for word in ["hello"]
    x = word                        # it reassigns the `x` defined outside the for-loop
end

Multiple Iterations

Thus far, we've considered for-loops that iterate over single values. We now extend their application to iterate over multiple values. Specifically, we'll examine two scenarios: iterating simultaneously over two lists and iterating over both the indices and values of a vector.

Iterating over Two Lists

There are two ways to simultaneously iterate over two lists x and y, depending on the combination of elements desired. First, if you seek to iterate over all the possible combinations of their elements, you need the function Iterators.product(x,y). This is part of the package Iterators, which is imported by default in each Julia session.

Alternatively, you can iterate over all the ordered pairs of elements from x and y. This is implemented through the function zip(x,y). In this case, each iteration will consider the pair of i-th elements from x and y,

list1 = [1, 2]
list2 = [3, 4]

for (a,b) in Iterators.product(list1,list2) #it takes all possible combinations
    println([a,b])
end

list1 = [1, 2]
list2 = [3, 4]

for (a,b) in zip(list1,list2)               #it takes pairs of elements with the same index
    println([a,b])
end

It's also possible to iterate over multiple values via array comprehensions. While iteration over pairs still requires the function zip, iterating over all possible combinations can be achieved with a simpler syntax. This involves the inclusion of mutiple for clauses within the comprehension.

x = [i * j for i in 1:2 for j in 1:2]

x = [i * j for (i,j) in zip(1:2, 1:2)]

Simultaneously Iterating over Indices and Values

We can also iterate over each pair of index-value of a vector. This is implemented through the function enumerate.

x = ["hello", "world"]

for (index,value) in enumerate(x)
    println("$index $value")
end

x = [10, 20]


y = [index * value for (index,value) in enumerate(x)]