Analysis of constructor methods in Python (with examples)

The content of this article is about the analysis of construction methods in Python (with examples). It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

In Python, you will see function names preceded and followed by double underscores, such as __init__(self). This type of writing has special meaning in Python. If an object uses one of these methods, that method will be executed under special circumstances, but such methods are rarely called directly.

If there is no need to be compatible with older versions of Python code, we should write all classes as new-style classes and use features such as the super function when writing code.

There are no "old-style" classes in Python 3.0, and there is no need to subclass Object or set the metaclass to type (starting line of code __metaclass__=type). That's because all All classes are implicitly subclasses of Object. If there is no explicit superclass, it will be subclassed directly; otherwise, it will be subclassed indirectly.

Constructor method in Python

The constructor method is different from other methods. When an object is created, the constructor method will be called immediately.

Rewrite general methods and special construction methods:

After understanding the concept of inheritance, we know that each class may have one or more superclasses, and subclasses inherit from the parent class. Inherit some behaviors of the parent class. Not only that, we can also override some super class methods to customize inheritance behavior.

class Bird:
    def __init__(self):
        self.hungry=True
    def eat(self):
        if self.hungry:
            print('我在吃')
            self.hungry=False
        else:
            print('我吃饱了，谢谢')
sb=Bird()
sb.eat()
sb.eat()

Print result:

我在吃
我吃饱了，谢谢

It can be known from the code that after the bird is full, it will change its hunger state to Flase means that the bird is full. When the eat function is called, it will print that I am full. Thank you. This is through the use of the __init__ function in a class. Let’s look at the extended case. Eating is the basic characteristic of birds, and Bird can be regarded as the base class of birds. Now we write a singing bird, because we have already written a bird base class, and now we only need to inherit it. Our bird will not only sing but also learn the skill of eating by default.

class Bird:
    def __init__(self):
        self.hungry=True
    def eat(self):
        if self.hungry:
            print('ahhh')
            self.hungry=False
        else:
            print('no thanks')

class SongBird(Bird):
    def __init__(self):

        self.sound='Squawk'

    def sing(self):
        print(self.sound)
sb=SongBird()
sb.sing()
sb.eat()
sb.eat()

Print results:

Traceback (most recent call last):
Squawk
  File "F:/Python培训/博客园随笔专用/文件操作/文件读写.py", line 20, in <module>
    sb.eat()
  File "F:/Python培训/博客园随笔专用/文件操作/文件读写.py", line 5, in eat
    if self.hungry:
AttributeError: &#39;SongBird&#39; object has no attribute &#39;hungry&#39;

Unfortunately, our birds can trigger The singing function, but when the eating function of the parent class is called, an exception is thrown. Looking at the eat function defined in the parent class, you need to set the hungry attribute to start the eat function. But what is puzzling is that we have inherited the base class Bird, and Bird also defines hungry, why does it not work? That's because the hungry attribute only takes effect when the parent class calls its own constructor. It can be seen that SingBird inherits all the functions of Bird, but does not trigger Bird's initialization function. Modify the following code

class Bird:
    def __init__(self):
        self.hungry=True
    def eat(self):
        if self.hungry:
            print('ahhh')
            self.hungry=False
        else:
            print('no thanks')
class SongBird(Bird):
    def __init__(self):
        Bird.__init__(self)
        self.sound='Squawk'
    def sing(self):
        print(self.sound)
sb=SongBird()
sb.sing()
sb.eat()
sb.eat()

Output result:

Squawk
ahhh
no thanks

We can know from the code that we When SongBird initializes the class, Bird's initialization function is called. Therefore, Bird's constructor is triggered. Now our birds can not only sing but also have the eating behavior of the basic species.

Look at its execution process. While SongBird initializes itself, it passes itself as a parameter to its parent class, which means telling the parent class that when you created me, you had to give me innate skills (knowing how to feed myself). That is, the hungry attribute is set.

Using the Super function

The above method was written before 3.0. The super function will be used in the new class to solve the above problems.

class Bird:
    def __init__(self):
        self.hungry=True
    def eat(self):
        if self.hungry:
            print('ahhh')
            self.hungry=False
        else:
            print('no thanks')
class SongBird(Bird):
    def __init__(self):
        super(SongBird, self).__init__()
        self.sound='Squawk'
    def sing(self):
        print(self.sound)
sb=SongBird()
sb.sing()
sb.eat()
sb.eat()

The current class and object are called as parameters, and any method of calling the object returned by the function is a method of calling the super class. Summary: The subclass and subclass object are passed explicitly and the constructor is called, but the constructor of the parent class is implicitly executed.

The above is the detailed content of Analysis of constructor methods in Python (with examples). For more information, please follow other related articles on the PHP Chinese website!