Skip to content

Comprehensive Python Guide: Generate Number Sequences with range()

Updated: at 02:50 AM

The range() function is a built-in Python function that allows you to generate sequences of numbers in an iterative manner. It is incredibly useful for writing Python code that involves iterative logic, numerical sequences, or repetitive operations. In this comprehensive guide, we will cover everything you need to know about using range() effectively in your Python programs.

Table of Contents

Open Table of Contents

Introduction to the range() Function

The range() function generates a sequence of integers between a starting value and stopping value. The sequence includes the starting value but excludes the stopping value.

for i in range(5):

# Output:

As seen above, range(5) generates the sequence [0, 1, 2, 3, 4]. By default, range() starts from 0 if no starting value is specified.

The basic syntax for range() is:

range(start, stop)
range(start, stop, step)

Let’s look at some examples to understand how to use the different forms of range():

# Example 1: range(10)
for i in range(10):

# Output: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

# Example 2: range(2, 8)
for i in range(2, 8):

# Output: 2, 3, 4, 5, 6, 7

# Example 3: range(2, 20, 3)
for i in range(2, 20, 3):

# Output: 2, 5, 8, 11, 14, 17

As you can see, by varying the start, stop, and step parameters, we can generate different sequences of numbers using range().

Now let’s dig deeper and go through the features and use cases of range() in detail.

Features and Capabilities

The range() function has several useful features that make it a versatile tool for generating numerical sequences.

Iterate Over a Sequence

The most common application of range() is to iterate over a sequence of numbers, as seen in the basic examples above:

for i in range(5):

This creates a loop that will repeat 5 times.

We can also define a start, stop, and step value for more customized iteration:

for i in range(3, 15, 2):

# Output: 3, 5, 7, 9, 11, 13

Generate a List of Numbers

Calling range() and passing the result to list() will generate a list of numbers:

nums = list(range(5))

# Output: [0, 1, 2, 3, 4]

This is useful for creating numerical lists for data analysis and visualization.

Specify Start, Stop & Step

As shown earlier, we can fully customize the sequence generated by range() using the start, stop, and step arguments:

# From 5 to 15 in steps of 3
nums = list(range(5, 15, 3))

# [5, 8, 11, 14]

This allows us to generate any sequence of numbers we need.

Choose Step Size

By setting different step sizes, we can generate sequences that count by 2’s, 3’s, 4’s etc:

# Count by 2
evens = list(range(0, 10, 2))
# [0, 2, 4, 6, 8]

# Count backwards by 3
backwards = list(range(10, 0, -3))
# [10, 7, 4, 1]

Negative step values make the sequence count backwards.

Generate Arithmetic Progressions

The step value allows us to create arithmetic progressions. For example:

linear = list(range(1, 20, 3))
# [1, 4, 7, 10, 13, 16, 19]

quadratic = list(range(1, 20, 4))
# [1, 5, 9, 13, 17]

Fast Sequence Generation

range() is implemented in C and executes very quickly. It is more efficient than manually generating sequences using a while loop in Python.

Memory Efficient

range() does not explicitly generate a list and store it in memory all at once like list(range()) does. It iterates through items one-by-one, which is more memory efficient.

Use Cases and Applications

Let’s go through some practical examples that demonstrate real-world uses of the range() function:

Looping a Specific Number of Times

A common need is to repeat an action a set number of times. range() provides a simple way to implement this:

for i in range(10):
   print("Hello World")

This will print “Hello World” 10 times without needing to increment a counter variable.

Indexing and Slicing Lists

We can use range() to generate indexes for slicing and looping through lists:

fruits = ["Apple", "Banana", "Cherry", "Date"]

for i in range(len(fruits)):

# Output:

Here range(len(fruits)) generates indexes 0 through 3 for the fruits list.

We can also use range() for slicing:

fruits = ["Apple", "Banana", "Cherry", "Date"]

# Output: ['Banana', 'Cherry']

Generating Test Data

range() can be used to quickly generate sequences of test data for experimenting and testing:

ids = list(range(100, 200)) # IDs from 100 to 199

import random
prices = [round(random.uniform(5, 15), 2) for i in range(100)]

This creates random test data for IDs and prices.

Mathematical Operations

We can apply mathematical operations to the sequence generated by range(). For example:

values = list(range(0, 21, 2))
squares = [x**2 for x in values]

# Output:
[0, 4, 16, 36, 64, 100]

This calculates the square of even numbers from 0 to 20.

Random Sampling

By converting range() to a list, we can use random sampling on it:

import random

nums = list(range(0, 20))
sample = random.sample(nums, k=3)

# Example output: [4, 10, 17]

This randomly samples 3 numbers from the sequence 0 to 19.

Number Lines and Counters

We can model a basic numeric counter or number line using range():

# Simple counter
for i in range(1, 10):

# Number line
num_line = list(range(-10, 11, 1))


-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

Read Fixed Number of Lines from File

To process a fixed number of lines from a file, range() can be used along with file iteration:

file = open('data.txt', 'r')

for i in range(5):
    line = next(file)


This will print the first 5 lines of the file.

Distribute Items into Buckets

range() allows bucketing items into evenly sized groups:

nums = [1, 2, 3, ..., 1000]

buckets = 10
size = len(nums) // buckets

for i in range(buckets):
    start = i * size
    end = (i+1) * size
    bucket = nums[start:end]
    # Process bucket

This splits 1000 items into 10 buckets of 100 items each.

Random Password Generation

We can use range() to quickly generate random passwords:

import random, string

length = 15
password = ''.join(random.choices(string.ascii_letters + string.digits, k=length))

# Output: kfIqJk99947ZXfc


range() can be used to implement pagination for limiting query results:


for page in range(1, 1000, RESULTS_PER_PAGE):
   start = (page - 1) * RESULTS_PER_PAGE
   end = page * RESULTS_PER_PAGE

   results = query_db(start, end)

This will display results 25 at a time across multiple pages.

As you can see, range() is useful for a diverse set of applications from simple loops and counters to complex data processing programs. The key is understanding how to construct the sequence you need by tuning start, stop, and step values.

Differences from NumPy arange()

In NumPy, a popular Python scientific computing library, there is a similar function called arange() that generates numeric ranges. It has a few key differences from the built-in range():

Here is an example contrasting the two:

import numpy as np

py_range = range(0, 5, 0.5)
# range(0, 5)

np_arange = np.arange(0, 5, 0.5)
# array([0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5])

So arange() should be preferred for floating point sequences, especially when numpy arrays are required.

Best Practices and Recommendations

Here are some best practices to use range() effectively:


The built-in Python range() function is an efficient, versatile tool for generating sequences of numbers within the Python language. Using range() can simplify code and make it more readable compared to manual iteration and index incrementing.

With the ability to tune start, stop and step parameters, range() provides extensive control over the sequences it produces. It enables a wide variety of applications from simple iteration to complex data processing algorithms.

Mastering range() is a fundamental Python skill that all programmers should learn. This guide covers all the key aspects of range() in Python along with plenty of examples to vividly demonstrate real-world usage. The techniques outlined here will level up your Python code and improve your ability to work with iterative sequences in your programs.