12 ordering = fields.CharField(required=False, allow_null=True)
13 value_ordering = fields.CharField(required=False, allow_null=True)
14
15 def save(self):16 ordering_field = self.validated_data['ordering_field']
17 ordering = self.validated_data.get('ordering')
18 value_ordering = self.validated_data.get('value_ordering')14 item = fields.IntegerField()
15 segment_by_ordering_field = fields.BooleanField(default=False)
16
17 def save(self):18 mapper = inspect(Model)
19
20 primary_key_field = mapper.primary_key[0].name 61
62 return attrs
63
64 def save(self): 65 request = self.context.get('request')
66 connection = get_request_connection(request)
67 draft = bool(request.get_argument('draft', False)) 7 name = fields.CharField()
8 params = fields.JSONField(required=False)
9
10 def save(self):11 handler = get_handler(self.validated_data['name'])
12 if not handler:
13 returnThe parameters in the overridden method don't match the method defined in the parent class. There are three possible scenarios for this:
- The number of parameters are different in both methods
- One or more names of the parameters are different in both methods
- The order of parameters is different in both methods
Python will allow this, but if the overridden method is intended to be executed from external code, you may want to reconsider this. Overriding a method without ensuring that both methods accept the same name, number, and order of parameters has the potential to cause an error when the overriding method is called with parameters that is illegal for the overridden method. This violates the Liskov substitution principle.
Bad practice
class Base:
def summation(cycle, x, y, z):
log(cycle)
return x + y + z
class UneqalArgLen(Base):
def summation(cycle, x, y):
log(cycle)
return x + y
class RenamedArg(Base):
def summation(cycle, x, y, zee=None):
log(cycle)
return x + y
class unorderdArgs(Base):
def summation(x, cycle, y, z):
log(cycle)
return x + y + z
Recommended
There can be multiple approaches to address this inconsistency. The first approach is to re-think the method signature in the parent class itself if the child classes are expected to implement a variable number of arguments in their own implementation. If the exploitation here is a special case, this can be dealt with making it compatible with the parent's class method signature, like this:
class Base:
def summation(cycle, x, y, z):
log(cycle)
return x + y + z
class FixedUneqalArgLen(Base):
def summation(cycle, x, y, z=None):
log(cycle)
return x + y
class NoRenamedArg(Base):
def summation(cycle, x, y, _): # using `_` won't trigger the issue.
log(cycle)
return x + y
class NounorderdArgs(Base):
def summation(cycle, x, y, z): # No surprises here
log(cycle)
return x + y + z