Itération d'une liste par paire (current, next) en Python

Question

J'ai parfois besoin d'itérer une liste en Python en regardant l'élément "courant" et l'élément "suivant". Jusqu'à présent, je l'ai fait avec du code comme :

for current, next in zip(the_list, the_list[1:]):
    # Do something

Cela fonctionne et fait ce que j'attends, mais y a-t-il une façon plus idiomatique ou efficace de faire la même chose ?

Answer 1

Voici un exemple pertinent tiré du itertools docs du module :

import itertools
def pairwise(iterable):
    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
    a, b = itertools.tee(iterable)
    next(b, None)
    return zip(a, b)   

Pour Python 2, vous avez besoin de itertools.izip au lieu de zip :

import itertools
def pairwise(iterable):
    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
    a, b = itertools.tee(iterable)
    next(b, None)
    return itertools.izip(a, b)

Comment cela fonctionne :

Tout d'abord, deux itérateurs parallèles, a y b sont créés (le tee() ), tous deux pointant vers le premier élément de l'itérable original. Le deuxième itérateur, b est déplacé d'un pas en avant (le next(b, None) ) appel). À ce stade a pointe vers s0 et b pointe vers s1. Les deux sites a y b peut parcourir l'itérateur original indépendamment - la fonction izip prend les deux itérateurs et crée des paires d'éléments retournés, faisant avancer les deux itérateurs au même rythme.

Une mise en garde : le tee() produit deux itérateurs qui peuvent avancer indépendamment l'un de l'autre, mais cela a un coût. Si l'un des itérateurs avance plus loin que l'autre, alors tee() doit conserver les éléments consommés en mémoire jusqu'à ce que le second itérateur les consomme également (il ne peut pas "rembobiner" l'itérateur original). Ici, cela n'a pas d'importance car un itérateur n'a qu'un pas d'avance sur l'autre, mais en général, il est facile d'utiliser beaucoup de mémoire de cette façon.

Et comme tee() peut prendre un n ce paramètre peut également être utilisé pour plus de deux itérateurs parallèles :

def threes(iterator):
    "s -> (s0,s1,s2), (s1,s2,s3), (s2, s3,4), ..."
    a, b, c = itertools.tee(iterator, 3)
    next(b, None)
    next(c, None)
    next(c, None)
    return zip(a, b, c)

Answer 2

Roulez le vôtre !

def pairwise(iterable):
    it = iter(iterable)
    a = next(it, None)

    for b in it:
        yield (a, b)
        a = b

Answer 3

Je mets juste ça en avant, Je suis très surpris que personne n'ait pensé à enumerate().

for (index, thing) in enumerate(the_list):
    if index < len(the_list):
        current, next_ = thing, the_list[index + 1]
        #do something

Answer 4

Depuis the_list[1:] crée en fait une copie de la liste entière (à l'exception de son premier élément), et zip() crée une liste de tuples immédiatement lorsqu'il est appelé, au total trois copies de votre liste sont créées. Si votre liste est très grande, vous pouvez préférer

from itertools import izip, islice
for current_item, next_item in izip(the_list, islice(the_list, 1, None)):
    print(current_item, next_item)

qui ne copie pas du tout la liste.

Answer 5

L'itération par index peut faire la même chose :

#!/usr/bin/python
the_list = [1, 2, 3, 4]
for i in xrange(len(the_list) - 1):
    current_item, next_item = the_list[i], the_list[i + 1]
    print(current_item, next_item)

Sortie :

(1, 2)
(2, 3)
(3, 4)