Python如何在已有类的基础上

在Python中，扩展或修改已有类的基础方法包括继承、组合和装饰器。这些方法可以帮助我们重用已有代码，增强代码的可维护性和可读性。 其中，继承是最常用的一种方式，通过继承，我们可以创建一个新的类，该类可以继承已有类的所有属性和方法，并且可以添加新的功能或重写已有的方法。下面我们详细介绍如何在Python中使用这些方法来扩展或修改已有类。

一、继承

继承是面向对象编程中最常用的一个特性，它允许一个类（子类）从另一个类（父类）继承属性和方法。通过继承，子类不仅可以重用父类的代码，还可以增加新的功能或重写父类的方法。

1.1、基本继承

在Python中，继承通过在类定义时指定父类来实现。以下是一个基本的继承示例：

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        raise NotImplementedError("Subclasses must implement this method")
class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"
class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

在这个例子中，Dog 和 Cat 类继承了 Animal 类，并实现了 speak 方法。通过这种方式，子类可以重用父类的代码并提供自己的实现。

1.2、重写方法

重写方法是指在子类中定义与父类同名的方法，以替换父类的方法。以下是一个示例：

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        return "Some sound"
class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"
dog = Dog("Buddy")
print(dog.speak())  # Output: Buddy says Woof!

在这个例子中，Dog 类重写了 Animal 类的 speak 方法。

1.3、调用父类的方法

在某些情况下，子类可能需要调用父类的方法。可以使用 super() 函数来实现这一点。以下是一个示例：

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        return "Some sound"
class Dog(Animal):
    def speak(self):
        original_sound = super().speak()
        return f"{self.name} says Woof! and {original_sound}"
dog = Dog("Buddy")
print(dog.speak())  # Output: Buddy says Woof! and Some sound

在这个例子中，Dog 类的 speak 方法调用了 Animal 类的 speak 方法，并在返回结果中包含了父类的方法结果。

二、组合

组合是一种设计原则，通过将对象作为类的属性来重用已有类的代码。与继承不同，组合更强调对象之间的关系，而不是类之间的关系。

2.1、基本组合

以下是一个基本的组合示例：

class Engine:
    def start(self):
        return "Engine started"
class Car:
    def __init__(self, model):
        self.model = model
        self.engine = Engine()
    def start(self):
        return self.engine.start()
car = Car("Toyota")
print(car.start())  # Output: Engine started

在这个例子中，Car 类包含一个 Engine 对象，并通过调用 Engine 对象的方法来实现自己的功能。

2.2、组合与继承的对比

组合和继承都有各自的优缺点。继承可以提供更强的代码重用性，但过度使用继承可能会导致代码的复杂性增加。组合更灵活，可以更容易地修改和扩展类的功能，但可能需要更多的代码来实现相同的功能。

三、装饰器

装饰器是一种设计模式，允许在不修改已有类的情况下，动态地为类添加功能。装饰器在函数或方法的前后添加额外的行为，通常用于日志记录、性能计数、权限校验等场景。

3.1、函数装饰器

以下是一个基本的函数装饰器示例：

def logger(func):
    def wrapper(*args, kwargs):
        print(f"Calling function {func.__name__}")
        result = func(*args, kwargs)
        print(f"Function {func.__name__} returned {result}")
        return result
    return wrapper
@logger
def add(a, b):
    return a + b
print(add(2, 3))

在这个例子中，logger 装饰器在 add 函数调用前后添加了日志记录功能。

3.2、类装饰器

类装饰器类似于函数装饰器，但它们用于装饰类。以下是一个基本的类装饰器示例：

def add_method(cls):
    cls.new_method = lambda self: "New method added"
    return cls
@add_method
class MyClass:
    pass
obj = MyClass()
print(obj.new_method())  # Output: New method added

在这个例子中，add_method 装饰器为 MyClass 类添加了一个新的方法。

3.3、装饰器与继承的对比

装饰器和继承都有各自的优缺点。继承可以提供更强的代码重用性，但过度使用继承可能会导致代码的复杂性增加。装饰器更灵活，可以动态地为类或函数添加功能，但可能会使代码难以理解和调试。

四、示例项目：扩展现有类的实战

为了更好地理解如何在Python中扩展或修改已有类，我们可以通过一个实际的项目来演示这些技术的应用。

4.1、项目背景

假设我们正在开发一个简单的银行系统，该系统包含一个基本的 Account 类。现在，我们需要扩展这个类以支持不同类型的账户，例如 SavingsAccount 和 CheckingAccount。

4.2、基本的Account类

首先，我们定义一个基本的 Account 类：

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
    def deposit(self, amount):
        if amount > 0:
            self.balance += amount
            return True
        return False
    def withdraw(self, amount):
        if 0 < amount <= self.balance:
            self.balance -= amount
            return True
        return False
    def get_balance(self):
        return self.balance
    def __str__(self):
        return f"Account owner: {self.owner}, Account balance: {self.balance}"

4.3、扩展Account类

接下来，我们通过继承扩展 Account 类，创建 SavingsAccount 和 CheckingAccount 类。

class SavingsAccount(Account):
    def __init__(self, owner, balance=0, interest_rate=0.01):
        super().__init__(owner, balance)
        self.interest_rate = interest_rate
    def add_interest(self):
        self.balance += self.balance * self.interest_rate
        return self.balance
class CheckingAccount(Account):
    def __init__(self, owner, balance=0, overdraft_limit=500):
        super().__init__(owner, balance)
        self.overdraft_limit = overdraft_limit
    def withdraw(self, amount):
        if 0 < amount <= self.balance + self.overdraft_limit:
            self.balance -= amount
            return True
        return False

4.4、使用组合扩展功能

现在，我们使用组合来为账户添加交易记录功能：

class TransactionLogger:
    def __init__(self):
        self.transactions = []
    def log(self, transaction):
        self.transactions.append(transaction)
    def get_transactions(self):
        return self.transactions
class AccountWithLogging(Account):
    def __init__(self, owner, balance=0):
        super().__init__(owner, balance)
        self.logger = TransactionLogger()
    def deposit(self, amount):
        result = super().deposit(amount)
        if result:
            self.logger.log(f"Deposited {amount}")
        return result
    def withdraw(self, amount):
        result = super().withdraw(amount)
        if result:
            self.logger.log(f"Withdrew {amount}")
        return result
    def get_transactions(self):
        return self.logger.get_transactions()

4.5、使用装饰器添加功能

最后，我们使用装饰器为账户添加日志记录功能：

def log_transactions(cls):
    original_deposit = cls.deposit
    original_withdraw = cls.withdraw
    def deposit(self, amount):
        result = original_deposit(self, amount)
        if result:
            print(f"Deposited {amount}")
        return result
    def withdraw(self, amount):
        result = original_withdraw(self, amount)
        if result:
            print(f"Withdrew {amount}")
        return result
    cls.deposit = deposit
    cls.withdraw = withdraw
    return cls
@log_transactions
class LoggedAccount(Account):
    pass
acc = LoggedAccount("Alice", 100)
acc.deposit(50)
acc.withdraw(30)