What's the Difference Between `@staticmethod` and `@classmethod` in Python?

Understanding the Differences between @staticmethod and @classmethod Decorators in Python

The @staticmethod and @classmethod decorators in Python allow you to create class-level methods with different behaviors. Here's a detailed explanation of their key differences:

Calling Conventions:

• @staticmethod: Static methods are not bound to any specific instance or class. They behave like regular functions that can be called directly from both instances and classes.
• @classmethod: Class methods are bound to the class itself, rather than to a particular instance. They are typically used to perform operations on the class itself, such as modifying attributes or creating alternative constructors.

Method Signatures:

• Static methods do not receive the class or instance as an implicit first argument.
• Class methods receive the class as the first implicit argument.
• Instance methods (methods without decorators) receive the instance as the first implicit argument.

Instantiation:

• Static methods can be called without creating an instance of the class.
• Class methods can be called from both instances and classes.
• Instance methods can only be called from instances of the class.

Practical Example:

Consider the following code snippet:

class A(object):
    def foo(self, x):
        print("executing foo({self}, {x})")

    @classmethod
    def class_foo(cls, x):
        print("executing class_foo({cls}, {x})")

    @staticmethod
    def static_foo(x):
        print("executing static_foo({x})")

a = A()

When calling foo, the instance a is implicitly passed as the first argument:

a.foo(1)
# executing foo(<__main__.A object at 0xb7dbef0c>, 1)

With class methods, the class of the instance is implicitly passed instead of self:

a.class_foo(1)
# executing class_foo(<class '__main__.A'>, 1)

Static methods do not receive any implicit arguments:

a.static_foo(1)
# executing static_foo(1)

Summary:

• @staticmethod decorators create methods that behave like regular functions, without any implicit class or instance binding.
• @classmethod decorators create methods that are bound to the class itself, allowing them to modify class attributes or create alternative constructors.

The above is the detailed content of What's the Difference Between `@staticmethod` and `@classmethod` in Python?. For more information, please follow other related articles on the PHP Chinese website!