{"id":1452,"date":"2023-08-24T22:35:38","date_gmt":"2023-08-24T17:05:38","guid":{"rendered":"https:\/\/geekpython.in\/?p=1452"},"modified":"2024-03-01T17:08:01","modified_gmt":"2024-03-01T11:38:01","slug":"nested-for-loops-in-python","status":"publish","type":"post","link":"https:\/\/geekpython.in\/nested-for-loops-in-python","title":{"rendered":"Understanding Nested for Loops in Python – How Does it Work"},"content":{"rendered":"\n

You may have used Python for<\/code> loops to iterate through iterable objects in order to access them independently and perform various operations. You’re probably familiar with the concept of nested for<\/code> loops as well.<\/p>\n\n\n\n

In Python, nested for<\/code> loops are loops that have one or more for<\/code> loops within them.<\/p>\n\n\n\n

Nested for<\/code> loops have a structure that is similar to the following code:<\/p>\n\n\n\n

for x in my_iterable:\n    for item in x:\n        print(item.upper())<\/pre><\/div>\n\n\n\n
You may have seen the use of nested for<\/code> loops in the creation of various patterns of asterisk or hyphen symbols.<\/p>\n\n\n\n
Working of Nested for Loops<\/h1>\n\n\n\n
A nested for<\/code> loop is made up of both an outer loop and an inner loop. When observing the structure of the nested for<\/code> loop mentioned earlier, you’ll observe that the initial part of the code represents an outer for<\/code> loop, and within this outer for<\/code> loop, there exists an inner for<\/code> loop.<\/p>\n\n\n\n
for anything in article: # Outer for-loop\n    # Some code here\n    for everything in anything: # Inner for-loop\n        # Some code here<\/pre><\/div>\n\n\n\n
But how they go hand in hand and iterate through data. Let’s uncover the iteration process of nested for<\/code> loops.<\/p>\n\n\n\n
my_iterable = [\"Sachin\", \"Rishu\", \"Yashwant\"]\n\nfor item in my_iterable:\n    for each_elem in item:\n        print(each_elem, end=\" \")<\/pre><\/div>\n\n\n\n
The outer loop accesses each item in my_iterable<\/code>.<\/p>\n\n\n\n
For each item in the outer loop (e.g., \"Sachin\"<\/code>), the inner loop iterates through each individual element in the item (e.g., \"S\"<\/code>, \"a\"<\/code>, \"c\"<\/code>, \"h\"<\/code>, \"i\"<\/code>, \"n\"<\/code>).<\/p>\n\n\n\n
The print statement prints each character with a space, producing output like \"S a c h i n \"<\/code>.<\/p>\n\n\n\n
S a c h i n R i s h u Y a s h w a n t<\/pre><\/div>\n\n\n\n
Example of Nested for Loops<\/h3>\n\n\n\n
names = [\"Sachin\", \"Rishu\", \"Yashwant\"]\ngames = [\"Cricket\", \"Snooker\"]\n\n\nfor item in names: # Outer loop\n    for game in games: # Inner loop\n        print(item, \"plays\", game)<\/pre><\/div>\n\n\n\n
The outer loop iterates through the names<\/code> list (Sachin, Rishu, Yashwant).<\/p>\n\n\n\n
For each name in the outer loop, the inner loop iterates through the games<\/code> list (Cricket, Snooker).<\/p>\n\n\n\n
The print<\/code> statement combines the current name with each game to output sentences like “Sachin plays Cricket<\/code>” and “Sachin plays Snooker<\/code>“.<\/p>\n\n\n\n
Sachin plays Cricket\nSachin plays Snooker\nRishu plays Cricket\nRishu plays Snooker\nYashwant plays Cricket\nYashwant plays Snooker<\/pre><\/div>\n\n\n\n
Nested for Loops with range() Function<\/h3>\n\n\n\n
for i in range(1, 2):\n    for x in range(3):\n        for num in range(x):\n            print(num)<\/pre><\/div>\n\n\n\n
The above code might be a bit confusing, let’s break it down into pieces:<\/p>\n\n\n\n
The outer for<\/code> loop (for i in range(1, 2)<\/code>) executes once because the range is from 1<\/strong> to 2<\/strong> (not inclusive), resulting in a single iteration. This loop governs the number of times the inner loops are executed.<\/p>\n\n\n\n
The middle or inner for<\/code> loop runs three times because of the range from 0<\/strong> to 2<\/strong>. The iterations produce the values 0<\/strong>, 1<\/strong>, and 2<\/strong>.<\/p>\n\n\n\n
The innermost for<\/code> loop’s behavior depends on the middle for<\/code> loop because its range relies on the current value of the x<\/code> variable.<\/p>\n\n\n\n
When the value of x<\/code> is 0<\/strong> (first iteration), the innermost loop won’t execute because the range is empty. When the value of x<\/code> is 1<\/strong> (second iteration), it runs for one time returning the value 0 due to the range(1)<\/code>, and then finally when x<\/code> is 2<\/strong> (third iteration), it runs two times returning the values 0<\/strong> and 1<\/strong> due to the range(2)<\/code>.<\/p>\n\n\n\n
0\n0\n1<\/pre><\/div>\n\n\n\n
Application of Nested for Loops in Real World<\/h1>\n\n\n\n
There are various ways to use nested for<\/code> loops. They come in handy when you need to perform multiple rounds of iterations, deal with layered data structures like lists inside dictionaries or lists within other lists for navigating through data, or when you want to process and analyze text by breaking it down into smaller parts.<\/p>\n\n\n\n
Example – Tokenizing Sentence into Words and Characters<\/h3>\n\n\n\n
text = \"Hey, there! Welcome to GeekPython.\"\nsentences = text.split(\". \")   # Splitting the text into sentences\n\nprint(\"Tokenized Sentences into Words and Characters:\")\nfor sentence in sentences:\n    print(\"- Sentence:\", sentence)\n    words = sentence.split(\" \")  # Splitting sentence into words\n    for word in words:\n        print(\"  - Word:\", word)\n        for character in word:\n            print(\"    - Character:\", character)<\/pre><\/div>\n\n\n\n
The above code tokenizes (breaking sentences into small units) the text data into words and characters using the nested for<\/code> loops. The code goes as follows:<\/p>\n\n\n\n
The text data is initially split into sentences using text.split(\". \")<\/code>, where the period followed by a space is used as the delimiter.<\/p>\n\n\n\n
The outer for<\/code> loop iterates through sentences and prints them. The current sentence is then split into words using sentence.split(\" \")<\/code>.<\/p>\n\n\n\n
Then subsequent for<\/code> loop iterates through the words of the current sentence and prints them.<\/p>\n\n\n\n
Additionally, a further nested for<\/code> loop is nested within the word loop, which processes the characters within each word, one at a time.<\/p>\n\n\n\n
The inner for<\/code> loops are executed for every cycle of the outer for<\/code> loop. This signifies that the code’s process is repeated for each sentence. However, since the provided code only deals with one sentence, it executes just once.<\/p>\n\n\n\n
Tokenized Sentences into Words and Characters:\n- Sentence: Hey, there! Welcome to GeekPython.\n  - Word: Hey,\n    - Character: H\n    - Character: e\n    - Character: y\n    - Character: ,\n  - Word: there!\n    - Character: t\n    - Character: h\n    - Character: e\n    - Character: r\n    - Character: e\n    - Character: !\n  - Word: Welcome\n    - Character: W\n    - Character: e\n    - Character: l\n    - Character: c\n    - Character: o\n    - Character: m\n    - Character: e\n  - Word: to\n    - Character: t\n    - Character: o\n  - Word: GeekPython.\n    - Character: G\n    - Character: e\n    - Character: e\n    - Character: k\n    - Character: P\n    - Character: y\n    - Character: t\n    - Character: h\n    - Character: o\n    - Character: n\n    - Character: .<\/pre><\/div>\n\n\n\n
You could have also performed the tokenization of textual data by reading the data from the file and to do so, you just need to adjust your code as shown below:<\/p>\n\n\n\n
with open(\"test.txt\") as file:\n    content = file.read()\n\n    sentences = content.split(\". \")\n\n    print(\"Tokenized sentences into words and characters:\")\n    for sentence in sentences:\n        print(\"- Sentence:\", sentence)\n        words = sentence.split(\" \")\n        for word in words:\n            print(\"  - Word:\", word)\n            for char in word:\n                print(\"    - Character:\", char)<\/pre><\/div>\n\n\n\n
Conclusion<\/h1>\n\n\n\n
Python’s for<\/code> loops are employed to sequentially go through a series of data elements, allowing access to each of them individually. Furthermore, a single for<\/code> loop can contain one or more additional for<\/code> loops within it, a concept commonly known as nested for<\/code> loops.<\/p>\n\n\n\n
In the context of nested for<\/code> loops, during every iteration of the outer for<\/code> loop, the inner for<\/code> loop iterates through each item present in the respective iterable. To illustrate, consider the scenario of shopping: envision visiting various shops and inspecting the items they offer. You start by exploring the first shop, examining all its items, and then proceed to the next shop, repeating this process until you have surveyed all available shops.<\/p>\n\n\n\n
Let’s recall what you’ve learned:<\/p>\n\n\n\n