10

这for party in feed.entry意味着什么以及这个 for 循环实际上是如何工作的？

for party in feed.entry:
    print(party.location.address.text)

（我习惯于 C++ 风格的 for 循环，但 Python 循环让我感到困惑。）

4

8 回答 8

25

feed.entry 是 feed 的属性，它的值是（如果不是，则此代码将失败）实现迭代协议的对象（例如数组）并具有iter方法，该方法返回迭代器对象

Iterator 有 next() 方法，返回下一个元素或引发异常，所以 python for 循环实际上是：

iterator = feed.entry.__iter__()
while True:
    try:
        party = iterator.next()
    except StopIteration:
        # StopIteration exception is raised after last element
        break

    # loop code
    print party.location.address.text
于 2009-08-18T06:53:46.040 回答
6

feed.entry 是允许迭代的东西，并且包含某种类型的对象。这与 c++ 大致相似：

for (feed::iterator party = feed.entry.begin(); party != feed.entry.end(); ++party) {
   cout << (*party).location.address.text;
}
于 2009-08-18T06:50:53.207 回答
5

要将我的 0.05$ 添加到以前的答案中，您可能还想看看enumerate 内置函数

for i, season in enumerate(['Spring', 'Summer', 'Fall', 'Winter']):
    print i, season

0 Spring
1 Summer
2 Fall
3 Winter
于 2009-08-18T07:45:23.660 回答
4

派对简单地迭代可迭代的 feed.entry

看看Dive into Python的解释。

于 2009-08-18T06:54:10.690 回答
3

形式上，Python 中的for语句总是在可迭代对象上运行——一个可以为其项提供迭代器的对象。该for语句连续next从迭代器中获取元素，将其分配给目标名称并使用它运行套件（“body”）。

#   |name|   |iterable|
for party in feed.entry:
    # body...
    print(party.location.address.text)

在示例中，feed.entry是可迭代的，party是目标名称并且print ...是套件。迭代器由for语句自动请求，并保存迭代状态 - 例如，如果可迭代是列表，则为下一个元素的索引。

如果您来自 C++，经典for (int i = 0; i < 10; ++i)循环代表外部迭代：迭代状态i保持在可迭代之外。这对应于 Python 的while循环：

# for (int i = 0; i < 10; ++i)
i = 0
while i < 10:
    i += 1
    # access the state of an iterable here

较新的for (auto party : entry)范围循环表示内部迭代：迭代状态由单独的迭代器保存。这对应于 Python 的for循环。然而，iterable/iterator 协议明显不同：Pythonfor用于iter(iterable)获取迭代器，它应该支持next(iterator)- 返回一个元素或 raise StopIteration。

用 Python 写的，语句的定义for对应如下：

# for party in feed.entry:
__iterator = iter(feed.entry)  # iterator -- not visible in containing scope
__iterating = True             # graceful exit to enter `else` clause
while __iterating:
    try:                          # attempt to...
        item = next(__iterator)   # ... get the next item
    except StopIteration:         # ... or stop
        __iterating = False       #     with a graceful exit
    else:
        party = item
        <suite>                # run the body with names bound
else:                          # entered in a graceful exit only
    <else suite>

（请注意，整个块 from __iterating = Trueto__iterating = False对包含范围来说是不“可见的”。实现使用各种优化，例如 CPython 允许内置迭代器返回 CNULL而不是引发 PythonStopIteration。）

该for语句只定义了iterable 和 iterator 的使用方式。如果您最熟悉外部迭代，那么查看可迭代和迭代器也会有所帮助。

该iter(iterable)调用有多种派生迭代器的方法- 这就像iter为各种结构类型重载一样。

  • 如果type(iterable).__iter__已定义，则将其作为方法调用，并将结果用作迭代器。

  • 如果已定义，则它由返回, , ...type(iterable).__getitem__的通用迭代器类型包装，并在索引时引发if引发。iterable[0]iterable[1]StopIterationIndexError

无论哪种方式，iter都返回一个迭代器或 raises TypeError。迭代器是定义（用于可重用性）和（用于实际迭代）的任何类型。通常，迭代器是可以保存状态以计算项目的对象。例如，一个列表迭代器对应于这个对象：__iter____next____next__

class ListIterator:
    """Python equivalent of ``iter(:list)``"""
    # iterator holds iteration state - e.g. iterable and current index
    def __init__(self, iterable: list):
        self.iterable = iterable
        self.index = 0

    # __next__ fetches item and advances iteration state - e.g. index += 1
    def __next__(self):
        # attempt to produce an item
        try:
            item = self.iterable[self.index]
        except IndexError:  # translate indexing protocol to iteration protocol
            raise StopIteration
        # update iteration state
        self.index += 1
        return item

    # iterators can be iterated on in ``for`` statements etc.
    def __iter__(self):
        return self

（请注意，人们会习惯性地将这样的对象编写为生成器函数。）

索引列表或增加一些指针只是可迭代/迭代器协议的一个非常基本的示例。例如，迭代器可以是无状态的并用于random.random()生成__next__无限的随机数流。例如，迭代器还可以保存外部信息的状态，并迭代地遍历文件系统。

于 2019-09-06T06:27:38.470 回答
1

在 Python 中，因为bucles 不像 C/C++ 的，它们最像 PHP 的foreach。您所做的不是像“（初始化；条件；增量）”那样在一段时间内进行迭代，它只是迭代列表中的每个元素（字符串像列表一样是可迭代的）。

例如：

for number in range(5):
    print number

将输出

0
1
2
3
4
于 2009-08-18T07:20:36.313 回答
1

我只是想为刚接触这个的人提供一个更通用的解释。

从语法上讲，for循环看起来像......

for <name to be assigned to> in <some sequence>:

    <block of code, optionally referencing the name>

解释器为序列中的每个项目（任何可以迭代的项目）运行一次块。每次运行该块时，它首先将序列中的下一个对象分配给该名称，该名称可以是任何有效的变量名称。

做for each in (1, 2, 3): print(each)[或多或少]与做...

i = 0
sequence = (1, 2, 3)
while True:
    try:
        each = sequence[i]
        print(each)
        i += 1
    except IndexError: pass

您还可以在赋值部分解压缩参数。就像你可以做类似的事情一样......

a, b = 1, 2

......你也可以做......

for a, b in [(1, 2), (3, 4), (5, 6)]: print(a + b)

...打印...

3
7
11
于 2013-10-11T15:35:23.407 回答
0

Python 的for循环适用于iterators，它必须实现iterator协议。有关更多详细信息，请参阅：

于 2009-08-18T10:02:07.207 回答