Suppose I have the following class in Python 3:
class CoolCar:
@classmethod
def myWheels(cls):
cls.Wheels().out()
class Wheels:
def __init__(self):
self.s = "I'm round!"
def out(self):
print(self.s)
All well and good. Now I want a derived class:
class TerribleTank(CoolCar):
class Wheels(CoolCar.Wheels):
def __init__(self):
self.s = "I'm square!!"
This works as I would expect:
CoolCar.myWheels()
TerribleTank.myWheels()
But what's bothering me is that I have to write CoolCar twice in the definition of TerribleTank. So I tried this:
class TerribleTank(CoolCar):
class Wheels(super().Wheels):
def __init__(self):
self.s = "I'm square!!"
Which does not work. Now, I know it doesn't work because super() is looking for a first-argument self/cls to begin its search.
So finally my question: Is there something like this that works, so that I don't need to explicitly write that second CoolCar?
Wheels.fooin one of my classes, and it simply works, with the right version of Wheels. For more information, please see the Factory Pattern chapter in Marc Summfield's Python in Practice.TerribleTankwill override this Wheel class. Now what does any class that inherits fromTerribleTankdo? Putting the originalWheelsclass at the module level only raises the problem one generation, it does not solve it.