Detaillierte Erläuterung der Verwendung der for-Schleife in Python_python

Dieser Artikel stellt hauptsächlich die Verwendung der for-Schleife in Python vor. Er stammt aus der technischen Dokumentation der offiziellen IBM-Website. Freunde in Not können auf

for-Schleife

Im vorherigen Artikel dieser Reihe, „Python erkunden, Teil 5: Programmieren in Python“, wurden if-Anweisungen und while-Schleifen, zusammengesetzte Anweisungen und die entsprechende Einrückung von Python-Anweisungen zur Kennzeichnung verwandter Blöcke des Python-Codes besprochen. Der Artikel endet mit einer Einführung in die Python-for-Schleife. Da die for-Schleife hinsichtlich ihrer Verwendung und Funktion jedoch mehr Aufmerksamkeit verdient, wird diese Schleife in diesem Artikel separat behandelt.

Die for-Schleife verfügt über eine einfache Syntax, die es Ihnen ermöglicht, ein einzelnes Element aus einem Containerobjekt zu extrahieren und bestimmte Operationen daran auszuführen. Einfach ausgedrückt: Mit einer for-Schleife iterieren Sie über die Elemente in einer Sammlung von Objekten. Eine Sammlung von Objekten kann ein beliebiger Python-Containertyp sein, einschließlich der im vorherigen Artikel besprochenen Tupel-, String- und Listentypen. Aber die Container-Metapher ist wirkungsvoller als diese drei Typen. Metaphern umfassen andere Sequenztypen wie Wörterbuch und Menge, die in zukünftigen Artikeln besprochen werden.

Aber bitte warten! Und noch mehr: For-Schleifen können verwendet werden, um über jedes Objekt zu iterieren, das die Iterationsmetapher unterstützt, was For-Schleifen sehr nützlich macht.

Listing 1 zeigt die grundlegende Syntax einer for-Schleife und demonstriert außerdem die Verwendung von continue- und break-Anweisungen in einer for-Schleife.

Listing 1. Pseudocode für eine for-Schleife

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.

Zweiter Artikel in dieser Reihe, „Exploring Python, Teil 2: Exploring Python Type Hierarchy“ führt Python-Tupel ein. Wie im Artikel erwähnt, sind Tupeltypen unveränderliche heterogene Container. Dies bedeutet hauptsächlich, dass ein Tupel Objekte unterschiedlichen Typs speichern kann, aber sobald es erstellt wurde, kann es nicht mehr geändert werden. Listing 2 zeigt, wie man eine for-Schleife verwendet, um die Elemente eines Tupels zu durchlaufen.

Listing 2. for-Schleife und Tupel

>>> 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

In diesem Beispiel wird zunächst ein Tupel mit dem Namen t erstellt, um die ganzen Zahlen 0 bis 9 (einschließlich 9) zu speichern. . Die erste for-Schleife durchläuft das Tupel und akkumuliert die Summe der Werte im Tupel in der Zählvariablen. Sobald der Code alle Elemente im Tupel durchlaufen hat, tritt er in die else-Klausel der for-Schleife ein und gibt den Wert der Zählvariablen aus.

Die zweite in Listing 2 gezeigte for-Schleife iteriert ebenfalls über alle Elemente im Tupel. Es werden jedoch nur die Werte der Elemente im Container akkumuliert, die durch 2 teilbar sind (denken Sie daran, dass die if-Anweisung wahr ist, wenn der Ausdruck ungleich Null ist, und die Verwendung des %-Operators, wenn num nicht durch 2 teilbar ist, einen Wert ungleich Null zurückgibt Wert) . Diese Einschränkung wird durch die Verwendung geeigneter if-Anweisungen und continue-Anweisungen erreicht. Wie im vorherigen Artikel erwähnt, bewirkt die continue-Anweisung, dass die Schleife, die sie enthält, mit der nächsten Iteration beginnt. Eine andere Möglichkeit, das gleiche Ergebnis zu erzielen, besteht darin, zu testen, ob das aktuelle Element im Tupel eine gerade Zahl ist (mithilfe von if not num % 2:), und wenn dies zutrifft, dann das aktuelle Element zur laufenden Summe hinzuzufügen. Sobald der Code die Iteration durch das Tupel abgeschlossen hat, wird die else-Klausel aufgerufen und die Summe ausgegeben.

Der dritte Artikel dieser Reihe, „Exploring Python: Teil 3: Exploring the Python Type Hierarchy“, behandelt Python-Strings. String ist ein unveränderlicher isomorpher Container, was bedeutet, dass er nur Zeichen enthalten kann und nach der Erstellung nicht mehr geändert werden kann. Listing 3 zeigt, wie man einen Python-String als Container für eine for-Schleife verwendet.

Listing 3. for-Schleifen und String

>>> 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

Dieses Beispiel stellt drei verschiedene for-Schleifen bereit, die alle über denselben String iterieren. Die erste for-Schleife durchläuft die Zeichenfolge „Python ist eine großartige Programmiersprache!“ und gibt die Zeichenfolge zeichenweise aus. In diesem Beispiel wird ein Komma an die print-Anweisungsvariable c angehängt. Dies führt dazu, dass die print-Anweisung Zeichenwerte gefolgt von einem Leerzeichen anstelle eines Zeilenumbruchzeichens druckt. Ohne das folgende Komma würden die Zeichen alle in separaten Zeilen gedruckt, was schwer lesbar wäre.

Die nächsten beiden for-Schleifen durchlaufen die Zeichenfolge und zählen, wie viele Vokale („a“, „e“, „i“, „o“ oder „u“) sie enthält. Die zweite for-Schleife sucht nur nach kleingeschriebenen Vokalen, wenn sie über die ursprüngliche Zeichenfolge iteriert. Die dritte for-Schleife durchläuft die temporäre Zeichenfolge, die durch Aufrufen der unteren Methode des Zeichenfolgenobjekts zurückgegeben wird. Die untere Methode wandelt alle Zeichen in einer Zeichenfolge in Kleinbuchstaben um. Daher findet die dritte for-Schleife zwei weitere Vokale.

Der vierte Artikel dieser Reihe, „Exploring Python, Teil 4: Exploring the Python Type Hierarchy“, stellt Python-Listen vor. Eine Liste ist ein heterogener, veränderlicher Container, das heißt, sie kann Objekte unterschiedlichen Typs speichern und nach der Erstellung geändert werden. Listing 4 zeigt, wie man eine Liste und eine for-Schleife verwendet.

Listing 4. for-Schleife und Liste Nachdem ich es schon oft gesehen habe, scheint dieses Beispiel zu einfach zu sein. Aber hier ist ein Teil der Sache: Die Verwendung einer for-Schleife macht es sehr einfach, jedes Element im Container zu verarbeiten, sogar eine Liste, die eine Vielzahl unterschiedlicher Objekte enthält. Dieses Beispiel durchläuft alle Elemente in einer Python-Liste und gibt jedes Element und seinen entsprechenden Python-Typ in einer separaten Zeile aus.
Iteration und veränderliche Container

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 提供了用于组合这两个概念的简单机制，称为列表理解，将来的文章中将讲述该内容。

Verwandte Empfehlungen:

Verwendung und Unterschied zwischen for-Schleife und foreach-Schleife in PHP

js über Beispiele für verschachtelte for-Schleifen

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Verwendung der for-Schleife in Python_python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!