In the last article, I wrote about how programs make decisions using conditionals. We went through how a program can make a decision, choosing one path over another based on whether a condition is true or false.
But what if we need to perform the same action multiple times? Let’s say you have a list of about 1,000 users and want to email each of them. You wouldn’t write the email-sending code 1,000 times. Instead, you would write it once and have the program repeat it for each user. This is where looping comes in.
Looping allows a program to repeatedly execute a block of code until a condition is met or until all items in a collection have been processed. It’s one of the most powerful concepts in programming because it helps us automate repetitive tasks and work with large amounts of data efficiently. Whether you’re building a web application, analyzing data, processing files, or developing APIs, you’ll find loops everywhere. Let’s see how Python and Go approach this concept.
Understanding Iteration
Iteration simply means moving through a collection of data one item at a time. For example, if you have:
students = [“John”, “Sarah”, “David”]
Iteration means accessing:
- John
- Sarah
- David
one after another. Loops are the mechanism that makes iteration possible. We will now consider some types of loops, first the for loop.
The For Loop
A for loop is used when you want to repeat something a specific number of times or go through a collection of items.
Python’s Approach: for item in sequence
Python’s for loop is designed around iteration. Instead of asking you to manage counters manually, Python allows you to directly loop through a sequence.
students = ["John", "Sarah", "David"]
for student in students:
print(student)
If you read that aloud, it almost sounds like English: “For each student in students, print the student.” That’s one of the reasons Python is often praised for readability. Python also provides the range() function when you want to repeat something a specific number of times.
for i in range(5):
print(i)
Output:
0
1
2
3
4
We can note that Python focuses less on how the loop works internally and more on what you’re trying to accomplish.
Go’s Approach: The Universal for Keyword
Instead of providing separate loop structures for different situations, Go uses a single keyword: for. This one keyword handles almost every looping scenario.
A traditional Go for loop looks like this:
for i := 0; i < 5; i++ {
fmt.Println(i)
}
This structure contains three parts: initialization; condition; post-action
In this example:
- i := 0 initializes the counter
- i < 5 determines how long the loop runs (in this case limiting to 5)
- i++ updates the counter by 1 after each iteration
When iterating over collections, Go uses the range keyword.
students := []string{"John", "Sarah", "David"}
for index, student := range students {
fmt.Println(index, student)
}
Unlike Python, Go exposes both the position and the value by default.
This reflects Go’s preference for being explicit about what’s happening during execution.
The While Loop
Not every situation involves iterating through a collection. Sometimes you want code to keep running as long as a condition remains true.
For example:
- Keep asking for a password until the user enters the correct one.
- Continue processing requests while the server is running.
- Retry an operation until it succeeds.
This is where while loops become useful.
Python’s Explicit while Loop
Python provides a dedicated keyword for this purpose:
count = 0
while count < 5:
print(count)
count += 1
The logic is straightforward, It continues running this block while the condition remains true and each time the loop runs, the condition is checked again So once the condition becomes false, the loop stops.
Go’s Approach: Using for as a While Loop
Go does not have a while keyword.
Instead, Go reuses its universal for loop. To create while-loop behavior, you simply remove the initialization and post-action sections.
count := 0
for count < 5 {
fmt.Println(count)
count++
}
Infinite Loops
Sometimes a loop is intended to run forever until something inside it stops execution.
Python:
while True:
print("Running...")
Go:
for {
fmt.Println("Running...")
}
You’ll often see these in:
- Web servers
- Background workers
- Event listeners
- Real-time systems
Breaking and Continuing
To understand breaking and continuing, we should understand that not every loop should run to completion. Sometimes we want to stop a loop early or skip a particular iteration. This is where break and continue become useful.
Using break
The break statement immediately terminates the loop.
Python example:
for number in range(10):
if number == 5:
break
print(number)
Output:
0
1
2
3
4
The moment the value reaches 5, the loop stops completely. Go works the same way:
for i := 0; i < 10; i++ {
if i == 5 {
break
}
fmt.Println(i)
}
Again, execution stops as soon as the break statement is reached.
Using continue
The continue statement is slightly different. Instead of stopping the loop, it skips the current iteration and moves to the next one.
Python:
for number in range(5):
if number == 2:
continue
print(number)
Output:
0
1
3
4
Notice that 2 is skipped. Go behaves the same way:
for i := 0; i < 5; i++ {
if i == 2 {
continue
}
fmt.Println(i)
}
The current iteration is skipped, but the loop itself continues running.
Python’s Angle vs Go’s Angle
Looking at loops gives us another glimpse into the philosophy of both languages.
Python’s Angle
Python is designed to make iteration feel natural.
- for item in sequence
- Dedicated while keyword
- Readable syntax
- Focus on expressing intent clearly
Python often hides implementation details so you can focus on solving the problem.
Go’s Angle
Go prefers consistency over having many specialized constructs.
- One loop keyword (for)
- Multiple looping styles using the same structure
- Explicit control over loop behavior
- Less language complexity
Go’s mindset is:
Learn one loop mechanism and use it everywhere.
Finally
Looping is one of the fast ways programs get work done in programming. Without loops, applications would struggle to process lists, handle user input, analyze data, or automate repetitive tasks. Python gives you specialized, highly readable constructs for iteration. Go gives you a single, versatile tool that can adapt to different situations.Both approaches are effective.
The real skill as a bilingual developer isn’t memorizing syntax, but it’s understanding the underlying concept. Once you understand what a loop is trying to achieve, switching between Python and Go becomes much easier. The syntax may change, but the logic remains exactly the same: repeat a task until you’re done. Thanks for reading this article, hit the like and comment what you think, thanks.
