super

Is there a difference between using super() and using the parent class name directly? For example: 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() Is there internally a difference between super().__init__() and Parent.__init__(self) ? Willem Van Onsem Not in this case . But in general , and especially when you use multiple inheritance , super() delegates to the next object in the Method Resolution Order (MRO) as is specified in the documentation

I have the following Python 2.7 code: class Frame: def __init__(self, image): self.image = image class Eye(Frame): def __init__(self, image): super(Eye, self).__init__() self.some_other_defined_stuff() I'm trying to extend the __init__() method so that when I instantiate an 'Eye' it does a bunch of other stuff (self.some_other_defined_stuff()), in addition to what Frame sets up. Frame.__init__() needs to run first. I get the following error: super(Eye, self).__init__() TypeError: must be type, not classobj Which I do not understand the logical cause of. Can someone explain please? I'm used to

I'm talking java language. Variable "this", when used inside a class, refers to the current instance of that class, which means you cannot use "this" inside a static method. But "super", when used inside a class, refers to the superclass of that class, not an instance of the superclass, which should mean that you can use "super" inside a static method. But it turns out you cannot. A possible explanation would be to say that "super" also refers to an instance of the superclass, but I can't see why it should... Here is the section in the JLS about the super keyword: http://docs.oracle.com/javase

Let's say I have a base class named Entity . In that class, I have a static method to retrieve the class name: class Entity { public static String getClass() { return Entity.class.getClass(); } } Now I have another class extend that. class User extends Entity { } I want to get the class name of User: System.out.println(User.getClass()); My goal is to see "com.packagename.User" output to the console, but instead I'm going to end up with "com.packagename.Entity" since the Entity class is being referenced directly from the static method. If this wasn't a static method, this could easily be solved

Is super() not meant to be used with staticmethods? When I try something like class First(object): @staticmethod def getlist(): return ['first'] class Second(First): @staticmethod def getlist(): l = super(Second).getlist() l.append('second') return l a = Second.getlist() print a I get the following error Traceback (most recent call last): File "asdf.py", line 13, in <module> a = Second.getlist() File "asdf.py", line 9, in getlist l = super(Second).getlist() AttributeError: 'super' object has no attribute 'getlist' If I change the staticmethods to classmethods and pass the class instance to

This question already has an answer here: What's the difference between “super()” and “super(props)” in React when using es6 classes? 10 answers I realize the super keyword can be used to call functions in a parent component. However, I'm not totally clear why you would use the super keyword in the example below - just passing it whatever props are being passed to the constructor. Can someone please shed some light on the various reasons for using the super keyword in an ES6 class constructor, in react? constructor(props) { super(props); this.state = { course: Object.assign({}, this.props

In Java classes and objects, we use "this" keyword to reference to the current object within the class. In some sense, I believe "this" actually returns the object of itself. Example for this: class Lion { public void Test() { System.out.println(this); //prints itself (A Lion object) } } In the scenario of a superclass and subclass. I thought that "super" keyword would return the object of the superclass. However it seems that I got it wrong this time: Example: class Parent { public Parent(){ } } class Child extends Parent { public Child(){ System.out.println(super.getClass()); //returns Child

There is a simple program, in the constructor, super() is called without extends to the super class, I can not understand what will does this in this situation ? public class Student { private String name; private int rollNum; Student(String name,int rollNum){ super();// I can not understand why super keyword here. this.name=name; this.rollNum=rollNum; } public static void main(String[] args) { Student s1 = new Student("A",1); Student s2 = new Student("A",1); System.out.println(s1.equals(s2)); } } JB Nizet Every class that doesn't explicitly extend another class implicitly extends java.lang