Cuál es la diferencia entre las funciones range y xrange en Python 2.¿X?

Range crea una lista, por lo que si lo hace range(1, 10000000) crea una lista en memoria con elementos 9999999.

xrange es un generador, por lo que es un objeto de secuencia es a que evalúa perezosamente.

Esto es cierto, pero en Python 3, range será implementado por Python 2 xrange(). Si realmente necesita generar la lista, tendrá que hacer:

list(range(1,100))

Recuerde, utilice el módulo timeit para probar cuál de los pequeños fragmentos de código es más rápido!

$ python -m timeit 'for i in range(1000000):' ' pass'
10 loops, best of 3: 90.5 msec per loop
$ python -m timeit 'for i in xrange(1000000):' ' pass'
10 loops, best of 3: 51.1 msec per loop

Personalmente, siempre uso range(), a menos que esté tratando con realmente listas enormes as como puedes ver, en cuanto al tiempo, para una lista de un millón de entradas, la sobrecarga adicional es de solo 0.04 segundos. Y como señala Corey, en Python 3.0 xrange desaparecerá y range le dará un buen comportamiento de iterador de todos modos.

xrange solo almacena los parámetros de rango y genera los números bajo demanda. Sin embargo, la implementación en C de Python actualmente restringe sus args a C longs:

xrange(2**32-1, 2**32+1)  # When long is 32 bits, OverflowError: Python int too large to convert to C long
range(2**32-1, 2**32+1)   # OK --> [4294967295L, 4294967296L]

Tenga en cuenta que en Python 3.0 solo hay range y se comporta como el 2.x xrange pero sin las limitaciones en los puntos finales mínimo y máximo.

Xrange devuelve un iterador y solo mantiene un número en memoria a la vez. range mantiene toda la lista de números en memoria.

Pase algún tiempo con la Referencia de la Biblioteca . Cuanto más familiarizado esté con él, más rápido podrá encontrar respuestas a preguntas como esta. Especialmente importantes son los primeros capítulos sobre objetos y tipos incorporados.

La ventaja del tipo xrange es que un objeto xrange siempre tome la misma cantidad de memoria, sin importar el tamaño del rango que represente. No hay ventajas de rendimiento consistentes.

Otra manera de encontrar la información rápida sobre una construcción Python es docstring y la función help:

print xrange.__doc__ # def doc(x): print x.__doc__ is super useful
help(xrange)

Range () vs xrange () en python:

Range() y xrange() son dos funciones que podrían usarse para iterar un cierto número de veces en bucles for en Python. En Python 3, no hay xrange, pero la función range se comporta como xrange en Python 2.Si desea escribir código que se ejecutará en Python 2 y Python 3, debe usar range ().

Range–) - Esto devuelve una lista de números creados usando la función range ().

Xrange () - Esto la función devuelve el objeto generador que se puede usar para mostrar números solo mediante bucle. Solo un rango particular se muestra bajo demanda y, por lo tanto, se llama "evaluación perezosa".

Ambos se implementan de diferentes maneras y tienen diferentes características asociadas con ellos. Los puntos de comparación son:

1. Tipo de retorno Operación de Memoria Velocidad de Uso
2. Memoria
3. Uso de la operación
4. Velocidad

1. Tipo de Retorno :

Range () devuelve – la lista como tipo de retorno.

Xrange() devuelve – objeto xrange ().

# initializing a with range()
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))

Salida :

The return type of range() is :
<type 'list'>
The return type of xrange() is :
<type 'xrange'>

2. Memoria :

La variable que almacena el rango creado por range() toma más memoria en comparación con la variable que almacena el rango usando xrange(). La razón básica de esto es que el tipo de retorno de range() es list y xrange() es el objeto xrange ().

# initializing a with range()
a = range(1,10000)

# initializing a with xrange()
x = xrange(1,10000)

# testing the size of a
print ("The size allotted using range() is : ")
print (sys.getsizeof(a))

# testing the size of a
print ("The size allotted using xrange() is : ")
print (sys.getsizeof(x))

Salida :

The size allotted using range() is : 
80064
The size allotted using xrange() is : 
40

3. Uso de operaciones:

Como range() devuelve la lista, todas las operaciones que se pueden aplicar en la lista se pueden usar en ella. Por otro lado, como xrange() devuelve el objeto xrange, las operaciones asociadas a list no se pueden aplicar sobre ellos, por lo tanto una desventaja.

# Python code to demonstrate range() vs xrange()
# on  basis of operations usage 

# initializing a with range()
a = range(1,6)

# initializing a with xrange()
x = xrange(1,6)

# testing usage of slice operation on range()
print ("The list after slicing using range is : ")
print (a[2:5])

# testing usage of slice operation on xrange()
print ("The list after slicing using xrange is : ")
print (x[2:5])

Salida :

The list after slicing using range is :
[3, 4, 5]
The list after slicing using xrange is :
Traceback (most recent call last):
  File "pp.py", line 18, in <module>
    print (x[2:5])
TypeError: sequence index must be integer, not 'slice'

4. Velocidad :

Debido al hecho de que xrange () evalúa solo el objeto generador que contiene solo los valores que son requerido por la evaluación perezosa, por lo tanto es más rápido en la implementación que range().

Puntos Importantes :

1. Si desea escribir código que se ejecutará tanto en Python 2 como en Python 3, use range () ya que la función xrange está obsoleta en Python 3.
2. range() es más rápido si se itera sobre la misma secuencia múltiple tiempo.
3. xrange () tiene que reconstruir el objeto entero cada vez, pero range () tendrá objetos enteros reales. (Siempre realizar peor en términos de memoria sin embargo).

Referencia

Range crea una lista, por lo que si hace range(1, 10000000) crea una lista en memoria con 10000000 elementos. xrange es un generador, por lo que se evalúa perezosamente.

Esto te trae dos ventajas:

1. Puede iterar listas más largas sin obtener un MemoryError.
2. Como resuelve cada número perezosamente, si detiene la iteración antes, no perderá tiempo creando toda la lista.

Me sorprende que nadie lea doc :

Esta función es muy similar a range(), pero devuelve un objeto xrange en lugar de una lista. Este es un tipo de secuencia opaca que produce los mismos valores que la lista correspondiente, sin almacenarlos todos simultáneamente. La ventaja de xrange() sobre range() es mínima (ya que xrange() todavía tiene que crear los valores cuando se les pide), excepto cuando se utiliza un rango muy grande en una máquina carente de memoria o cuando todos los los elementos nunca se usan (como cuando el bucle normalmente termina con break).

Es por razones de optimización.

Range() creará una lista de valores de principio a fin (0 .. 20 en su ejemplo). Esto se convertirá en una operación costosa en rangos muy grandes.

Xrange() por otro lado está mucho más optimizado. solo calculará el siguiente valor cuando sea necesario (a través de un objeto de secuencia xrange) y no crea una lista de todos los valores como lo hace range ().

Encontrará la ventaja de xrange sobre range en este simple ejemplo:

import timeit

t1 = timeit.default_timer()
a = 0
for i in xrange(1, 100000000):
    pass
t2 = timeit.default_timer()

print "time taken: ", (t2-t1)  # 4.49153590202 seconds

t1 = timeit.default_timer()
a = 0
for i in range(1, 100000000):
    pass
t2 = timeit.default_timer()

print "time taken: ", (t2-t1)  # 7.04547905922 seconds

El ejemplo anterior no refleja nada sustancialmente mejor en el caso de xrange.

Ahora mira el siguiente caso donde range es realmente muy lento, comparado con xrange.

import timeit

t1 = timeit.default_timer()
a = 0
for i in xrange(1, 100000000):
    if i == 10000:
        break
t2 = timeit.default_timer()

print "time taken: ", (t2-t1)  # 0.000764846801758 seconds

t1 = timeit.default_timer()
a = 0
for i in range(1, 100000000):
    if i == 10000:
        break
t2 = timeit.default_timer() 

print "time taken: ", (t2-t1)  # 2.78506207466 seconds

Con range, ya crea una lista de 0 a 100000000 (consume mucho tiempo), pero xrange es un generador y solo genera números basados en la necesidad, es decir, si la iteración continuar.

En Python-3, la implementación de la funcionalidad range es la misma que la de xrange en Python-2, mientras que han eliminado xrange en Python-3

Feliz Codificación!!

Range(): range(1, 10) devuelve una lista de 1 a 10 números y mantiene la lista completa en memoria.

Xrange (): Como range (), pero en lugar de devolver una lista, devuelve un objeto que genera los números en el rango bajo demanda. Para el bucle, esto es ligeramente más rápido que range() y más eficiente en memoria. xrange () object like an iterator and generates the numbers on demand.(Evaluación perezosa)

In [1]: range(1,10)

Out[1]: [1, 2, 3, 4, 5, 6, 7, 8, 9]

In [2]: xrange(10)

Out[2]: xrange(10)

In [3]: print xrange.__doc__

xrange([start,] stop[, step]) -> xrange object

range(x,y) devuelve una lista de cada número entre x e y si usa un bucle for, entonces range es más lento. De hecho, range tiene un rango de índice más grande. range(x.y) imprimirá una lista de todos los números entre x e y

xrange(x,y) devuelve xrange(x,y) pero si se utiliza un bucle for, entonces xrange es más rápido. xrange tiene un rango de índice más pequeño. xrange no solo imprimirá xrange(x,y) sino que mantendrá todos los números que contiene.

[In] range(1,10)
[Out] [1, 2, 3, 4, 5, 6, 7, 8, 9]
[In] xrange(1,10)
[Out] xrange(1,10)

Si usas un bucle for, entonces sería trabajo

[In] for i in range(1,10):
        print i
[Out] 1
      2
      3
      4
      5
      6
      7
      8
      9
[In] for i in xrange(1,10):
         print i
[Out] 1
      2
      3
      4
      5
      6
      7
      8
      9

No Hay mucha diferencia cuando se utiliza bucles, aunque hay una diferencia cuando acaba de impresión!

En python 2.x

Range (x) devuelve una lista, que se crea en memoria con x elementos.

>>> a = range(5)
>>> a
[0, 1, 2, 3, 4]

Xrange (x) devuelve un objeto xrange que es un objeto generador que genera los números bajo demanda. se calculan durante for-loop (Evaluación perezosa).

Para el bucle, esto es ligeramente más rápido que range() y más eficiente en memoria.

>>> b = xrange(5)
>>> b
xrange(5)

Al probar el rango contra xrange en un bucle (sé que debería usar timeit , pero esto fue rápidamente hackeado de la memoria usando un ejemplo de comprensión de lista simple) encontré lo siguiente:

import time

for x in range(1, 10):

    t = time.time()
    [v*10 for v in range(1, 10000)]
    print "range:  %.4f" % ((time.time()-t)*100)

    t = time.time()
    [v*10 for v in xrange(1, 10000)]
    print "xrange: %.4f" % ((time.time()-t)*100)

Que da:

$python range_tests.py
range:  0.4273
xrange: 0.3733
range:  0.3881
xrange: 0.3507
range:  0.3712
xrange: 0.3565
range:  0.4031
xrange: 0.3558
range:  0.3714
xrange: 0.3520
range:  0.3834
xrange: 0.3546
range:  0.3717
xrange: 0.3511
range:  0.3745
xrange: 0.3523
range:  0.3858
xrange: 0.3997 <- garbage collection?

O, usando xrange en el bucle for:

range:  0.4172
xrange: 0.3701
range:  0.3840
xrange: 0.3547
range:  0.3830
xrange: 0.3862 <- garbage collection?
range:  0.4019
xrange: 0.3532
range:  0.3738
xrange: 0.3726
range:  0.3762
xrange: 0.3533
range:  0.3710
xrange: 0.3509
range:  0.3738
xrange: 0.3512
range:  0.3703
xrange: 0.3509

¿Mi fragmento está probando correctamente? ¿Algún comentario sobre la instancia más lenta de xrange? O un mejor ejemplo: -)

Algunas de las otras respuestas mencionan que Python 3 eliminó a 2.x range y renombrado 2.x xrange a range. Sin embargo, a menos que estés usando 3.0 o 3.1 (que nadie debería estar), en realidad es un tipo algo diferente.

Como los documentos 3.1 dicen: {[14]]}

Los objetos de rango tienen muy poco comportamiento: solo admiten indexación, iteración y la función len.

Sin embargo, en 3.2+, range es una secuencia completa-soporta rebanadas extendidas, y todos los métodos de collections.abc.Sequence con la misma semántica como list.^*

Y, al menos en CPython y PyPy (las únicas dos implementaciones 3.2+ que existen actualmente), también tiene implementaciones en tiempo constante de los métodos index y count y el operador in (siempre y cuando solo le pases enteros). Esto significa que escribir 123456 in r es razonable en 3.2+, mientras que en 2.7 o 3.1 sería una idea horrible.

_{* El hecho de que issubclass(xrange, collections.Sequence) devuelve True en 2.6-2.7 y 3.0 - 3.1 es un bug que se solucionó en 3.2 y no se hizo backport.}

Xrange() y range() en python funcionan de manera similar como para el usuario , pero la diferencia viene cuando estamos hablando de cómo se asigna la memoria al usar ambas funciones.

Cuando estamos usando range() asignamos memoria para todas las variables que está generando, por lo que no se recomienda usar con mayor no. de variables a generar.

Xrange() por otro lado genera solo un valor particular a la vez y solo se puede usar con el bucle for para imprimir todos los valores requerir.

Range genera la lista completa y la devuelve. xrange no generates genera los números en la lista bajo demanda.

Lea el siguiente post para la comparación entre range y xrange con análisis gráfico.

Rango de Python Vs xrange

Xrange utiliza un iterador (genera valores sobre la marcha), range devuelve una lista.

¿Qué?
range devuelve una lista estática en tiempo de ejecución.
xrange devuelve un object (que actúa como un generador, aunque ciertamente no es uno) a partir del cual se generan valores cuando se requiere.

¿Cuándo usar cuál?

• Use xrange si desea generar una lista para un rango gigantesco, digamos 1 mil millones, especialmente cuando tiene un "sistema sensible a la memoria" como un teléfono celular.
• Use range si desea iterar sobre la lista varios tiempo.

PS: Python 3.función x range = = Python 2.función xrange de x.

En un requisito para escanear/imprimir elementos 0-N , range y xrange funcionan de la siguiente manera.

Range() - crea una nueva lista en la memoria y toma todo el 0 a N elementos(totalmente N+1) y los imprime. xrange () - crea una instancia iteradora que escanea a través de los elementos y mantiene solo el elemento encontrado actual en la memoria , por lo tanto, utilizando la misma cantidad de memoria todo el tiempo.

En caso de que el elemento requerido esté algo al principio de la lista solo entonces guarda un buena cantidad de tiempo y memoria.

La diferencia disminuye para argumentos más pequeños a range(..) / xrange(..):

$ python -m timeit "for i in xrange(10111):" " for k in range(100):" "  pass"
10 loops, best of 3: 59.4 msec per loop

$ python -m timeit "for i in xrange(10111):" " for k in xrange(100):" "  pass"
10 loops, best of 3: 46.9 msec per loop

En este caso xrange(100) es solo un 20% más eficiente.

Todo el mundo lo ha explicado mucho. Pero quería verlo por mí mismo. Yo uso python3. Por lo tanto, abrí el monitor de recursos (en Windows!), y primero, ejecutó el siguiente comando primero:

a=0
for i in range(1,100000):
    a=a+i

Y luego comprobó el cambio en la memoria 'En uso'. Era insignificante. Entonces, ejecuté el siguiente código:

for i in list(range(1,100000)):
    a=a+i

Y tomó una gran parte de la memoria para su uso, al instante. Y estaba convencido. Puedes probarlo por ti mismo.

Si está utilizando Python 2X, reemplace 'range()' con 'xrange()' en el primer código y 'list(range())' con 'range()'.

Range devuelve un list mientras que xrange devuelve un objeto xrange que toma la misma memoria independientemente del tamaño del rango,ya que en este caso,solo se genera un elemento y está disponible por iteración mientras que en el caso de usar range, todos los elementos se generan a la vez y están disponibles en la memoria.

Rango :-rango llenará todo a la vez.lo que significa que cada número del rango ocupará la memoria.

Xrange: - xrange es algo así como el generador, que va a entrar en la imagen cuando se desea que el rango de números, pero usted no quiere que se almacenen, como cuando se quiere utilizar en para loop.so memoria eficiente.

De los documentos de ayuda.

Python 2.7.12

>>> print range.__doc__
range(stop) -> list of integers
range(start, stop[, step]) -> list of integers

Return a list containing an arithmetic progression of integers.
range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.
When step is given, it specifies the increment (or decrement).
For example, range(4) returns [0, 1, 2, 3].  The end point is omitted!
These are exactly the valid indices for a list of 4 elements.

>>> print xrange.__doc__
xrange(stop) -> xrange object
xrange(start, stop[, step]) -> xrange object

Like range(), but instead of returning a list, returns an object that
generates the numbers in the range on demand.  For looping, this is 
slightly faster than range() and more memory efficient.

Python 3.5.2

>>> print(range.__doc__)
range(stop) -> range object
range(start, stop[, step]) -> range object

Return an object that produces a sequence of integers from start (inclusive)
to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
These are exactly the valid indices for a list of 4 elements.
When step is given, it specifies the increment (or decrement).

>>> print(xrange.__doc__)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'xrange' is not defined

La diferencia es aparente. En Python 2.x, range devuelve una lista, xrange devuelve un objeto xrange que es iterable.

En Python 3.x, range se convierte en xrange de Python 2.x, y xrange se elimina.

Ver este post para encontrar la diferencia entre rango y xrange:

Para citar:

range devuelve exactamente lo que piensa: una lista de consecutivos enteros, de una longitud definida que comienza con 0. xrange, sin embargo, devuelve un "xrange object" , que actúa en gran medida como un iterador