Which to use: self or super?

Question

I am wrapping up a python class deque to queue to make my code more readable:

from collections import deque

class Queue(deque):
    def enqueue(self,a):
        super(Queue, self).append(a)

    def dequeue(self,a):
        super(Queue, self).popleft(a)

My question is which one I should use here, self.append() or super(Queue, self).append(), Why?

super points to the parent class, but the self points to this class. you cannot compare those keywords — pylover, Jan 12 '13 at 15:06
I tried to use it but it's fine in both case so I want to know if there is any difference between them. — Bob Fang, Jan 12 '13 at 15:07
Both options are possible - as long as you know the right syntax. Your usage of super makes no sense....read the super() documentation. — , Jan 12 '13 at 15:07
exactly both the options are possible. have you tried before posting? — , Jan 12 '13 at 15:59
@SànLuthra I did test it. I know both is okay but I am thinking which one is better — Bob Fang, Jan 12 '13 at 16:09

Ellioh · Answer 1 · 2013-01-13T07:36:15.073

super() is used to call a base class method that is redefined in the derived class. If your class were defining append() and popleft() methods extending their behavior, it would be reasonable to use super() inside append() and popleft(). However, your example redefines nothing from deque, so there is no need for super().

The following example shows when super() is used:

class Queue(deque):
    def append(self, a):
        # Now you explicitly call a method from base class
        # Otherwise you will make a recursive call
        super(Queue, self).append(a)
        print "Append!!!"

However, in case of multiple inheritance what super() does is more complicated than just allowing to call a method from base class. Detailed understanding requires understanding MRO (method resolution order). As a result, even in the example above it is usually better to write:

class Queue(deque):
    def append(self, a):
        # Now you explicitly call a method from base class
        # Otherwise you will make a recursive call
        deque.append(self, a)
        print "Append!!!"

score 1 · Answer 2 · answered Jan 12 '13 at 15:05

1

Given these two choices, you should use self.append, because your code using super is not valid Python.

The correct alternate version would be super(Queue, self).append.

answered Jan 12 '13 at 15:05

Borealid

95,191
9
106
122

Is there any difference on these two methods? – Bob Fang Jan 12 '13 at 15:06

score 1 · Answer 3 · answered Jan 12 '13 at 15:07

1

Go for self (putting aside that your use of super is incorrect as Borealid stated).

However, I believe that in this case it's better to not extend deque, but rather wrap it.

from collections import deque

class Queue(object):
    def __init__(self):
        self.q = deque

    def enqueue(self, a):
        return self.q.append(a)

    def dequeue(self, a):
        return self.q.popleft(a)

Also, note the returns - in your code they are missing and you cannot get the dequeued value.

answered Jan 12 '13 at 15:07

Emil Ivanov

37,300
12
75
90

It's usually better to use composition (my example), rather than inheritance (your example). It's much more simple. Also, in your case the details (read: methods) or deque will leak to your class and the abstraction won't be as nice. – Emil Ivanov Jan 12 '13 at 15:09
1

Generally saying composition is better than inheritance? – Bob Fang Jan 12 '13 at 15:11
@dorafmon: most of the time, yes. – Emil Ivanov Jan 12 '13 at 15:12
May I ask why is this? Sorry I am a beginner and not very good at OOP – Bob Fang Jan 12 '13 at 15:15
This would take a book to explain :). Luckily, there's one verrrrrry goooood: [Code Complete](http://www.amazon.com/dp/0735619670/?tag=stackoverfl08-20). Also, look at [this](http://stackoverflow.com/questions/49002/prefer-composition-over-inheritance) question. – Emil Ivanov Jan 12 '13 at 15:17
Thanks a lot for your kindness and patience. – Bob Fang Jan 12 '13 at 15:19
@dorafmon: Whether to subclass a type or not isn't always clear-cut. This is illustrated by the classic [circle-ellipse problem](http://en.wikipedia.org/wiki/Circle-ellipse_problem) encountered when using object-oriented programming. – martineau Jan 12 '13 at 16:40
Composition is better if your class is just trying to reuse another class' functionality. If a base class really is a more general case of the derived one, inheritance is perfectly valid. – Ellioh Jan 12 '13 at 19:47

score 0 · Answer 4 · answered Jan 12 '13 at 15:08

Who told you it was a good idea to even think of using super instead of self? You want to affect a single instance of the Queue, not append a to the module scope (never mind the fact that super.append throws AttributeError)

from collections import deque

class Queue(deque):
    def enqueue(self, a):
        self.append(a)

    def dequeue(self, a):
        self.popleft(a)

Which to use: self or super?

4 Answers4