Inheritance best practice : *args, **kwargs or explicitly specifying parameters [closed]

by

Liskov Substitution Principle

Generally you don’t want you method signature to vary in derived types. This can cause problems if you want to swap the use of derived types. This is often referred to as the Liskov Substitution Principle.

Benefits of Explicit Signatures

At the same time I don’t think it’s correct for all your methods to have a signature of *args, **kwargs. Explicit signatures:

  • help to document the method through good argument names
  • help to document the method by specifying which args are required and which have default values
  • provide implicit validation (missing required args throw obvious exceptions)

Variable Length Arguments and Coupling

Do not mistake variable length arguments for good coupling practice. There should be a certain amount of cohesion between a parent class and derived classes otherwise they wouldn’t be related to each other. It is normal for related code to result in coupling that reflects the level of cohesion.

Places To Use Variable Length Arguments

Use of variable length arguments shouldn’t be your first option. It should be used when you have a good reason like:

  • Defining a function wrapper (i.e. a decorator).
  • Defining a parametric polymorphic function.
  • When the arguments you can take really are completely variable (e.g. a generalized DB connection function). DB connection functions usually take a connection string in many different forms, both in single arg form, and in multi-arg form. There are also different sets of options for different databases.
  • …

Are You Doing Something Wrong?

If you find you are often creating methods which take many arguments or derived methods with different signatures you may have a bigger issue in how you’re organizing your code.

More Related Contents:

  1. What are the differences between type() and isinstance()?
  2. How do I call a parent class’s method from a child class in Python?
  3. How to “perfectly” override a dict?
  4. How to invoke the super constructor in Python?
  5. super() fails with error: TypeError “argument 1 must be type, not classobj” when parent does not inherit from object
  6. How can I dynamically create derived classes from a base class
  7. Cast base class to derived class python (or more pythonic way of extending classes)
  8. Subclassing int in Python
  9. inheritance from str or int
  10. Chain-calling parent initialisers in python [duplicate]
  11. Python super() raises TypeError
  12. TypeError: Cannot create a consistent method resolution order (MRO) [duplicate]
  13. Should all Python classes extend object? [duplicate]
  14. Which classes cannot be subclassed?
  15. List all base classes in a hierarchy of given class?
  16. How to call a property of the base class if this property is being overwritten in the derived class?
  17. Simple python inheritance
  18. Python Method overriding, does signature matter?
  19. How to call Base Class’s __init__ method from the child class? [duplicate]
  20. Inherit docstrings in Python class inheritance
  21. Python inheritance – how to disable a function
  22. Overriding append method after inheriting from a Python List
  23. Abstract methods in Python [duplicate]
  24. Force child class to override parent’s methods
  25. Python: deleting a class attribute in a subclass
  26. The inheritance of attributes using __init__
  27. How to remove a field from the parent Form in a subclass?
  28. Accessing attribute from parent class inside child class
  29. Inheritance and init method in Python
  30. Python: Inheritance versus Composition

Leave a Comment