The difference between python object-oriented methods

Python has been an object-oriented language from the beginning. Because of this, it is easy to create classes and objects in Python.

Methods include: instance methods, static methods and class methods. All three methods belong to classes in memory. The difference lies in the calling method.

Instance method: called by the object; at least one self parameter; when executing a normal method, the object calling the method is automatically assigned to self;

Class method: called by the class; at least one cls Parameters; when executing a class method, the class calling the method is automatically copied to cls;

Static method: called by the class; no default parameters.

Instance method

class Kls(object):
    def __init__(self, data):
        self.data = data
    def printd(self):
        print(self.data)
ik1 = Kls('leo')
ik2 = Kls('lee')
ik1.printd()
ik2.printd()

Output:

leo 
lee

In the above example, printd is an instance method. The first parameter of the instance method is self. When the instance method is called using ik1.printd(), the instance ik1 will be passed to the self parameter, so that the self parameter can refer to the instance that is currently calling the instance method. Taking advantage of this feature of instance methods, the above code correctly outputs the member data of the two instances.

Related recommendations: "Python Video Tutorial"

Class method

Python's class method uses the decorator @classmethod. For definition, let’s look directly at the example.

class Kls(object):
    num_inst = 0
    def __init__(self):
        Kls.num_inst = Kls.num_inst + 1
    @classmethod
    def get_no_of_instance(cls):
        return cls.num_inst
ik1 = Kls()
ik2 = Kls()
print ik1.get_no_of_instance()
print Kls.get_no_of_instance()

Output:

2 
2

In the above example, we need to count the number of instances of class Kls, so a class variable num_inst is defined to store the number of instances. Through the use of the decorator @classmethod, the method get_no_of_instance is defined as a class method. When calling a class method, Python will pass the class (class Kls) to cls so that the class variable num_inst can be referenced inside get_no_of_instance.

Since when calling a class method, you only need to pass the type itself to the class method, therefore, the class method can be called either through the class or through the instance.

Static method

In development, we often need to define some methods, which are related to the class, but do not need to reference the class or instance during implementation, for example , set environment variables, modify variables of another class, etc. At this time, we can use static methods.

Python uses the decorator @staticmethod to define a static method.

IND = 'ON'

class Kls(object):
    def __init__(self, data):
        self.data = data
    @staticmethod
    def checkind():
        return IND == 'ON'
    def do_reset(self):
        if self.checkind():
            print('Reset done for: %s' % self.data)
    def set_db(self):
        if self.checkind():
            print('DB connection made for: %s' % self.data)
ik1 = Kls(24)
ik1.do_reset()
ik1.set_db()

Output:

Reset done for: 24 
DB connection made for: 24

In the code, we define a global variable IND. Since IND is related to the class Kls, we add the method Checkind is placed and defined in class Kls. The method checkind only needs to check the value of IND without referencing the class or instance. Therefore, we define the method checkind as a static method.

For static methods, Python does not need to pass classes or instances, so you can use either classes or instances to call static methods.

The difference between instance methods, class methods and static methods

We use code to illustrate the differences between instance methods, class methods and static methods. Pay attention to the definition and use of methods foo, class_foo, and static_foo in the following code.

class Kls(object):
    def foo(self, x):
        print('executing foo(%s,%s)' % (self, x))
    @classmethod
    def class_foo(cls,x):
        print('executing class_foo(%s,%s)' % (cls,x))
    @staticmethod
    def static_foo(x):
        print('executing static_foo(%s)' % x)
ik = Kls()
# 实例方法
ik.foo(1)
print(ik.foo)
print('==========================================')
# 类方法
ik.class_foo(1)
Kls.class_foo(1)
print(ik.class_foo)
print('==========================================')
# 静态方法
ik.static_foo(1)
Kls.static_foo('hi')
print(ik.static_foo)

Output:

executing foo(<__main__.Kls object at 0x0551E190>,1)
<bound method Kls.foo of <__main__.Kls object at 0x0551E190>>
==========================================
executing class_foo(<class &#39;__main__.Kls&#39;>,1)
executing class_foo(<class &#39;__main__.Kls&#39;>,1)
<bound method type.class_foo of <class &#39;__main__.Kls&#39;>>
==========================================
executing static_foo(1)
executing static_foo(hi)
<function static_foo at 0x055238B0>

For instance methods, the instance ik will be passed as the first parameter to the self parameter when calling. Therefore, calling ik.foo(1) prints the address of instance ik.

For class methods, class Kls will be passed to the cls parameter as the first parameter when calling. Therefore, Kls type information is output when calling ik.class_foo(1).

As mentioned earlier, class methods can be called through classes or instances. In the above code, we verified it again.

For static methods, there is no need to pass a class or instance when calling. In fact, static methods are very similar to functions we define outside the class, except that static methods can be called through classes or instances.

It is worth noting that in the above example, foo is just a function, but when calling ik.foo we get a function that has been bound to the instance ik. Calling foo requires two arguments, but calling ik.foo requires only one argument. foo is bound to ik, so when we print ik.foo, we will see the following output:

<bound method Kls.foo of <__main__.Kls object at 0x0551E190>>

When ik.class_foo is called, since class_foo is a class method, class_foo is bound to Kls Bind (instead of binding to ik). When we print ik.class_foo, the output is:

<bound method type.class_foo of <class &#39;__main__.Kls&#39;>>

When calling ik.static_foo, the static method is not bound to the class or instance, therefore, when printing ik.static_foo (or Kls.static_foo), the output :

<function static_foo at 0x055238B0>

In summary, whether to bind to a class or instance, this is the difference between instance methods, class methods, and static methods.

The above is the detailed content of The difference between python object-oriented methods. For more information, please follow other related articles on the PHP Chinese website!