标签: super

我可以super()在Python 2.5.6中使用干净的Python 3 语法吗？
也许有某种__future__进口？

我试图在块内的超类上调用一个方法.为了避免保留周期,我需要对super的弱引用.我如何获得对超级的弱引用？

[self somethingWithCompletion:^(){
   [super doStuff];
}];

我尝试了以下但是给出了编译错误.

__weak MySuperClass *superReference = super;

在Raymond Hettinger 在PyCon 2015上的演讲" 超级考虑超级发言 "中,他解释了super在多重继承环境中使用Python 的优势.这是雷蒙德在演讲中使用的一个例子:

class DoughFactory(object):
    def get_dough(self):
        return 'insecticide treated wheat dough'


class Pizza(DoughFactory):
    def order_pizza(self, *toppings):
        print('Getting dough')
        dough = super().get_dough()
        print('Making pie with %s' % dough)
        for topping in toppings:
            print('Adding: %s' % topping)


class OrganicDoughFactory(DoughFactory):
    def get_dough(self):
        return 'pure untreated wheat dough'


class OrganicPizza(Pizza, OrganicDoughFactory):
    pass


if __name__ == '__main__':
    OrganicPizza().order_pizza('Sausage', 'Mushroom')

有人在台下问雷蒙德有关使用的差异self.get_dough(),而不是super().get_dough().我对Raymond的简要回答并不是很了解,但我编写了这个例子的两个实现来看看差异.两种情况的输出相同:

Getting dough
Making pie with pure untreated wheat dough
Adding: Sausage
Adding: …

我怎么会叫一个Random从java.util.Random成supertype constructor？

例如

Random rand = new Random();
int randomValue = rand.nextInt(10) + 5;

public Something() 
{
    super(randomValue);
    //Other Things
}

当我尝试这个时,编译器说我" 在调用randomValue之前无法引用supertype constructor".

我想在一个特征中扩展一个特征,如下所示:

  trait NodeTypes {
    trait Node {
      def allNodesHaveThis: Int
    }
  }

  trait ScrumptiousTypes extends NodeTypes {
    trait Node extends super.Node {
      def scrumptiousness: Int
    }
  }

  trait YummyTypes extends NodeTypes {
    trait Node extends super.Node {
      def yumminess: Int
    }
  }

  object Graph extends NodeTypes with ScrumptiousTypes with YummyTypes {
    case class Node() extends super.Node {
      override def allNodesHaveThis = 1
      override def scrumptiousness = 2  // error: ScrumptiousTypes.Node has been disinherited
      override def yumminess = 3
    }
  } …

我们的想法是在一个页面上有多个小部件,并包含这个'小部件'所需的所有js和css文件(以这种方式管理文件很容易).重复的文件不是问题.每个小部件的模板都包含在页面中{%include%}从小部件的模板中我试图将内容添加到父级的块中:

家长:

{%block js%}
{%endblock%}

WIDGET

{%block js%}
   {{block.super}}
   ///my widget spectyfic JS
{%end block%}

这是一个错误 {{block.super}}: Caught AttributeError while rendering: 'BlockNode' object has no attribute 'context'

我不确定我怎么能延长阻止...似乎这在django中是不可能的......任何想法？定义多个块将无法正常工作,因为我们不知道有多少不同的小部件,每个页面上都有我们的名字...(而且这不是一个nemplate的担心)

可能重复:
Super可以处理多重继承吗？

Python继承？我有一个类结构(下面),并希望子类调用__init__父双方.这可能是以"超级"方式做的还是只是一个可怕的想法？

class Parent1(object):
    def __init__(self):
        self.var1 = 1

class Parent2(object):
    def _init__(self):
        self.var2 = 2

class Child(Parent1, Parent2):
    def __init__(self):
        ## call __init__ of Parent1
        ## call __init__ of Parent2
        ## super(Child, self).__init__()

我想知道Python 3中的新超级是如何实现的.

在我做了一个小例子之后,这个问题就出现在了我脑海中,我得到了一个奇怪的错误.我正在使用Pyutilib组件架构(PCA),我已经制作了自定义元类来驱动另一个类的创建:

from pyutilib.component.core import implements, SingletonPlugin, PluginMeta, Interface

class IPass(Interface):
    pass

class __MetaPlugin(PluginMeta):
    def __new__(cls, name, baseClasses, classdict):
        print(cls, name, baseClasses, classdict)
        if baseClasses:
            baseClasses += (SingletonPlugin,)
        return PluginMeta.__new__(cls, name, baseClasses, classdict)

class Pass(metaclass=__MetaPlugin):
    implements(IPass)

    def __init__(self, inputs=[], outputs=[]):
        self.inputs = []
        self.outputs = []


class A(Pass):
    def __init__(self):
        print(self.__class__) # <class '__main__.A'>
        print(self.__class__.__class__) # <class '__main__.__MetaPlugin'>
        print(PluginMeta.__class__) # <class 'type'>
        super().__init__() # SystemError: super(): empty __class__ cell
        #Pass.__init__(self) - this works

a = A()

我收到以下错误: …

因此,我有一个用于串行API的大量消息Payload类,每个类都有许多不可变字段,一个解析方法和一些共享的方法.我构造它的方式是每个都将从字段行为的namedtuple继承,并从父类接收公共方法.但是,我在构造函数方面遇到了一些困难:

class Payload:
    def test(self):
        print("bar")

class DifferentialSpeed(Payload, namedtuple('DifferentialSpeed_', 
    'left_speed right_speed left_accel right_accel')):
    __slots__ = ()
    def __init__(self, **kwargs):
        super(DifferentialSpeed, self).__init__(**kwargs)
        # TODO: Field verification
        print("foo")

    @classmethod
    def parse(self, raw):
        # Dummy for now
        return self(left_speed = 0.0, right_speed = 0.1,
                    left_accel = 0.2, right_accel = 0.3)

    def __str__(self):
        return "Left Speed: %fm/s\nRight Speed: %fm/s\n"\
            "Left Acceleration: %fm/s^2\nRight Acceleration: %fm/s^2" % (
            self.left_speed, self.right_speed, self.left_accel, self.right_accel)


payload = DifferentialSpeed.parse('dummy')
print(payload)

这有效,但我得到以下警告:

DeprecationWarning: object.__init__() takes no parameters
  super(DifferentialSpeed, self).__init__(**kwargs)

如果我**kwargs …

super()直接使用和使用父类名称有区别吗？例如:

class Parent:
    def __init__(self):
        print("In parent")
        self.__a=10

class Child(Parent):
    def __init__(self):
        super().__init__()     # using super()
        Parent.__init__(self)  # using Parent class name

c=Child()

是否有内部之间的差异super().__init__()和Parent.__init__(self)？