Skip to content

Using range() in for Loops to Control Iterations in Python

Updated: at 04:56 AM

The range() function is an incredibly useful built-in function in Python that allows you to generate a sequence of integers to loop over in for loops. By leveraging range(), you can precisely control the number of iterations in your for loops, making your code more efficient, scalable, and maintainable.

In this comprehensive guide, you will learn:

Table of Contents

Open Table of Contents

What is the range() Function in Python?

The range() function generates a sequence of integers based on the start, stop, and step arguments provided. It returns a range object that represents an immutable sequence of numbers which is efficient to iterate over in for loops.

Here is the basic syntax for range():

range(start, stop, step)

Calling range() with just the stop value will give you a sequence from 0 to up to but not including the provided stop:

for i in range(5):

# Output:

This allows you to iterate exactly 5 times. The range object creates the sequence of numbers on demand instead of allocating the full sequence in memory at once like a list. This makes it very efficient for large sequences.

Now let’s look at how we can control iterations using range() in for loops.

Using range() in for Loops

The range() function pairs perfectly with for loops to iterate a specific number of times. The integer sequence generated by range() can be looped over directly:

for i in range(10):
   print(f"Iteration {i}")

This will print “Iteration 0” through “Iteration 9” for exactly 10 iterations controlled by range(10).

We can also specify a start, stop, and step size for more control:

for i in range(5, 15, 2):
    print(f"Iteration {i}")

This will print the odd numbers between 5 and 15, iterating only 5 times.

The key advantage is range() lets you control iterations statefully and programmatically. You can calculate stop values or steps based on application logic vs hard coding iterations.

Let’s explore more range() patterns and techniques for for loop control.

Specifying Start, Stop, and Step Values with range()

The flexibility of passing start, stop, and step arguments to range() allows us to precisely control iterations.

Start and Stop Only

This is the simplest way to use range() by passing just the start and stop values:

for i in range(1, 10):

This will print integers from 1 up to but not including 10. Great for looping a set number of times.

With a Step Value

Adding a step or stride controls the interval between numbers:

for i in range(0, 20, 5):

This iterates 0, 5, 10, 15 by skipping 5 each loop. This is useful for iterating at a fixed interval.

With a Negative Step

A negative step will decrement the sequence:

for i in range(10, 0, -1):

This counts down from 10 to 1, great for controlled backwards iteration.

One Item Sequence

You can specify matching start and stop values to create a range with just one item:

for i in range(5, 5):

This will only print 5 once, acting as initialization.

Iterating Forever

Calling range() with no arguments will create an infinite sequence from 0, allowing you to iterate forever:

for i in range( ):

Use Ctrl+C to stop this safely. Useful for repeatedly executing code in loops.

There are many possible patterns by combining start, stop, and step values when using range() for for loop control and iteration.

Iterating Over a Sequence with Index Using range()

A common need is iterating over a sequence and accessing the index value at each iteration.

Using range() and len() together allows you to safely iterate with indexes:

fruits = ["apple", "banana", "cherry"]

for i in range(len(fruits)):
    print(f"Index {i} has fruit: {fruits[i]}")

This idiom is commonly used with lists, tuples, dictionaries, and other data structures in Python.

The key benefit is range(len( )) will iterate the correct number of times regardless of the length of the sequence. It avoids potential errors like hard coding a set number of iterations.

Use Cases and Examples

Let’s look at some common use cases and examples for using range() in for loops for iteration control.

Repeat Action N Times

Use range() when you need to repeat an action a set number of times:

print("Hello World!")
for _ in range(5):
    print("Repeating this 5 times")

This repeats the print statement 5 times without needing a counter variable.

Iterate Over Sequence and Modify

You can iterate over a sequence and modify it:

numbers = [1, 2, 3, 4]

for i in range(len(numbers)):
    numbers[i] *= 10


This multiplies each item in the list by 10 programmatically.

Iterate Fixed Interval

Use range() to loop at a fixed interval regardless of sequence size:

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for i in range(0, len(my_list), 2):

This will print just the even indexed items spacing the iteration.

Implement Countdown Timer

To create a simple countdown timer:

import time

for i in range(10, 0, -1):


The range handles the controlled backward iteration from 10 down to 1. Great for timers and clocks.

These are just a few examples of how range() can provide programmatic control over for loop iterations for many different use cases.

Iterating in Reverse with range()

A common need is to iterate in reverse order, which can be done cleanly using range() and a negative step value.

For example, to print a list in reverse order:

my_list = [1, 2, 3, 4, 5]

for i in range(len(my_list)-1, -1, -1):

Setting range from the last index down to 0 with a step of -1 reverses the iteration order.

We can also reverse any sequence using:

my_list = [1, 2, 3, 4, 5]

for i in range(len(my_list)-1, -1, -1):
  print(my_list[i], end=' ')

This simple pattern allows reversing iterations easily with range().

Proper Incrementing and Decrementing

When using range() for controlled iteration, be mindful how start, stop, and step values are specified to properly increment or decrement the sequence.


To loop from 0 to n, use:

for i in range(n):

To increment from a to b, use:

for i in range(a, b):


To loop from n down to 0, use:

for i in range(n, -1, -1):

And to decrement from b down to a:

for i in range(b, a-1, -1):

Having the stop value be one less when decrementing avoids off-by-one errors.

Getting these right can take a bit of practice, so always double check your start, stop, and ranges when iterating.

Functions for Working with range()

Python includes some built-in functions that work nicely with the range object returned by range().

Converting to a List

To convert a range to a list to allow slicing, sorting, etc:

nums = list(range(5)) # [0, 1, 2, 3, 4]

Check Membership

You can check if a value is within a range quickly using in:

result = 5 in range(4, 8) # True

Checks if a number exists between the start and stop values.

Generate Repeated Values

To repeat the same value n times in a list, use:

repeated = [0] * 5 # [0, 0, 0, 0, 0]

Multiplying a one element list repeats it. Handy with range() lengths.

These utilities help broaden what you can do with ranges beyond just iteration.

Common Mistakes to Avoid

While range() is straightforward to use, there are some common mistakes and edge cases to be aware of.

Off-By-One Errors

It’s easy to be off-by-one with start, stop, and step values. Double check ranges match expected iteration counts.

Infinite Loops

Calling range() without arguments produces an infinite sequence - use caution to avoid infinite loops.

Float Arguments

range() only works with integer arguments. Floats will raise a TypeError.

Reversal Logic Errors

Reversing range iteration requires adjusting start and stop offsets properly. Review the decrementing logic patterns.

Unintentional Skips

Large step values can cause unexpected iteration skips - know your data size vs range offsets.

Hard Coding

Avoid hard coded iteration counts - leverage range() and len() for programmatic control.


The built-in Python range() function is an indispensable tool for controlling for loop iterations. By leveraging range(), you can iterate a precise number of times, skip iterations, reverse loops, and avoid off-by-one errors.

Key takeaways include:

Learning to properly harness range() for iteration is a fundamental Python skill that will allow you to write simpler, safer, and more Pythonic loops as you continue your programming journey.