Python面向对象

一、基础概念

1. 类（Class）

类是抽象的模板，用于定义对象的结构和行为。它包含属性（变量）和方法（函数）。类的作用是作为创建对象的蓝图，定义了对象的属性和行为。

2. 对象（Object）/ 实例（Instance）

对象是类的实例化结果，是具体的实体。类是对象的模板，而对象是类的具体实例。

示例：

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

my_car = Car("Toyota", "Red")  # my_car 是 Car 类的实例

二、核心特性

1. 封装（Encapsulation）

封装是将数据（属性）和操作数据的方法封装到一个类中，隐藏内部实现细节，只暴露必要的接口。封装的优点包括提高代码的安全性和降低代码的复杂性。

示例：

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # 私有属性

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance -= amount
        else:
            print("Insufficient funds")

    def get_balance(self):
        return self.__balance

2. 继承（Inheritance）

继承允许一个类（子类）继承另一个类（父类）的属性和方法。继承的优点是代码复用和层次结构清晰。

示例：

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

    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

my_dog = Dog("Buddy")
print(my_dog.speak())  # 输出: Buddy says Woof!

3. 多态（Polymorphism）

多态允许不同的对象对同一消息做出响应，即同一个接口可以被不同的底层实现所使用。多态的实现方式包括方法重写（Override）和方法重载（Overload）。

示例：

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 ** 2

shapes = [Rectangle(4, 5), Circle(3)]
for shape in shapes:
    print(shape.area())  # 多态：调用不同的 area 方法

三、魔法方法（Magic Methods）

魔法方法是 Python 中以双下划线开头和结尾的特殊方法，用于实现特定的功能。

1. 初始化与字符串表示

• __init__：初始化对象属性。

• __str__：定义对象的字符串表示。

示例：

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

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

2. 数学比较方法

这些方法用于实现对象之间的比较。

• __eq__：等于（==）

• __ne__：不等于（!=）

• __gt__：大于（>）

• __ge__：大于等于（>=）

• __lt__：小于（<）

• __le__：小于等于（<=）

示例：

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

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

    def __eq__(self, other):
        return self.age == other.age

    def __ge__(self, other):
        return self.age >= other.age

    def __le__(self, other):
        return self.age <= other.age

    def __ne__(self, other):
        return self.age != other.age

    def __gt__(self, other):
        return self.age > other.age

    def __lt__(self, other):
        return self.age < other.age

3. 长度魔法方法

• __len__：返回对象的长度。

示例：

class MyList:
    def __init__(self, elements):
        self.elements = elements

    def __len__(self):
        return len(self.elements)

my_list = MyList([1, 2, 3, 4])
print(len(my_list))  # 输出：4

4. 构造函数

• __new__：构造函数，用于创建对象。

示例：

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

obj1 = Singleton()
obj2 = Singleton()
print(obj1 is obj2)  # 输出：True

5. 析构函数

• __del__：析构函数，用于释放对象的资源。

示例：

class File:
    def __init__(self, filename):
        self.filename = filename
        self.file = open(filename, "w")

    def __del__(self):
        self.file.close()
        print(f"File {self.filename} closed")

file = File("test.txt")
del file  # 输出：File test.txt closed

6. 上下文管理

• __enter__ 和 __exit__：实现资源自动管理。

示例：

class File:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode

    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.file.close()

with File("test.txt", "w") as f:
    f.write("Hello, World!")

四、类的成员

类的成员包括属性（变量）和方法（函数）。这些成员可以分为以下几类：

1. 属性

• 实例属性：属于某个实例，每个实例独立。

• 类属性：属于类本身，所有实例共享。

2. 方法

• 实例方法：需要实例化对象后调用。

• 类方法：使用 @classmethod 装饰器，第一个参数为类本身（cls）。

• 静态方法：使用 @staticmethod 装饰器，不绑定类或实例。

五、动态添加类成员

可以在类的外部动态地为类或实例添加属性或方法。

1. 动态添加实例属性

示例：

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

person = Person("Alice")
person.age = 30  # 动态添加实例属性
print(person.age)  # 输出：30

2. 动态添加类属性

示例：

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

Person.species = "Homo sapiens"  # 动态添加类属性
print(Person.species)  # 输出：Homo sapiens
print(person.species)  # 输出：Homo sapiens

3. 动态添加方法

示例：

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

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

Person.greet = greet  # 动态添加实例方法
person = Person("Alice")
print(person.greet())  # 输出：Hello, my name is Alice!

六、属性封装

封装是面向对象的核心特性之一，通过封装可以隐藏类的内部实现细节，只暴露必要的接口。

1. 私有属性

在 Python 中，使用双下划线（__）前缀表示私有属性，这些属性不能直接从外部访问。

2. 使用 @property 装饰器

可以通过 @property 装饰器定义只读属性，或者通过 @<property_name>.setter 提供属性的设置方法。

示例：

class Person:
    def __init__(self, name, age):
        self.__name = name  # 私有属性
        self.__age = age    # 私有属性

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, value):
        if not value:
            raise ValueError("Name cannot be empty")
        self.__name = value

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self, value):
        if value < 0:
            raise ValueError("Age cannot be negative")
        self.__age = value

    def __str__(self):
        return f"Person(name={self.__name}, age={self.__age})"

# 使用封装的属性
person = Person("Alice", 30)
print(person.name)  # 输出：Alice
person.name = "Bob"  # 修改属性
print(person)  # 输出：Person(name=Bob, age=30)

七、单例模式

单例模式是一种设计模式，确保一个类只有一个实例，并提供一个全局访问点。

1. 使用 __new__ 方法实现单例

示例：

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

singleton1 = Singleton()
singleton2 = Singleton()
print(singleton1 is singleton2)  # 输出：True

2. 使用装饰器实现单例

示例：

def singleton(cls):
    instances = {}

    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]

    return get_instance

@singleton
class MyClass:
    def __init__(self, value):
        self.value = value

obj1 = MyClass(10)
obj2 = MyClass(20)
print(obj1 is obj2)  # 输出：True
print(obj1.value)  # 输出：10