Следует ли всегда отдавать предпочтение xrange () перед range ()?

Для производительности, особенно когда вы выполняете итерацию в большом диапазоне, обычно лучше xrange(). Однако есть еще несколько случаев, почему вы можете предпочесть range():

• В python 3 range() делает то, что раньше делал xrange(), а xrange() не существует. Если вы хотите написать код, который будет работать как на Python 2, так и на Python 3, вы не можете использовать xrange().

• range() в некоторых случаях может быть быстрее - например. при повторении одной и той же последовательности несколько раз. xrange() должен каждый раз восстанавливать целочисленный объект, но range() будет иметь реальные целочисленные объекты. (Однако он всегда будет хуже работать с памятью)

• xrange() не может использоваться во всех случаях, когда нужен реальный список. Например, он не поддерживает срезы или какие-либо методы списков.

[Edit] Есть пара сообщений, в которых упоминается, как range() будет обновлен с помощью инструмента 2to3. Для записи, вот результат запуска инструмента на некоторых примерах использования range() и xrange().

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)

Как вы можете видеть, при использовании в цикле for или в понимании или в случае, когда он уже заключен в список (), диапазон остается неизменным.

Нет, у них обоих есть свое применение:

Используйте xrange() при итерации, так как это экономит память. Сказать:

for x in xrange(1, one_zillion):

скорее, чем:

for x in range(1, one_zillion):

С другой стороны, используйте range(), если вам действительно нужен список чисел.

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

Вы должны отдавать предпочтение range() перед xrange() только тогда, когда вам нужен реальный список. Например, когда вы хотите изменить список, возвращаемый range(), или когда вы хотите его разрезать. Для итерации или даже обычной индексации xrange() будет работать нормально (и обычно намного эффективнее). Есть точка, в которой range() немного быстрее, чем xrange() для очень маленьких списков, но в зависимости от вашего оборудования и различных других деталей безубыточность может иметь длину 1 или 2; не о чем беспокоиться. Предпочитаю xrange().

Еще одно отличие состоит в том, что реализация xrange() в Python 2 не может поддерживать числа, превышающие целые числа C, поэтому, если вы хотите иметь диапазон, используя встроенную поддержку большого числа Python, вы должны использовать range().

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 такой проблемы нет:

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() более эффективен, потому что вместо создания списка объектов он генерирует только один объект за раз. Вместо 100 целых чисел и всех их накладных расходов и списка для их добавления у вас есть только одно целое число за раз. Более быстрая генерация, лучшее использование памяти, более эффективный код.

Если мне специально не нужен список для чего-то, я всегда предпочитаю xrange()

range () возвращает список, xrange () возвращает объект xrange.

xrange () немного быстрее и немного более эффективен с точки зрения памяти. Но выигрыш не очень большой.

Дополнительная память, используемая списком, конечно, не просто тратится впустую, списки имеют больше функций (срез, повтор, вставка и т. Д.). Точные различия можно найти в документации. Нет правила жесткости, используйте то, что нужно.

Python 3.0 все еще находится в разработке, но IIRC range () будет очень похож на xrange () из 2.X, а list (range ()) может использоваться для создания списков.

Я просто хотел бы сказать, что ДЕЙСТВИТЕЛЬНО не так уж и сложно получить объект xrange с функцией среза и индексирования. Я написал код, который работает довольно хорошо и работает так же быстро, как xrange, когда он учитывается (итерации).

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)

Честно говоря, я думаю, что проблема в целом глупая, и xrange все равно должен это делать ...

Хороший пример, приведенный в книге: person Grijesh Chauhan    schedule 17.08.2013