多态性

深入理解 Python 中的多态性概念，包括方法重写、动态方法调用、鸭子类型以及多态在实际开发中的应用

分类: Python 基础难度: 中级

面向对象多态继承方法重写

多态性

概述

多态性（Polymorphism）是面向对象编程的核心特性之一，它允许不同类的对象对同一消息做出不同的响应。在 Python 中，多态性主要通过方法重写和鸭子类型来实现，使得代码更加灵活、可扩展和易于维护。

学习目标

通过本章学习，你将能够：

理解多态性的基本概念和原理
掌握通过继承和方法重写实现多态
了解 Python 的鸭子类型特性
学会使用 isinstance()和 hasattr()进行类型检查
能够设计支持多态的类结构
理解多态在实际开发中的应用场景

前置知识

Python 类的定义和实例化
类的继承机制
方法的定义和重写
面向对象编程基础概念

详细内容

多态的基本概念

多态性指的是同一个接口可以有多种不同的实现方式。在运行时，程序会根据对象的实际类型来决定调用哪个方法，而不是根据变量的声明类型。

基本示例

class Animal:
    def speak(self):
        pass
    
    def move(self):
        print("动物在移动")

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

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

class Bird(Animal):
    def speak(self):
        return "啾啾!"
    
    def move(self):
        print("鸟儿在飞翔")

## 多态的体现
def make_animal_speak(animal):
    """这个函数可以接受任何 Animal 类型的对象"""
    print(animal.speak())
    animal.move()

## 使用示例
animals = [Dog(), Cat(), Bird()]

for animal in animals:
    make_animal_speak(animal)
## 输出:
## 汪汪!
## 动物在移动
## 喵喵!
## 动物在移动
## 啾啾!
## 鸟儿在飞翔

方法重写实现多态

通过在子类中重写父类的方法，可以实现多态性：

class Shape:
    """图形基类"""
    def __init__(self, name):
        self.name = name
    
    def area(self):
        raise NotImplementedError("子类必须实现 area 方法")
    
    def perimeter(self):
        raise NotImplementedError("子类必须实现 perimeter 方法")
    
    def describe(self):
        return f"这是一个{self.name}"

class Rectangle(Shape):
    def __init__(self, width, height):
        super().__init__("矩形")
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height
    
    def perimeter(self):
        return 2 * (self.width + self.height)

class Circle(Shape):
    def __init__(self, radius):
        super().__init__("圆形")
        self.radius = radius
    
    def area(self):
        return 3.14159 * self.radius ** 2
    
    def perimeter(self):
        return 2 * 3.14159 * self.radius

class Triangle(Shape):
    def __init__(self, a, b, c):
        super().__init__("三角形")
        self.a = a
        self.b = b
        self.c = c
    
    def area(self):
#        # 使用海伦公式计算面积
        s = (self.a + self.b + self.c) / 2
        return (s * (s - self.a) * (s - self.b) * (s - self.c)) ** 0.5
    
    def perimeter(self):
        return self.a + self.b + self.c

## 多态函数
def print_shape_info(shape):
    """打印图形信息的通用函数"""
    print(shape.describe())
    print(f"面积: {shape.area():.2f}")
    print(f"周长: {shape.perimeter():.2f}")
    print("-" * 30)

## 使用示例
shapes = [
    Rectangle(5, 3),
    Circle(4),
    Triangle(3, 4, 5)
]

for shape in shapes:
    print_shape_info(shape)

鸭子类型

Python 支持鸭子类型（Duck Typing）：”如果它走起来像鸭子，叫起来像鸭子，那它就是鸭子”。这意味着对象的类型不重要，重要的是它是否具有所需的方法。

class Duck:
    def quack(self):
        print("嘎嘎嘎!")
    
    def fly(self):
        print("鸭子在飞")

class Airplane:
    def quack(self):
        print("飞机引擎声!")
    
    def fly(self):
        print("飞机在飞")

class Dog:
    def bark(self):
        print("汪汪!")

## 鸭子类型的体现
def make_it_fly(obj):
    """只要对象有 fly 方法就可以调用"""
    if hasattr(obj, 'fly'):
        obj.fly()
    else:
        print(f"{obj.__class__.__name__} 不能飞")

def make_it_quack(obj):
    """只要对象有 quack 方法就可以调用"""
    if hasattr(obj, 'quack'):
        obj.quack()
    else:
        print(f"{obj.__class__.__name__} 不会嘎嘎叫")

## 使用示例
objects = [Duck(), Airplane(), Dog()]

for obj in objects:
    print(f"--- {obj.__class__.__name__} ---")
    make_it_fly(obj)
    make_it_quack(obj)
    print()

类型检查和多态

在多态编程中，有时需要进行类型检查：

class Vehicle:
    def __init__(self, brand):
        self.brand = brand
    
    def start(self):
        print(f"{self.brand} 启动")

class Car(Vehicle):
    def __init__(self, brand, doors):
        super().__init__(brand)
        self.doors = doors
    
    def start(self):
        print(f"{self.brand} 汽车启动,有{self.doors}个门")
    
    def honk(self):
        print("滴滴!")

class Motorcycle(Vehicle):
    def __init__(self, brand, engine_size):
        super().__init__(brand)
        self.engine_size = engine_size
    
    def start(self):
        print(f"{self.brand} 摩托车启动,{self.engine_size}cc 引擎")
    
    def wheelie(self):
        print("摩托车翘头!")

def operate_vehicle(vehicle):
    """操作交通工具的通用函数"""
#    # 多态调用
    vehicle.start()
    
#    # 类型检查和特定操作
    if isinstance(vehicle, Car):
        vehicle.honk()
        print("这是一辆汽车")
    elif isinstance(vehicle, Motorcycle):
        vehicle.wheelie()
        print("这是一辆摩托车")
    
#    # 检查是否有特定方法
    if hasattr(vehicle, 'honk'):
        print("这个交通工具可以鸣笛")
    
    print(f"品牌: {vehicle.brand}")
    print("-" * 30)

## 使用示例
vehicles = [
    Car("奔驰", 4),
    Motorcycle("哈雷", 1200),
    Vehicle("通用品牌")
]

for vehicle in vehicles:
    operate_vehicle(vehicle)

抽象基类和多态

使用抽象基类可以更好地定义多态接口：

from abc import ABC, abstractmethod

class Drawable(ABC):
    """可绘制对象的抽象基类"""
    
    @abstractmethod
    def draw(self):
        """绘制方法,子类必须实现"""
        pass
    
    @abstractmethod
    def get_area(self):
        """获取面积,子类必须实现"""
        pass
    
    def display_info(self):
        """显示信息,通用方法"""
        print(f"绘制 {self.__class__.__name__}")
        self.draw()
        print(f"面积: {self.get_area()}")

class Square(Drawable):
    def __init__(self, side):
        self.side = side
    
    def draw(self):
        print(f"绘制边长为{self.side}的正方形")
    
    def get_area(self):
        return self.side ** 2

class Circle(Drawable):
    def __init__(self, radius):
        self.radius = radius
    
    def draw(self):
        print(f"绘制半径为{self.radius}的圆形")
    
    def get_area(self):
        return 3.14159 * self.radius ** 2

## 多态函数
def render_shapes(shapes):
    """渲染图形列表"""
    total_area = 0
    for shape in shapes:
        shape.display_info()
        total_area += shape.get_area()
        print()
    
    print(f"总面积: {total_area:.2f}")

## 使用示例
shapes = [Square(5), Circle(3), Square(2)]
render_shapes(shapes)

实际应用案例

案例 1：支付系统

from abc import ABC, abstractmethod

class PaymentProcessor(ABC):
    """支付处理器抽象基类"""
    
    @abstractmethod
    def process_payment(self, amount):
        """处理支付"""
        pass
    
    @abstractmethod
    def validate_payment_info(self, payment_info):
        """验证支付信息"""
        pass

class CreditCardProcessor(PaymentProcessor):
    def process_payment(self, amount):
        print(f"使用信用卡支付 ¥{amount}")
        print("连接银行网关...")
        print("支付成功!")
        return True
    
    def validate_payment_info(self, payment_info):
#        # 验证信用卡信息
        card_number = payment_info.get('card_number', '')
        if len(card_number) == 16:
            print("信用卡信息验证通过")
            return True
        print("信用卡信息无效")
        return False

class AlipayProcessor(PaymentProcessor):
    def process_payment(self, amount):
        print(f"使用支付宝支付 ¥{amount}")
        print("调用支付宝 API...")
        print("支付成功!")
        return True
    
    def validate_payment_info(self, payment_info):
#        # 验证支付宝信息
        account = payment_info.get('account', '')
        if '@' in account or len(account) == 11:
            print("支付宝账户验证通过")
            return True
        print("支付宝账户无效")
        return False

class WechatPayProcessor(PaymentProcessor):
    def process_payment(self, amount):
        print(f"使用微信支付 ¥{amount}")
        print("调用微信支付 API...")
        print("支付成功!")
        return True
    
    def validate_payment_info(self, payment_info):
#        # 验证微信支付信息
        openid = payment_info.get('openid', '')
        if len(openid) > 10:
            print("微信支付信息验证通过")
            return True
        print("微信支付信息无效")
        return False

class PaymentService:
    """支付服务类"""
    
    def __init__(self):
        self.processors = {
            'credit_card': CreditCardProcessor(),
            'alipay': AlipayProcessor(),
            'wechat': WechatPayProcessor()
        }
    
    def process_order_payment(self, payment_method, amount, payment_info):
        """处理订单支付"""
        processor = self.processors.get(payment_method)
        
        if not processor:
            print(f"不支持的支付方式: {payment_method}")
            return False
        
        print(f"开始处理支付,方式: {payment_method}")
        
#        # 多态调用:不同的处理器有不同的实现
        if processor.validate_payment_info(payment_info):
            return processor.process_payment(amount)
        else:
            print("支付信息验证失败")
            return False

## 使用示例
payment_service = PaymentService()

## 不同的支付方式
orders = [
    {
        'method': 'credit_card',
        'amount': 299.99,
        'info': {'card_number': '1234567890123456'}
    },
    {
        'method': 'alipay',
        'amount': 199.50,
        'info': {'account': 'user@example.com'}
    },
    {
        'method': 'wechat',
        'amount': 99.00,
        'info': {'openid': 'wx_openid_12345'}
    }
]

for order in orders:
    print("=" * 40)
    success = payment_service.process_order_payment(
        order['method'], 
        order['amount'], 
        order['info']
    )
    print(f"支付结果: {'成功' if success else '失败'}")
    print()

案例 2：文件处理系统

from abc import ABC, abstractmethod
import json
import csv
import xml.etree.ElementTree as ET

class FileProcessor(ABC):
    """文件处理器抽象基类"""
    
    @abstractmethod
    def read_file(self, filepath):
        """读取文件"""
        pass
    
    @abstractmethod
    def write_file(self, filepath, data):
        """写入文件"""
        pass
    
    @abstractmethod
    def get_file_type(self):
        """获取文件类型"""
        pass

class JSONProcessor(FileProcessor):
    def read_file(self, filepath):
        try:
            with open(filepath, 'r', encoding='utf-8') as f:
                return json.load(f)
        except Exception as e:
            print(f"读取 JSON 文件失败: {e}")
            return None
    
    def write_file(self, filepath, data):
        try:
            with open(filepath, 'w', encoding='utf-8') as f:
                json.dump(data, f, ensure_ascii=False, indent=2)
            print(f"JSON 文件写入成功: {filepath}")
            return True
        except Exception as e:
            print(f"写入 JSON 文件失败: {e}")
            return False
    
    def get_file_type(self):
        return "JSON"

class CSVProcessor(FileProcessor):
    def read_file(self, filepath):
        try:
            data = []
            with open(filepath, 'r', encoding='utf-8') as f:
                reader = csv.DictReader(f)
                for row in reader:
                    data.append(dict(row))
            return data
        except Exception as e:
            print(f"读取 CSV 文件失败: {e}")
            return None
    
    def write_file(self, filepath, data):
        try:
            if not data:
                return False
            
            with open(filepath, 'w', newline='', encoding='utf-8') as f:
                writer = csv.DictWriter(f, fieldnames=data[0].keys())
                writer.writeheader()
                writer.writerows(data)
            print(f"CSV 文件写入成功: {filepath}")
            return True
        except Exception as e:
            print(f"写入 CSV 文件失败: {e}")
            return False
    
    def get_file_type(self):
        return "CSV"

class XMLProcessor(FileProcessor):
    def read_file(self, filepath):
        try:
            tree = ET.parse(filepath)
            root = tree.getroot()
            return self._xml_to_dict(root)
        except Exception as e:
            print(f"读取 XML 文件失败: {e}")
            return None
    
    def _xml_to_dict(self, element):
        """将 XML 元素转换为字典"""
        result = {}
        for child in element:
            if len(child) == 0:
                result[child.tag] = child.text
            else:
                result[child.tag] = self._xml_to_dict(child)
        return result
    
    def write_file(self, filepath, data):
        try:
            root = ET.Element("root")
            self._dict_to_xml(root, data)
            tree = ET.ElementTree(root)
            tree.write(filepath, encoding='utf-8', xml_declaration=True)
            print(f"XML 文件写入成功: {filepath}")
            return True
        except Exception as e:
            print(f"写入 XML 文件失败: {e}")
            return False
    
    def _dict_to_xml(self, parent, data):
        """将字典转换为 XML 元素"""
        if isinstance(data, dict):
            for key, value in data.items():
                child = ET.SubElement(parent, str(key))
                self._dict_to_xml(child, value)
        else:
            parent.text = str(data)
    
    def get_file_type(self):
        return "XML"

class FileManager:
    """文件管理器"""
    
    def __init__(self):
        self.processors = {
            '.json': JSONProcessor(),
            '.csv': CSVProcessor(),
            '.xml': XMLProcessor()
        }
    
    def get_processor(self, filepath):
        """根据文件扩展名获取处理器"""
        import os
        _, ext = os.path.splitext(filepath.lower())
        return self.processors.get(ext)
    
    def process_file(self, input_path, output_path=None):
        """处理文件"""
        processor = self.get_processor(input_path)
        
        if not processor:
            print(f"不支持的文件类型: {input_path}")
            return False
        
        print(f"使用{processor.get_file_type()}处理器")
        
#        # 多态调用:不同处理器有不同的读取方式
        data = processor.read_file(input_path)
        
        if data is None:
            return False
        
        print(f"成功读取{processor.get_file_type()}文件")
        print(f"数据内容: {data}")
        
#        # 如果指定了输出路径,则写入文件
        if output_path:
            output_processor = self.get_processor(output_path)
            if output_processor:
#                # 多态调用:不同处理器有不同的写入方式
                return output_processor.write_file(output_path, data)
        
        return True

## 使用示例(需要实际的文件来测试)
file_manager = FileManager()

## 示例数据
sample_data = [
    {"name": "张三", "age": 25, "city": "北京"},
    {"name": "李四", "age": 30, "city": "上海"}
]

## 演示多态性
processors = [JSONProcessor(), CSVProcessor(), XMLProcessor()]

for processor in processors:
    print(f"\n=== {processor.get_file_type()} 处理器 ===")
    filename = f"test.{processor.get_file_type().lower()}"
    
#    # 多态调用:每个处理器都有自己的写入实现
    if processor.write_file(filename, sample_data):
#        # 多态调用:每个处理器都有自己的读取实现
        read_data = processor.read_file(filename)
        print(f"读取的数据: {read_data}")

注意事项

接口一致性：多态要求子类保持与父类相同的接口
里氏替换原则：子类对象应该能够替换父类对象而不影响程序正确性
避免类型检查：尽量避免使用 isinstance()进行类型检查，优先使用鸭子类型
合理使用抽象类：使用抽象基类可以更好地定义多态接口
性能考虑：多态调用可能比直接调用稍慢，但通常可以忽略

扩展阅读

Python 官方文档：多态和鸭子类型
《设计模式》中关于多态的应用
SOLID 原则中的开闭原则和里氏替换原则
函数式编程中的多态概念

多态性

多态性

概述