What is the difference between xrange and range in Python?
Question
Register Now
It will take less than 1 minute to register for lifetime. Bonus Tip - We don't send OTP to your email id Make Sure to use your own email id for free books and giveaways
Top Categories
Pragya Rani
Answers ( 22 )
a = range(1,10000)
# initializing a with xrange()
x = xrange(1,10000)
# testing the type of a
print (“The return type of range() is : “)
print (type(a))
# testing the type of x
print (“The return type of xrange() is : “)
print (type(x))
The return type of range() is :
The return type of xrange() is :
range() returns a list object which is iterable whereas xrange() returns the generator object that can be used to display numbers only by looping
1) If you stored the range by using range() then it takes a lot of memory then xrange()
2) since range() returns the list, all the list operation can be applied to this but not with xrange because it returns xrange object.
3) since xrange() evaluates only the generator object containing only the values which are required, it is faster compare to range()
import sys
x = range(1,100000)
a = xrange(1,100000)
print (“The size allotted using range() is : “)
print (sys.getsizeof(x))
print (“The size allotted using xrange() is : “)
print (sys.getsizeof(a))
1. range() will return a list of numbers.For eg range(1,100) will output a list of 99 integer values.
2.xrange() will return a generator object and it output results using for loop.
3.In terms of memory consumption range() consumes more memory and more time to execute when compared to xrange()
Difference betwen range and Xrange is 1.Return value type
2.Memory consumption
3.Speed.
1.Range returns list of python objects whereas xrange returns xrange objects.
2.Range consumes more memory.
3.xrange was introduced in py 2.0 whereas range came in py 3.
4.xrange is faster to implement.
Both the range() and xrange() functions are used to iterate a certain number of times in a ‘for’ loop. The xrange() function was available in Python2 but it has been deprecated in Python3 and hence we should only use range().
The range() function returns a range object which is nothing but a type of iterable whereas the xrange() function returns a generator function that only displays values when its looping.
See the difference in the code:
a = range(1,10)
x = xrange(1,10)
print (“The return type of range() is : “)
print (type(a))
print(a)
print (“The return type of xrange() is : “)
print (type(x))
print(x)
It generates the output as:
The return type of range() is :
[1, 2, 3, 4, 5, 6, 7, 8, 9]
The return type of xrange() is :
xrange(1, 10)
Now, talking in terms of memory consumption, the range() function consumes more memory than xrange() because the range function returns a list while xrange() returns a xrange() object as we see in the output of the code above.
Since the range() function returns a list hence all the list manipulation can be done on it whereas the same manipulation can’t be performed on the xrange() function, hence its disadvantageous on that end.
Talking about the speed of implementation, the xrange() function is faster in implementation than that of the range() because it only deals with the generator function which contains only the values needed for the lazy evaluation( Only particular range is displayed on demand and hence called “lazy evaluation“ and it’s a characteristic of the xrange() function.
xrange is used only in Python 2. There is no xrange in python 3.
1. range returns a list of numbers
2. xrange creates numbers as you need them i.e evaluates lazily
Since the xrange function does not create a list it does not require as much memory as the range function.
As range() returns the list, all the operations that can be applied on the list can be used on it. On the other hand, as xrange() returns the xrange object, operations associated to list cannot be applied on them, hence a disadvantage.
xrange and range are the exact same in terms of functionality. They both provide a way to generate a list of integers for you to use, however you please. The only difference is that range returns a Python list object and xrange returns an xrange object.
The main difference between the “Xrange” and “Range” in “Python Programming Language” are as follows respectively: The “Range” always returns a “Python List Objects” whereas “Xrange” always returns an “Xrange” object.
a = range(1,10000)
x = xrange(1,10000)
print (“The return type of range() is : “) # testing the type of a
print (type(a))
print (“The return type of xrange() is : “) # testing the type of x
print (type(x))
output :-
The return type of range() is :
The return type of xrange() is :
For the most part, xrange and range are the exact same in terms of functionality. They both provide a way to generate a list of integers for you to use, however you please. The only difference is that range returns a Python list object and xrange returns an xrange object.
What does that mean? Good question! It means that xrange doesn’t actually generate a static list at run-time like range does. It creates the values as you need them with a special technique called yielding. This technique is used with a type of object known as generators.
if you have a really gigantic range you’d like to generate a list for, say one billion, xrange is the function to use. This is especially true if you have a really memory sensitive system such as a cell phone that you are working with, as range will use as much memory as it can to create your array of integers, which can result in a MemoryError and crash your program. It’s a memory hungry beast.
That being said, if you’d like to iterate over the list multiple times, it’s probably better to use range. This is because xrange has to generate an integer object every time you access an index, whereas range is a static list and the integers are already “there” to use.
range() and xrange() are two functions that could be used to iterate a certain number of times in for loops in Python.
a = range(1,1000) #initialize an object a with range
b = xrange(1,1000) #initialize an object b with xrange
On the basis of return type:
print (type(a))
print(type(b))
Output:
#type of object a
#type of object b
On the basis of memory:
The variable storing the range created by range() takes more memory as compared to variable storing the range using xrange(). The basic reason for this is the return type of range() is list and xrange() is xrange() object.
print (sys.getsizeof(a))
print (sys.getsizeof(b))
Output:
80064 #memory, variable a takes
40 #memory variable b takes
On the basis of Operations usage:
As range() returns the list, all the operations that can be applied on the list can be used on it. On the other hand, as xrange() returns the xrange object, operations associated to list cannot be applied on them, hence a disadvantage.
print (a[2:5])
print (b[2:5])
Error:
Traceback (most recent call last):
File “1f2d94c59aea6aed795b05a19e44474d.py”, line 18, in
print (b[2:5])
TypeError: sequence index must be integer, not ‘slice’
Output:
[3, 4, 5]
On the basis of Speed:
Because of the fact that xrange() evaluates only the generator object containing only the values that are required by lazy evaluation, therefore is faster in implementation than range().
In Python 2.x, we had the two underlying methods to generate a list of integers within a given range – range() and xrange()
NOTE: In Python 3, range() was decommissioned and xrange() renamed to range()
1) range()
The range() returns a list type object. For example, the expression range(1, 100, 1) will produce a 99 int numbers range. It gets all the numbers in one go.
>>> r = range(1, 100, 1)
>>> type(r)
2) xrange()
The xrange() provides results as an xrange object. It performs a lazy evaluation. It keeps the arguments and produces numbers on call. Unlike range(), it avoids getting all the number in one go.
The xrange object allows iteration, indexing, and the len() method. You can have a for loop to traverse it and gets the numbers in every iteration.
>>> xr = xrange(1, 100, 1)
>>> type(xr)
Where should we use xrange()?
1) When the range has a broader scope. It will improve speed and require less memory.
2) If you plan to run on smaller devices (which have memory constraints)
Where should we use range()?
1) When you have to traverse the list frequently, then it’s better to use range(). With xrange(), it would be an overhead to instantiate an integer object for every indexing request
2) If you are not looking for a wide range
3) If you wish to keep your Python 2.x code compatible with the version 3.x
• range() returns – range object.
xrange() returns – xrange() object.
• The variable storing the range created by range() takes more memory as compared to variable storing the range using xrange(). The basic reason for this is the return type of range() is list and xrange() is xrange() object.
• As range() returns the list, all the operations that can be applied on the list can be used on it. On the other hand, as xrange() returns the xrange object, operations associated to list cannot be applied on them, hence a disadvantage.
• Because of the fact that xrange() evaluates only the generator object containing only the values that are required by lazy evaluation, therefore is faster in implementation than range().
1. The range() and xrange() are two functions in Python, where range returns python list object and xrange() returns an xrange object.
2. These (range() and xrange()) are same in terms of functionality but xrange() is not used in python 3.x. It perform function in python 2.x
3. range() is faster if iterating over same sequence multiple time whereas xrange() is used to reconstruct the integer object everytime
1. range() and xrange() are same in functionality but range() performs function both in python 2.x and 3.x whereas xrange() performs only in 2.x
2. range() is faster if iterating over same sequence multiple times but xrange() has to reconstruct the integer object everytime.
3. range() returns python list object whereas xrange() returns xrange object.
range() and xrange() can be used to iterate a certain number of times in for loops in python.
Points of difference-
– Return type:
range() returns range object.(iterable)
xrange() returns xrange() object.(returns generator object that can be used to display numbers by looping)
example:
a=range(1, 1000)
x=xrange(1, 1000)
print(type(a))
print(type(x))
output:
list
xrange
Memory:
range() takes more memory as compared to xrange()
you can get size by importing sys and using sys.getsizeof(variable_name)
Operations usage:
Since range is a list all the operations which apply to list can be applied to a range but same is not the case with xrange().
Speed- xrange is faster
• Return type :-
range() : returns a list.
xrange() : returns an xrange() object.
CODE:
a = range(1,10000)
x = xrange(1,10000)
print (“range() return type : “)
print (type(a))
print (“xrange() return type : “)
print (type(x))
OUTPUT:
range() return type :
xrange() return type :
• Memory :-
range() takes more memory because itreturns a list.
xrange() takes lesser memory when compared to range() as it returns an xrange() object.
CODE:
a = range(1,10000)
x = xrange(1,10000)
print (“The size allotted using range() is : “)
print (sys.getsizeof(a))
print (“The size allotted using xrange() is : “)
print (sys.getsizeof(x))
OUTPUT:
The size allotted using range() is :
80064
The size allotted using xrange() is :
40
• Operations usage:-
range() returns a list & therefore, all the operations that can be applied on the list can be used on it.
xrange() returns the xrange() object, operations associated to list cannot be applied on it.
CODE:
a = range(1,6)
x = xrange(1,6)
print (“The list after slicing using range is : “)
print (a[2:5])
print (“The list after slicing using xrange is : “)
print (x[2:5])
OUTPUT:
The list after slicing using range is :
[3, 4, 5]
The list after slicing using xrange is :
ERROR:
Traceback (most recent call last):
File “1f2d94c59aea6aed795b05a19e44474d.py”, line 18, in
print (x[2:5])
TypeError: sequence index must be integer, not ‘slice’
• Speed :-
xrange() evaluates only the generator object containing only the values that are required by lazy evaluation. Therefore is faster in IMPLEMENTATION than range().
Range returns a Python list object and xrange returns an xrange object.
It means that xrange doesn’t actually generate a static list at run-time like range does. It creates the values as you need them (on the fly) with a special technique called yielding. This technique is used with a type of object known as generators.
1. The range() and xrange() are two functions in Python, where range returns python list object and xrange() returns an xrange object.
2. These (range() and xrange()) are same in terms of functionality but xrange() is not used in python 3.x. It perform function in python 2.x
3. range() is faster if iterating over same sequence multiple time whereas xrange() is used to reconstruct the integer object everytime
range() will return a list of numbers
xrange() will return an generator object which will be used only in looping.
code:
x = range(1,100)
y = xrange(3,4000)
print(“The range is” )
print(type(x))
print(“The xrange is”)
print(type(y))
Both range and xrange have the same functionality i.e. to generate a list of integers. However, range return a Python list object, and xrange returns an xrange object. This means that xrange doesn’t create a static list of numbers at runtime, but creates it as you need ( When we pass param in a for loop to generate number).
Example:
python_list = range(1,100) => return a list of numbers from 1 to 100
print(python_list) => prints [1, 2, 3,………………….100]
python_xrange = xrange(1, 100) => return an xrange object
print(python_xrange) => prints xrange(1, 100)
Now that we know what range and xrange is let’s see why we need both of them.
1. The choice of using range or xrange largely depends upon the use case. If we have to create a list of 100 numbers, we can go with either one of them. But what if we have to create a list of (1-1000000000) and our system is memory critical, then xrange is used.
2. Let’s say we have a list of numbers from 1-10000 and the program has to iterate through the list multiple times, it is preferred to use range as xrange will generate the number every time the program access a number.
Python 3 Update:
In python 3 xrange has been depreciated and range function works similar to xrange.
1.The xrange() function in Python is used to generate a sequence of numbers, similar to the range() function. However, xrange() is used only in Python 2.x whereas range() is used in Python 3.x.
2.range() object returns range object while xrange() object returns xrange object.
3.xrange don’t support slicing, concatenation or repetition while range supports slicing, concatenation (sing chain function)
4. Using in, not in, min() or max() on xrange is inefficient, while it can be used efficiently on range
5.range consumes more memory.
6.xrange is faster to implement.