Polymorphism is a core concept in Python object-oriented programming, referring to "one interface, multiple implementations", allowing for unified processing of different types of objects. 1. Polymorphism is implemented through method rewriting. Subclasses can redefine parent class methods. For example, the spoke() method of Animal class has different implementations in Dog and Cat subclasses. 2. The practical uses of polymorphism include simplifying code structure and enhancing scalability, such as calling the draw() method uniformly in the graphical drawing program, or handling the common behavior of different characters in game development. 3. Python implementation polymorphism needs to satisfy: the parent class defines a method, and the child class overrides the method, but does not require inheritance of the same parent class. As long as the object implements the same method, this is called "duck type". 4. Notes include keeping the method signature consistent, avoiding over-design, and improving security in combination with isinstance() or hasattr().

Polymorphism in Python is a core concept in object-oriented programming. Simply put, it is "one interface, multiple implementations". It allows us to handle different types of objects in a unified way.

What is polymorphism?

In Python, polymorphism is usually reflected in method overriding. Subclasses can redefine methods inherited from parent class so that the same method name has different behaviors in different classes.

For example, you have an Animal class that has a speak() method. Then Dog and Cat are its subclasses, and they each implement their own speak() method:

 class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

At this time, you can call these methods in a unified way:

 animals = [Dog(), Cat()]
for animal in animals:
    print(animal.speak())

This is the power of polymorphism: the same call method, different execution results.

The practical use of polymorphism

One of the most common uses of polymorphism is to simplify the code structure , especially when dealing with multiple similar objects. For example, you are developing a graph drawing program, including circles, rectangles, triangles, etc., and each shape has a draw() method. After using polymorphism, you can uniformly traverse all the graphics and call draw() without caring about what the graphics are.

• Unified event handling for various controls in the graphical interface library
• Common behaviors of different characters in game development (such as movement, attack)
• Different types of data source reading methods are consistent in data processing

The advantage of this is that the code is clearer and more scalable.

How to achieve polymorphism?

Python's dynamic typing characteristics make polymorphism very natural to implement. Only two conditions need to be met:

• The parent class defines a method (can also be an abstract method)
• Subclass rewrites this method

Python does not force inheritance relationships to achieve polymorphism like Java. Even if the same parent class is not inherited, as long as the object implements the same name and parameter method, it can be handled uniformly.

For example:

 class Car:
    def move(self):
        print("Car moves on the road")

class Boat:
    def move(self):
        print("Boat sails on water")

vehicles = [Car(), Boat()]
for v in vehicles:
    v.move()

Although Car and Boat do not have a common parent class, because both implement move() method, they can also reflect polymorphic effects. This practice is called "Duck Typing" - it looks like a duck, and it sounds like a duck, and it is a duck.

Pay attention to small details

• The method signature must be consistent : If you want to call through a unified interface, the method parameters of each subclass should be consistent, otherwise an error may occur.
• Avoid over-design : Not all places require polymorphism. Sometimes it is clearer to directly judge the type.
• It is safer to use in conjunction with isinstance() or hasattr() : especially if you are not sure if the object has a method.

Basically that's it. Polymorphism sounds high-end, but in fact it means using a unified interface to process different objects in the right place. Python is quite natural.

The above is the detailed content of Polymorphism in python classes. For more information, please follow other related articles on the PHP Chinese website!