En Python, les fonctions itertools.count(), itertools.cycle() et itertools.repeat() du module itertools de la bibliothèque standard peuvent être utilisées pour créer des itérateurs infinis.
Cet article décrit le contenu suivant.
- Compter indéfiniment :
itertools.count() - Cycle éléments d’un itérable indéfiniment:
itertools.cycle() - Répétez indéfiniment la même valeur :
itertools.repeat()
Pour chaque fonction, des exemples de processus itératifs avec l’instruction for et de combinaison avec la fonction zip() sont présentés.
Consultez les articles suivants pour plus d’informations sur l’instruction for et la fonction zip().
Si vous les utilisez dans l’instruction for, veillez à spécifier la condition de fin et l’arrêt ; sinon, le code se retrouvera dans une boucle infinie.
Des boucles infinies avec des compteurs, etc. peuvent être implémentées avec l’instruction while, mais il est souvent plus facile de les écrire en utilisant les fonctions itertools.
itertools.count() crée un itérateur qui renvoie des valeurs qui comptent ou décroissent à l’infini.
Par défaut, il commence à 0 et augmente de 1.
import itertools
for i in itertools.count():
print(i)
if i > 3:
break
# 0
# 1
# 2
# 3
# 4
Vous pouvez spécifier la valeur de départ avec le premier argument start et l’incrément avec le deuxième argument step.
for i in itertools.count(2):
print(i)
if i > 3:
break
# 2
# 3
# 4
for i in itertools.count(step=3):
print(i)
if i > 8:
break
# 0
# 3
# 6
# 9
for i in itertools.count(2, 3):
print(i)
if i > 8:
break
# 2
# 5
# 8
# 11
Si vous voulez compter à rebours, vous pouvez spécifier une valeur négative pour le pas.
for i in itertools.count(10, -1):
print(i)
if i < 8:
break
# 10
# 9
# 8
# 7
Vous pouvez le spécifier comme nombre à virgule flottante, mais il peut être plus précis d’utiliser la multiplication dans certains cas.
Lors du comptage avec des nombres à virgule flottante, une meilleure précision peut parfois être obtenue en substituant un code multiplicatif tel que :
(start + step * i for i in count()).
itertools.count() — Functions creating iterators for efficient looping — Python 3.9.7 documentation
for i in itertools.count(0.1, 1.5):
print(i)
if i > 3:
break
# 0.1
# 1.6
# 3.1
for i in itertools.count():
ii = 0.1 + 1.5 * i
print(ii)
if ii > 3:
break
# 0.1
# 1.6
# 3.1
Lorsqu’il est combiné avec zip (), des tuples avec compteur peuvent être créés.
l1 = ['a', 'b', 'c']
l2 = ['x', 'y', 'z']
print(list(zip(itertools.count(), l1, l2)))
# [(0, 'a', 'x'), (1, 'b', 'y'), (2, 'c', 'z')]
Notez que si vous utilisez enumerate() et zip(), des tuples imbriqués sont créés.
print(list(enumerate(zip(l1, l2))))
# [(0, ('a', 'x')), (1, ('b', 'y')), (2, ('c', 'z'))]
Si vous l’utilisez dans la boucle for, vous pouvez également utiliser enumerate() et zip() pour extraire chaque valeur comme suit.
names = ['Alice', 'Bob', 'Charlie']
ages = [24, 50, 18]
for i, (name, age) in enumerate(zip(names, ages)):
print(i, name, age)
# 0 Alice 24
# 1 Bob 50
# 2 Charlie 18
itertools.cycle() crée un itérateur qui parcourt à l’infini les éléments d’un objet itérable tel qu’une liste.
l = [1, 10, 100]
sum_value = 0
for i in itertools.cycle(l):
print(i)
sum_value += i
if sum_value > 300:
break
# 1
# 10
# 100
# 1
# 10
# 100
# 1
# 10
# 100
Exemple de spécification de range() :
sum_value = 0
for i in itertools.cycle(range(3)):
print(i)
sum_value += i
if sum_value > 5:
break
# 0
# 1
# 2
# 0
# 1
# 2
Exemple de combinaison avec zip() :
l1 = [1, 10, 100]
l2 = [0, 1, 2, 3, 4, 5, 6]
print(list(zip(itertools.cycle(l1), l2)))
# [(1, 0), (10, 1), (100, 2), (1, 3), (10, 4), (100, 5), (1, 6)]
itertools.cycle() enregistre une copie de l’objet itérable d’origine. Notez que si la taille de l’objet itérable d’origine est grande, il peut utiliser beaucoup de mémoire.
Notez que ce membre de la boîte à outils peut nécessiter un stockage auxiliaire important (selon la longueur de l’itérable).
itertools.cycle() — Fonctions créant des itérateurs pour un bouclage efficace — Documentation Python 3.9.7
itertools.repeat() crée un itérateur qui renvoie la même valeur à l’infini.
sum_value = 0
for i in itertools.repeat(10):
print(i)
sum_value += i
if sum_value > 40:
break
# 10
# 10
# 10
# 10
# 10
Le nombre d’itérations peut être spécifié avec le second argument times.
for i in itertools.repeat(10, 3):
print(i)
# 10
# 10
# 10
Le premier argument peut être n’importe quel objet. Il est également possible de répéter un objet fonction. Dans l’exemple suivant, la fonction intégrée len() est répétée.
for l in itertools.repeat([0, 1, 2], 3):
print(l)
# [0, 1, 2]
# [0, 1, 2]
# [0, 1, 2]
for func in itertools.repeat(len, 3):
print(func('abc'))
# 3
# 3
# 3
Un exemple de combinaison avec zip() est le suivant. Vous pouvez ajouter des éléments constants.
l = [0, 1, 2, 3]
print(list(zip(itertools.repeat(10), l)))
# [(10, 0), (10, 1), (10, 2), (10, 3)]