在Python 2的子类中重写__init__方法的一部分

Question

I'm wanting to create a subclass of a subclass (Barrier is a type of wall, which is a type of obstacle), and I'm wanting the barrier to have the same init method as wall with the exception that the self.type = 'barrier', but I'm not sure how to do this (I'm very new to programming so I'm sorry if this is very simple but I haven't been able to find an answer I understand). So far I have:

class Obstacle:
    def __init__(self, type):
        self.type = 'obstacle'

    def __str__(self):
        return "obstacle"

class Wall(Obstacle):

    def __init__(self, origin, end):

        self.type = 'wall'
        self.origin = origin
        self.end = end

        # etc.... (i.e. there are more things included in here which the 
        # that the barrier also needs to have (like coordinate vectors etc.)

class Barrier(Wall):

    def __str__(self):
        return "Barrier obstacle"

How do I change it so that class Barrier has identical contents of the init method as Walls do, except their "self.type = 'barrier'"?

Answer 1

Just override that one attribute after invoking the Wall version:

class Barrier(Wall):
    def __init__(self, origin, end):
        super().__init__(origin, end)
        self.type = 'barrier'

    def __str__(self):
        return "Barrier obstacle"

You may want to consider using class attributes instead however; none of your instance attributes are dynamic and specific to each instance of the class. The type attribute of each of these classes surely won't change from one instance to another:

class Obstacle:
    type = 'obstacle'

    def __str__(self):
        return self.type

class Wall(Obstacle):
    type = 'wall'

    def __init__(self, origin, end):
        super().__init__()
        self.origin = origin
        self.end = end
        # etc.... (i.e. there are more things included in here which the 
        # that the barrier also needs to have (like coordinate vectors etc.)

class Barrier(Wall):
    type = 'barrier'

Answer 2

Since the "type" seems to depend on the class, I would simply not put the type attribute in the object , but at the class level :

class Obstacle:

    

    def __init__(self):
        # do something
        pass

    def __str__(self):
        return "obstacle"

class Wall(Obstacle):

    

    def __init__(self, origin, end):
        super().__init__()
        self.origin = origin
        self.end = end

class Barrier(Wall):

    

    def __str__(self):
        return "Barrier obstacle"

Furthermore you better call the super().__init__ method if you override it. Since otherwise initializations higher in the class hierarchy will not take place (this is sometimes desired behavior, but usually it is not).

The advantage of this is that it is - in my opinion at least - more elegant. Since here it is clear that type is defined per class. But furthermore it will reduce the amount of memory that is used. Since we store one attribute per class, not one per object.

However in case you want to alter the attribute of a single object, that is still possible. For instance:

>>> obs1 = Obstacle()
>>> weird_obs = Obstacle()
>>> weird_obs.type = 'weird obstacle'
>>> obs2 = Obstacle()
>>> obs1.type
'obstacle'
>>> weird_obs.type
'weird obstacle'
>>> obs2.type
'obstacle'

So we still have the flexibility to add a specific type to a specific object. But by default, if we query an obstacles type , it will perform a fallback and return the type that is defined on the class level.