Nested Loops in Python

In Python, if we define a loop inside the loop, that loop will be called the nested loop. In this Python tutorial, we will learn how to define nested loops in Python and how loop control statements work with nested loops. So let's get started.

What are nested loops in Python?

In Python, to create loops, we only have two keywords for and while , which are also known as for loop and while loop. To create a nested loop, we can define a loop inside a loop. For example, we can define a for loop inside a while loop, a while loop inside a for loop, a for loop inside a for loop, or a while loop inside a while loop.

In the nested loop, the first loop is known as the outer loop, and the nested loop is known as the inner loop. If both the loops outer and inner have the iteration range of N, then the total number of times the loops will be executed is N ² times. Nested loops are generally used when we work with multidimensional arrays and multi-structural data structures.

How to create a Nested for loop in Python?

Python for loop is not just a loop but also an iterator. Using a for loop in Python, we can iterate over iterable objects like string, list, tuple, dictionary, set, etc. To create a nested for loop in Python, we can define a for loop inside a for loop.

Syntax

The syntax for creating a nested for loop in Python is as follows:

#outer loop
for i in sequence1:
    #outer loop body
    #inner loop
    for j in sequence2:
        #inner loop body

In the above example, you can see that the inner loop j is inside the body of the outer loop i , making it a nested for loop. Now let's discuss some examples of nested for loops.

Example 1

In our first example, we will use the nested for loop to create a 3X3 matrix in Python. We will take the help of a nested for loop to accept the data for all the rows and columns and use another nested for loop to print that matrix.

Algorithm

• Initialize an empty list matrix .
• Create an outer loop row from range 0 to 3, representing the row of 3 x3 matrix.
• Inside the outer loop create an empty list r , that will hold the values for each row.
• Inside the outer loop, create an inner loop col from range 0 to 3, defining 3 columns for each row 3X 3 .
• In the body of the inner for loop asks the user to enter the values for the matrix and append them to the empty list r .
• Outside the inner for loop append the r list to the empty list matrix .
• Now to print the matrix we can either use the print statement directly or use a nested loop structure to print the items in a pattern.

#initialize an empty matrix
matrix = []

#the 3 rows
for row in range(3):
    #empty row list that will hold the data for each row
    r= []
    
    #nested loop for 
    #the 3 coloums data
    for col in range(3):
        data = int(input(f"Input the data for {row+1}x{col+1}: "))
        
        #add the column data to r
        r.append(data)
    #add the row to the matix    
    matrix.append(r)

#print the matrix data using nested for loop
print("\nThe 3X3 Matrix you entered is:")
for row in range(3):
    for col in range(3):
        print(matrix[row][col], end=" ")
    print()

Output

Input the data for 1x1: 1
Input the data for 1x2: 2
Input the data for 1x3: 3
Input the data for 2x1: 4
Input the data for 2x2: 5
Input the data for 2x3: 6
Input the data for 3x1: 7
Input the data for 3x2: 8
Input the data for 3x3: 9

The 3X3 Matrix you entered is:
1 2 3 
4 5 6 
7 8 9

In the above program, we first run the nested for loop to accept the matrix elements. And in the second nested for loop, we print those elements. In both nested for loops the outer and inner for loops has the range of 3, making it a 3X3 = 9 times of the inner body execution.

Example 2

The nested for loops are often used with the range functions to print star patterns or pyramids. Let's print the following pattern with a nested for loop in Python.

*****
 ****
  ***
   **
    *

To print the following pattern , we need two inner loops inside the outer loop. With the first inner loop, we will print the white spaces " " and with the second inner loop star "*".

#outer loop i
for i in range(5):
    #first inner loop for stars
    for k in range(0,i):
        print(" ",end="")
        
    #second inner loop for star
    for j in range(i,5):
        print("*", end="")
    print()

Nested while loop inside a for loop

Similar to the nested for loop, we can define a nested while loop inside a for loop. The concept of nested while loop is the same as nested for loop. Let's Implement the

Example 1 of the above section uses a while loop inside a for a loop.

#initialize an empty matrix
matrix = []

#the 3 rows
for row in range(3):
    #empty row list that will hold the data for each row
    r= []

    col =0
    #nested loop for 
    #the 3 coloums data
    while col<3:
        data = int(input(f"Input the data for {row+1}x{col+1}: "))
        
        #add the column data to r
        r.append(data)

        #increase the col value
        col+=1
        
    #add the row to the matix    
    matrix.append(r)

#print the matrix data using nested for loop
print("\nThe 3X3 Matrix you entered is:")
print(matrix)

Output

Input the data for 1x1: 4
Input the data for 1x2: 4
Input the data for 1x3: 4
Input the data for 2x1: 5
Input the data for 2x2: 5
Input the data for 2x3: 5
Input the data for 3x1: 6
Input the data for 3x2: 6
Input the data for 3x3: 6

The 3X3 Matrix you entered is:
[[4, 4, 4], [5, 5, 5], [6, 6, 6]]

In this example, we used the while loop inside the for loop to accept the column data from the user.

Example 2: Create the following rectangular pattern using the nested while loop in Python.

**********
**********
**********

Rectangle pattern in Python using nested while loop

rows = 0
while rows<3:
    columns = 0
    while columns < 10:
        print("*", end="")
        #increment the value of columns
        columns+=1

        
    #print a new line
    print()

    #increment the value of rows
    rows+=1

Nested Loop Control Statements

There are two loop control statements in Python

1. break
2. continue

Python break in nested loop

The break is a reserved keyword in Python. It is used inside a loop body and terminates the loop execution or iteration. The break keyword-only terminates that loop in which native body it is defined. For instance, if the loop is nested and the break keyword is inside the inner loop, the inner loop will be terminated. If the break is in the outer loop, it will terminate the outer loop.

Example 1 break inside the inner loop

for i in range(3):
    print("Outer Loop:", i)
    for j in range(3):
        if j==i:
            #when i=0 &j=0,i=1 & j=1,  and i=2&j=2 break the inner loop
            break
        else:
            print("\tInner Loop:", j)

Output

Outer Loop: 0
Outer Loop: 1
	Inner Loop: 0
Outer Loop: 2
	Inner Loop: 0
	Inner Loop: 1

In this example, you can see that the outer loop executes 3 times, and the inner loop stops running after i==j . This is because when Python parses the break statement inside the inner loop j, it terminates the inner loop's execution.

Example 2 break outside the inner loop inside the outer body

for i in range(3):
    print("Outer Loop:", i)
    for j in range(3):
        print("\tInner Loop:", j)

    break 

Output

Outer Loop: 0
	Inner Loop: 0
	Inner Loop: 1
	Inner Loop: 2

In the example, the break statement is defined in the outer loop body. When Python read that break statement, it terminates the outer loop i and stop its further execution.

Python continue in a nested loop

continue is another loop control keyword. It can skip the loop iteration and directly jump to the next iteration without executing the loop body code written after it. Similar to the break keyword, the continue will only affect that loop statement where it is defined. If it is present in the inner loop body, it will only affect the inner loop,  and if it is present in the outer loop, it will affect the outer loop.

Example 1 continue inside the inner loop

for i in range(3):
    print("Outer Loop:", i)
    for j in range(3):
        if i==j:
            continue
        print("\tInner Loop:", j)

Output

Outer Loop: 0
	Inner Loop: 1
	Inner Loop: 2
Outer Loop: 1
	Inner Loop: 0
	Inner Loop: 2
Outer Loop: 2
	Inner Loop: 0
	Inner Loop: 1

In the above example, the continue statement skips the inner loop execution when i , and j values were the same.

Example 2 continue inside the outer loop and outside the inner loop

for i in range(3):
    if i==1:
        continue
    print("Outer Loop:", i)
    for j in range(3):
        if i==j:
            continue
        print("\tInner Loop:", j)     

Output

Outer Loop: 0
	Inner Loop: 1
	Inner Loop: 2
Outer Loop: 2
	Inner Loop: 0
	Inner Loop: 1

In this example, the continue statement skips the outer loop iteration when the i value was 1 .

How to use list comprehension to write a nested loop in a single line

List comprehension is a shorthand technique in Python to create a list using for loop using a single-line statement. We can use the list comprehension technique and create a matrix using a single-line statement.

Example nested loop in the list comprehension.

array = [[i,j] for i in range(3) for j in range(3) if i!=j]

print(array)

Output

[[0, 1], [0, 2], [1, 0], [1, 2], [2, 0], [2, 1]]

The above single-line list comprehension code is equivalent to the following code

array=[]

for i in range(3):
    for j in range(3):
        if i!=j:
            array.append([i,j])

The list comprehension saves us time and lines of code.

Nested while loop in Python

We generally use while loop in Python when we are not certain about the number of times a code statement should be executed. The while loop executes a code repeatedly until the condition becomes False or it encounters the break statement. When we define a while loop inside a while loop, it is called a nested while loop.

nested while loop syntax in Python

while expression:
    #outer while loop body
    while expression:
        #inner while loop body

Example

Let's see an example and implement a nested while loop in Python. Write a script in Python that prints the first 10 even numbers 5 times.

times = 0
#outer loop to execute the inner loop 5 times
while times<5:
    even = 2
    #inner loop print the first 10 even numbers
    while even<=20:
        print(even, end=" ")
        #increment the value of even
        even+=2
    #new line
    print()
    #increment the value of times
    times+=1

Output

2 4 6 8 10 12 14 16 18 20 
2 4 6 8 10 12 14 16 18 20 
2 4 6 8 10 12 14 16 18 20 
2 4 6 8 10 12 14 16 18 20 
2 4 6 8 10 12 14 16 18 20

When should we nested loops in Python?

Nested loops come in handy when iterating over the matrix and nested data structures, including complex algorithms such as sorting and searching. The nested loop allows us to go deep into data structures, but it comes with a price. Putting a single-layer nested loop increases the time complexity of a program to O(N ² ).

Alternative of Nested loops

In data structures like graphs and trees, where to go deep into the branches, we may require n nested loops. In such cases, Recursion provides a better alternative to the nested for or while loop.

Conclusion

When we define a loop inside the body of another loop, it is called the nested loop in Python. To create a nested loop, we have two loop statements for loop and while loop, we can either define for loop inside a for loop or while loop inside a while loop or mix them and create a nested loop statement. Many important sorting algorithms use the nested loop to sort the data values present in an array or list.

People are also reading:

• Python isinstance() function
• How to create files in Python?
• Python range() Function Explained
• How to shuffle list in Python?
• Python Take list as an input from a user
• Generate Random Float numbers in Python
• Python Class Variables vs Instance Variables
• Generate Random Strings and Passwords in Python
• Python random choice function to select a random item from a list and Set
• Python TypeError: ‘dict’ object is not callable solution