标签: super

superJava中关键字的含义和用法是什么？

为什么我们必须使用__getitem__而不是通常的操作员访问？

class MyDict(dict):
    def __getitem__(self, key):
        return super()[key]

我们得到了TypeError: 'super' object is not subscriptable.

相反,我们必须使用super().__getitem__(key),但我从未完全理解为什么 - 它究竟是什么阻止了超级操作以允许操作员访问的方式？

标化只是一个例子,我也有同样的问题__getattr__,__init__等等.

本文档试图解释为什么,但我不明白.

我正在学习文档的反应,但不确定super()这个例子中的作用.通常,是否需要传递给生成新实例的参数,然后调用React.Component的构造函数方法将这些参数合并到实例中？没有任何争论,它会做什么？

class LikeButton extends React.Component {
  constructor() {
    super();
    this.state = {
      liked: false
    };
    this.handleClick = this.handleClick.bind(this);
  }
  handleClick() {
    this.setState({liked: !this.state.liked});
  }
  render() {
    const text = this.state.liked ? 'liked' : 'haven\'t liked';
    return (
      <div onClick={this.handleClick}>
        You {text} this. Click to toggle.
      </div>
    );
  }
}

ReactDOM.render(
  <LikeButton />,
  document.getElementById('example')
);

在调用super()之前是否存在要进行某些处理的情况？

这是一个人为的例子.有更好的例子吗？这被认为是pythonic吗？

class Base(object):
    def __init__(self, name):
        print "Base %s created" % name
        self._name = name

class UpperBase(A):
    """ Similar to base but the name is in uppercase. """
    def __init__(self, name):
        name = name.upper() 
        super(UpperBase, self).__init__(name)

我希望当子类重写父类中的方法时,super.method()会在该子方法中调用它.

有没有办法在编译时检查这个？
如果没有,当发生这种情况时,我将如何抛出运行时异常？

我看过这样的帖子:

1. 什么是Python中的元类？
2. Python中元类的(具体)用例是什么？
3. Python的超级很漂亮,但是你无法使用它

但不知怎的,我感到困惑.许多混淆如:

何时以及为什么我必须做以下事情？

# Refer link1
return super(MyType, cls).__new__(cls, name, bases, newattrs)

要么

# Refer link2
return super(MetaSingleton, cls).__call__(*args, **kw)

要么

# Refer link2
return type(self.__name__ + other.__name__, (self, other), {})

超级工作怎么样？

什么是link1中的类注册表和unregistry以及它究竟是如何工作的？(我认为它与单身人士有关.我可能是错的,来自C背景.我的编码风格仍然是功能和OO的混合).

类实例化(子类,元类,超类型)和方法调用的流程是什么(

metaclass->__new__, metaclass->__init__, super->__new__, subclass->__init__ inherited from metaclass

)具有良好评论的工作代码(虽然第一个链接非常接近,但它没有谈论cls关键字和超级(..)和注册表).优选地,具有多重继承的示例.

PS:我把最后一部分作为代码,因为Stack Overflow格式化将文本转换metaclass->__new__ 为元类 - > 新

我有这样的代码:

class A(object):
    def __init__(self):
          self.a = 1

class B(A):
    def __init__(self):
        self.b = 2
        super(self.__class__, self).__init__()

class C(B):
    def __init__(self):
        self.c = 3
        super(self.__class__, self).__init__()

实例化B按预期工作但实例化C无限递归并导致堆栈溢出.我怎么解决这个问题？

我只是潜入一些更高级的python主题(好吧,至少先进了我).我现在正在阅读有关多继承以及如何使用super()的内容.我或多或少地理解了使用超级函数的方式,但是(1)这样做会有什么问题？:

class First(object):
    def __init__(self):
        print "first"

class Second(object):
    def __init__(self):
        print "second"

class Third(First, Second):
    def __init__(self):
        First.__init__(self)
        Second.__init__(self)
        print "that's it"

关于super(),Andrew Kuchlings关于Python Warts的论文说:

当Derived类从多个基类继承并且其中一些或全部具有init 方法时,super()的使用也将是正确的

所以我重写了上面的例子如下:

class First(object):
    def __init__(self):
        print "first"

class Second(object):
    def __init__(self):
        print "second"

class Third(First, Second):
    def __init__(self):
        super(Third, self).__init__(self)
        print "that's it"

但是,这只运行它可以找到的第一个initFirst.(2)可以super()用来运行init的First和Second,如果是的话,如何运行？运行super(Third, self).__init__(self)两次只运行First.init()两次..

增加一些混乱.如果继承类的init()函数采用不同的参数,该怎么办？例如,如果我有这样的东西怎么办:

class First(object): …

假设我已经设置了以下类:

class Foo:
     def __init__(self, frob, frotz):
          self.frobnicate = frob
          self.frotz = frotz
class Bar:
     def __init__(self, frob, frizzle):
          self.frobnicate = frob
          self.frotz = 34
          self.frazzle = frizzle

我怎么能(如果我可以)在这个上下文中使用super()来消除重复的代码？

关于多父继承,当我打电话给super.__init__,为什么不__init__调用parent2的函数？谢谢.

class parent(object):
    var1=1
    var2=2
    def __init__(self,x=1,y=2):
        self.var1=x
        self.var2=y

class parent2(object):
    var4=11
    var5=12
    def __init__(self,x=3,y=4):
        self.var4=x
        self.var5=y

    def parprint(self):
        print self.var4
        print self.var5

class child(parent, parent2):
    var3=5
    def __init__(self,x,y):
        super(child, self).__init__(x,y)

childobject = child(9,10)
print childobject.var1
print childobject.var2
print childobject.var3
childobject.parprint()

输出是

9
10
5
11
12