The Bilingual Developer: Python and Go Looping & Iteration

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.