blocks|key|4062011|text|因为cb[0]和cb.__getitem__(0)是一样的。请看这上面的python+documentation。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4062012|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/reference/datamodel.html^0|2|5|8|H|10|K|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

Because <code>cb[0]</code> is the same as <code>cb.__getitem__(0)</code>. See the <a href="http://docs.python.org/reference/datamodel.html" rel="nofollow noreferrer">python documentation</a> on this.

blocks|key|1287154|text|像__getitem__这样的特殊方法会向对象添加特殊的行为，包括迭代。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1287155|http://docs.python.org/reference/datamodel.html#object.|1287156|"for循环预计将为非法索引引发IndexError，以允许正确检测序列的结尾。“|1287157|引发IndexError发出序列结束的信号。|1287158|你的代码基本上等同于：|1287159|i+=+0
while+True:
++++try:
++++++++yield+object[i]
++++++++i+%2B=+1
++++except+IndexError:
++++++++break|code-block|syntax|javascript|1287160|其中object是您在for循环中迭代的对象。|1287161|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/reference/datamodel.html#object.__getitem__^0|1|B|0|0|1J|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|15|8|@]|D|@$9|16|A|17|1|18]]|E|$]]|$1|H|3|I|5|6|7|19|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|1A|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|1B|8|@]|D|@]|E|$]]|$1|N|3|O|5|P|7|1C|8|@]|D|@]|E|$Q|R]]|$1|S|3|T|5|6|7|1D|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11]]]]

Special methods such as <code>__getitem__</code> add special behaviors to objects, including iteration. 

<a href="http://docs.python.org/reference/datamodel.html#object.__getitem__" rel="noreferrer">http://docs.python.org/reference/datamodel.html#object.getitem</a>

"for loops expect that an IndexError will be raised for illegal indexes to allow proper detection of the end of the sequence."

Raise IndexError to signal the end of the sequence.

Your code is basically equivalent to:

<pre><code>i = 0
while True:
 try:
 yield object[i]
 i += 1
 except IndexError:
 break
</code></pre>

Where object is what you're iterating over in the for loop.

blocks|key|1285538|text|如果你看一下定义迭代器的PEP234，它会说：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1285539|1.+An+object+can+be+iterated+over+with+"for"+if+it+implements
+++__iter__()+or+__getitem__().

2.+An+object+can+function+as+an+iterator+if+it+implements+next().|code-block|syntax|javascript|1285540|entityMap|0|LINK|mutability|MUTABLE|url|http://www.python.org/dev/peps/pep-0234^0|C|6|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

If you take a look at <a href="http://www.python.org/dev/peps/pep-0234" rel="noreferrer">PEP234</a> defining iterators, it says:

<pre><code>1. An object can be iterated over with "for" if it implements
 __iter__() or __getitem__().

2. An object can function as an iterator if it implements next().
</code></pre>

blocks|key|4062170|text|迭代对__getitem__的支持可以看作是一个“遗留特性”，当PEP234引入可迭代性作为主要概念时，它允许更平滑的过渡。它只适用于没有__iter__的类，这些类的__getitem__接受整数0、1和c，一旦索引变得太高(如果有的话)，就会引发IndexError，通常是在__iter__出现之前编码的“序列”类(尽管没有什么可以阻止您以这种方式编写新类)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4062171|就我个人而言，我不希望在新代码中依赖它，尽管它没有被弃用，也不会消失(在Python3中也可以很好地工作)，所以这只是一个风格和品味问题(“显式比隐式好”，所以我宁愿显式地支持可迭代性，而不是依赖__getitem__对它的隐式支持--但不是很重要)。|4062172|entityMap^0|3|B|1X|8|2C|B|3H|A|3W|8|0|2Q|B|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|I|$]]

Iteration's support for <code>__getitem__</code> can be seen as a "legacy feature" which allowed smoother transition when PEP234 introduced iterability as a primary concept. It only applies to classes without <code>__iter__</code> whose <code>__getitem__</code> accepts integers 0, 1, &amp;c, and raises <code>IndexError</code> once the index gets too high (if ever), typically "sequence" classes coded before <code>__iter__</code> appeared (though nothing stops you from coding new classes this way too).

Personally, I would rather not rely on this in new code, though it's not deprecated nor is it going away (works fine in Python 3 too), so this is just a matter of style and taste ("explicit is better than implicit" so I'd rather explicitly support iterability rather than rely on <code>__getitem__</code> supporting it implicitly for me -- but, not a bigge).

blocks|key|4062233|text|__getitem__早于迭代器协议，并且在过去是使事物可迭代的唯一方法。因此，它仍然被支持作为一种迭代方法。本质上，迭代的协议是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4062234|4062235|检查__iter__方法。如果存在，请使用新的迭代protocol.|ordered-list-item|4062236|Otherwise，尝试使用连续更大的整数值调用__getitem__，直到它引发IndexError。|4062237|4062238|(2)曾经是做这件事的唯一方法，但它的缺点是它假设了比支持迭代所需的更多的东西。为了支持迭代，你必须支持随机访问，这对于像文件或网络流这样的东西来说要昂贵得多，因为向前走很容易，但向后走需要存储所有东西。__iter__允许在没有随机访问的情况下进行迭代，但由于随机访问通常允许迭代，而且打破向后兼容性会很糟糕，因此仍然支持__getitem__。|4062239|entityMap^0|0|B|0|0|2|8|0|O|B|0|0|2U|8|4I|B|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|J|3|K|5|I|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|P|$]]

<code>__getitem__</code> predates the iterator protocol, and was in the past the only way to make things iterable. As such, it's still supported as a method of iterating. Essentially, the protocol for iteration is:

<ol>
<li>Check for an <code>__iter__</code> method. If it exists, use the new iteration protocol.</li>
<li>Otherwise, try calling <code>__getitem__</code> with successively larger integer values until it raises IndexError.</li>
</ol>

(2) used to be the only way of doing this, but had the disadvantage that it assumed more than was needed to support just iteration. To support iteration, you had to support random access, which was much more expensive for things like files or network streams where going forwards was easy, but going backwards would require storing everything. <code>__iter__</code> allowed iteration without random access, but since random access usually allows iteration anyway, and because breaking backward compatability would be bad, <code>__getitem__</code> is still supported.

blocks|key|4907286|text|这是有历史原因的。在Python2.2之前，__getitem__是创建可以使用for循环迭代的类的唯一方法。在2.2中添加了__iter__协议，但为了保持向后兼容性，__getitem__仍然在for循环中工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4907287|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

This is so for historical reasons. Prior to Python 2.2 __getitem__ was the only way to create a class that could be iterated over with the for loop. In 2.2 the __iter__ protocol was added but to retain backwards compatibility __getitem__ still works in for loops.

Why does defining __getitem__ on a class make it iterable? 

For instance if I write:

<pre><code>class b:
 def __getitem__(self, k):
 return k

cb = b()

for k in cb:
 print k
</code></pre>

I get the output:

<pre><code>0
1
2
3
4
5
6
7
8
...
</code></pre>

I would really expect to see an error returned from "for k in cb:"

Why does defining __getitem__ on a class make it iterable in python?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

为什么在类上定义__getitem__会让它变得可迭代？例如，如果我写道：class b:  def __getitem__(self, k):    return kcb = b()for k in cb:  print k我得到了输出：012345678...我真的希望看到"for k in cb:“返回一个错误。

问为什么在类上定义getitem使得它在python中是可迭代的？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在类上定义__getitem__使得它在python中是可迭代的？EN