Você deve sempre favorecer xrange () acima do intervalo ()?

Por que ou por que não?

Para o desempenho, especialmente quando você está interagindo em uma grande variedade, xrange()geralmente é melhor. No entanto, ainda existem alguns casos pelos quais você pode preferir range():

• No python 3, range()faz o que xrange()costumava fazer e xrange()não existe. Se você deseja escrever um código que será executado no Python 2 e no Python 3, não poderá usá-lo xrange().

• range()pode realmente ser mais rápido em alguns casos - por exemplo. se iterando na mesma sequência várias vezes. xrange()precisa reconstruir o objeto inteiro toda vez, mas range()terá objetos inteiros reais. (No entanto, sempre terá um desempenho pior em termos de memória)

• xrange()não é utilizável em todos os casos em que é necessária uma lista real. Por exemplo, ele não suporta fatias ou qualquer método de lista.

[Editar] Existem algumas postagens mencionando como range()será atualizado pela ferramenta 2to3. Para o registro, aqui está o resultado da execução da ferramenta em alguns exemplos de usos range()exrange()

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)

Como você pode ver, quando usado em um loop ou compreensão for, ou onde já está envolvido com list (), o intervalo permanece inalterado.

Não, ambos têm seus usos:

Use xrange()ao iterar, pois economiza memória. Dizer:

for x in xrange(1, one_zillion):

ao invés de:

for x in range(1, one_zillion):

Por outro lado, use range()se você realmente deseja uma lista de números.

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

Você deve favorecer range()mais xrange()somente quando você precisa de uma lista real. Por exemplo, quando você deseja modificar a lista retornada por range()ou quando deseja cortá-la. Para iteração ou até apenas indexação normal, xrange()funcionará bem (e geralmente com muito mais eficiência). Há um ponto em que range()é um pouco mais rápido do que xrange()para listas muito pequenas, mas, dependendo do seu hardware e de vários outros detalhes, o ponto de equilíbrio pode ser o resultado do comprimento 1 ou 2; não é algo para se preocupar. Preferir xrange().

Uma outra diferença é que xrange () não pode suportar números maiores que C ints; portanto, se você deseja ter um intervalo usando o suporte de grande número incorporado do python, você deve usar 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 não tem esse problema:

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()é mais eficiente porque, em vez de gerar uma lista de objetos, apenas gera um objeto por vez. Em vez de 100 números inteiros, toda a sobrecarga e a lista para inseri-los, você apenas tem um número inteiro por vez. Geração mais rápida, melhor uso da memória, código mais eficiente.

A menos que eu precise especificamente de uma lista para alguma coisa, eu sempre a favor xrange()

range () retorna uma lista, xrange () retorna um objeto xrange.

xrange () é um pouco mais rápido e um pouco mais eficiente em termos de memória. Mas o ganho não é muito grande.

Obviamente, a memória extra usada por uma lista não é desperdiçada, as listas têm mais funcionalidades (cortar, repetir, inserir, ...). As diferenças exatas podem ser encontradas na documentação . Não há regra rígida, use o que for necessário.

O Python 3.0 ainda está em desenvolvimento, mas o intervalo IIRC () será muito semelhante ao xrange () de 2.X e list (range ()) pode ser usado para gerar listas.

Gostaria apenas de dizer que REALMENTE não é tão difícil obter um objeto xrange com funcionalidade de fatia e indexação. Eu escrevi um código que funciona muito bem e é tão rápido quanto o xrange para quando conta (iterações).

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)

Honestamente, acho que a questão toda é meio boba e o xrange deve fazer tudo isso de qualquer maneira ...

Um bom exemplo dado no livro: Python Prático Por Magnus Lie Hetland

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

Eu não recomendaria usar o intervalo em vez de xrange no exemplo anterior - embora apenas os cinco primeiros números sejam necessários, o intervalo calcula todos os números e isso pode levar muito tempo. Com o xrange, isso não é um problema, pois calcula apenas os números necessários.

Sim, eu li a resposta do @ Brian: No python 3, range () é um gerador de qualquer maneira e xrange () não existe.

Vá com alcance por estes motivos:

1) O xrange desaparecerá nas versões mais recentes do Python. Isso oferece fácil compatibilidade futura.

2) o alcance assumirá as eficiências associadas ao xrange.

Ok, todos aqui têm uma opinião diferente sobre as vantagens e desvantagens de xrange versus range. Eles estão na maioria corretos, o xrange é um iterador, e o intervalo é atualizado e cria uma lista real. Na maioria dos casos, você realmente não notará diferença entre os dois. (Você pode usar o mapa com alcance, mas não com xrange, mas ele consome mais memória.)

O que eu acho que você quer ouvir, no entanto, é que a escolha preferida é o intervalo. Como o range no Python 3 é um iterador, a ferramenta de conversão de código 2to3 converterá corretamente todos os usos do xrange em range e emitirá um erro ou aviso para o uso do range. Se você deseja converter facilmente seu código no futuro, usará apenas xrange e listará (xrange) quando tiver certeza de que deseja uma lista. Aprendi isso durante o CPython sprint na PyCon este ano (2008) em Chicago.

• range(): range(1, 10)retorna uma lista de 1 a 10 números e mantém a lista inteira na memória.
• xrange(): Como range(), mas em vez de retornar uma lista, retorna um objeto que gera os números no intervalo sob demanda. Para loop, isso é levemente mais rápido range()e mais eficiente em memória. xrange()objeto como um iterador e gera os números sob demanda (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()faz o mesmo que xrange()costumava fazer no Python 3 e não xrange()existe um termo no Python 3. range()Na verdade, pode ser mais rápido em alguns cenários se você estiver repetindo a mesma sequência várias vezes. xrange()precisa reconstruir o objeto inteiro toda vez, mas range()terá objetos inteiros reais.

Embora xrangeseja mais rápido do que rangena maioria das circunstâncias, a diferença de desempenho é bastante mínima. O pequeno programa abaixo compara a iteração sobre a rangee 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)

Os resultados abaixo mostram que xrangeé realmente mais rápido, mas não o suficiente para transpirar.

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

Portanto, use todos os meios xrange, mas a menos que você esteja usando um hardware restrito, não se preocupe muito com isso.