Class method types in Python

There are 3 types of methods that can be created in a class in Python: instance methods, class methods and static methods.

Static method

• This is created with the decorator @staticmethod.
• This is essentially a free function, except it is placed inside the scope or namespace of the class. So to call it you would need to invoke the class or an object of that class.

Class method

• This is created with the decorator @classmethod.
• This method needs at least one input and that first input (typically called cls) is the class.
• This method not only gets the namespace of the class (like the static method), but additionally also has access to everything about the class. For example, it can access all the attributes of the class.

Instance method

• This does not have any decorator. This is the canonical method on an object or instance of the class.
• This method needs at least one input and that first input (typically named self) is an object or instance of the class.
• This method not only gets the namespace of the class and access to the attributes of the class, but additionally also has access to other instance members and methods of the class.

Here is sample code that uses all three types of methods:

class A:
    X = 23

    def __init__(self):
        self.y = 46

    def instance_foo(self):
        """Instance method."""

        print(dir(self))

        # Member access
        print(self.X)
        print(A.X)
        print(self.y)

        # Method access
        self.instance_foo2()
        self.class_foo()
        A.class_foo()
        self.static_foo()
        A.static_foo()

    def instance_foo2(self):
        return

    @classmethod
    def class_foo(cls):
        """Class method."""

        print(dir(cls))

        # Member access
        print(cls.X)
        print(A.X)

        # Method access
        A.class_foo2()
        A.static_foo()

    @classmethod
    def class_foo2(cls):
        return

    @staticmethod
    def static_foo():
        """Static method."""

        # Member access
        print(A.X)

        # Method access
        A.static_foo2()
        A.class_foo2()

    @staticmethod
    def static_foo2():
        return

# Calling instance method
a = A()
a.instance_foo()

# Calling class method
A.class_foo()
a.class_foo()

# Calling static method
A.static_foo()
a.static_foo()