itertools

Offre plein de fonctions pratiques qui permettent de faciliter le travail sur les séquences (liste, tuples, chaînes).

pour enchaîner plusieurs itérables (ça peut être des listes, des strings, ...) :

for x in itertools.chain([1, 2, 3], [4, 5], [6, 7]):
    print(x)
  

donne un itérateur comme si c'était sur la liste [1, 2, 3, 4, 5, 6, 7]

Fonction de cycling à l'infini sur un itérable :

it = itertools.cycle(range(4))
for x in range(10):
    print(next(it))
  

imprime ici 0 1 2 3 0 1 2 3 0 1.

Fonction repeat qui répète un objet n fois :

for x in itertools.repeat('a', 5):
    print(x)
  

imprime ici a a a a a.

Fonction tee qui génère plusieurs itérateurs à partir d'une séquence :

for x in itertools.tee(['a', 'b'], 2):
    for y in x:
        print(y)
  

imprime a b a b.

Fonction count qui compte à l'infini :

it = itertools.count(3, 2)
for x in range(5):
    print(next(it))
  

imprime ici 3 5 7 9 11.

Fonction islice :

• donne un itérateur sur un range d'éléments d'un itérable :

  for x in itertools.islice(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 1, 6):
      print(x)
      

  imprime b c d e f.
• on peut en plus indiquer un pas pour ne prendre que un élément sur 2 par exemple :

  for x in itertools.islice(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 1, 6, 2):
      print(x)
      

  imprime b d f.

Fonction product qui renvoie le produit cartésien :

• for x in itertools.product(['a', 'b', 'c'], ['A', 'B']):
      print(x)
      

  renvoie toutes les paires d'un élément du premier itérable et d'un élément du 2ème itérable : ('a', 'A'), ('a', 'B'), ('b', 'A'), ...
• la première boucle est sur la première liste.
• on peut avoir plus que 2 listes (si 3 listes, renvoie des triplets).

Fonction permutations qui renvoie toutes les permutations possibles :

• for x in itertools.permutations(['a', 'b', 'c']):
      print(x)
      

  imprime tous les tuples correspondant à toutes les permutations possibles (('a', 'b', 'c'), ('a', 'c', 'b'), ...
• on peut utiliser seulement une partie des éléments pour générer les permutations possibles :

  for x in itertools.permutations(['a', 'b', 'c'], 2):
      print(x)
      

  imprime ('a', 'b'), ('a', 'c'), ('b', 'a'), ... (2 éléments seulement).

Génération des combinaisons de p éléments à partir d'un itérable :

• sans remise : itertools.combinations(range(5), 2) (toutes les combinaisons de 2 éléments parmi les 5, dans l'ordre où ils sont dans l'itérable de départ), donne donc ici (0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4).
• avec remise (chaque élément peut apparaître plusieurs fois dans le tuple) : itertools.combinations_with_replacement(range(5), 2), donne donc ici (0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4)

Fonction compress qui sélectionne seulement les éléments du premier itérable pour lesquels l'élément correspondant du 2ème itérable est vrai :

for x in itertools.compress(['A', 'B', 'C', 'D'], [1, 0, 1, 0]):
    print(x)
  

imprime les éléments A C.

Fonction ifilter qui garde seulement les éléments d'une itérable quand une expression est vraie (équivalent à filter, mais renvoie un itérateur plutôt qu'une liste) :

• for x in itertools.ifilter(lambda t: t < 4, [1, 2, 5, 3, 7]):
      print(x)
      

  imprime les éléments 1 2 3.
• on peut faire l'inverse en ne gardant que les éléments pour lesquels l'expression est fausse :

  for x in itertools.ifilterfalse(lambda t: t < 4, [1, 2, 5, 3, 7]):
      print(x)
      

  imprime les éléments 5 7.

Fonction imap qui applique une fonction sur les éléments d'un itérable et renvoie un itérateur (équivalent à map, mais renvoie un itérateur plutôt qu'une liste) :

for x in list(itertools.imap(lambda t : 2 * t, [1, 2, 3])):
    print(x)
  

imprime les éléments 2 4 6.

Fonction starmap : comme imap, sauf que chaque élément peut être une séquence de n éléments et la fonction prend n éléments :

for x in itertools.starmap(lambda x, y: x + y, [[1, 2], [3, 4], [5, 6]]):
    print(x)
  

imprime 3 7 11.

Fonction izip : comme zip, mais retourne un itérateur plutôt qu'une liste :

for x in itertools.izip(['a', 'b', 'c'], ['A', 'B', 'C']):
    print(x)
  

donne :
('a', 'A')
('b', 'B')
('c', 'C')

Fonction dropwhile qui jette au contraire les éléments d'un itérable tant qu'une expression est vraie, puis dès la première valeur fausse, garde tous les éléments :

for x in itertools.dropwhile(lambda t: t < 4, [1, 2, 5, 3, 7]):
  print(x)
  

jette les éléments tant qu'ils sont toujours inférieur à 4, et dès qu'on atteint 5, garde tous les éléments (même si la condition redevient vraie pour certains). Imprime ici 5 3 7.

Fonction takewhile : garde les éléments d'un itérable tant qu'une expression est vraie, puis dès la première valeur fausse, jette tous les éléments :

for x in itertools.takewhile(lambda t: t < 4, [1, 2, 5, 3, 7]):
    print(x)
  

imprime ici 1 2.

Fonction groupby qui permet de grouper les éléments en fonction d'une fonction clef pour calculer des aggrégats :

• il faut d'abord trier la liste sur la clef.
• puis, on boucle sur chaque clef et on a un itérateur sur liste des valeurs correspondante.
• exemple :

  y = [['a', 2], ['b', 3], ['a', 3], ['b', 1], ['c', 2], ['a', 5]]
  y.sort(key = lambda x: x[0])
  for key, group in itertools.groupby(y, lambda t: t[0]):
      print(key, list(group))
      

  donne :
  a [['a', 2], ['a', 3], ['a', 5]]
  b [['b', 3], ['b', 1]]
  c [['c', 2]]
• on peut ainsi calculer la somme des valeurs par groupe :

  y = [['a', 2], ['b', 3], ['a', 3], ['b', 1], ['c', 2], ['a', 5]]
  y.sort(key = lambda t: t[0])
  for key, group in itertools.groupby(y, lambda x: x[0]):
      print(key, sum(map(lambda x: x[1], group)))
      

  donne :
  a 10
  b 4
  c 2