Python object-oriented inheritance and polymorphism

The content shared with you in this article is about Python object-oriented inheritance and polymorphism. It has certain reference value. Friends in need can refer to it

In OOP programming, when we define A class can inherit from an existing class. The new class is called a subclass (Subclass), and the inherited class is called a base class, parent class, or super class (Base class, Supper class).

For example, we have written a class named Animal, and there is a run() method that can print directly:

class Animal(object):
    def run(self):
        print('Animal is running...')

When we need to write Dog and Cat classes, we can directly print from Animal class inheritance:

class Dog(Animal):
    pass
class Cat(Animal):
    pass

For Dog, Animal is its parent class, and for Animal, Dog is its subclass. Cat and Dog are similar.

What are the benefits of inheritance? The biggest advantage is that the subclass obtains all the functions of the parent class. Since Animal implements the run() method, Dog and Cat, as its subclasses, automatically have the run() method without doing anything:

dog = Dog()
dog.run()

cat = Cat()
cat.run()

Animal is running...
Animal is running...

Of course, you can also add subclasses Some methods, such as Dog class.

The second benefit of inheritance requires us to make a little improvement to the code. You see, whether it is Dog or Cat, when they run(), they display Animal is running.... The logical way is to display Dog is running... and Cat is running... respectively, so , the improvements to the Dog and Cat classes are as follows:

class Animal(object):
    def run(self):
        print('Animal is running...')class Dog(Animal):
    def run(self):
        print('Dog is haha running...')

    def eat(self):
        print('Eating meat...')
class Cat(Animal):
    def run(self):
        print('Cat is miaomiao running...')

    def eat(self):
        print('Eating fish...')dog = Dog()
dog.run()
dog.eat()

cat = Cat()
cat.run()
cat.eat()

再次运行，结果如下：

Dog is haha running...
Eating meat...
Cat is miaomiao running...
Eating fish...

When the same run() method exists in both the subclass and the parent class, we say that the run() of the subclass overrides the run of the parent class. (), when the code is running, the subclass's run() will always be called. In this way, we get another benefit of inheritance: polymorphism.

To understand what polymorphism is, we first need to explain a little more about data types. When we define a class, we actually define a data type. The data types we define are no different from the data types that come with Python, such as str, list, and dict:

a = list()#a是list类型#a是list类型

b = Animal() #b是Animal类型

c = Dog #c是Dog类型

To determine whether a variable is a certain type, you can use isinstance() to determine:

>>> isinstance(a, list)
True
>>> isinstance(b, Animal)
True
>>> isinstance(c, Dog)
True

It seems that a, b, and c do correspond to the three types of list, Animal, and Dog.

But wait, try:

>>> isinstance(c, Animal)
True

It seems that c is not only Dog, c is also Animal!

But if you think about it carefully, this makes sense, because Dog inherits from Animal. When we create an instance c of Dog, we think that the data type of c is Dog. But it’s not wrong that c is also Animal. Dog is originally a type of Animal!

So, in the inheritance relationship, if the data type of an instance is a subclass, its data type can also be regarded as the parent class. However, the reverse is not true:

>>> b = Animal()
>>> isinstance(b, Dog)
False

Dog can be regarded as Animal, but Animal cannot be regarded as Dog.

To understand the benefits of polymorphism, we need to write another function that accepts a variable of type Animal:

def run_twice(animal):
    animal.run()
    animal.run()

When we pass in an instance of Animal, run_twice() Print out:

>>> run_twice(Animal())
Animal is running...
Animal is running...

When we pass in the instance of Dog, run_twice() prints out:

>>> run_twice(Dog())
Dog is running...
Dog is running...

It doesn’t seem interesting, but if we think about it carefully, if we then Define a pig type, also derived from Animal:

class Pig(Animal):
    def run(self):
        print('Pig is running slowly...')

When we call run_twice(pig())

>>> run_twice(Pig())
Pig is running slowly...
Pig is running slowly...

The advantage of polymorphism is that when we need to pass in Dog, Cat, Pig , we only need to receive the Animal type, because Dog, Cat, and Pig are all Animal types, and then operate according to the Animal type. Since the Animal type has a run() method, any type passed in, as long as it is an Animal class or subclass, will automatically call the run() method of the actual type. This is the meaning of polymorphism:

For a variable, we only need to know that it is of type Animal, without knowing exactly its subtype, we can safely call the run() method, and whether the specific call of the run() method works on Animal, Dog, cat, or Pig On the object, it is determined by the exact type of the object at runtime. This is the real power of polymorphism: the caller only cares about the call, regardless of the details. When we add a new subclass of Animal, we only need to ensure that the run() method is written Correct, regardless of how the original code is called. This is the famous "open and closed" principle:

Closed to modification: There is no need to modify functions such as run_twice() that rely on the Animal type.

Inheritance can also be inherited level by level. Any class can ultimately be traced back to the root class object. These inheritance relationships look like an inverted tree:

Related recommendations:

Python object-oriented access restrictions

Python object-oriented classes and examples

##

The above is the detailed content of Python object-oriented inheritance and polymorphism. For more information, please follow other related articles on the PHP Chinese website!