Explication détaillée de l'utilisation de la boucle for dans Python_python

Cet article présente principalement l'utilisation de la boucle for en Python. Il provient de la documentation technique du site officiel d'IBM. Les amis dans le besoin peuvent se référer à

boucle for

<.> L'article précédent de cette série, « Exploration de Python, Partie 5 : Programmation en Python », traitait des instructions if et des boucles while, discutait des instructions composées et de l'indentation appropriée des instructions Python pour indiquer les blocs associés de code Python. L'article se termine par une introduction à la boucle Python for. Mais en termes d'utilisation et de fonction, la boucle for mérite plus d'attention, c'est pourquoi cet article traite de cette boucle séparément.

La boucle for a une syntaxe simple qui vous permet d'extraire un seul élément d'un objet conteneur et d'effectuer certaines opérations dessus. En termes simples, à l'aide d'une boucle for, vous parcourez les éléments d'une collection d'objets. Une collection d’objets peut être n’importe quel type de conteneur Python, y compris les types de tuple, de chaîne et de liste abordés dans l’article précédent. Mais la métaphore du conteneur est plus puissante que ces trois types. Les métaphores incluent d'autres types de séquences tels que le dictionnaire et l'ensemble, qui seront abordés dans les prochains articles.

Mais s'il vous plaît, attendez ! Il y a plus : les boucles for peuvent être utilisées pour parcourir n'importe quel objet prenant en charge la métaphore d'itération, ce qui rend les boucles for très utiles.

Le listing 1 montre la syntaxe de base d'une boucle for et montre également comment utiliser les instructions continue et break dans une boucle for.

Listing 1. Pseudocode pour une boucle for

for item in container:
 
  if conditionA:    # Skip this item
    continue
 
  elif conditionB:   # Done with loop
    break
 
  # action to repeat for each item in the container
 
else:
 
  # action to take once we have finished the loop.

Deuxième article de cette série, "Exploration de Python, Partie 2 : Exploration de la hiérarchie des types Python" introduit les tuples Python. Comme mentionné dans l'article, les types de tuples sont des conteneurs hétérogènes immuables. Cela signifie principalement qu'un tuple peut stocker des objets de différents types, mais une fois créé, il ne peut plus être modifié. Le listing 2 montre comment utiliser une boucle for pour parcourir les éléments d'un tuple.

Listing 2. for boucle et tuple

>>> t = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) 
>>> count = 0
>>> for num in t:
...   count += num
... else:
...   print count
... 
45
>>> count = 0
>>> for num in t:
...   if num % 2:
...     continue
...   count += num
... else:
...   print count
... 
20

Cet exemple crée d'abord un tuple nommé t pour stocker les entiers 0 à 9 (dont 9 ) . La première boucle for parcourt le tuple, accumulant la somme des valeurs du tuple dans la variable count. Une fois que le code a parcouru tous les éléments du tuple, il entre dans la clause else de la boucle for et imprime la valeur de la variable count.

La deuxième boucle for présentée dans le listing 2 parcourt également tous les éléments du tuple. Cependant, il n'accumule que les valeurs des éléments du conteneur qui sont divisibles par 2 (rappelez-vous que l'instruction if est vraie si l'expression est différente de zéro, et l'utilisation de l'opérateur % lorsque num n'est pas divisible par 2 renverra un résultat différent de zéro. valeur) . Cette restriction est accomplie en utilisant des instructions if et des instructions continue appropriées. Comme mentionné dans l'article précédent, l'instruction continue fait commencer la boucle la contenant à l'itération suivante. Une autre façon d'obtenir le même résultat consiste à tester si l'élément actuel dans le tuple est un nombre pair (en utilisant if not num % 2 :), et si c'est vrai, ajouter l'élément actuel à la somme cumulée. Une fois que le code a terminé son itération dans le tuple, la clause else est appelée, imprimant la somme.

Le troisième article de cette série, « Exploration de Python : Partie 3 : Exploration de la hiérarchie des types Python », traite des chaînes Python. String est un conteneur isomorphe immuable, ce qui signifie qu'il ne peut contenir que des caractères et ne peut pas être modifié une fois créé. Le listing 3 montre comment utiliser une chaîne Python comme conteneur pour une boucle for.

Listing 3. for boucles et chaîne

>>> st = "Python Is A Great Programming Language!"
>>> for c in st:
...   print c,
... 
P y t h o n  I s  A  G r e a t  P r o g r a m m i n g  L a n g u a g e !
>>> count = 0
>>> for c in st:
...   if c in "aeiou":
...     count += 1
... else:
...   print count
...
10
>>> count = 0
>>> for c in st.lower():
...   if c in "aeiou":
...     count += 1
... else:
...   print count
... 
12

Cet exemple fournit trois boucles for différentes qui parcourent toutes la même chaîne. La première boucle for parcourt la chaîne « Python est un excellent langage de programmation ! » et imprime la chaîne un caractère à la fois. Dans cet exemple, une virgule est ajoutée après la variable d'instruction d'impression c. Cela amène l'instruction print à imprimer les valeurs de caractères suivies d'un caractère espace au lieu d'un caractère de nouvelle ligne. Sans la virgule suivante, les caractères seraient tous imprimés sur des lignes distinctes, ce qui serait difficile à lire.

Les deux boucles for suivantes parcourent la chaîne et comptent le nombre de voyelles ("a", "e", "i", "o" ou "u") qu'elle contient. La deuxième boucle for recherche uniquement les voyelles minuscules lors d'une itération sur la chaîne d'origine. La troisième boucle for parcourt la chaîne temporaire renvoyée en appelant la méthode inférieure de l'objet chaîne. La méthode lower convertit tous les caractères de la chaîne en minuscules. Par conséquent, la troisième boucle for trouve deux voyelles supplémentaires.

Le quatrième article de cette série, « Exploration de Python, partie 4 : Exploration de la hiérarchie des types Python », présente les listes Python. Une liste est un conteneur mutable hétérogène, ce qui signifie qu'elle peut stocker des objets de différents types et peut être modifiée après sa création. Le listing 4 montre comment utiliser une liste et une boucle for.

Listing 4. for boucle et list L'ayant vu plusieurs fois), cet exemple peut paraître trop simpliste. Mais voici une partie du problème : l'utilisation d'une boucle for rend très simple le traitement de chaque élément du conteneur, même une liste contenant une variété d'objets différents. Cet exemple parcourt tous les éléments d'une liste Python et imprime chaque élément et son type Python correspondant sur une ligne distincte.
Itération et conteneurs mutables

Python list 是一个可变序列，提供了一种令人好奇的可能性：for 循环主体可以修改其正在迭代的 list。正如您可能认为的，这样并不好，如果进行此操作，Python 解释器将无法很好地工作，如清单 5 所示。
清单 5. 在 for 循环中修改容器

>>> mylist = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for item in mylist:
...   if item % 2:
...     mylist.insert(0, 100)
... 
^CTraceback (most recent call last):
 File "<stdin>", line 3, in ?
KeyboardInterrupt
>>> print mylist
[100, ...., 100, 100, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # Many lines deleted for clarity
>>> mylist = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for item in mylist[:]:
...   if item % 2:
...     mylist.insert(0, 100)
... 
>>> print mylist
[100, 100, 100, 100, 100, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

本例中的第一个 for 循环只要在原始 list 中发现奇数，它就在 list 的开始插入数值 100。当然，这是一种演示此问题的不同寻常的方式，但却非常好。一旦在三个点的 Python 提示后按 Enter 键，Python 解释器就处于无限循环的混乱中。要停止这种混乱，必须通过按 Ctrl-C（其在 Python 输出中显示为 ^C）来中断进程，然后会出现 KeyboardInterrupt 异常。如果打印出修改的 list，将看到 mylist 现在包含大量的值为 100 的元素（新元素的准确数量取决于您中断循环的速度）。

本例中的第二个 for 循环演示了如何避免此问题。使用切片运算符创建原始 list 的副本。现在 for 循环将迭代该副本，而对原始 list 进行修改。最终的结果是修改后的原始 list，它现在以五个值为 100 的新元素开始。

for 循环和序列索引

如果您用过其他编程语言，Python for 循环可能看起来有点儿古怪。您可能认为它更像 foreach 循环。基于 C 的编程语言具有 for 循环，但它的设计目的是对一系列操作执行特定次数。Python for 循环可以通过使用内置的 range 和 xrange 方法来模拟该行为。清单 6 中演示了这两种方法。
清单 6. range 和 xrange 方法

>>> r = range(10)
>>> print r
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> type(r)
<type &#39;list&#39;>
>>> xr = xrange(10)
>>> print xr
xrange(10)
>>> type(xr)
<type &#39;xrange&#39;>

本例首先演示了 range 方法，它创建一个包含一系列整数的新 list。调用 range 方法的一般形式是提供单个值，用作整数 list 的上限。零为起始值。因此，调用 range(10) 将创建包含整数 0 至 9（包含 9）的 list。range 方法接受起始索引以及步长。所以，调用 range(11,20) 将创建从 11 至 19（包含 19）的整数 list，而调用 range(12, 89, 2) 将创建从 12 至 88 的偶数 list。

由于 xrange 方法也创建整数 list（其使用相同参数），所以它与 range 方法非常相似。但是，xrange 方法仅在需要时才在 list 中创建整数。例如，在清单 6 中，尝试打印出新创建的 xrange 时除了 xrange 的名称，不会显示任何数据。当需要迭代大量整数时，xrange 方法更适用，因为它不会创建极大的 list，那样会消耗大量计算机内存。

清单 7 演示了如何在 for 循环内使用 range 方法来创建整数 1 至 10（包含 10）的乘法表。
清单 7. 创建乘法表

>>> for row in range(1, 11):
...   for col in range(1, 11):
...     print "%3d " % (row * col),
...   print
... 
 1  2  3  4  5  6  7  8  9  10 
 2  4  6  8  10  12  14  16  18  20 
 3  6  9  12  15  18  21  24  27  30 
 4  8  12  16  20  24  28  32  36  40 
 5  10  15  20  25  30  35  40  45  50 
 6  12  18  24  30  36  42  48  54  60 
 7  14  21  28  35  42  49  56  63  70 
 8  16  24  32  40  48  56  64  72  80 
 9  18  27  36  45  54  63  72  81  90 
 10  20  30  40  50  60  70  80  90 100

本例使用两个 for 循环，外面的 for 循环关注乘法表中的每一行，嵌套的 for 循环关注每行内的列。每个循环都迭代包含整数 1 至 10（包含 10）的 list。最里面的 print 语句使用了一个名为 字符串格式化 的新概念来创建格式设置精美的表。字符串格式化是一种非常有用的技术，用于以格式设置精美的布局创建由不同数据类型组成的 string。现在详细信息并不重要，将来的文章中将讲述这些内容（了解 C 编程语言的 printf 方法的任何人都会很熟悉这些内容）。在本例中，字符串格式化指定将从整数创建新 string 且需要保留三个字符来存放该整数（如果该整数小于三个字符，将在左边用空格填补，从而使数据排列整齐）。第二个 print 语句用于打印新行，从而使乘法表中的下一行被打印在新的行中。

range 方法还可用于迭代容器，通过使用适当的索引访问序列中的每一项。要进行此操作，需要包含容器的允许范围索引值的整数 list，这可以通过使用 range 方法和 len 方法来轻松实现，如清单 8 所示。
清单 8. 在 for 循环内索引容器

>>> st = "Python Is A Great Programming Language!"
>>> for index in range(len(st)): 
...   print st[index],
... 
P y t h o n  I s  A  G r e a t  P r o g r a m m i n g  L a n g u a g e !
>>> for item in st.split(' '):
...   print item, len(item)
... 
Python 6
Is 2
A 1
Great 5
Programming 11
Language! 9

这个最后的示例演示了如何使用 len 方法作为 range 方法的参数，创建可用于单独访问 string 中每个字符的整数 list。第二个 for 循环还显示了如何将 string 分割为子字符串的 list（使用空格字符来指示子字符串的边界）。for 循环迭代子字符串 list，打印每个子字符串及其长度。

结束语

本文讨论了 Python for 循环并演示了它的一些使用方式。可以将 for 循环与提供迭代器的任何 Python 对象结合使用，这些对象包括 tuple、string 和 list 等内置序列类型。for 循环和 list 序列一起使用时具有强大的功能，您会发现自己在许多情况中都要使用它们。Python 提供了用于组合这两个概念的简单机制，称为列表理解，将来的文章中将讲述该内容。

Recommandations associées :

Utilisation et différence entre la boucle for et la boucle foreach en PHP

js à propos des exemples de boucles for imbriquées

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!