range() vs xrange() in Python

These are two functions used to iterate a certain number of items in for loops. In python2 we use xrange() function and in python3 we use the range(). But if you want to write a code that will run on both python2 and python3, you should use range(). In other ways, they are different in their characteristics. Return type, memory, and operation usage speed are some of them.

	xrange() – Python2	range() – Python3
Return type	Object	List
Memory	High	Low
Operation usage	Such operations cannot be performed on xrange().	All arithmetic operations can be performed as it returns a list.
Speed	Execution speed is faster	Execution speed is slower

range(): It returns a list containing arithmetic progressions of integers. It’s eager, meaning it generates the entire list and stores it in memory. This can be inefficient for large ranges because it consumes memory.

• Returns: A list of numbers.
• Syntax: range(start, stop[, step])
  • start: The starting value of the sequence (inclusive).
  • stop: The end value of the sequence (exclusive).
  • step: The difference between each pair of consecutive values (default is 1).
• Memory Usage: Stores all numbers in the range as a list in memory. This can be problematic for large ranges because it consumes a lot of memory.
• Performance: Because it generates the entire list at once, operations that iterate over the range can be faster in terms of indexing and accessing elements, but the initial memory allocation can be costly.

numbers = range(0, 10, 2)
print(numbers)  # Output: [0, 2, 4, 6, 8]

xrange(): It returns an xrange object, which generates the numbers on demand as you iterate over it. It’s more memory efficient for large ranges because it generates the numbers dynamically.

• Returns: An xrange object, which is an iterable that generates numbers on demand (lazy evaluation).
• Syntax: xrange(start, stop[, step])
  • start, stop, and step have the same meaning as in range().
• Memory Usage: Does not generate and store all numbers at once. Instead, it computes each number on the fly and keeps only the current value in memory, making it much more memory efficient for large ranges.
• Performance: Iterating over the range can be slower than range() due to the overhead of generating each number on the fly, but this is typically negligible compared to the memory savings.

numbers = xrange(0, 10, 2)
for num in numbers:
    print(num)
# Output:
# 0
# 2
# 4
# 6
# 8

Differences Summary

• List vs. Iterator: range() returns a list, whereas xrange() returns an iterator.
• Memory Efficiency: range() can consume a large amount of memory for large ranges since it stores the entire list, while xrange() is memory efficient as it generates numbers on the fly.
• Performance: range() may have better performance for accessing elements repeatedly due to pre-generated list but at the cost of higher memory usage. xrange() is generally slower for element access due to on-the-fly computation, but the memory usage is minimal.
• Use Case: Use range() when the sequence is small or when you need to store and access the entire sequence multiple times. Use xrange() for large ranges, especially in loops, where memory efficiency is more critical than access speed.

In Python 3, xrange() was removed, and range() behaves like xrange() in Python 2, meaning it returns an iterator rather than creating a list in memory. So, in Python 3, range() is more efficient than range() in Python 2. To summarize, range() and xrange() in Python 2 serve different purposes depending on the memory and performance needs. Python 3’s range() merges the best aspects of both.