Maneira mais limpa de obter o último item do iterador Python

Qual é a melhor maneira de obter o último item de um iterador no Python 2.6? Por exemplo, diga

my_iter = iter(range(5))

Qual é o caminho mais curto-code / mais limpa de obter 4a partir de my_iter?

Eu poderia fazer isso, mas não parece muito eficiente:

[x for x in my_iter][-1]

item = defaultvalue
for item in my_iter:
    pass

Use um dequede tamanho 1.

from collections import deque

#aa is an interator
aa = iter('apple')

dd = deque(aa, maxlen=1)
last_element = dd.pop()

Se você estiver usando Python 3.x:

*_, last = iterator # for a better understanding check PEP 448
print(last)

se você estiver usando o python 2.7:

last = next(iterator)
for last in iterator:
    continue
print last

Nota:

Normalmente, a solução apresentada acima é o que você precisa para casos regulares, mas se você está lidando com uma grande quantidade de dados, é mais eficiente usar um dequetamanho 1. ( fonte )

from collections import deque

#aa is an interator
aa = iter('apple')

dd = deque(aa, maxlen=1)
last_element = dd.pop()

Provavelmente vale a pena usar __reversed__se estiver disponível

if hasattr(my_iter,'__reversed__'):
    last = next(reversed(my_iter))
else:
    for last in my_iter:
        pass

Tão simples quanto:

max(enumerate(the_iter))[1]

É improvável que seja mais rápido do que o loop for vazio devido ao lambda, mas talvez dê a outra pessoa uma ideia

reduce(lambda x,y:y,my_iter)

Se o iter estiver vazio, um TypeError é gerado

Tem isso

list( the_iter )[-1]

Se a duração da iteração for verdadeiramente épica - tão longa que materializar a lista irá exaurir a memória - então você realmente precisa repensar o design.

eu usaria reversed , exceto que leva apenas sequências em vez de iteradores, o que parece bastante arbitrário.

De qualquer maneira, você terá que percorrer todo o iterador. Com eficiência máxima, se você não precisar do iterador nunca mais, pode simplesmente destruir todos os valores:

for last in my_iter:
    pass
# last is now the last item

Eu acho que esta é uma solução abaixo do ideal, no entanto.

A biblioteca toolz oferece uma boa solução:

from toolz.itertoolz import last
last(values)

Mas adicionar uma dependência não principal pode não valer a pena para usá-la apenas neste caso.

Veja este código para algo semelhante:

http://excamera.com/sphinx/article-islast.html

você pode usá-lo para pegar o último item com:

[(last, e) for (last, e) in islast(the_iter) if last]

Eu apenas usaria next(reversed(myiter))

A questão é sobre como obter o último elemento de um iterador, mas se o seu iterador for criado aplicando condições a uma sequência, então reverso pode ser usado para encontrar o "primeiro" de uma sequência reversa, olhando apenas para os elementos necessários, aplicando reverter para a própria sequência.

Um exemplo inventado,

>>> seq = list(range(10))
>>> last_even = next(_ for _ in reversed(seq) if _ % 2 == 0)
>>> last_even
8

Como alternativa para iteradores infinitos, você pode usar:

from itertools import islice 
last = list(islice(iterator(), 1000))[-1] # where 1000 is number of samples 

Achei que seria mais lento, dequemas é tão rápido e, na verdade, mais rápido do que o método de loop (de alguma forma)

A pergunta está errada e só pode levar a uma resposta complicada e ineficiente. Para obter um iterador, é claro que você começa a partir de algo que é iterável, que na maioria dos casos oferece uma maneira mais direta de acessar o último elemento.

Depois de criar um iterador a partir de um iterável, você fica preso em percorrer os elementos, porque essa é a única coisa que um iterável fornece.

Portanto, a maneira mais eficiente e clara não é criar o iterador em primeiro lugar, mas usar os métodos de acesso nativos do iterável.