La boucle for



est l'outil de flux de contrôle le plus basique dans la plupart des langages de programmation. Par exemple, une simple boucle for



C ressemble à ceci :

int i;
for (i=0;i<N;i++)
{
  //do something
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Il n'y a pas de meilleure façon d'écrire for



une boucle C. Dans les cas complexes, vous devez généralement écrire des boucles imbriquées laides ou définir de nombreuses variables auxiliaires (comme i



dans le code ci-dessus).



Heureusement, les choses sont plus pratiques en Python. Il existe de nombreuses astuces dans ce langage pour écrire des boucles plus gracieuses qui nous facilitent la vie. En Python, il est tout à fait possible d'éviter les boucles imbriquées et les variables auxiliaires, et nous pouvons même personnaliser la boucle nous-mêmes for



.



Cet article vous guidera à travers les astuces de bouclage Python les plus utiles. J'espère que cela vous aidera à découvrir la beauté de cette langue.

Obtenez des valeurs et des indices en même temps

Un exemple courant d'utilisation d'une boucle for



consiste à obtenir des indices et des valeurs à partir d'une liste. Quand j'ai commencé à apprendre Python, j'ai écrit mon code de cette façon :

for i in range(len(my_list)):
    print(i, my_list[i])
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Cela a fonctionné, bien sûr. Mais ce n'est pas une solution de style Python. Quelques mois plus tard, j'ai appris l'implémentation standard de style Python :

for i, v in enumerate(my_list):
    print(i, v)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Comme nous pouvons le voir, la fonction intégrée enumerate



nous facilite la vie.

Comment éviter les boucles imbriquées avec la fonction Product

Les boucles imbriquées sont un vrai casse-tête. Ils peuvent réduire la lisibilité de votre code et le rendre plus difficile à comprendre. Par exemple, l' interruption des boucles imbriquées n'est généralement pas facile à mettre en œuvre. Nous devons savoir où la boucle la plus interne a été interrompue, la deuxième boucle interne la plus haute, et ainsi de suite.



Heureusement, Python a une fonction product



intégrée impressionnante itertools



. Nous pouvons l'utiliser pour éviter d'écrire de nombreuses boucles imbriquées.



Voyons à quel point c'est utile avec un exemple simple :

list_a = [1, 2020, 70]
list_b = [2, 4, 7, 2000]
list_c = [3, 70, 7]

for a in list_a:
    for b in list_b:
        for c in list_c:
            if a + b + c == 2077:
                print(a, b, c)
# 70 2000 7
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Comme on peut le voir, il faut trois boucles imbriquées pour obtenir trois nombres de trois listes dont la somme est 2077. Le code n'est pas très joli.



Essayons maintenant d'utiliser une fonction product



.

from itertools import product

list_a = [1, 2020, 70]
list_b = [2, 4, 7, 2000]
list_c = [3, 70, 7]

for a, b, c in product(list_a, list_b, list_c):
    if a + b + c == 2077:
        print(a, b, c)
# 70 2000 7
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Comme on peut le voir, grâce à l'utilisation de la fonction product



, un seul cycle suffit.



Étant donné que la fonction product



génère un produit direct des données itérables d'entrée, elle nous permet d'éviter les boucles imbriquées dans de nombreux cas.

Utiliser le module Itertools pour écrire de belles boucles

En fait, une fonction product



n'est que la pointe de l'iceberg. Si vous apprenez le module Python intégré itertools



, un tout nouveau monde s'ouvre devant vous. Cette boîte à outils contient de nombreuses méthodes utiles pour couvrir nos besoins de bouclage. Une liste complète d'entre eux peut être trouvée dans la documentation officielle . Voyons quelques exemples.

Comment créer une boucle sans fin

Il existe au moins trois façons de créer une boucle infinie :



1. À l'aide d'une fonction count



:

natural_num = itertools.count(1)
for n in natural_num:
    print(n)
# 1,2,3,...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

2. Fonction cycle



:

many_yang = itertools.cycle('Yang')
for y in many_yang:
    print(y)
# 'Y','a','n','g','Y','a','n','g',...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

3. Par la fonction repeat



:

many_yang = itertools.repeat('Yang')
for y in many_yang:
    print(y)
# 'Yang','Yang',...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Combiner plusieurs itérateurs en un seul

La fonction chain()



vous permet de combiner plusieurs itérateurs en un seul.

from itertools import chain

list_a = [1, 22]
list_b = [7, 20]
list_c = [3, 70]

for i in chain(list_a, list_b, list_c):
    print(i)
# 1,22,7,20,3,70
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Sélectionnez les éléments en double adjacents

La fonction est groupby



utilisée pour sélectionner des éléments dupliqués adjacents dans un itérateur et les joindre.

from itertools import groupby

for key, group in groupby('YAaANNGGG'):
    print(key, list(group))
# Y ['Y']
# A ['A']
# a ['a']
# A ['A']
# N ['N', 'N']
# G ['G', 'G', 'G']
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Comme indiqué ci-dessus, des symboles similaires adjacents sont connectés ensemble. De plus, nous pouvons dire à la fonction groupby



comment déterminer l'identité de deux éléments :

from itertools import groupby

for key, group in groupby('YAaANNGGG', lambda x: x.upper()):
    print(key, list(group))
# Y ['Y']
# A ['A', 'a', 'A']
# N ['N', 'N']
# G ['G', 'G', 'G']
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Personnaliser le cycle

Après avoir examiné les exemples ci-dessus, réfléchissons aux raisons pour lesquelles les boucles for



Python sont si flexibles et gracieuses. Autant que je sache, cela est dû au fait que nous pouvons utiliser des for



fonctions dans l'itérateur de boucle . Dans tous les exemples ci-dessus, l'itérateur utilise simplement des fonctions spéciales. Toutes les astuces ont le même schéma :

for x in function(iterator)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Le module intégré lui-même n'implémente itertools



que les fonctions les plus courantes pour nous. Si nous oublions une fonction ou ne trouvons pas celle dont nous avons besoin, nous pouvons simplement l'écrire nous-mêmes. Pour être plus précis, ces fonctions sont des générateurs . C'est pourquoi nous pouvons générer des boucles infinies avec eux.



Fondamentalement, nous pouvons personnaliser la boucle for



comme nous le ferions avec un générateur personnalisé.



Regardons un exemple simple :

def even_only(num):
    for i in num:
        if i % 2 == 0:
            yield i


my_list = [1, 9, 3, 4, 2, 5]
for n in even_only(my_list):
    print(n)
# 4
# 2
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Comme vous pouvez le voir dans l'exemple ci-dessus, nous avons défini un générateur appelé even_only



. Si nous utilisons ce générateur dans une boucle for, l'itération ne se produira que pour les nombres pairs de la liste.



Bien entendu, cet exemple n'est qu'une explication. Il existe d'autres façons de faire la même chose, comme l'utilisation de la vue en liste .

my_list = [1, 9, 3, 4, 2, 5]
for n in (i for i in my_list if not i % 2):
    print(n)
# 4
# 2
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Production

La tâche de création de boucles en Python peut être résolue de manière très flexible et gracieuse. Pour écrire des boucles simples et pratiques, nous pouvons utiliser des outils intégrés ou même définir nous-mêmes des générateurs.

---

Publicité

Serveur fiable à louer , créez votre propre configuration en quelques clics et commencez à travailler en une minute. Tout fonctionnera sans problème et avec un temps de disponibilité très élevé !



Rejoignez notre chat Telegram .