Qual è la differenza tra gamma e xrange funzioni in Python 2.X?

Question

A quanto pare xrange è più veloce, ma non ho idea del perché è più veloce (e non c'è prova oltre l'aneddotica così lontano che è più veloce) o che cosa, oltre che è diverso

for i in range(0, 20):
for i in xrange(0, 20):

Answer 1

gamma crea un elenco, in modo che, se range(1, 10000000) crea una lista in memoria con 9999999 elementi.

xrange è una sequenza di oggetti che valuta pigramente.

Esso deve essere aggiunto da @Thiago del suggerimento, che in python3, l'intervallo l'equivalente di python xrange

Answer 2

gamma crea un elenco, in modo che, se range(1, 10000000) crea una lista in memoria con 9999999 elementi.

xrange è un generatore, in modo è una sequenza di oggetti è un che valuta pigramente.

Questo è vero, ma in Python 3, .range() saranno attuati da Python 2 .xrange().Se è necessario generare un elenco, è necessario fare:

list(range(1,100))

Answer 3

Ricordate, utilizzare il timeit modulo per il test di piccoli frammenti di codice è più veloce!

$ 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, io uso sempre .range(), meno che io non abbia a che fare con davvero le liste enormi ... come potete vedere, il tempo-saggio, per un elenco di milioni di voci, overhead aggiuntivo è solo lo 0,04 secondi.E come Corey, in Python 3.0 .xrange() andrà via e .range() vi darà bello iteratore comportamento comunque.

Answer 4

xrange memorizza solo la gamma di parametri e genera i numeri su richiesta.Tuttavia l'implementazione C di Python attualmente limita la sua arg 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]

Nota che in Python 3.0 c'è solo range e si comporta come il 2.x xrange ma senza i limiti di minimo e massimo dei punti finali.

Answer 5

xrange restituisce un iteratore e mantiene solo un numero nella memoria alla volta.gamma mantiene l'intero elenco di numeri in memoria.

Answer 6

Vi consigliamo di trascorrere del tempo con la Biblioteca Di Riferimento.Il più familiare siete con esso, il più veloce è possibile trovare le risposte a domande come questa.Particolarmente importanti sono i primi capitoli su builtin oggetti e tipi.

Il vantaggio del xrange tipo è che un xrange oggetto sarà sempre prendere la stessa quantità di memoria, non importa la dimensione dell'intervallo che rappresenta.Non esistono grandi vantaggi in termini di prestazioni.

Un altro modo per trovare informazioni su un Python costruire è la docstring e la funzione help:

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

Answer 7

gamma crea un elenco, in modo che, se l'intervallo(1, 10000000) crea una lista in memoria con 10000000 elementi.xrange è un generatore, in modo da valutare pigramente.

Questo comporta due vantaggi:

1. Si può scorrere elenchi più lunghi senza ottenere un MemoryError.
2. Come si risolve ogni numero pigramente, se si smette di iterazione presto, non devi perdere tempo con la creazione di tutta la lista.

Answer 8

Io sono scioccato nessuno leggere doc:

Questa funzione è molto simile a range(), ma restituisce un xrange oggetto invece di un elenco.Questo è un opaco tipo di sequenza che produce gli stessi valori della lista corrispondente, senza in realtà la memorizzazione di tutti contemporaneamente.Il vantaggio di xrange() oltre range() è minima (dal xrange() ancora per creare i valori, quando ha chiesto per loro), tranne quando una gamma molto ampia che viene utilizzato in una memoria affamato di macchina o quando tutta la gamma degli elementi non sono mai utilizzato (come quando il ciclo è di solito risolto con break).

Answer 9

È per motivi di ottimizzazione.

gamma() per creare un elenco di valori, dall'inizio alla fine (0 ..20 nel tuo esempio).Questo diventerà un'operazione costosa su grandi distanze.

xrange (), invece, è molto più ottimizzato.solo di calcolare il valore successivo, quando necessario (tramite un xrange oggetto sequenza) e non creare un elenco di tutti i valori come la funzione range() fa.

Answer 10

Troverete il vantaggio di xrange oltre range in questo semplice esempio:

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

L'esempio di cui sopra non riflettono nulla sostanzialmente migliore in caso di xrange.

Ora guarda caso in cui range è davvero molto lento, rispetto a 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, si è già creato un elenco da 0 a 100000000(tempo), ma xrange è un generatore che genera solo i numeri in base alle necessità, che è, se l'iterazione continua.

In Python-3, l'attuazione del range la funzionalità è identica a quella del xrange in Python-2, mentre hanno fatto via con xrange in Python-3

Codifica Felice!!

Answer 11

range (a): intervallo(1, 10) restituisce una lista da 1 a 10 numeri e tenere premuto intero elenco in memoria.

xrange(): Come range(), ma invece di restituire una lista, restituisce un oggetto che genera i numeri nell'intervallo su richiesta.Per loop, questo è leggermente più veloce di gamma() e la memoria più efficiente.xrange() oggetto come un iteratore e genera i numeri su richiesta.(Lazy Evaluation)

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

Answer 12

range(x,y) restituisce un elenco di ogni numero tra x e y, se si utilizza un for loop, quindi range è più lento.Infatti, range ha un grande Indice di gamma. range(x.y) stampare un elenco di tutti i numeri compresi tra x e y

xrange(x,y) restituisce xrange(x,y) ma se è stato utilizzato un for loop, quindi xrange è più veloce. xrange ha un Indice più piccolo della gamma. xrange non solo la stampa xrange(x,y) ma ancora mantenere tutti i numeri che sono in esso.

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

Se si utilizza un for loop, poi sarebbe

[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

Non c'è molta differenza quando si utilizza il loop, se c'è una differenza, quando la stampa!

Answer 13

In python 2.x

gamma(x) restituisce un elenco, che viene creato in memoria con x elementi.

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

xrange(x) restituisce un xrange oggetto che è un generatore di obj che genera i numeri su richiesta.sono calcolati durante il ciclo for(Lazy Evaluation).

Per loop, questo è leggermente più veloce rispetto intervallo di memoria più efficiente.

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

Answer 14

Durante il test contro i xrange in un ciclo (so che dovrei usare timeit, ma questo è stato rapidamente violato dalla memoria utilizzando un semplice elenco di comprensione esempio) ho trovato il seguente:

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)

che assicura:

$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, utilizzando xrange nel ciclo 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

È il mio frammento di test correttamente?Commenti su il più lento istanza di xrange?O un esempio migliore :-)

Answer 15

Alcune delle altre risposte ricordare che Python 3 eliminato 2.x range e rinominato 2.x xrange per range.Tuttavia, a meno che non si sta utilizzando 3.0 o 3.1 (che nessuno dovrebbe essere), è in realtà un po ' diversa.

Come 3.1 documenti dire:

La gamma di oggetti che hanno molto poco di comportamento:hanno solo il supporto di indicizzazione, l'iterazione, e il len funzione.

Tuttavia, nel 3,2+, range è una sequenza completa—supporta estesa a fette, e di tutti i metodi di collections.abc.Sequence con la stessa semantica di un list.^*

E, almeno in CPython e PyPy (due soli 3.2+ implementazioni che attualmente esistono), si ha anche il tempo costante implementazioni di index e count i metodi e le in operatore (come passare solo numeri interi).Questo significa scrivere 123456 in r è ragionevole 3.2+, mentre nel 2,7 3,1 sarebbe un'idea terribile.

---

_{* Il fatto che issubclass(xrange, collections.Sequence) restituisce True a 2.6-2.7 e 3.0-3.1 è un bug che è stato risolto in 3.2 e non backport.}

Answer 16

xrange() e la funzione range() in python funziona allo stesso modo come per l'utente , ma la differenza è quando stiamo parlando di come la memoria viene allocata utilizzare sia la funzione.

Quando si utilizza la funzione range() abbiamo allocare memoria per tutte le variabili che si sta generando, quindi non è raccomandato per l'uso con i più grandi no.di variabili che devono essere generati.

xrange() invece di generare solo un particolare valore alla volta e può essere utilizzato solo con il ciclo for per stampare tutti i valori richiesti.

Answer 17

gamma genera l'intero elenco e la restituisce.xrange non -- genera i numeri della lista su richiesta.

Answer 18

Leggere il seguente post per il confronto tra gamma e xrange con l'analisi grafica.

Python gamma Vs xrange

Answer 19

xrange utilizza un iteratore (genera valori al volo), intervallo restituisce un elenco.

Answer 20

Cosa????
range restituisce un elenco statico in fase di runtime.
xrange restituisce un object (che agisce come un generatore, anche se certamente non è uno) da cui valori sono generati come e quando richiesto.

Quando utilizzare?

• Utilizzare xrange se si desidera generare un elenco per una gigantesca gamma, dire 1 miliardo, soprattutto quando si ha una "memoria di sistema sensibili" come un telefono cellulare.
• Utilizzare range se si desidera scorrere l'elenco più volte.

PS:Python 3.x range funzione == Python 2.x xrange funzione.

Answer 21

Su un requisito per la scansione/stampa 0-N elementi , gamma e xrange funziona come segue.

gamma() - crea un nuovo elenco in memoria e prende tutta la 0 per N elementi(in totale N+1) e li stampa.xrange() - crea un iteratore istanza che esegue la scansione di tutti gli elementi e mantiene solo la corrente incontrato elemento in memoria , quindi utilizzando stessa quantità di memoria per tutto il tempo.

Nel caso In cui l'elemento richiesto è un po ' all'inizio della lista solo allora esso consente di risparmiare una buona quantità di tempo e di memoria.

Answer 22

La differenza diminuisce il per i piccoli argomenti 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

In questo caso xrange(100) è solo circa il 20% più efficiente.

Answer 23

Ognuno di noi ha spiegato molto.Ma l'ho voluto vedere per me.Io uso python3.Così, ho aperto il monitor risorse (in Windows!), e prima, eseguite il seguente comando prima:

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

e poi controllato il cambiamento 'In Uso' di memoria.Era insignificante.Allora, ho eseguito il seguente codice:

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

E ci sono voluti un grande pezzo di memoria per l'uso, istantaneamente.E mi sono convinta.Si può provare per te.

Se si utilizza Python 2X, quindi sostituire il " range()' con 'xrange()' nel primo codice e 'in lista(gamma())' con 'gamma()'.

Answer 24

Gamma restituisce un elenco mentre xrange restituisce un xrange oggetto che ha la stessa memoria, a prescindere dalla gamma di dimensioni,come in questo caso,un solo elemento viene generato e disponibile per ogni iterazione, mentre in caso di utilizzo di gamma, tutti gli elementi sono generati in una sola volta e sono disponibili in memoria.

Answer 25

intervallo: intervallo di compilare tutto in una volta.il che significa che ogni numero della gamma occuperà di memoria.

xrange :-xrange è qualcosa di simile a un generatore ,esso entra in foto quando si desidera che l'intervallo di numeri, ma non si desidera loro di essere conservati,come quando si desidera utilizzare nel ciclo for.così la memoria efficiente.

Answer 26

Con l'aiuto di documenti.

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 differenza è evidente.In Python 2.x, range restituisce una lista xrange restituisce un xrange oggetto che è iterable.

In Python 3.x, range diventa xrange di Python 2.x, e xrange viene rimosso.

Answer 27

Inoltre, se non list(xrange(...)) sarà equivalente a range(...).

Così list è lento.

Anche xrange in realtà non completamente terminare la sequenza

Ecco perché la sua non è una lista, è un xrange oggetto

Answer 28

Vedere questo post per trovare la differenza tra gamma e xrange:

Citazione:

range restituisce esattamente quello che si pensa:un elenco di consecutivi numeri interi, di lunghezza definita a partire da 0. xrange, tuttavia, restituisce un "xrange oggetto", che agisce come un grande affare come un iteratore