super() and the Inheritance Hierarchy

Thanks for video. One problem, though. I keep getting an AttributeError when calling cube.volume(): type object ‘super’ has no attribute ‘area’ The cube instance of Cube has the property “area”, but it’s throwing an error when it goes looking for it in the parent(s). When I replace face_area = super().area() with face_area = self.area(), cube.volume() works fine. Any thoughts?

It appears the issue may be with the import into the iPython terminal. When I run the code in the Python Interactive Window in VS Code it’s fine, but calling cube.volume() after importing via the terminal (into iPython) throws the error. Oh well, no worries. Thanks!

Hey Everyone, am sorry if this question is stupid. I am a little struggling, when i import the Parent class all is well but if i import the child class i get this area

from shapes import Rectangle, Square, Cube
>>> cu = Cube(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/real_python_project/int/shapes.py", line 15, in __init__
    super().__init__(length, length)  # accessing the parent method intialisation
TypeError: __init__() takes 2 positional arguments but 3 were given

Hi UgandanGuy,

I’m only guessing as I can’t see your code, but if you inherited from Rectangle instead of Square, you might see this message. Rectangle takes two arguments (which means 3 because of “self”), whereas Square only takes one (which means 2 because of “self”).

Double check you have:

class Cube(Square): . . .

…ct

Thanks Christopher. I liked the video. I was working along side you but not copying verbatim. My little toy looks like this:

# in shapes.py
class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

    def perimeter(self):
        return (self.length + self.width) * 2

    def __str__(self):
        return "rectangle with length = {} and width = {}".format(self.length, self.width)

class Square(Rectangle):
    def __init__(self, length):
        super().__init__(length, length)

    def __str__(self):
        return "square with side-length = {}".format(self.length)


rect = Rectangle(2,4)
print("Rectangle of length {} and width {} has area {} and perimiter {}".format(rect.length, rect.width, rect.area(), rect.perimeter()))

sq = Square(6)
print("Square with sides = {} has area {} and perimeter {}".format(sq.length, sq.area(), sq.perimeter))

print(rect)
print(sq)

The output looks like this:

Rectangle of length 2 and width 4 has area 8 and perimiter 12 Square with sides = 6 has area 36 and perimeter <bound method Rectangle.perimeter of <main.Square object at 0x102e32940>> rectangle with length = 2 and width = 4 square with side-length = 6

Process finished with exit code 0

It seems the perimeter method doesn’t get inherited quite as expected. I’m using PyCharm with Python 3.6. Any thoughts?

Hi Thomas,

You’ve missed the function call brackets to perimeter. The output you’re seeing is Python telling you about the function rather than calling the function.

Change your line to this:

print("Square with sides = {} has area {} and perimeter {}".format(sq.length, sq.area(), sq.perimeter()))

And you should be good to go.

Hello Chris,

I was following the tutorial and everything was fine until i created Cube class and I can’t get past this error. I even copied the code from above and still continue to get this error.

ImportError: cannot import name ‘Cube’

from shapes import Cube Traceback (most recent call last): File “<stdin>”, line 1, in <module> ImportError: cannot import name ‘Cube’

Please advise.

Thanks, dave

davevikram are you in the REPL? import doesn’t actually re-import until you quit and start again (simplest method).

At 4:44 you say, # super() is a shortcut for super(Cube, self), but I think in this context you mean super(Square, self)?

Hi Dan,

First off, no, I’m not using the REPL. I’ve cut and paste code from the REPL into a slide. You are correct that the base REPL does not allow reimports, so if you need to get at it again you will have to restart.

The comment in the sample code:

# super() is a shortcut for super(Cube, self)

is actually correct. The call to super() is a shortcut to the call of super with the current class. In the example the Cube is the current class. The result of this call is Square’s method. Think of super() as being short for “parent of”. In this case we’re looking for “parent of Cube”, which is Square. A call to the shortcut “super()” is short for “parent of self’s class”.

Hi, I am trying to understand what is the proper way to call class-level attributes of a parent class from a method in the child class.

In the following example I see that I can use Shape.color, Rectangle.color, super().color to get the color attribute from the parent class in the get_color method of the subclass. I was wondering which one is the most valid call or whether they are equivalent?

class Shape:
    color = "RED"

    def __init__(self, length):
        self.length = length


class Rectangle(Shape):

    def __init__(self, length):
        super(Rectangle, self).__init__(length)

    def get_color(self):
        # return Shape.color
        # return Rectangle.color
        return super().color

Thanks

Hi Konstantinos,

The idea behind object inheritance is that the child gets everything from the parent. The only reason to use super is if you’re trying to get at something in the parent not in the child. This only happens if you’re overriding.

You seldom see super used with attributes, it is almost always used with methods where the parent has a different implementation than the child. The most common use when overriding __init__ in the child object and wanting to call the parent’s method of the same name.

You can use super with attributes, for example if both Shape and Rectangle declared color. But in practice, if you’re changing those kinds of constants you probably wanted an instance variable rather than a class level one. I’m sure there are exceptions out there, I just don’t see it used very often in code.

In the case of your get_color method, personally, I’d most likely reference it as self.color.

Hope that helps.