The range() Function

Understanding the Basic Signature

At its core, range() acts as a generator for a sequence of integers starting from zero up to, but not including, the specified stop value. This 'exclusive' upper bound is a fundamental design philosophy in Python, ensuring that the total count of elements produced matches the integer provided as the argument. When you pass a single integer, say 5, the function generates the sequence 0, 1, 2, 3, 4. Understanding this is crucial because it aligns with zero-based indexing used throughout Python collections. Because range objects are lazy, they do not consume memory proportional to the size of the sequence; they calculate the next number only when the loop requests it. This behavior provides a significant performance advantage when you need to iterate over millions of items, as it avoids pre-allocating a massive list in memory before the loop even starts its first iteration.

# Generates integers from 0 to 4
for i in range(5):
    print(f"Current index: {i}")  # Prints 0 through 4 sequentially

Defining Start and Stop Bounds

While the single-argument version defaults to starting at zero, you can exert finer control by providing both a start and a stop value. By providing two arguments, you define the inclusive lower bound and the exclusive upper bound, allowing you to iterate through custom integer ranges that do not begin at zero. This flexibility is vital when you need to align your loop logic with specific data constraints, such as processing records starting from a specific offset or skipping initial metadata entries in a data structure. The logic remains consistent: the start value is included, and the stop value is excluded. If you set the start equal to the stop, the sequence remains empty, as there are no numbers that satisfy the criteria of being greater than or equal to the start while remaining strictly less than the stop value. This avoids common off-by-one errors during complex logic development.

# Iterate from 5 up to 9
for count in range(5, 10):
    print(f"Value: {count}")  # Starts at 5, stops before 10

Implementing Custom Step Increments

Beyond simple sequences, the range() function accepts a third argument known as the 'step'. This parameter dictates the increment between each generated integer in the sequence. By default, the step is 1, but changing it allows for powerful patterns, such as selecting every second item or counting backward. When providing a step, you must include a start and a stop value. If the step is positive, the function generates an increasing sequence; if negative, the start must be greater than the stop to generate a decreasing sequence. The efficiency of the range object remains intact here, as it performs simple arithmetic to calculate the next step rather than storing every integer. This is the idiomatic way to handle tasks like stepping through indices by a certain stride or reversing the iteration order without creating a reversed copy of a data structure, which saves significant processing time.

# Count backwards from 10 to 2 with a step of -2
for i in range(10, 0, -2):
    print(f"Countdown: {i}")  # Outputs 10, 8, 6, 4, 2

Memory Efficiency and Type Representation

A common point of confusion for newcomers is that range() does not return a list. Instead, it returns a range object, which is an immutable sequence type that represents the logic of the numbers without storing them. If you attempt to print a range object directly, you will see a description of its parameters rather than the values themselves. To view the contents as a list, you must explicitly convert the object using the list() constructor. This explicit conversion is a conscious choice by the developer: it forces you to acknowledge that you are about to allocate memory for all these integers at once. By defaulting to a lazy range object, Python protects you from accidentally exhausting system resources when dealing with sequences that span vast ranges of integers, ensuring that memory usage stays constant regardless of the total count of numbers.

# range object is lazy; list() materializes it into memory
number_range = range(0, 1000000)
print(type(number_range))  # Outputs: <class 'range'>
numbers = list(range(3))   # Forces creation of [0, 1, 2]

Practical Iteration Over Indices

In many real-world scenarios, you need to modify the contents of a list or process multiple lists simultaneously. Iterating directly over the items provides the values, but using range() in combination with len() provides access to the index, which is necessary if you need to perform modifications or reference neighboring elements. For example, if you are comparing a current item with its predecessor, having the index allows you to index into the sequence easily. This pattern is also essential when you need to iterate through two lists of equal length simultaneously by index. By using range(len(some_list)), you establish a bridge between the list size and the iteration logic, ensuring that your code is robust even when the data set changes size. This technique is a fundamental tool for building flexible and maintainable data processing loops in professional software development.

data = ['a', 'b', 'c']
# Use index to modify the list or access neighbors
for i in range(len(data)):
    print(f"Item at index {i} is {data[i]}")

Interview questions

All Python interview questions →

Check yourself

Take the full Python quiz →