Le moyen le plus propre d'obtenir le dernier élément de l'itérateur Python

Quelle est la meilleure façon d'obtenir le dernier élément d'un itérateur dans Python 2.6? Par exemple, dites

my_iter = iter(range(5))

Quel est le plus court / Code manière la plus propre d'obtenir à 4partir my_iter?

Je pourrais le faire, mais cela ne semble pas très efficace:

[x for x in my_iter][-1]

item = defaultvalue
for item in my_iter:
    pass

Utilisez un dequede taille 1.

from collections import deque

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

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

Si vous utilisez Python 3.x:

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

si vous utilisez python 2.7:

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

Note latérale:

Habituellement, la solution présentée ci-dessus est celle dont vous avez besoin pour les cas réguliers, mais si vous avez affaire à une grande quantité de données, il est plus efficace d'utiliser un dequede taille 1. ( source )

from collections import deque

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

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

__reversed__Cela vaut probablement la peine d'être utilisé s'il est disponible

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

Aussi simple que:

max(enumerate(the_iter))[1]

Il est peu probable que ce soit plus rapide que la boucle for vide à cause du lambda, mais cela donnera peut-être une idée à quelqu'un d'autre

reduce(lambda x,y:y,my_iter)

Si l'iter est vide, une TypeError est levée

Il y a ça

list( the_iter )[-1]

Si la durée de l'itération est vraiment épique - si longue que la matérialisation de la liste épuisera la mémoire - alors vous devez vraiment repenser la conception.

J'utiliserais reversed, sauf qu'il ne prend que des séquences au lieu d'itérateurs, ce qui semble plutôt arbitraire.

Quoi qu'il en soit, vous devrez parcourir tout l'itérateur. Avec une efficacité maximale, si vous n'avez plus jamais besoin de l'itérateur, vous pouvez simplement supprimer toutes les valeurs:

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

Je pense cependant que c'est une solution sous-optimale.

La bibliothèque toolz fournit une solution intéressante:

from toolz.itertoolz import last
last(values)

Mais l'ajout d'une dépendance non essentielle peut ne pas valoir la peine de l'utiliser uniquement dans ce cas.

Voir ce code pour quelque chose de similaire:

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

vous pouvez l'utiliser pour récupérer le dernier article avec:

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

Je voudrais juste utiliser next(reversed(myiter))

La question est d'obtenir le dernier élément d'un itérateur, mais si votre itérateur est créé en appliquant des conditions à une séquence, alors inversé peut être utilisé pour trouver le "premier" d'une séquence inversée, en regardant uniquement les éléments nécessaires, en appliquant inverser la séquence elle-même.

Un exemple artificiel,

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

Alternativement, pour les itérateurs infinis, vous pouvez utiliser:

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

Je pensais que ce serait plus lent alors dequemais c'est aussi rapide et c'est en fait plus rapide que pour la méthode en boucle (en quelque sorte)

La question est fausse et ne peut conduire qu'à une réponse compliquée et inefficace. Pour obtenir un itérateur, vous partez bien sûr de quelque chose qui est itérable, qui dans la plupart des cas offrira un moyen plus direct d'accéder au dernier élément.

Une fois que vous avez créé un itérateur à partir d'un itérable, vous êtes obligé de parcourir les éléments, car c'est la seule chose qu'un itérable fournit.

Ainsi, le moyen le plus efficace et le plus clair n'est pas de créer l'itérateur en premier lieu mais d'utiliser les méthodes d'accès natives de l'itérable.