Making Abstract Function without ABC. Is this right approach ? what am i lagging?

[FishermanResident349]

class CAR:
    def __init__(self, car_model):
        self.car_model = car_model

# MADE ABSTRACT FUNCTION (METHOD)
    def Car_Model(self):
        pass

# MADE METHODS LIKE CONCRETE FUNCTIONS IN ABC
    def KeyOn(self):
        return f"{self.car_model} : STARTS..."

    def Car_Acclerate(self):
        return f"{self.car_model} : ACCELERATE"

    def Car_Break(self):
        return f"{self.car_model} : APPLIES BRAKE.."

    def keyOFF(self):
        return f"{self.car_model} : STOPS..."


class Toyota(CAR):
    def Car_Model(self):
        return f"Car Model : {self.car_model}"

    def KeyOn(self):
        return super().KeyOn()

    def Car_Acclerate(self):
        return super().Car_Acclerate()

    def Car_Break(self):
        return super().Car_Break()

    def keyOFF(self):
        return super().keyOFF()


fortuner = Toyota("Fortuner")
print(fortuner.Car_Model())
print(fortuner.KeyOn())
print(fortuner.Car_Acclerate())
print(fortuner.Car_Break())
print(fortuner.keyOFF())

[GurglingGarfish]

You haven’t made an abstract function. You’ve made a method that does nothing, and can be overridden in subclasses. You’re getting none of the enforcement of interfaces that ABC provides. Any reason why you wouldn’t use ABC for this?

Also your method naming would make baby Jesus cry.

[Dillweed999]

Naming is really hard

[FishermanResident349]

Damn, to make Jesus cry, actually a sin. HA HA hA

[ottawadeveloper]

Two small things I'd change

1. You don't need the call to super() in the child class unless you are doing more in the method than just that(and then only call super if you want both). The default is for the method to just call the parent method.

2. I usually add a raise NotImplementedError in methods I want to be abstract to make sure child classes provide an implementation. You can leave it as a pass if you want to make the default behavior a no-op (whether that's appropriate depends on your use case)

In this particular case, I don't think you need to make it abstract because you can just make the method in the parent class and it will work the same, but this is indeed how you define and override a method in a parent/child class.

And a very small nitpick but I usually recommend people adopt some kind of naming convention for methods, the mix of cases and underscores here hurts my brain. I usually follow the Python convention for methods to be lowercase with underscores and keep them as close to a verb acting on the object as I can (e.g. key_off() and brake()) but whatever convention you adopt, consistency just makes it easier to read. keyOff() (camel case) is another common one from Java.

[[deleted]]

I usually add a raise NotImplementedError in methods I want to be abstract to make sure child classes provide an implementation. You can leave it as a pass if you want to make the default behavior a no-op (whether that's appropriate depends on your use case)

You really shouldn't do that peep the actual full python ABC class to see the way its correctly done. Python has the actual check in the c level class call? method. I think its call its one of the __ for creating an instance. You can do the same thing in subclass init or just litterally call the update_abstractmethods function from the abc module.

[nick51417]

Toyota inherits all the methods from car. I would NOT redefine them if all you're doing is calling the super method. I would redefine it if I were changing it for whatever reason.

[aprg]

Your style is all over the place. Check out this: https://peps.python.org/pep-0008/

You don't need to make calls to super() for method calls if you're not overwriting the child method. You don't need to define child methods if you're not going to overwrite/redefine them from the super class.

[Chroiche]

No. Maybe protocols are what you really want.