Polymorphism in Python: Duck Types and Interfaces

Polymorphism is an important concept of object-oriented programming, which allows different classes of objects to operate through the same interface. As a dynamically typed language, the polymorphism of Python is fully reflected in duck types and interfaces. This article will introduce polymorphism in Python in detail, including the concepts of duck types and interfaces, implementation methods, and practical application examples.

The basic concept of polymorphism

Polymorphism allows the same operation to be applied to different objects, behaving differently depending on the type of object.

There are two main forms of polymorphism:

1. Subtype polymorphism: A child class object can replace a parent class object.
2. Parametric polymorphism: The same function can accept different types of parameters.

In Python, polymorphism is mainly implemented through duck types and interfaces.

Duck type

Duck typing is a feature of a dynamically typed language that determines the type of an object by its behavior, rather than by inheritance. Its name comes from the duck test: "If it walks like a duck and barks like a duck, then it is a duck." ”

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

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

class Duck:
    def speak(self):
        return "Quack!"

def make_sound(animal):
    print(animal.speak())

# 使用示例
dog = Dog()
cat = Cat()
duck = Duck()

make_sound(dog)  # 输出: Woof!
make_sound(cat)  # 输出: Meow!
make_sound(duck)  # 输出: Quack!           

In this example, the make_sound function accepts any object that has a speak method, regardless of the specific type of the object. This is the embodiment of the duck type.

interface

An interface is a type of abstraction in object-oriented programming that defines the methods that an object must implement. In Python, although there is no explicit interface keyword, interfaces can be implemented through an Abstract Base Class (ABC).

Use ABC to define the interface

Python's abc module provides the ability to define abstract base classes and abstract methods.

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

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

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

# 使用示例
dog = Dog()
cat = Cat()

print(dog.speak())  # 输出: Woof!
print(cat.speak())  # 输出: Meow!           

In this example, the Animal class is an abstract base class that defines an abstract method speak. The Dog and Cat classes inherit from the Animal class and implement the speak method.

Combination of interface and duck type

In Python, interfaces and duck types can be used in combination to make the code more flexible and powerful. Define interfaces to regulate the behavior of objects, while utilizing duck types for polymorphism.

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

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

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

class Duck:
    def speak(self):
        return "Quack!"

def make_sound(animal):
    print(animal.speak())

# 使用示例
dog = Dog()
cat = Cat()
duck = Duck()

make_sound(dog)  # 输出: Woof!
make_sound(cat)  # 输出: Meow!
make_sound(duck)  # 输出: Quack!           

In this example, the make_sound function accepts not only objects that implement the Animal interface, such as Dog and Cat, but also other objects with speak methods, such as Duck.

Practical application examples

Drawing tools

Suppose you want to implement a simple drawing tool that is capable of drawing different shapes such as circles, rectangles, and triangles. This can be achieved using duck types and interfaces.

Define interface and shape classes

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def draw(self):
        pass

class Circle(Shape):
    def draw(self):
        return "Drawing a circle"

class Rectangle(Shape):
    def draw(self):
        return "Drawing a rectangle"

class Triangle(Shape):
    def draw(self):
        return "Drawing a triangle"           

Define plot functions

def draw_shape(shape):
    print(shape.draw())           

Example of use

circle = Circle()
rectangle = Rectangle()
triangle = Triangle()

draw_shape(circle)  # 输出: Drawing a circle
draw_shape(rectangle)  # 输出: Drawing a rectangle
draw_shape(triangle)  # 输出: Drawing a triangle           

In this example, the Shape interface defines an abstract method draw, which is implemented by all shape classes. The draw_shape function accepts any object that implements the Shape interface and calls its draw method.

Payment systems

Suppose you want to implement a payment system that supports multiple payment methods (such as credit cards, PayPal, and Bitcoin). This can be achieved using interfaces and duck types.

Define interfaces and payment classes

from abc import ABC, abstractmethod

class Payment(ABC):
    @abstractmethod
    def pay(self, amount):
        pass

class CreditCardPayment(Payment):
    def pay(self, amount):
        return f"Paying {amount} using Credit Card"

class PayPalPayment(Payment):
    def pay(self, amount):
        return f"Paying {amount} using PayPal"

class BitcoinPayment:
    def pay(self, amount):
        return f"Paying {amount} using Bitcoin"           

Define the payout function

def process_payment(payment, amount):
    print(payment.pay(amount))           

Example of use

credit_card = CreditCardPayment()
paypal = PayPalPayment()
bitcoin = BitcoinPayment()

process_payment(credit_card, 100)  # 输出: Paying 100 using Credit Card
process_payment(paypal, 200)  # 输出: Paying 200 using PayPal
process_payment(bitcoin, 300)  # 输出: Paying 300 using Bitcoin           

In this example, the Payment interface defines an abstract method pay, which is implemented by all payment classes. The process_payment function accepts any object that implements the Payment interface and calls its pay method. In addition, the BitcoinPayment class, although it does not explicitly implement the Payment interface, can also be accepted by process_payment functions due to its pay method.

summary

This article details the concept of polymorphism in Python, including the implementation of duck types and interfaces. By using duck types, you can manipulate objects based on their behavior rather than their type, making your code more flexible. By defining an interface, you can standardize the behavior of an object and ensure that the class implements the necessary methods. Using a combination of duck types and interfaces, you can write code that is both flexible and secure. Through concrete examples, the application of polymorphism in real projects is demonstrated, including drawing tools and payment systems.