Sollten Sie immer xrange () gegenüber range () bevorzugen?

Warum oder warum nicht?

Die Leistung xrange()ist normalerweise besser , insbesondere wenn Sie über einen großen Bereich iterieren . Es gibt jedoch noch einige Fälle, die Sie bevorzugen könnten range():

• Tut in Python 3, range()was xrange()früher getan wurde und xrange()nicht existiert. Wenn Sie Code schreiben möchten, der sowohl auf Python 2 als auch auf Python 3 ausgeführt wird, können Sie diesen nicht verwenden xrange().

• range()kann in einigen Fällen sogar schneller sein - z. wenn Sie dieselbe Sequenz mehrmals durchlaufen. xrange()muss das Integer-Objekt jedes Mal rekonstruieren, hat aber range()echte Integer-Objekte. (Es wird jedoch immer schlechter in Bezug auf das Gedächtnis abschneiden)

• xrange()ist nicht in allen Fällen verwendbar, in denen eine echte Liste benötigt wird. Beispielsweise werden keine Slices oder Listenmethoden unterstützt.

[Bearbeiten] In einigen Beiträgen wird erwähnt, wie range()das 2to3-Tool aktualisiert wird. Hier ist die Ausgabe des Ausführens des Tools für einige Beispielverwendungen von range()undxrange()

RefactoringTool: Skipping implicit fixer: buffer
RefactoringTool: Skipping implicit fixer: idioms
RefactoringTool: Skipping implicit fixer: ws_comma
--- range_test.py (original)
+++ range_test.py (refactored)
@@ -1,7 +1,7 @@

 for x in range(20):
-    a=range(20)
+    a=list(range(20))
     b=list(range(20))
     c=[x for x in range(20)]
     d=(x for x in range(20))
-    e=xrange(20)
+    e=range(20)

Wie Sie sehen können, bleibt der Bereich unverändert, wenn er in einer for-Schleife oder einem Verständnis verwendet wird oder wenn er bereits mit list () umschlossen ist.

Nein, beide haben ihre Verwendung:

Verwenden Sie diese xrange()Option beim Iterieren, da dadurch Speicherplatz gespart wird. Sagen:

for x in xrange(1, one_zillion):

eher, als:

for x in range(1, one_zillion):

Verwenden range()Sie andererseits, wenn Sie tatsächlich eine Liste von Zahlen möchten.

multiples_of_seven = range(7,100,7)
print "Multiples of seven < 100: ", multiples_of_seven

Sie sollten bevorzugen range()über xrange()nur , wenn Sie eine aktuelle Liste benötigen. Zum Beispiel, wenn Sie die von zurückgegebene Liste ändern möchten range()oder wenn Sie sie in Scheiben schneiden möchten. Für die Iteration oder auch nur für die normale Indizierung xrange()funktioniert es gut (und normalerweise viel effizienter). Es gibt einen Punkt, an dem range()es etwas schneller ist als xrange()bei sehr kleinen Listen, aber abhängig von Ihrer Hardware und verschiedenen anderen Details kann die Gewinnschwelle bei Länge 1 oder 2 liegen. kein Grund zur Sorge. Lieber xrange().

Ein weiterer Unterschied besteht darin, dass xrange () keine Zahlen unterstützen kann, die größer als C ints sind. Wenn Sie also einen Bereich mit der in Python integrierten Unterstützung für große Zahlen haben möchten, müssen Sie range () verwenden.

Python 2.7.3 (default, Jul 13 2012, 22:29:01) 
[GCC 4.7.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> range(123456787676676767676676,123456787676676767676679)
[123456787676676767676676L, 123456787676676767676677L, 123456787676676767676678L]
>>> xrange(123456787676676767676676,123456787676676767676679)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
OverflowError: Python int too large to convert to C long

Python 3 hat dieses Problem nicht:

Python 3.2.3 (default, Jul 14 2012, 01:01:48) 
[GCC 4.7.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> range(123456787676676767676676,123456787676676767676679)
range(123456787676676767676676, 123456787676676767676679)

xrange()ist effizienter, da anstelle einer Liste von Objekten jeweils nur ein Objekt generiert wird. Anstelle von 100 Ganzzahlen und dem gesamten Overhead sowie der Liste, in die sie eingefügt werden sollen, haben Sie jeweils nur eine Ganzzahl. Schnellere Generierung, bessere Speichernutzung, effizienterer Code.

Wenn ich nicht speziell eine Liste für etwas brauche, bevorzuge ich immer xrange()

range () gibt eine Liste zurück, xrange () gibt ein xrange-Objekt zurück.

xrange () ist etwas schneller und speichereffizienter. Aber der Gewinn ist nicht sehr groß.

Der zusätzliche Speicher, der von einer Liste verwendet wird, wird natürlich nicht nur verschwendet, Listen haben mehr Funktionen (Slice, Repeat, Insert, ...). Genaue Unterschiede finden Sie in der Dokumentation . Es gibt keine Bonehard-Regel, verwenden Sie, was benötigt wird.

Python 3.0 befindet sich noch in der Entwicklung, aber IIRC range () wird xrange () von 2.X sehr ähnlich sein und list (range ()) kann zum Generieren von Listen verwendet werden.

Ich möchte nur sagen, dass es WIRKLICH nicht so schwierig ist, ein xrange-Objekt mit Slice- und Indizierungsfunktionalität zu erhalten. Ich habe einen Code geschrieben, der ziemlich gut funktioniert und genauso schnell ist wie xrange, wenn es darauf ankommt (Iterationen).

from __future__ import division

def read_xrange(xrange_object):
    # returns the xrange object's start, stop, and step
    start = xrange_object[0]
    if len(xrange_object) > 1:
       step = xrange_object[1] - xrange_object[0]
    else:
        step = 1
    stop = xrange_object[-1] + step
    return start, stop, step

class Xrange(object):
    ''' creates an xrange-like object that supports slicing and indexing.
    ex: a = Xrange(20)
    a.index(10)
    will work

    Also a[:5]
    will return another Xrange object with the specified attributes

    Also allows for the conversion from an existing xrange object
    '''
    def __init__(self, *inputs):
        # allow inputs of xrange objects
        if len(inputs) == 1:
            test, = inputs
            if type(test) == xrange:
                self.xrange = test
                self.start, self.stop, self.step = read_xrange(test)
                return

        # or create one from start, stop, step
        self.start, self.step = 0, None
        if len(inputs) == 1:
            self.stop, = inputs
        elif len(inputs) == 2:
            self.start, self.stop = inputs
        elif len(inputs) == 3:
            self.start, self.stop, self.step = inputs
        else:
            raise ValueError(inputs)

        self.xrange = xrange(self.start, self.stop, self.step)

    def __iter__(self):
        return iter(self.xrange)

    def __getitem__(self, item):
        if type(item) is int:
            if item < 0:
                item += len(self)

            return self.xrange[item]

        if type(item) is slice:
            # get the indexes, and then convert to the number
            start, stop, step = item.start, item.stop, item.step
            start = start if start != None else 0 # convert start = None to start = 0
            if start < 0:
                start += start
            start = self[start]
            if start < 0: raise IndexError(item)
            step = (self.step if self.step != None else 1) * (step if step != None else 1)
            stop = stop if stop is not None else self.xrange[-1]
            if stop < 0:
                stop += stop

            stop = self[stop]
            stop = stop

            if stop > self.stop:
                raise IndexError
            if start < self.start:
                raise IndexError
            return Xrange(start, stop, step)

    def index(self, value):
        error = ValueError('object.index({0}): {0} not in object'.format(value))
        index = (value - self.start)/self.step
        if index % 1 != 0:
            raise error
        index = int(index)


        try:
            self.xrange[index]
        except (IndexError, TypeError):
            raise error
        return index

    def __len__(self):
        return len(self.xrange)

Ehrlich gesagt denke ich, dass das ganze Problem irgendwie albern ist und xrange sollte das alles sowieso tun ...

Ein gutes Beispiel aus dem Buch: Practical Python von Magnus Lie Hetland

>>> zip(range(5), xrange(100000000))
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]

Ich würde im vorherigen Beispiel nicht empfehlen, range anstelle von xrange zu verwenden. Obwohl nur die ersten fünf Zahlen benötigt werden, berechnet range alle Zahlen, und das kann viel Zeit in Anspruch nehmen. Mit xrange ist dies kein Problem, da nur die benötigten Zahlen berechnet werden.

Ja, ich habe die Antwort von @ Brian gelesen: In Python 3 ist range () sowieso ein Generator und xrange () existiert nicht.

Gehen Sie aus folgenden Gründen mit Reichweite:

1) xrange wird in neueren Python-Versionen verschwinden. Dies gibt Ihnen eine einfache Zukunftskompatibilität.

2) Der Bereich übernimmt die mit xrange verbundenen Wirkungsgrade.

Okay, jeder hier hat eine andere Meinung zu den Kompromissen und Vorteilen von xrange gegenüber range. Sie sind größtenteils korrekt, xrange ist ein Iterator, und der Bereich wird konkretisiert und erstellt eine tatsächliche Liste. In den meisten Fällen werden Sie keinen Unterschied zwischen den beiden bemerken. (Sie können eine Karte mit Reichweite verwenden, jedoch nicht mit xrange, sie verbraucht jedoch mehr Speicher.)

Was ich denke, dass Sie Rallye hören möchten, ist, dass die bevorzugte Wahl xrange ist. Da range in Python 3 ein Iterator ist, konvertiert das Codekonvertierungstool 2to3 alle Verwendungen von xrange korrekt in range und gibt einen Fehler oder eine Warnung für die Verwendung von range aus. Wenn Sie sicher sein möchten, dass Sie Ihren Code in Zukunft problemlos konvertieren können, verwenden Sie nur xrange und list (xrange), wenn Sie sicher sind, dass Sie eine Liste möchten. Das habe ich beim CPython-Sprint auf der PyCon in diesem Jahr (2008) in Chicago gelernt.

• range(): range(1, 10)Gibt eine Liste mit 1 bis 10 Zahlen zurück und speichert die gesamte Liste.
• xrange(): Like range(), aber anstatt eine Liste zurückzugeben, wird bei Bedarf ein Objekt zurückgegeben, das die Zahlen im Bereich generiert. Für Schleifen ist dies etwas schneller als range()und speichereffizienter. xrange()Objekt wie ein Iterator und generiert die Zahlen bei Bedarf (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__
Out[3]: xrange([start,] stop[, step]) -> xrange object

range()Funktioniert genauso wie xrange()in Python 3 und es gibt keinen Begriff xrange()in Python 3. range()In einigen Szenarien kann dies sogar schneller sein, wenn Sie dieselbe Sequenz mehrmals durchlaufen. xrange()muss das Integer-Objekt jedes Mal rekonstruieren, hat aber range()echte Integer-Objekte.

Es xrangeist zwar schneller als rangein den meisten Fällen, aber der Leistungsunterschied ist ziemlich gering. Das kleine Programm unten vergleicht das Iterieren über a rangeund an xrange:

import timeit
# Try various list sizes.
for list_len in [1, 10, 100, 1000, 10000, 100000, 1000000]:
  # Time doing a range and an xrange.
  rtime = timeit.timeit('a=0;\nfor n in range(%d): a += n'%list_len, number=1000)
  xrtime = timeit.timeit('a=0;\nfor n in xrange(%d): a += n'%list_len, number=1000)
  # Print the result
  print "Loop list of len %d: range=%.4f, xrange=%.4f"%(list_len, rtime, xrtime)

Die folgenden Ergebnisse zeigen, dass dies xrangezwar schneller ist, aber nicht ausreicht, um darüber zu schwitzen.

Loop list of len 1: range=0.0003, xrange=0.0003
Loop list of len 10: range=0.0013, xrange=0.0011
Loop list of len 100: range=0.0068, xrange=0.0034
Loop list of len 1000: range=0.0609, xrange=0.0438
Loop list of len 10000: range=0.5527, xrange=0.5266
Loop list of len 100000: range=10.1666, xrange=7.8481
Loop list of len 1000000: range=168.3425, xrange=155.8719

Verwenden xrangeSie es also auf jeden Fall , aber machen Sie sich keine Sorgen, es sei denn, Sie verwenden eine eingeschränkte Hardware.