What is the difference between range and xrange in python?

Yes, rangeand xrangethey produce the same result but in a different way.

The bases

As you may have already guessed, the function rangereturns a list:

>>> type(range(10))
list

The range function will occupy the amount of memory according to the size of the range that you pass to it as a parameter.

On the other hand, the function xrangereturns its own data type, the xrange-type :

>>> type(xrange(10))
xrange

Well, there is not much science behind the xrange, in fact it does not have any difference rangein terms of performance, the advantage is that xrangeit will always occupy the same amount of memory (RAM) regardless of the size of the range:

The xrange type is an immutable sequence which is commonly used for looping. The advantage of the xrange type is that an xrange object will always take the same amount of memory, no matter the size of the range it represents. There are no consistent performance advantages.

In short, the ultimate goal of both functions is to return lists, but we could say that xrangethey do so on demand due to their "lazy" nature.

Iterators

In both cases there is support for the iteration protocol since both have the method __iter__:

>>> r = range(10)
>>> r
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> r.__iter__
<method-wrapper '__iter__' of list object at 0xb603fdcc>

>>> xr = xrange(10)
>>> xr
xrange(10)
>>> xr.__iter__
<method-wrapper '__iter__' of xrange object at 0xb600e4d0>

So the following cases are equivalent:

>>> for item in r:
...     print item
...
0
1
2
3
4
5
6
7
8
9
>>> for item in r.__iter__():
...     print item
...
0
1
2
3
4
5
6
7
8
9

The same applies to xr. The big difference is that when you iterate over ryou are doing it over a list that has already been evaluated (and loaded into memory) and when iterating over xryou are doing it over a "lazy" list that passes you the values ​​as you need them ( loading into memory one at a time).

Now this may not make much sense with a range of 10 integers, but try it with a few million and you'll notice the difference in your RAM.

generators

I know this is not part of the original question but it seemed pertinent to add it to the answer since generators are objects that finally implement the iteration protocol.

They are similar to list comprehensions but are created using parentheses instead of square brackets.

Examples:

>>> lista = [1, 2, 3, 4, 5]
>>> [x**2 for x in lista]
[1, 4, 9, 16, 25]
>>> (x**2 for x in lista)
<generator object <genexpr> at 0xb60427fc>

Now, the generators work in a similar way xrangeas they are also "lazy" and only return the value as long as you need it without loading everything into memory by using the expression yield.

References

• Built-in Functions
• Iterator types
• Generator types

The function rangegenerates an internal temporary list that is manipulated item by item, while xrangeproducing an interator (defines the interface to walk through the aggregate of items and access them, so that the client doesn't have to know the details and is able to handle them anyway) which can be passed through without the expense of what could be a large temporary list object.

Example:

Stop xat range(10000): It will generate a list of 10 thousand elements and then it will go through each one of them in turn.

For xin xrange(10000): Will generate 10 thousand integers one by one, passing each one to the variable x in turn.

Reference

In python2, they are different functions and their minor differences are explained quite well in the xrange documentation : it xrangegenerates an xrange object , and it rangegenerates a list. The advantage of the object XRangeis that it does not need to generate all the elements until it is necessary, which means significant resource savings. In addition, in the CPython implementation (which is the most common of python) this type of loops can be optimized much better and simpler.

With Python3 there are no longer two functions, unifying into a single function rangethat would be equivalent to the xrangepython2 function. To get a list it is necessary to call the list constructor (eg: list(range(1000)))