What is the Python convention for method overriding?

General Discussions
, ,
1

How do I indicate I’m overriding a method in Python override convention?

In Java, for example, the @Override annotation not only provides compile-time checking of an override but also serves as excellent self-documenting code.

I’m looking for a way to document overrides in Python, ideally a convention that serves as a clear indicator, similar to @Override in Java. While I can add comments or docstrings, what is the idiomatic way to indicate that a method is being overridden in Python? Bonus points if this can also be used to trigger checks in tools like pylint.

2

From my experience, one simple way to indicate a method override in Python is by using a comment. Even though Python doesn’t have an explicit @Override annotation like Java, a clear comment can be just as effective for developers reading your code. It keeps things simple without affecting the execution or tooling, like pylint. Here’s an example:

class Base:
    def method(self):
        pass

class Derived(Base):
    # python override: Overriding method from Base class
    def method(self):
        pass

This approach makes the code easy to understand and can be a quick way to signal an override without the need for extra tools

3

That’s a great point, @alveera.khn! Another option that I’ve found useful is using pylint’s @override decorator convention. While it’s not part of the official Python syntax, linters like pylint recognize it. By using this, we can get an extra layer of safety with static analysis, making sure we’re actually overriding a method correctly.

from typing import override

class Base:
    def method(self):
        pass

class Derived(Base):
    @override
    def method(self):
        pass

For teams that use linters and care about maintaining consistent standards, this can be a powerful way to both document and verify the python override in your code.

4

I really like @prynka.chatterjee suggestion! Building on that, I’ve also used docstrings to document method overrides. While this approach won’t trigger any checks from linters, it’s a fantastic way to provide additional context for developers looking at the code. It can also be useful for tools like Sphinx to generate documentation automatically.

class Base:
    def method(self):
        pass

class Derived(Base):
    def method(self):
        """
        python override: Overriding the method from Base class.
        """
        pass

This method not only keeps things clear but also ensures that anyone reading the code understands exactly why the override is happening, making the python override even more explicit in the overall documentation.