Jaka jest różnica między funkcjami range i xrange w Pythonie 2.X?

Range tworzy listę, więc jeśli to zrobisz {[1] } tworzy listę w pamięci z elementami 9999999.

xrange jest generatorem, więc {[9] } jest obiektem sekwencji jest , który ocenia leniwie.

To prawda, ale w Pythonie 3 zakres będzie zaimplementowany przez Xrange () Pythona 2. Jeśli chcesz wygenerować listę, musisz wykonać:

list(range(1,100))

Pamiętaj, użyj modułu timeit, aby sprawdzić, który z małych fragmentów kodu jest szybszy!

$ 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

Osobiście zawsze używam funkcji range (), chyba że miałem do czynienia z naprawdę ogromnymi listami - jak widać, jeśli chodzi o czas, dla listy miliona wpisów dodatkowy koszt to tylko 0,04 sekundy. I jak wskazuje Corey, w Pythonie 3.0 xrange odejdzie, a range i tak da Ci ładne zachowanie iteratora.

xrange przechowuje tylko params zakresu i generuje liczby na żądanie. Jednak implementacja C Pythona obecnie ogranicza swoje args do C longów:

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]

Zauważ, że w Pythonie 3.0 istnieje tylko range i zachowuje się jak 2.x xrange ale bez ograniczeń co do minimalnych i maksymalnych punktów końcowych.

Xrange zwraca iterator i przechowuje tylko jedną liczbę w pamięci na raz. range przechowuje całą listę numerów w pamięci.

Spędź trochę czasu z referencją do biblioteki . Im bardziej jesteś z nim zaznajomiony, tym szybciej znajdziesz odpowiedzi na takie pytania. Szczególnie ważne są pierwsze kilka rozdziałów o budowanych obiektach i typach.

Zaletą typu xrange jest to, że obiekt xrange będzie zawsze weź taką samą ilość pamięci, bez względu na rozmiar zakresu, który reprezentuje. Nie ma stałych zalet wydajności.

Another way to find szybkie informacje na temat konstrukcji Pythona to docstring i funkcja help:

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

Range() vs xrange () w Pythonie:

Range() i xrange () to dwie funkcje, które mogą być użyte do iteracji pewnej liczby pętli for w Pythonie. W Pythonie 3 nie ma xrange, ale funkcja range zachowuje się jak xrange w Pythonie 2.Jeśli chcesz napisać kod, który będzie działał zarówno w Pythonie 2, jak i Pythonie 3, powinieneś użyć metody range ().

Range() – zwraca listę liczb utworzonych za pomocą funkcji range ().

Xrange–) - To funkcja zwraca obiekt generatora, który może być użyty do wyświetlania liczb tylko przez zapętlenie. Tylko określony zakres jest wyświetlany na żądanie i stąd nazywany "leniwą oceną".

Oba są realizowane na różne sposoby i mają różne cechy z nimi związane. Punkty porównania to:

1. Return Type Memory Operation Usage Speed
2. pamięć
3. Użycie Operacji
4. Speed

1. Typ Zwrotu :

Zwraca Range () – listę jako typ zwracany.

Xrange () zwraca- obiekt 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))

Wyjście:

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

2. Pamięć:

Zmienna przechowująca zakres utworzony przez range() zajmuje więcej pamięci niż zmienna przechowująca Zakres za pomocą xrange (). Podstawowym powodem tego jest zwracany typ range () is list, a xrange() to obiekt 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))

Wyjście :

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

3. Użycie operacji:

Ponieważ funkcja range () zwraca listę, można na niej użyć wszystkich operacji, które można zastosować na liście. Z drugiej strony, ponieważ xrange () zwraca obiekt xrange, operacje powiązane z list nie mogą być na nich stosowane, co jest wadą.

# 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])

Wyjście:

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. Prędkość:

Ze względu na fakt, że xrange() oblicza tylko obiekt generatora zawierający tylko wartości, które są wymagane przez leniwe ewaluacje, dlatego jest szybsze w implementacji niż range ().

Ważne Punkty:

1. Jeśli chcesz napisać kod, który będzie działał zarówno na Pythonie 2, jak i Pythonie 3, Użyj funkcji range (), ponieważ funkcja xrange jest przestarzała w Pythonie 3.
2. range() jest szybsze, jeśli iteracja nad tą samą sekwencją jest wielokrotna razy.
3. xrange () musi za każdym razem rekonstruować obiekt integer, ale range() będzie zawierać rzeczywiste obiekty liczb całkowitych. (Zawsze będzie wykonaj gorzej jednak pod względem pamięci).

Numer referencyjny

Range tworzy listę, więc jeśli wykonasz range (1, 10000000) tworzy listę w pamięci z 10000000 elementów. xrange jest generatorem, więc ocenia leniwie.

To daje dwie zalety:

1. możesz iterować dłuższe listy bez otrzymywania MemoryError.
2. ponieważ rozwiązuje każdą liczbę leniwie, jeśli zatrzymasz iterację wcześniej, nie będziesz tracił czasu na tworzenie całej listy.

Jestem w szoku, że nikt nie czyta doc :

Ta funkcja jest bardzo podobna do range(), ale zwraca obiekt xrange zamiast listy. Jest to nieprzezroczysty Typ sekwencji, który daje te same wartości co odpowiednia lista, bez przechowywania ich wszystkich jednocześnie. Przewaga xrange() nad range() jest minimalna (ponieważ xrange() nadal musi tworzyć wartości, gdy jest o nie pytany) z wyjątkiem sytuacji, gdy bardzo duży zakres jest używany na głodnej pamięci maszynie lub gdy cały zakres elementy nigdy nie są używane (np. gdy pętla jest zwykle zakończona break).

Jest to ze względów optymalizacyjnych.

Range() utworzy listę wartości od początku do końca (0 .. 20 w twoim przykładzie). Będzie to kosztowne działanie na bardzo dużych zakresach.

Xrange() z drugiej strony jest znacznie bardziej zoptymalizowany. obliczy następną wartość tylko wtedy, gdy będzie to potrzebne (za pomocą obiektu sekwencji xrange) i nie utworzy listy wszystkich wartości, tak jak robi to range ().

W tym prostym przykładzie znajdziesz przewagę xrange nad range:

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

Powyższy przykład nie odzwierciedla niczego znacznie lepszego w przypadku xrange.

Teraz spójrz na następujący przypadek, gdzie range jest naprawdę bardzo powolny, w porównaniu do 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

Z range, tworzy już listę od 0 do 100000000 (czasochłonne), ale {[2] } jest generatorem i generuje liczby tylko na podstawie potrzeby, czyli jeśli iteracja kontynuuje.

Szczęśliwego Kodowania!!

Range(): range(1, 10) zwraca listę od 1 do 10 liczb i przechowuje całą listę w pamięci.

Xrange (): podobnie jak range (), ale zamiast zwracać listę, zwraca obiekt, który na żądanie generuje liczby z zakresu. W przypadku zapętlania jest to nieco szybsze niż range () i wydajniejsze pamięci. obiekt xrange () jak iterator i generuje liczby na żądanie.(Ocena Leniwa)

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) zwraca listę każdej liczby pomiędzy x I y jeśli użyjesz pętli for, to range jest wolniejsze. W rzeczywistości range ma większy zakres indeksów. range(x.y) wyświetli listę wszystkich liczb pomiędzy x i y

xrange(x,y) zwraca xrange(x,y) ale jeśli użyłeś pętli for, to xrange jest szybszy. xrange ma mniejszy zakres indeksów. xrange nie tylko wydrukuje xrange(x,y), ale nadal zachowa wszystkie liczby, które są w nim.

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

Jeśli użyjesz pętli for, to praca

[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

Nie ma dużej różnicy przy używaniu pętli, ale jest różnica podczas samego drukowania!

W Pythonie 2.x

Range (x) zwraca listę utworzoną w pamięci z elementami x.

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

Xrange (x) zwraca obiekt xrange będący generatorem obj, który generuje liczby na żądanie. są one obliczane podczas pętli for (ocena leniwa).

W przypadku zapętlania jest to nieco szybsze niż range () i wydajniejsze pamięć.

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

Podczas testowania zakresu na xrange w pętli (wiem, że powinienem użyć timeit , ale to zostało szybko zhakowane z pamięci za pomocą prostego przykładu rozumienia listy) znalazłem następujące:

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)

Co daje:

$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?

Lub, używając xrange w pętli 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

Czy mój fragment testuje się prawidłowo? Jakieś uwagi na temat wolniejszej instancji xrange? Albo lepszy przykład: -)

Niektóre z innych odpowiedzi wspominają, że Python 3 wyeliminował 2.x range i przemianowane na 2.x xrange do range. Jednak, o ile nie używasz 3.0 lub 3.1 (których nikt nie powinien być), Jest to w rzeczywistości nieco inny typ.

Jako 3.1 docs mówią:

Obiekty Range zachowują się bardzo słabo: obsługują tylko indeksowanie, iterację i funkcję len.

Jednak w 3.2+ range jest pełna sekwencja-obsługuje rozszerzone plastry, a wszystkie metody collections.abc.Sequence z tą samą semantyką co list.^*

I, przynajmniej w CPython i PyPy (jedyne dwie implementacje 3.2+, które obecnie istnieją), ma również implementacje w czasie stałym metod index i count oraz operatora in (o ile przekazujesz tylko liczby całkowite). Oznacza to, że pisanie 123456 in r jest rozsądne w 3.2+, podczas gdy w 2.7 lub 3.1 byłoby to okropnym pomysłem.

_{* fakt, że issubclass(xrange, collections.Sequence) zwraca True W 2,6-2,7 i 3.0-3.1 jest błędem, który został naprawiony w 3.2 i nie był backportowany.}

Xrange() i range () w Pythonie działają podobnie jak w przypadku użytkownika, ale różnica pojawia się, gdy mówimy o tym, jak pamięć jest przydzielana przy użyciu obu funkcji.

Kiedy używamy funkcji range() przydzielamy pamięć dla wszystkich generowanych zmiennych, więc nie jest zalecane używanie z większym no. zmiennych do wygenerowania.

Xrange () z drugiej strony generuje tylko określoną wartość w danym czasie i może być użyte tylko z pętlą for do wypisania wszystkich wartości wymagane.

Range generuje całą listę i zwraca ją. xrange nie -- generuje liczby z listy na żądanie.

Przeczytaj poniższy post, aby porównać zakres i xrange z analizą graficzną.

Python range Vs xrange

Xrange używa iteratora (generuje wartości w locie), range zwraca listę.

Co?
range zwraca listę statyczną w czasie wykonywania.
xrange zwraca object (który działa jak generator, choć z pewnością nie jest nim), z którego wartości są generowane w razie potrzeby.

Kiedy użyć którego?

• użyj xrange jeśli chcesz wygenerować listę dla gigantycznego zakresu, powiedzmy 1 miliarda, zwłaszcza gdy masz "system wrażliwy na pamięć", taki jak telefon komórkowy.
• użyj range jeśli chcesz iterować na liście kilka razy.

PS: Python 3.x ' S range function = = Python 2.funkcja x xrange.

Na wymogu skanowania / drukowania 0-N elementów, zakres i xrange działa w następujący sposób.

Range () - wytworzy nową listę w pamięci i przeniesie całe 0 do n pozycji (całkowicie N+1) i wyświetli je. xrange () - tworzy instancję iteratora, która skanuje elementy i przechowuje tylko bieżący napotkany element w pamięci, przez co cały czas wykorzystuje tę samą ilość pamięci.

W przypadku gdy wymagany element znajduje się nieco na początku listy tylko wtedy zapisuje dużo czasu i pamięci.

Różnica maleje dla mniejszych argumentów do 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

W tym przypadku xrange(100) jest tylko o około 20% bardziej wydajny.

Wszyscy bardzo to wyjaśnili. Ale chciałem, żeby zobaczył to na własne oczy. Używam python3. Tak więc otworzyłem Monitor zasobów (w Windows!), A Najpierw wykonała następującą komendę:

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

, a następnie zaznaczono zmianę w pamięci "w użyciu". To było nieistotne. Następnie uruchomiłem następujący kod:

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

I potrzeba było dużej części pamięci do użycia, natychmiast. I byłem przekonany. Możesz sam spróbować.

Jeśli używasz Pythona 2X, to zamień "range ()" z "xrange ()" w pierwszym kodzie i "list (range ())" Z " range ()".

Range zwraca list podczas gdy xrange zwraca obiekt xrange, który pobiera tę samą pamięć niezależnie od rozmiaru zakresu,jak w tym przypadku, tylko jeden element jest generowany i dostępny w iteracji, podczas gdy w przypadku użycia range, wszystkie elementy są generowane jednocześnie i są dostępne w pamięci.

Range: - range wypełni wszystko na raz.co oznacza, że każda liczba z zakresu zajmie pamięć.

Xrange: - xrange jest czymś w rodzaju generatora, pojawi się w obrazku, gdy chcesz zakres liczb, ale nie chcesz, aby były przechowywane, jak gdy chcesz użyć w for loop.so pamięć wydajna.

Z dokumentów pomocy.

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

Różnica jest widoczna. W Pythonie 2.x, range zwraca listę, xrange zwraca obiekt xrange, który można iterować.

W Pythonie 3.x, range staje się xrange Pythona 2.X i xrange jest usuwane.

Zobacz ten post aby znaleźć różnicę między zakresem i xrange:

Cytuję:

range zwraca dokładnie to, co myślisz: listę kolejnych liczby całkowite o określonej długości rozpoczynającej się od 0. xrange, jednak, zwraca "obiekt xrange" , który działa jak iterator