Python面向对象编程：探索代码的结构之美

在这里插入图片描述

文章目录

- 一、引言
- 二、为什么学习面向对象编程
- - 2.1 提高代码的可维护性：通过封装、继承和多态实现模块化设计
  - 2.2 提升代码的复用性：通过类和对象的创建实现代码的重用
- 三、类和对象的基本概念
- - 3.1 类和对象的定义和关系：类是对象的模板，对象是类的实例
  - 3.2 属性和方法：类和对象具有的特征和行为
  - 3.3 初始化方法：__init__()方法的作用和使用
- 四、类的继承与多态
- - 4.1 继承的概念和分类：单继承和多继承
  - 4.2 多态的实现：不同对象对相同方法的不同表现
- 五、封装和访问控制
- - 5.1 封装的概念和作用：将数据和操作封装在类中
  - 5.2 公有、私有和受保护的访问控制：属性和方法的可见性和访问限制
- 六、魔法方法和特殊属性
- - 6.1 魔法方法的介绍和使用：__repr__()、__str__()等
  - 6.2 特殊属性的应用：__dict__、__name__等
- 七、类的设计原则和模式
- - 7.1 SOLID原则：单一职责、开闭原则、里式替换、接口隔离原则
  - 7.2 常见设计模式：工厂模式、单例模式、观察者模式等
- 八、实践项目：创建一个简单的图书管理系统

重温Python，适合新手搭建知识体系，也适合大佬的温故知新~

一、引言

面向对象编程为Python开发提供了一种有效的编程范式，可以提高代码的可重用性、简化复杂性、增强扩展性、保护数据安全和提高代码的可维护性。

面向对象编程对Python的重要性：

可重用性：面向对象编程通过封装数据和行为在一个对象中，使得代码更加模块化和可重用。通过定义类和创建对象，可以在不同的项目中重复使用代码，提高开发效率。
简化复杂性：面向对象编程通过抽象、继承和多态等特性，可以将复杂的问题分解成简单的对象，并通过对象之间的交互解决问题。这样可以简化代码的设计和实现过程，提高代码的可读性和维护性。
扩展性：面向对象编程允许通过继承和多态来扩展已有的类，从而实现新的功能。这种灵活性使得代码可以随着需求的变化而进行扩展和修改，同时保持原有代码的稳定性。
封装性：面向对象编程通过将数据和行为封装在一个对象中，实现了数据的隐藏和保护。这样可以防止外部直接访问和修改对象的内部状态，提高代码的安全性和稳定性。
可维护性：面向对象编程使得代码更加结构化和模块化，易于理解和维护。通过将功能相似的代码封装在类中，可以更好地组织代码，减少了代码的冗余和重复，使得代码更加可读和易于修改。

二、为什么学习面向对象编程

2.1 提高代码的可维护性：通过封装、继承和多态实现模块化设计

通过封装、继承和多态的应用，可以将代码模块化，降低代码的耦合度，增加代码的可读性、可维护性和可扩展性，可以提高代码的可维护性，并实现模块化的设计。

封装：

封装是指将数据和对数据的操作封装在一起，以形成一个独立的单元。通过封装，我们可以隐藏内部实现细节，只暴露必要的接口给其他部分使用。这样可以增强代码的安全性和可维护性。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def get_name(self):
        return self.name

    def get_age(self):
        return self.age

person = Person("Alice", 25)

print(person.get_name())  # 输出 "Alice"
print(person.get_age())  # 输出 25

继承：

继承是指通过创建一个新类，从现有的类中继承属性和方法。通过继承，可以避免重复编写代码，提高代码的重用性。同时，通过继承还可以实现多层次的抽象和模块化的设计。

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        pass

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

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

dog = Dog("Buddy")
cat = Cat("Whiskers")

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

多态：

多态是指相同的接口可以有不同的实现方式。通过多态，可以将不同的对象当作同一类型来对待，从而增加代码的灵活性和可扩展性。

class Shape:
    def area(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

# 将Rectangle和Circle对象当作Shape类型的对象来对待，并调用相同的方法area，从而实现了对不同对象的统一处理
shapes = [Rectangle(4, 5), Circle(3)]

for shape in shapes:
    print(shape.area())

2.2 提升代码的复用性：通过类和对象的创建实现代码的重用

通过类和对象的创建，可以实现代码的重用和模块化设计。将相关的属性和方法封装在一个类中，可以提高代码的可读性和可维护性；通过对象的创建，可以实现对类中属性和方法的共享和调用；通过继承的应用，可以实现代码的重用和扩展，避免了重复编写相同功能的代码。

小案例：

假设我们有一个表示汽车的类Car，其中包含了汽车的颜色、品牌和型号等属性，以及加速、刹车和转向等方法。我们可以创建多个Car对象，每个对象都具有相同的属性和方法，但是它们的具体属性值可能不同。

class Car:
    def __init__(self, color, brand, model):
        self.color = color
        self.brand = brand
        self.model = model

    # 加速
    def accelerate(self):
        print(f"The {self.color} {self.brand} {self.model} is accelerating.")

    # 刹车
    def brake(self):
        print(f"The {self.color} {self.brand} {self.model} is braking.")

    # 转向
    def turn(self, direction):
        print(f"The {self.color} {self.brand} {self.model} is turning {direction}.")

# 创建两个Car对象，具有相同的属性和方法，但具体的属性值不同
car1 = Car("red", "Toyota", "Camry")
car2 = Car("blue", "Honda", "Civic")

# 调用对象的方法
car1.accelerate()  # 输出 "The red Toyota Camry is accelerating."
car2.brake()  # 输出 "The blue Honda Civic is braking."

代码重用性的好处：如果我们需要创建更多的汽车对象，只需简单地实例化新的对象即可，而无需重新编写类或方法。此外，如果我们需要修改汽车的某个属性或方法，只需在类定义中进行修改，所有的对象都会受到影响。

三、类和对象的基本概念

3.1 类和对象的定义和关系：类是对象的模板，对象是类的实例

类和对象之间的关系：

类是对象的模板或蓝图，它定义了对象应该具有的属性和方法。
对象是根据类的定义创建的一个具体实体，它具有类定义中所描述的属性和方法。

类和对象之间的关系：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hello(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

# 创建Person类的对象
person1 = Person("Alice", 25)
person2 = Person("Bob", 30)

# 访问对象的属性和方法
print(person1.name)  # 输出 "Alice"
print(person2.age)  # 输出 30

person1.say_hello()  # 输出 "Hello, my name is Alice and I am 25 years old."
person2.say_hello()  # 输出 "Hello, my name is Bob and I am 30 years old."

3.2 属性和方法：类和对象具有的特征和行为

属性 | 方法和类 | 对象之间的关系：

属性是类或对象的特征或状态，用于描述对象的状态、特征或数据。
方法是类或对象的行为或操作，用于执行某些具体的动作或操作。

属性和方法在类和对象中的应用：

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print(f"{self.name} is barking!")

    def eat(self, food):
        print(f"{self.name} is eating {food}.")

# 创建Dog类的对象
dog1 = Dog("Buddy", 3)
dog2 = Dog("Max", 5)

# 访问对象的属性
print(dog1.name)  # 输出 "Buddy"
print(dog2.age)  # 输出 5

# 调用对象的方法
dog1.bark()  # 输出 "Buddy is barking!"
dog2.eat("bone")  # 输出 "Max is eating bone."

3.3 初始化方法：init()方法的作用和使用

init()方法用于在创建对象时对对象进行初始化。它的作用是在新建对象时分配内存空间，并对对象的属性进行初始化，通常被放在类的定义中，并且必须以self作为第一个参数。它可以接受任意数量的额外参数，用于初始化对象中的属性。

简单的Person类的定义：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

当创建一个Person对象时，必须提供name和age参数，Python会自动调用__init__()方法来创建person1对象并进行初始化。

创建了一个名为person1的Person对象：

person1 = Person("Alice", 25)

init()方法的作用是确保对象在创建时处于正确的状态，并且可以避免在后续操作中出现错误。通过使用__init__()方法，可以方便地对对象的属性进行初始化，并且可以在创建对象时自动完成这些操作，从而提高了代码的可读性和可维护性。

四、类的继承与多态

4.1 继承的概念和分类：单继承和多继承

继承是面向对象编程中的重要概念，它允许我们构建具有层次结构的类，并且可以在子类中重用和扩展父类的功能。单继承和多继承提供了不同的继承方式，可以根据具体需求选择适合的继承方式。通过继承，一个类可以派生出子类，从而使子类可以继承父类的属性和方法。这种机制允许我们创建具有层次结构的类，其中子类可以继承和扩展父类的功能。

单继承：

单继承是指一个子类只能继承一个父类的特性。在类定义时将父类作为参数传递给子类，实现单继承。子类会继承父类的所有属性和方法，并且可以在子类中添加新的属性和方法。

# 父类
class Parent:
    def __init__(self):
        self.parent_attr = "Parent attribute"
    
    def parent_method(self):
        print("Parent method")
 
# 子类
# 通过调用super().init()方法，子类可以调用父类的初始化方法来初始化父类的属性
class Child(Parent):
    def __init__(self):
        super().__init__()  # 调用父类的初始化方法
        self.child_attr = "Child attribute"
    
    def child_method(self):
        print("Child method")

创建一个Child对象并调用父类和子类的方法：

obj = Child()
obj.parent_method()  # 输出 "Parent method"
obj.child_method()  # 输出 "Child method"
print(obj.parent_attr)  # 输出 "Parent attribute"
print(obj.child_attr)  # 输出 "Child attribute"

多继承：

多继承是指一个子类可以同时继承多个父类的特性。在类定义时将多个父类作为参数传递给子类，实现多继承。

# 父类
class Parent1:
    def parent1_method(self):
        print("Parent1 method")

# 父类
class Parent2:
    def parent2_method(self):
        print("Parent2 method")
  
# 子类
class Child(Parent1, Parent2):
    def child_method(self):
        print("Child method")

创建一个Child对象并调用父类和子类的方法：

obj = Child()
obj.parent1_method()  # 输出 "Parent1 method"
obj.parent2_method()  # 输出 "Parent2 method"
obj.child_method()  # 输出 "Child method"

ps：在多继承中，如果多个父类中有相同的方法，子类会按照继承的顺序优先调用第一个父类的方法。这种潜在的冲突可以通过方法重写或使用super()来解决。

4.2 多态的实现：不同对象对相同方法的不同表现

多态是指不同对象对相同方法的不同表现。具体来说，多态允许我们在不考虑对象类型的情况下，调用同一个方法，不同的对象会对该方法做出不同的响应。

多态的实现：

class Animal:
    def __init__(self, name):
        self.name = name
        
    # 方法没有任何实现，因为不同的动物会发出不同的声音
    def make_sound(self):
        pass

# 子类Dog和Cat重写了make_sound()方法，返回它们各自的声音
class Dog(Animal):
    def make_sound(self):
        return "Woof"
    
class Cat(Animal):
    def make_sound(self):
        return "Meow"

通过这种方式，我们可以创建一个Animal对象，并调用make_sound()方法，不同的对象会对该方法做出不同的响应：

# 创建一个Animal对象
animal = Animal("Generic animal")
# 创建一个Dog对象
dog = Dog("Fido")
# 创建一个Cat对象
cat = Cat("Whiskers")

# 调用make_sound()方法
print(animal.make_sound())  # 输出 None
print(dog.make_sound())  # 输出 "Woof"
print(cat.make_sound())  # 输出 "Meow"

在不考虑对象类型的情况下，我们可以调用相同的方法，并让不同的对象对该方法做出不同的响应。这种机制使得代码更加灵活和可扩展，同时也避免了冗长的判断语句和复杂的类型转换。

五、封装和访问控制

5.1 封装的概念和作用：将数据和操作封装在类中

封装是指将数据和操作封装在类中，以达到数据的保护和隐藏实现细节的目的。具体来说，封装可以通过以下两种方式实现：

将属性和方法设为私有的，即在属性和方法名称前面加上双下划线__。这样做可以防止属性被外部直接访问，同时也可以避免子类意外地修改父类的属性。如果需要访问或修改属性，可以通过getter和setter方法实现。
使用@property装饰器来创建getter和setter方法，使得我们可以像访问属性一样访问方法，从而隐藏实现细节。

封装的概念和作用：

class Person:
    def __init__(self, name, age):
        self.__name = name  # 将属性设为私有的
        self.__age = age
        
    # 定义getter方法
    @property
    def name(self):
        return self.__name
    
    # 定义setter方法
    @name.setter
    def name(self, value):
        self.__name = value
    
    # 定义getter方法
    @property
    def age(self):
        return self.__age
    
    # 定义setter方法，可以加入了一些判断逻辑来确保数据的合法性
    @age.setter
    def age(self, value):
        if value < 0:
            # 传入的值不符合要求，则抛出ValueError异常
            raise ValueError("Age cannot be negative")
        self.__age = value
    
    def display_info(self):
        print(f"Name: {self.__name}, Age: {self.__age}")

通过创建Person对象，并调用它们的方法，我们可以看到封装的效果：

# 创建一个Person对象
p = Person("Alice", 25)

# 通过getter方法获取属性的值
print(p.name)  # 输出 "Alice"
print(p.age)  # 输出 25

# 通过setter方法修改属性的值
p.name = "Bob"
p.age = 30

p.display_info()  # 输出 "Name: Bob, Age: 30"

通过将数据和操作封装在类中，我们可以隐藏实现细节，保护数据的安全性，同时也提高了代码的可维护性和可扩展性。

5.2 公有、私有和受保护的访问控制：属性和方法的可见性和访问限制

属性和方法的可见性和访问限制是通过命名规则来实现的。

Python使用单下划线和双下划线作为前缀来表示不同级别的访问控制：

公有访问控制：没有任何前缀。公有属性和方法可以被类的实例、子类和其他代码直接访问。
私有访问控制：双下划线__作为前缀。私有属性和方法只能在类内部访问，无法通过实例、子类或其他代码直接访问。但是，在Python中，私有属性和方法并不是真正无法访问的，而是进行了名称修饰，将其名称变更为_类名__属性名或_类名__方法名的形式，以实现一定程度的隐藏。
受保护的访问控制：单下划线_作为前缀。受保护属性和方法可以被类的实例和子类访问，但约定上不建议直接访问。这种访问控制主要是一种约定，用于告诉其他开发者某个属性或方法被认为是类内部使用的，不建议在外部直接使用。

公有、私有和受保护的访问控制：

class MyClass:
    def __init__(self):
        self.public_var = "Public"  # 公有属性
        self._protected_var = "Protected"  # 受保护属性
        self.__private_var = "Private"  # 私有属性
    
    def public_method(self):
        print("This is a public method")  # 公有方法
    
    def _protected_method(self):
        print("This is a protected method")  # 受保护方法
    
    def __private_method(self):
        print("This is a private method")  # 私有方法

# 创建一个类的实例
obj = MyClass()

# 访问公有属性和调用公有方法
print(obj.public_var)  # 输出 "Public"
obj.public_method()  # 输出 "This is a public method"

# 访问受保护属性和调用受保护方法
print(obj._protected_var)  # 输出 "Protected"
obj._protected_method()  # 输出 "This is a protected method"

# 访问私有属性和调用私有方法（通过名称修饰）
print(obj._MyClass__private_var)  # 输出 "Private"
obj._MyClass__private_method()  # 输出 "This is a private method"

总结起来，公有访问控制允许外部直接访问属性和方法，私有访问控制将属性和方法隐藏在类内部，受保护访问控制则提供了一种约定，告诉其他开发者某个属性或方法是类内部使用的。这些访问控制级别可以帮助我们封装数据和隐藏实现细节，以提高代码的可维护性和安全性。

六、魔法方法和特殊属性

6.1 魔法方法的介绍和使用：repr()、str()等

**魔法方法（Magic Method）**是一些特殊的方法，它们以双下划线 __ 开头和结尾，例如 __repr__()、__str__()。这些方法在某些特定场景下会被自动调用，可以用来实现类的一些特殊行为。

__repr__():

__repr__() 是一个魔法方法，用于返回一个对象的字符串表示形式（通常是一段可执行的代码），以便在交互式环境中显示或调试时使用。如果没有定义 __repr__() 方法，则调用 print() 函数打印该对象时，默认输出的是该对象的内存地址。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Person('{self.name}', {self.age})"

p = Person("Alice", 25)
print(p)  # 输出 "Person('Alice', 25)"

__str__():

__str__() 是一个魔法方法，用于返回一个对象的字符串表示形式（通常是人类可读的文本），以便在用户界面或日志文件中使用。如果没有定义 __str__() 方法，则调用 print() 函数打印该对象时，会尝试调用 __repr__() 方法来获取字符串表示。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Person('{self.name}', {self.age})"

    def __str__(self):
        return f"{self.name}, {self.age}"

# 输出的是 "Alice, 25"，而不是默认的内存地址或__repr__()方法返回的字符串
p = Person("Alice", 25)
print(p)  # 输出 "Alice, 25"

6.2 特殊属性的应用：dict、name等

**特殊属性（Special Attribute）**是一些预定义的属性，以双下划线 __ 开头和结尾，例如 __dict__、__name__ 等。这些属性提供了有关对象或类的一些额外信息，可以在编程中使用。

__dict__:

__dict__ 是一个特殊属性，它是一个字典，包含了对象或类的所有属性和方法的名称和值。通过访问 __dict__ 属性，我们可以动态获取对象或类的属性和方法，并对其进行操作或修改，可以根据需要修改、添加或删除对象的属性。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f"Hello, my name is {self.name}.")

p = Person("Alice", 25)

# 访问对象的 __dict__ 属性，获取到该对象的属性和对应的值的字典形式
print(p.__dict__)
# 输出: {'name': 'Alice', 'age': 25}

# 修改对象的属性
p.age = 30
print(p.__dict__)
# 输出: {'name': 'Alice', 'age': 30}

# 添加新的属性
p.location = "New York"
print(p.__dict__)
# 输出: {'name': 'Alice', 'age': 30, 'location': 'New York'}

__name__：

__name__ 是一个特殊属性，它用于获取类或函数的名称。对于类而言，__name__ 返回类的名称；对于函数而言，__name__ 返回函数的名称。

class Person:
    pass

def say_hello():
    print("Hello!")

print(Person.__name__)  # 输出 "Person"
print(say_hello.__name__)  # 输出 "say_hello"

七、类的设计原则和模式

7.1 SOLID原则：单一职责、开闭原则、里式替换、接口隔离原则

SOLID 原则是一组设计原则，旨在创建可维护、可扩展和可重用的软件。这些原则包括单一职责、开闭原则、里式替换、接口隔离和依赖倒置原则，简称为 SOLID。

单一职责原则：

单一职责原则指一个类或模块只应该有一个单一的功能，也就是说，一个类或模块只应该有一个单一的责任。如果一个类或模块负责多个不同的任务，那么它将会变得难以维护、扩展和测试。

# 不遵循单一职责原则的代码，既负责保存员工信息到数据库，又负责计算员工税收信息
class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def save(self):
        # 保存员工信息到数据库
        pass

    def calculate_tax(self):
        # 计算员工税收信息
        pass

# 遵循单一职责原则的代码
# 只负责表示员工信息
class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

# 负责保存员工信息到数据库
class EmployeeDB:
    def save(self, employee):
        # 保存员工信息到数据库
        pass

# 负责计算员工税收信息
class TaxCalculator:
    def calculate_tax(self, employee):
        # 计算员工税收信息
        pass

开闭原则：

开闭原则指一个模块或类应该对扩展开放，对修改关闭。也就是说，应该通过扩展已有的代码来满足新的需求，而不是修改已有的代码。如果一个模块或类需要频繁地修改，那么它将会变得难以维护和测试。

# 不遵循开闭原则的代码
# 矩形
class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def set_width(self, width):
        self.width = width

    def set_height(self, height):
        self.height = height

    def area(self):
        return self.width * self.height

# 正方形，继承 Rectangle 类
class Square(Rectangle):
    def __init__(self, side):
        super().__init__(side, side)

    # 重写了 set_width() 和 set_height() 方法
    # 导致在修改正方形的一边时，另一边也会跟着变化，从而破坏了矩形的定义
    def set_width(self, width):
        self.width = width
        self.height = width

    def set_height(self, height):
        self.width = height
        self.height = height

# 遵循开闭原则的代码
# 将 Rectangle 和 Square 类都实现为继承自 Shape 类的子类，再分别实现它们自己的 area() 方法
class Shape:
    def area(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

class Square(Shape):
    def __init__(self, side):
        self.side = side

    def area(self):
        return self.side ** 2

里式替换原则：

里式替换原则指子类应该能够替换掉它们的父类，并且程序仍然能够正常工作。也就是说，子类应该保持与父类相同的行为，而不是改变其原本的含义。

# 不遵循里式替换原则的代码
class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def set_width(self, width):
        self.width = width

    def set_height(self, height):
        self.height = height

    def area(self):
        return self.width * self.height

class Square(Rectangle):
    def __init__(self, side):
        super().__init__(side, side)

    def set_width(self, width):
        self.width = width
        self.height = width

    def set_height(self, height):
        self.width = height
        self.height = height

def print_area(rectangle):
    rectangle.set_width(2)
    rectangle.set_height(3)
    print(f"Area: {rectangle.area()}")

r = Rectangle(3, 4)
s = Square(3)
print_area(r)  # 输出 "Area: 6"
# 传递一个 Square 对象作为参数时，由于 Square 类重写了 set_width() 和 set_height() 方法，导致输出的面积不是预期的值
print_area(s)  # 输出 "Area: 9"

# 遵循里式替换原则
# 可以将 Rectangle 和 Square 类都实现为继承自 Shape 类的子类，并分别实现它们自己的 area() 方法

接口隔离原则：

接口隔离原则指一个接口应该只包含被调用者需要的方法，而不应该包含被调用者不需要的方法。也就是说，接口应该尽可能地小，以减少对实现类的依赖和影响。

# 不遵循接口隔离原则的代码
class Document:
    def __init__(self, content):
        self.content = content

    def print(self):
        # 打印文档内容
        pass

    def fax(self):
        # 传真文档内容
        pass

    def scan(self):
        # 扫描文档内容
        pass

class MultiFunctionPrinter:
    def __init__(self, document):
        self.document = document

    def print(self):
        self.document.print()

    def fax(self):
        self.document.fax()

    def scan(self):
        self.document.scan()

class OldFashionedPrinter:
    def __init__(self, document):
        self.document = document

    def print(self):
        self.document.print()

# 遵循接口隔离原则的代码
# 将 Printable、Faxable 和 Scanable 接口分别抽象出来，然后让它们各自实现自己需要的方法
class Printable:
    def print(self):
        pass

class Faxable:
    def fax(self):
        pass

class Scanable:
    def scan(self):
        pass

class Document:
    def __init__(self, content):
        self.content = content

class MultiFunctionPrinter(Printable, Faxable, Scanable):
    def __init__(self, document):
        self.document = document

    def print(self):
        self.document.print()

    def fax(self):
        self.document.fax()

    def scan(self):
        self.document.scan()

class OldFashionedPrinter(Printable):
    def __init__(self, document):
        self.document = document

    def print(self):
        self.document.print()

7.2 常见设计模式：工厂模式、单例模式、观察者模式等

工厂模式：

工厂模式是一种创建型设计模式，它提供了一种封装对象创建过程的方式。它使用一个共同的接口来创建不同类型的对象，而不必暴露具体的实例化逻辑。

class Shape:
    def draw(self):
        pass

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

class Square(Shape):
    def draw(self):
        print("Drawing a square")

class ShapeFactory:
    # 静态方法
    @staticmethod
    # 根据传入的形状类型来创建相应的对象
    def create_shape(shape_type):
        if shape_type == "circle":
            return Circle()
        elif shape_type == "square":
            return Square()
        else:
            raise ValueError("Invalid shape type")

# 使用工厂模式创建对象，隐藏了具体的实例化逻辑
shape = ShapeFactory.create_shape("circle")
shape.draw()  # 输出 "Drawing a circle"

单例模式：

单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供了全局访问点来获取该实例。

# 单例模式确保在整个应用程序中只有一个实例存在
class Singleton:
    _instance = None # 静态变量 

    # 静态方法
    @staticmethod
    def get_instance():
        if Singleton._instance is None:
            Singleton._instance = Singleton()
        return Singleton._instance

# 使用单例模式获取对象实例
singleton1 = Singleton.get_instance()
singleton2 = Singleton.get_instance()

print(singleton1 is singleton2)  # 输出 True

观察者模式：

观察者模式是一种行为型设计模式，它定义了对象之间的一种一对多的依赖关系，使得当一个对象的状态发生改变时，所有依赖它的对象都会收到通知并自动更新。

# 主题类
class Subject:
    def __init__(self):
        # _observers 列表来保存所有注册的观察者对象
        self._observers = []

    # 添加
    def attach(self, observer):
        self._observers.append(observer)

    # 移除
    def detach(self, observer):
        self._observers.remove(observer)

    # 通知
    def notify(self):
        for observer in self._observers:
            observer.update()

# 观察者类
class Observer:
    # 用于接收并处理通知
    def update(self):
        pass

# 具体的观察者类
class ConcreteObserver(Observer):
    def update(self):
        print("Received notification")

# 使用观察者模式
subject = Subject()
observer = ConcreteObserver()
subject.attach(observer)
# 所有已注册的观察者都会接收到通知并执行相应的操作
subject.notify()  # 输出 "Received notification"

八、实践项目：创建一个简单的图书管理系统

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
        self.is_borrowed = False

    # 借阅图书
    def borrow(self):
        if self.is_borrowed:
            print("This book is already borrowed.")
        else:
            self.is_borrowed = True
            print("Successfully borrowed the book:", self.title)

    # 归还图书
    def return_book(self):
        if self.is_borrowed:
            self.is_borrowed = False
            print("Successfully returned the book:", self.title)
        else:
            print("This book is not currently borrowed.")


class Library:
    def __init__(self):
        self.books = []

    # 添加图书
    def add_book(self, book):
        self.books.append(book)
        print("Added book:", book.title)

    # 删除图书
    def remove_book(self, book):
        if book in self.books:
            self.books.remove(book)
            print("Removed book:", book.title)
        else:
            print("Book not found in the library.")

    # 显示图书
    def display_books(self):
        if len(self.books) == 0:
            print("No books in the library.")
        else:
            print("Books in the library:")
            for book in self.books:
                print(book.title, "by", book.author)


# 创建图书和图书馆对象
book1 = Book("Python Crash Course", "Eric Matthes")
book2 = Book("Clean Code", "Robert C. Martin")
book3 = Book("The Pragmatic Programmer", "Andrew Hunt and David Thomas")

library = Library()

# 添加图书到图书馆
library.add_book(book1)
library.add_book(book2)
library.add_book(book3)

# 显示图书馆的所有图书
library.display_books()

# 借阅一本图书
book2.borrow()

# 再次显示图书馆的所有图书
library.display_books()

# 归还图书
book2.return_book()

# 再次显示图书馆的所有图书
library.display_books()