为什么`x[i]` 不等价于`x.__getitem__(x)`？

如何解决为什么`x[i]` 不等价于`x.__getitem__(x)`？

来自documentation：

x[i] 大致相当于 type(x).__getitem__(x,i)。

与看起来更简单的 x.__getitem__(i) 相比，上述有什么好处？
编辑：为什么 Python 会这样？

作为标准行为的一个缺点，让我展示这个示例代码，我惊讶地发现最后一个断言失败，而倒数第二个断言（直接调用 __getitem__）通过。

def poww_bar(base):
    class Bar():
        def __getitem__(self,x):
            return lambda: base**x
    return Bar()

def poww_foo(base):
    class Foo():
        pass
    f = Foo()
    f.__getitem__ = lambda x: lambda: base ** x
    return f

pow_bar2 = poww_bar(2)
pow_foo2 = poww_foo(2)


assert pow_bar2.__getitem__(3)() == 8 # OK
assert pow_bar2[3]() == 8 # OK

assert pow_foo2.__getitem__(3)() == 8 # OK
assert pow_foo2[3]() == 8 # TypeError: 'Foo' object is not subscriptable

解决方法

方法是类属性，而不是实例属性。

没有与 __getitem__ 关联的名为 pow_bar2 的实例属性。因此查找继续检查类中是否有该名称的属性，并成功找到 Bar.__getitem__。

但过程并没有就此结束。 pow_bar2.__getitem__(i) 不等同于 Bar.__getitem__(i)，因为 Python 首先检查属性查找会生成一个实现 descriptor protocol 的对象。由于 Bar.__getitem__ 是 function 的一个实例，它确实实现了描述符协议。

下一步不是返回函数本身，而是返回Bar.__dict__['__getitem__'].__get__(pow_bar2,Bar)的结果。 （我切换到使用 Bar.__dict__ 来强调我们不会进入触发描述符协议的无限循环。）这是一个 method 的实例，它本身是一个通过是自己的参数，连同 pow_bar2，作为原始函数的参数。

因此，pow_bar2.__getitem__(i) 相当于 Bar.__dict__['__getitem__'].__get__(pow_bar2,Bar)(i)，大致相当于 Bar.__dict__['__getitem__'](pow_bar2,i)。

---

但实际上，pow_bar2[i] 只是比 pow_bar2.__getitem__(i) 更短且更容易识别（由于其他语言对此语法已有数十年的支持）。 __getitem__ 是将 [] extendable 用于其他类的原因，而不是将其限制为内置类型。

---

描述符协议不仅仅是一个一次性的特性，它使实例方法行为看起来比必要的更复杂。它还确定类方法、静态方法和属性的工作方式，并可进一步用于以其他方式自定义属性行为。

,

这可能只是一种优化。一个类函数在类定义中只有一个引用。对象函数将在每个对象中都有一个引用。所以 __getitem__ 方法被指定为一个类函数，所以他们不需要浪费时间查看它的对象定义。

这当然都是猜测。