Python: ¿Las subclases pueden sobrecargar los métodos heredados?

Estoy haciendo una aplicación de carrito de compras en Google App Engine. Tengo muchas clases que se derivan de un controlador de base:

class BaseHandler(webapp.RequestHandler): def get(self, CSIN=None): self.body(CSIN) 

¿Significa esto que el método body() de cada clase descendiente necesita tener el mismo argumento? Esto es engorroso. Solo un descendiente usa ese argumento. ¿Y qué pasa cuando agrego nuevos argumentos? ¿Necesito pasar y cambiar cada clase?

 class Detail(BaseHandler): def body(self, CSIN): class MainPage(BaseHandler): def body(self, CSIN=None): #@UnusedVariable class Cart(BaseHandler): def body(self, CSIN): #@UnusedVariable 

Los métodos anulados no tienen que tener los mismos parámetros que los demás en principio, pero sí tienen que tener los mismos parámetros formales con los que se llama. Entonces, dado que cualquier manejador puede tener un body llamado por get , sí tienen que ser el mismo. En este sentido, el punto de la anulación es que la persona que llama no conoce la clase exacta del objeto y, por lo tanto, si no todos tienen los mismos parámetros, normalmente la persona que llama no sabría qué pasar. Por lo tanto, creo que las anulaciones con diferentes parámetros serían un truco inusual.

Si cambia los argumentos con los que se llama, entonces sí, tiene que cambiar las funciones para que coincidan. Esto no tiene nada que ver con la herencia, es cómo funcionan las funciones de Python.

Si desea un poco más de flexibilidad, podría usar argumentos de palabras clave, que son una forma elegante de pasar un diccionario como argumento:

 class Detail(BaseHandler): def body(self, **kwargs): print kwargs['CSIN'] class MainPage(BaseHandler): def body(self, **kwargs): # can ignore kwargs class Cart(BaseHandler): def body(self, **kwargs): # can ignore kwargs class BaseHandler(webapp.RequestHandler): def get(self, CSIN=None): self.body(CSIN = CSIN, some_new_arg = 3) class SomeNewHandler(BaseHandler): def body(self, **kwargs): print kwargs['some_new_arg'] 

Sin embargo, cuestiono ligeramente la sensatez de esto: si va a agregar muchos parámetros nuevos y la mayoría de las implementaciones ignoran la mayoría de los parámetros, entonces tal vez el body no sea realmente una función de esos argumentos. Tal vez en realidad los argumentos son parte del estado del objeto de controlador, que simplemente pasa como parámetros. Obviamente, la diferencia es algo subjetiva: para las funciones que solo se llaman una vez por objeto, no hay mucha diferencia práctica entre pasar un diccionario y usar el self como el diccionario.

Python coincide con los métodos de sobrecarga basados ​​solo en el nombre. Lo que significa que

 class Base: def method(self, param2): print "cheeses" class NotBase(Base): def method(self): print "dill" obj = NotBase(); obj.method() 

dará salida a dill (mientras que obj.method (“cosas”) fallará).

Sin embargo, en tu caso este no es el comportamiento deseable. Si sobrecarga el método del body con menos parámetros que los requeridos por la invocación en el método base get , al invocar el método get en dichas clases se producirá un error.