在python中'返回的'超级对象'是什么意思？

Question

根据http://docs.python.org/2/library/functions.html#super，

  

如果省略第二个参数，则返回的超级对象是   未结合的。

哪个是超级（类型）。

我想知道什么是无限的，什么时候有限。

Answer 1

编辑：在super的上下文中，下面的大部分内容都是错误的。请参阅John Y的评论。

super(Foo, a).bar从方法解析顺序（MRO）中的下一个对象返回名为bar的方法，在这种情况下绑定到对象a，{{1}的实例}}。如果省略Foo，则返回的方法将被解除绑定。方法只是对象，但它们可以绑定或不绑定。

未绑定方法是一种不依赖于类实例的方法。它没有接收类的实例作为隐式的第一个参数。

您仍然可以调用未绑定的方法，但是您需要明确地传递该类的实例作为第一个参数。

以下给出了绑定和未绑定方法的示例以及如何使用它们。

a

Answer 2

针对您问题的其他答案（answer，answer）已经说明了绑定/未绑定单词的含义。

因此，我的重点是仅解释从 super() 函数返回的未绑定代理对象的用途（即如果仅使用1个参数）。

获取未绑定对象的原因是稍后将其绑定。

尤其是，对于从super()函数返回的未绑定对象，您可以使用其__get__()方法将其绑定到适当的对象，例如

super(C).__get__(c)        # where C is a class and c is an object

---

为说明这一点，让我们创建3个相关类和3个对象-每个类一个：

class A:
    def __init__(self, name):
        self.name = name
    def message(self, source):
        print(f"From: {source}, class: A, object: {self.name}")

class B(A):
    def __init__(self, name):
        self.name = name
    def message(self, source):
        print(f"From: {source}, class: B, object: {self.name}")

class C(B):
    def __init__(self, name):
        self.name = name
    def message(self, source):
        print(f"From: {source}, class: C, object: {self.name}")

a = A("a")
b = B("b")
c = C("c")

现在在交互式控制台中，首先了解事物：

>>> super(B)                  # unbounded (note 'None')
<super: __main__.B, None>

>>> super(B).__get__(b)       # bounded to object b (note address)
<super: __main__.B, <__main__.B at 0xa9bdac0>>

>>> b                         # note: the same address
'<__main__.B at 0xa9bdac0>

然后-显示使用类/对象的不同组合的结果
（在我们的案例中，委托方法.message()）

>>> super(B).__get__(b).message("super(B)")
From: super(B), class: A, object: b

>>> super(C).__get__(c).message("super(C)")
From: super(C), class: B, object: c

>>> super(B).__get__(c).message("super(C)")
From: super(C), class: A, object: c

最后是将代理绑定和解绑定到适当类的示例：

>>> A.name = "Class A"            # Preparing for it - 
>>> B.name = "Class B"            # creating some class attributes

>>> super(B).__get__(B).name      # Proxy super(B) bounded to class B
'Class A'

>>> super(B).__get__(C).name      # Proxy super(B) bounded to class C
'Class A'

>>> super(C).__get__(C).name      # Proxy super(C) bounded to class C
'Class B'

Answer 3

为解释术语绑定/未绑定，我将使用功能，并且-简而言之，我将放弃详细信息和警告。

有2个视图：

---

1. 从用户的角度来看，共有3种功能：

   1. 免费功能（未绑定），例如内置功能df['Time'] = df['Time'].astype('datetime64') ：

      sum()

   2. 绑定到对象的功能（别名：对象方法）意味着用户必须将其绑定到特定对象带有点（sum([1, 2, 3]) # 6 ）表示法。

      例如使用内置的.方法：

      .upper()

   3. 绑定到类（其他名称： class方法）的功能意味着用户必须将其绑定到特定的类 —再次使用相同的点（"Alice".upper() # ALICE "Jacob".upper() # JACOB (the same method; different object, different result) ）表示法。

      示例：

      .

---

1. 从设计者的角度来看，存在相同的3种功能，因此我对它们使用相同的数字：

   1. 在类之外定义了免费（未绑定）功能：

      A.some_class_method()               # A is a class
      B.some_class_method(parameters)     # B is a class
      

   2. 绑定到对象的功能 是在类内部定义的，第一个参数为对象保留并命名为def free_function(parameters): ... （仅惯例，但很强大）：

      self

   3. 绑定到类的函数是在类内部定义的，第一个参数为类保留并命名为class A: def bound_to_object(self, other_parameters): ... （仅约定，但非常强大），并在其前面加上cls装饰器：

      @classmethod

Answer 4

“Unbound”表示它将返回类，而不是类的实例。