Definition of Nested Loop
A nested loop is a loop inside another loop, where the inner loop executes its entire set of instructions for each iteration of the outer loop. This means that the inner loop is fully executed before the outer loop iteration moves on to the next iteration.
Types of Loops that can be Nested
In Python, both the for
loop and the while
loop can be nested. The for
loop is used for a fixed number of repetitions while iterating over a sequence, such as a list, tuple, or string.
The while
loop is used to repeat a set of statements as long as a condition is continuously met.
Purpose of Using Nested Loops
The primary purpose of nested loops is to work with multidimensional data structures. Nested loops enable us to iterate over multidimensional lists, creating complex data structures.
Nested loops are useful in many programming tasks, including searching, sorting, and manipulating data structures.
Python Nested For Loop
The nested for
loop is a powerful programming construct that allows us to execute a set of instructions repeatedly and manipulate complex data structures. The syntax for the nested for
loop is:
for i in range(x):
for j in range(y):
instructions
Here, the outer loop iterates x
times, while the inner loop iterates y
times.
The instructions inside the nested loop are executed x*y
times.
Example of Printing Multiplication Table
Let’s consider an example of printing the multiplication table using nested for
loops.
for i in range(1, 11):
for j in range(1, 11):
print(i*j, end='t')
print('')
In this code, the outer loop iterates over the number from 1 to 10, while the inner loop multiplies each of these numbers by the numbers from 1 to 10, and prints the result.
Example of Printing Patterns
Nested for
loops can also be used to print different patterns, such as pyramids, triangles, rectangles, and more. Here’s an example of printing a triangle using asterisks:
n = 5
for i in range(n):
for j in range(i):
print('*', end='')
print('')
for i in range(n, 0, -1):
for j in range(i):
print('*', end='')
print('')
In this code, we first iterate over the range of numbers from 0 to 4, and print the asterisks corresponding to each iteration.
Then we iterate over the range of numbers from 5 to 1, and print the asterisks corresponding to each iteration.
3) While Loop Inside a For Loop
Python allows for nesting of loops where a while
loop can be placed inside a for
loop. This can be useful in many different instances, such as when iterating over multidimensional data structures and manipulating data.
In this section, we will look into the example of printing the rectangle pattern using a while
loop inside a for
loop.
Example of Printing Rectangle Pattern
for i in range(1, 6):
j = 1
while j <= 6:
print('*', end='')
j += 1
print('')
In this code, the outer for
loop iterates five times from i = 1
to i = 5
. The inner while
loop iterates six times from j = 1
to j = 6
.
For each iteration of the inner while
loop, it prints an asterisk, thus printing a row of six asterisks. The outer for
loop prints a newline after each row, resulting in a rectangle pattern.
Break Statement in Nested Loop
The break
statement is used in Python to exit the current loop iteration and proceed to the next iteration or exit the entire loop. When used in a nested loop, the break
statement only exits the inner loop and returns the program’s control to the outer loop.
This can be useful when searching for a specific value in nested data structures.
Example of Using Break Statement
for i in range(1, 4):
for j in range(1, 4):
if i == 2 and j == 2:
break
else:
print(i, j)
In this code, the outer for
loop iterates three times from i = 1
to i = 3
. The inner for
loop iterates three times from j = 1
to j = 3
.
If the value of i
is 2 and the value of j
is 2, we use the break
statement to exit the inner loop. If it’s another combination of i
and j
, we print the value of i
and j
.
Continue Statement in Nested Loop
The continue
statement is used in Python to skip the current iteration of the loop and proceed to the next iteration. When used in a nested loop, the continue
statement only skips the current iteration of the inner loop and proceeds to the next iteration of the inner loop.
This can be useful when processing complex data structures and filtering out unwanted values.
Example of Using Continue Statement
for i in range(1, 6):
for j in range(1, 6):
if i == j:
continue
else:
print(f'i: {i}, j: {j}')
In this code, the outer for
loop iterates five times from i = 1
to i = 5
. The inner for
loop also iterates five times from j = 1
to j = 5
.
If the value of i
is equal to the value of j
, we use the continue
statement to skip the iteration. If it’s another combination of i
and j
, we print the values of i
and j
.
4) Single Line Nested Loops Using List Comprehension
List comprehension is a handy Python feature that allows us to create and manipulate lists in a single line of code. It can also be used to create nested loops and perform operations on multidimensional data structures.
In this section, we will look at examples of using nested loops in list comprehension.
Example of Using Nested Loops in List Comprehension
matrix = [[i*j for j in range(1, 6)] for i in range(1, 6)]
print(matrix)
In this code, we create a two-dimensional list called matrix
, consisting of five rows and five columns. We use nested loops in list comprehension, where the inner loop iterates through a range from 1 to 5 and performs a multiplication operation on the current value in the outer range.
The result is a matrix that stores the multiplication table of numbers from 1 to 5.
Filtering Out the Same Numbers Using If Condition
Nested loops in list comprehension can also be used to filter out unwanted values using an if condition. Let’s consider an example of filtering out the same numbers.
numbers = [(i, j) for i in range(1, 6) for j in range(1, 6) if i != j]
print(numbers)
In this code, we create a list called numbers
, consisting of all possible combinations of two numbers between 1 and 5, excluding the combinations where both numbers are the same. We use an if condition in the nested loop in list comprehension to check if the values of i
and j
are not equal.
The result is a list that stores all the possible combinations of two different numbers.
5) Nested While Loop in Python
In Python, a nested while
loop is a loop inside another while
loop. This can be useful for iterating through multidimensional data structures or performing repeated operations until a specific condition is met.
In this section, we will explore the syntax of a nested while
loop, an example of printing the first 10 numbers for 5 lines, and using a for
loop inside a while
loop.
Syntax of Nested While Loop
The syntax for a nested while
loop in Python is as follows:
while condition1:
while condition2:
# statements
Here, the outer while
loop will continue to iterate as long as condition1
is satisfied, and the inner while
loop will continue to iterate as long as condition2
is satisfied. The statements inside the inner loop will execute until condition2
is false, and then control will return to the outer loop.
Example of Printing First 10 Numbers for 5 Lines
Let’s consider an example of printing the first 10 numbers for 5 lines using a nested while
loop.
i = 1
while i <= 5:
j = 1
while j <= 10:
print(j, end=' ')
j += 1
print('')
i += 1
In this code, the outer while
loop iterates 5 times and is used to print 5 lines.
The inner while
loop iterates 10 times to print the first 10 numbers for each line. The statements inside the nested while
loop print the current value of j
and a space character, and then increment j
by 1 until j
is no longer less than or equal to 10.
For Loop Inside While Loop
We can also use a for
loop inside a while
loop in Python. This can be useful when we do not know the exact number of iterations required to perform a specific task.
i = 1
while i <= 5:
for j in range(1, i+1):
print('*', end='')
print('')
i += 1
In this code, we use a while
loop to iterate through 5 lines and a for
loop to print a star pattern on each line. The inner for
loop iterates between 1 and the current value of i
, printing a star character for each iteration.
This results in a star pattern where the number of stars on each line increases by one.
6) When to Use a Nested Loop in Python
It can be challenging to determine when to use a nested loop in Python. In this section, we will explore some cases where nested loops might come in handy.
We will also discuss printing star and number patterns using rows and columns and the time complexity of nested loops.
Handy When Dealing with Nested Arrays or Lists
Nested loops can be extremely useful when working with nested arrays or lists. Suppose we have a multidimensional list that requires iterating through multiple dimensions to extract individual elements.
It is necessary to use nested loops to iterate through all dimensions and perform the required operation.
Printing Star and Number Patterns using Rows and Columns
Printing star and number patterns using rows and columns can also make use of nested loops. In these cases, nested loops are used to iterate through rows and columns of the pattern, calculating the value to be printed at each index.
Time Complexity of Nested Loops
The time complexity (also known as Big O notation) of nested loops can be calculated by multiplying the time complexities of each loop. Suppose the outer loop executes N
times, and the inner loop executes M
times.
In that case, the time complexity of the nested loop is O(N*M)
. If we use an if condition inside the loops, the time complexity increases, making it necessary to optimize the code to reduce execution steps.
Conclusion
Nested loops are a powerful tool in Python for dealing with multidimensional data structures and performing complex operations. In this article, we explored the syntax of a nested while
loop, an example of printing 10 numbers for 5 lines, using a for
loop inside a while
loop, and when to use a nested loop in Python.
Additionally, we discussed printing star and number patterns using rows and columns and the time complexity of nested loops. By applying these concepts in our code, we can improve our efficiency and productivity as programmers.
Nested loops are a powerful programming construct in Python that allows us to iterate through multidimensional data structures and perform complex operations. In this article, we covered the definition, types, purpose, and syntax of nested loops in Python.
We also looked at examples of how to use nested loops in printing different patterns, how to use break and continue statements, and how to use nested loops in list comprehension. Lastly, we discussed when to use nested loops and the time complexity of nested loops.
By mastering these concepts, we can become better programmers and develop efficient and concise code that can solve complex programming problems. The takeaway from this article is that nested loops are an essential tool in Python that can help us manage and process complex data structures.