How to prevent a method from being overridden in Python?

In Python, although there is no built-in final keyword, it can simulate unsurpassable methods through name rewriting, runtime exceptions, decorators, etc. 1. Use a double underscore prefix to trigger name override, making it difficult for subclasses to override methods; 2. Use a custom decorator to determine the caller type and throw an exception to prevent subclass redefinition; 3. Use a custom decorator to mark the method as final and check it in combination with metaclasses or class decorators; 4. The behavior can be encapsulated as property attributes to reduce the possibility of being modified. These methods provide varying degrees of protection, but none of them completely restrict the coverage behavior.

In Python, by default, the class methods can be overwritten by subclasses. If you want a method to not be overwritten, the most direct way is to achieve "unoverwritten" effects through naming conventions and design patterns, because Python itself does not have keywords like Java's final or C#'s sealed .

Here are some common practices:

Name overwriting is achieved using double underscore prefix (Name Mangling)

Python provides a mechanism called "Name Mangling". When you precede two underscores (such as __method_name ) of a class's method or property, Python will overwrite the name, making it harder to access or overwrite externally.

 class Base:
    def __my_method(self):
        print("This is a private method")

    def call_my_method(self):
        self.__my_method()

class Derived(Base):
    def __my_method(self):
        print("Trying to override")

d = Derived()
d.call_my_method() # Output "This is a private method"

illustrate:

• In fact, Derived.__my_method does not override Base.__my_method , but defines a new method.
• Because Base.__my_method was renamed to _Base__my_method , there will be no conflict.
• This approach is not to completely block coverage, but to make coverage more difficult.

Throw exception directly in the method

If you want to explicitly prohibit subclasses from overwriting a method at runtime, you can add judgment logic to the method. If you detect that the current class is not the original class that defines the method, an exception will be thrown.

 class Base:
    def my_method(self):
        if type(self) != Base:
            raise TypeError("my_method cannot be overridden")
        print("Original implementation")

class Derived(Base):
    def my_method(self):
        print("Trying to override")

Use scenarios:

• Suitable for situations where you want to find problems during the development or debugging phase.
• The disadvantage is that an error will only be reported when the method is called, and the error cannot be discovered in advance.

Simulate final method using decorator

You can customize a decorator to mark certain methods as "not overridable", and implement final -like functionality by checking whether the methods have been redefined.

 def final(method):
    setattr(method, '__is_final__', True)
    Return method

class Base:
    @final
    def my_method(self):
        print("This is a final method")

class Derived(Base):
    def my_method(self):
        print("Trying to override")

Then you can combine metaclasses or class decorators to check whether the final convention is violated.

Advantages of this method:

• More flexible, and the rules can be customized according to project needs.
• Illegal overwrite behavior can be detected when the class is defined.

But some additional auxiliary code is required to implement the full functionality.

Tips: Use property alternatives

If you do not want a behavior to be modified, you can also consider encapsulating it into a read-only property property.

 class Base:
    @property
    def status(self):
        return "original"

class Derived(Base):
    @property
    def status(self):
        return "overridden" # will still be overwritten

However, this method cannot really prevent coverage, it just provides an idea.

In general, Python is a language that emphasizes "trust programmers" and does not encourage coercive restrictions on certain behaviors. But in actual development, if you do have the need to prevent methods from being covered, you can achieve "soft limitations" through the above methods.

Basically these methods are all. Although they cannot be completely "sealed", they are enough in most cases.

The above is the detailed content of How to prevent a method from being overridden in Python?. For more information, please follow other related articles on the PHP Chinese website!