Utilizzo di metodi specifici per una sottoclasse

Mi sono imbattuto in questa pagina SESE: Che cosa è un uso appropriato del downcasting? (per C #) - e parla di quando calpestare, e dei possibili svantaggi.

Nelle sotto classi Python sono leggermente diversi

Esempio:

Supponiamo che abbia la seguente classe abstract :

from abc import ABCMeta
from abc import abstractmethod

class Weapon(metaclass=ABCMeta):

    def __init__(self, name, damage):
        self.name = name
        self.damage = damage

    @abstractmethod
    def prepare(self):
        pass

    @abstractmethod
    def attack(self):
        pass

    @abstractmethod
    def cleanup(self):
        pass

    def __str__(self):
        return "Name: {} Damage: {}".format(self.name, self.damage) 

e Sottoclasse:

from Weapon import Weapon

class ChargeGun(Weapon):

    def __init__(self, name, damage):
        super().__init__(name, damage)

    def prepare(self):
        print("Aiming my Gun");

    def attack(self):
        print("Shooting")

    def cleanup(self):
        print("Lowering gun, and turning off laser sight")

    def charge(self):
        print("Charging Gun. Please hold..(elevator music playing)")

Nella mia sottoclasse ChargeGun , ho il metodo def charge(self): , e posso dichiarare nel principale un oggetto ChargeGun e usarlo, come questo:

cg = ChargeGun("Standard ChargeGun",5)
cg.prepare()
cg.charge()

Se dovessi introdurre Sword come sottoclasse Weapon , il charge(self): non sarebbe implementato e Sword non ne è nemmeno a conoscenza. In Python, non è necessario downcast o utilizzare un modello di progettazione.

Python non è Java / C #.

Domande

1. Come dovresti pensare quando crei sottoclassi nelle lingue come Python? Dovremmo pensare da un punto di vista astratto, e refactoring il nostro codice?

   Esempio: def charge(self): potrebbe essere visto come un modo per preparare un ChargeGun in modo che possiamo rimuoverlo. Se avessi un silenziatore, questo è un componente di una pistola, quindi forse avrebbe senso avere una classe abstract WeaponComponent , un silenziatore e mirino laser potrebbero essere oggetti di quella classe e ognuno di essi sovrascriverebbe il metodo def prepare(self): . Una Spada potrebbe avere una gemma o una pietra che gli conferisce un'abilità extra di colpo, ecc.

Questo è solo un modo di pensare, non sto dicendo che è il modo migliore per refactoring.

2. Va bene approfittare della capacità di Python di utilizzare i metodi di a sottoclasse direttamente?