Explication détaillée d'exemples de boucle for en python

Cet article présente principalement quelques réflexions sur l'utilisation de la boucle for en python. Les amis qui en ont besoin peuvent se référer à

Pourquoi devrais-je me mettre au défi de ne pas écrire for dans le code ? boucle? Parce que cela vous oblige à utiliser une syntaxe ou des bibliothèques plus avancées et authentiques. L'article utilise Python comme exemple pour parler de nombreuses syntaxes que tout le monde a vues dans le code d'autres personnes mais qui les utilisent rarement eux-mêmes.

C'est un défi. Je veux que vous évitiez d’écrire des boucles for sous aucun prétexte. De même, je souhaite également que vous trouviez un scénario dans lequel il est trop difficile d’écrire autrement que par l’utilisation d’une boucle for. S'il vous plaît partagez vos découvertes, j'aimerais les entendre

Cela fait un moment que j'ai commencé à explorer les superbes fonctionnalités du langage Python. Au début, c'était juste un défi que je me suis donné de m'entraîner à utiliser davantage de fonctionnalités du langage au lieu de ce que j'avais appris d'autres langages de programmation. Mais les choses deviennent progressivement plus intéressantes ! Non seulement le code devient plus court et plus propre, mais il semble également plus structuré et régulier, et je parlerai davantage de ces avantages dans cet article.

Prenons d'abord un peu de recul et regardons l'intuition derrière l'écriture d'une boucle for :

1 Parcourez une séquence pour extraire des informations

2. Générer une autre séquence à partir de la séquence

3. Écrire des boucles est une seconde nature pour moi car je suis programmeur

Heureusement, il existe déjà d'excellents outils dans Python Tools pour vous aider à atteindre ces objectifs ! Tout ce que vous avez à faire est de changer d’avis et d’examiner le problème sous un angle différent.

Que gagnerez-vous en n'écrivant pas de boucles partout

1. Moins de lignes de code

2. Meilleure lisibilité du code

3. Utilisez uniquement l'indentation. pour gérer le texte du code

Voyons le squelette du code ci-dessous :

Regardez la structure du code ci-dessous : >

Cet exemple utilise plusieurs niveaux de code imbriqué, qui est très difficile à lire. Ce que j'ai trouvé dans ce code, c'est l'utilisation aveugle de l'indentation pour mélanger la logique de gestion (avec, try-sauf) et la logique métier (pour, si). Si vous respectez la convention consistant à utiliser uniquement l'indentation pour la logique administrative, la logique métier principale doit être supprimée immédiatement.

# 1
with ...:
  for ...:
    if ...:
      try:
      except:
    else:

«Les structures plates sont meilleures que les structures imbriquées» - "Zen of Python"

Pour éviter les boucles for, vous pouvez utiliser ces outils 1 . Analyse de liste/

Générateur

Expression

Regardez un exemple simple. Cet exemple compile principalement une nouvelle séquence basée sur une séquence existante : <.>

Si vous aimez MapReduce, vous pouvez utiliser la carte ou l'analyse de liste de Python :

result = []
for item in item_list:
  new_item = do_something_with(item)
  result.append(item)

Idem, si vous souhaitez simplement obtenir un itérateur, vous pouvez utiliser une expression génératrice avec presque la même syntaxe. (Comment ne pas tomber amoureux de la cohérence de Python ?)

result = [do_something_with(item) for item in item_list]

2. Les fonctions

représentent une manière plus fonctionnelle et d'ordre supérieur de devenir Think à ce sujet, si vous souhaitez mapper une séquence à une autre séquence, appelez directement la fonction map. (Les compréhensions de liste peuvent également être utilisées à la place.) result = (do_something_with(item) for item in item_list)

Si vous souhaitez réduire une séquence à un élément, utilisez réduire

doubled_list = map(lambda x: x * 2, old_list)

De plus, de nombreuses fonctions intégrées dans Python peuvent/vont (je ne sais pas si c'est une bonne ou une mauvaise chose, vous en choisissez une, c'est un peu difficile à comprendre sans ajouter ceci phrase) consommant des itérateurs :

from functools import reduce
summation = reduce(lambda x, y: x + y, numbers)

3. Extraire des fonctions ou des expressions

Les deux méthodes ci-dessus gèrent très bien une logique plus simple, mais qu'en est-il des plus complexes logique? En tant que programmeurs, nous résumons les choses difficiles en fonctions, et cette approche peut également être utilisée ici. Si vous écrivez ce genre de code :

>>> a = list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> all(a)
False
>>> any(a)
True
>>> max(a)
9
>>> min(a)
0
>>> list(filter(bool, a))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> set(a)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> dict(zip(a,a))
{0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9}
>>> sorted(a, reverse=True)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> str(a)
'[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]'
>>> sum(a)
45

Vous donnez évidemment trop de responsabilités à un morceau de code. Pour vous améliorer, je vous propose de faire ceci :

results = []
for item in item_list:
  # setups
  # condition
  # processing
  # calculation
  results.append(result)

Que diriez-vous de boucles for imbriquées ?

def process_item(item):
  # setups
  # condition
  # processing
  # calculation
  return result

results = [process_item(item) for item in item_list]

La compréhension des listes peut vous aider :

results = []
for i in range(10):
  for j in range(i):
    results.append((i, j))

Si vous souhaitez économiser beaucoup de état interne Que faire ?

results = [(i, j)
      for i in range(10)
      for j in range(i)]

Extrayons une expression pour les implémenter :

# finding the max prior to the current item
a = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
results = []
current_max = 0
for i in a:
  current_max = max(i, current_max)
  results.append(current_max)

# results = [3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

"Attendez, vous venez d'utiliser une boucle for dans l'expression de cette fonction, c'est de la triche ! 

D'accord, malin, essaie ça.

def max_generator(numbers):
  current_max = 0
  for i in numbers:
    current_max = max(i, current_max)
    yield current_max

a = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
results = list(max_generator(a))

4. N'écrivez pas la boucle for vous-même, itertools le fera pour vous

Ce module est vraiment merveilleux. Je pense que ce module peut couvrir 80% des cas où vous souhaitez écrire une boucle for. Par exemple, l'exemple précédent pourrait être réécrit comme ceci :

De plus, si vous parcourez une séquence de combinaisons, il existe des produits(), des permutations( ), combinaisons() Il peut être utilisé.

Conclusion

from itertools import accumulate
a = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
resutls = list(accumulate(a, max))

1 Dans la plupart des cas, il n'est pas nécessaire d'écrire une boucle for.

2. Vous devez éviter d'utiliser des boucles for, ce qui rendra le code plus lisible.

Action

1. Regardez à nouveau votre code et trouvez n'importe quel endroit où vous avez écrit intuitivement une boucle for auparavant, réfléchissez-y à nouveau et écrivez-le sans for. boucle. Encore une fois, cela n'a pas de sens.

2. Partagez un exemple où il vous était difficile de ne pas utiliser de boucle for.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!