上一期【人工智能-6】递归函数及装饰器

下一期【人工智能-8】迭代器和生成器的区别及其各自实现方式和使用场景

前言

在编程中，类和对象是面向对象编程（OOP）的核心概念。类作为创建对象的模板，封装了数据（属性）和操作数据的方法。对象则是类的具体实例，具有独立的状态和行为。理解类和对象的关系以及它们的属性和方法，是掌握面向对象编程的关键。

1.类和对象

1.1 类

汉语中有一个词语物以类聚 ,意思是同类的东西聚在一起，说白了就是对一类事物的统称，例如：轿车，suv，越野车都可以统称为车，这里车就是这个类。

定义：类是创建对象的模板或蓝图，描述了对象的共同特征和行为
本质：类是一种自定义数据类型，封装了数据（属性）和操作数据的方法

class Dog:# 这就是一个类
    # 类属性
    species = "Canis familiaris"
    
    # 初始化方法
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age

• 类名就是标识符，建议（有点强烈）首字母大写
• 类名实质上就是变量，它绑定一个类
• self代表类实例化的对象本身

1.2对象

车这个类里面包含的轿车，suv或者更细的划分小米su7，秦plus都是对象

定义：对象是类的具体实例，具有独立的状态和行为
特点:每个对象都有自己独立的内存空间
创建:通过实例化类来创建对象

变量(实例) = 类名([参数])

my_dog = Dog("Buddy", 3)
your_dog = Dog("Lucy", 5)

• 变量存储的是实例化后的对象地址
• 类参数按照初始化方法的形参传递

2.属性

2.1实例属性：对象的个性特征

定义：每个对象特有的属性，存储在对象自身的内存空间
属性的调用:

实例.属性名    

class Car:
    def __init__(self, brand, color):
        self.brand = brand  # 实例属性
        self.color = color  # 实例属性
# 创建实例
my_car = Car("特斯拉", "red")
your_car = Car("SU7", "blue")

print(my_car.color)   # 输出: red
print(your_car.color) # 输出: blue

2.2类属性：共享的特征

定义：属于类本身的属性，所有实例共享 （所有实例共享一个值，即对其修改后会影响所有实例）

• 类属性,可以通过该类直接访问
• 类属性,可以通过类的实例直接访问

class Circle:
    # 类属性
    pi = 3.14159
    
    def __init__(self, radius):
        self.radius = radius  # 实例属性

# 通过类名访问类属性
print(Circle.pi)  # 输出: 3.14159

circle1 = Circle(5)
circle2 = Circle(10)

# 通过实例访问类属性
print(circle1.pi)  # 输出: 3.14159
print(circle2.pi)  # 输出: 3.14159

# 修改类属性
Circle.pi = 3.14
print(circle1.pi)  # 输出: 3.14
print(circle2.pi)  # 输出: 3.14

2.3属性访问规则

• 实例属性优先：当实例属性与类属性同名时，实例访问返回实例属性值
• 动态添加属性：Python 允许在运行时添加属性（灵活但需谨慎）

class Person:
    category = "Human"  # 类属性

p = Person()
p.category = "Employee"  # 添加实例属性

print(p.category)        # 输出: Employee (实例属性)
print(Person.category)   # 输出: Human (类属性)

3.方法

3.1实例方法：对象的具体行为

定义：操作实例属性的方法（实例方法就是函数，至少有一个指向实例对象的形参self ）

• 可以访问和修改实例属性
• 可以访问类属性

实例.实例方法名(调用传参)
# 或
类名.实例方法名(实例, 调用传参)

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
    
    # 实例方法
    def deposit(self, amount):
        """存款"""
        self.balance += amount
        return f"存入 ¥{amount}，当前余额: ¥{self.balance}"
    
    def withdraw(self, amount):
        """取款"""
        if amount > self.balance:
            return "余额不足"
        self.balance -= amount
        return f"取出 ¥{amount}，当前余额: ¥{self.balance}"

# 使用
account = BankAccount("Alice", 1000)
print(account.deposit(500))  # 存入 ¥500，当前余额: ¥1500
print(account.withdraw(200)) # 取出 ¥200，当前余额: ¥1300

3.2类方法：类级别的操作

定义：类方法是用于描述类的行为的方法，类方法属于类，不属于该类创建的对象

• 类方法需要使用@classmethod装饰器定义
• 第一个参数必须是 cls（指向类本身）
• 可以访问和修改类属性
• 不能访问实例属性
• 通过类和类的实例都可以调用

应用场景：
1.创建替代构造函数（工厂方法）
2.管理类级别的配置

class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day
    
    @classmethod
    def from_string(cls, date_str):
        """从字符串创建Date对象（类方法作为工厂函数）"""
        year, month, day = map(int, date_str.split('-'))
        # map函数的作用是将右边的参数直接交给左边的函数（int）执行
        return cls(year, month, day)  # 创建并返回新对象

# 使用类方法创建对象
new_year = Date.from_string("2025-01-01")
print(f"{new_year.year}-{new_year.month}-{new_year.day}")  # 2025-1-1

3.3静态方法：独立的功能单元

定义：与类和实例无关的工具函数

• 定义在类内部，作用域也是在类内部
• 使用@staticmethod装饰器定义
• 不需要self和cls参数
• 本质上是一个放在类命名空间里的普通函数
• 通过类或类实例调用
• 可以访问类属性（可以通过类名显式的访问）但不能访问实例属性

使用场景：
实用工具函数
与类相关但不依赖类状态的功能
避免污染全局命名空间

class MathUtils:
    @staticmethod
    def add(a, b):
        """加法"""
        return a + b
    
    @staticmethod
    def factorial(n):
        """计算阶乘"""
        if n == 0:
            return 1
        return n * MathUtils.factorial(n-1)
    
    @staticmethod
    def is_prime(n):
        """检查质数"""
        if n <= 1:
            return False
        for i in range(2, int(n**0.5)+1):
            if n % i == 0:
                return False
        return True

# 使用静态方法
print(MathUtils.add(5, 3))        # 8
print(MathUtils.factorial(5))     # 120
print(MathUtils.is_prime(17))     # True

3.4魔术方法：自定义类的行为

定义：魔术方法是一种特殊的方法，用双下划线包裹，例如__init__，__str__，__add__等。这些方法允许您自定义类的行为，以便与内置Python功能（如+运算符、迭代、字符串表示等）交互。
这里简单列举一下

1. __init__(self, ...): 初始化对象，通常用于设置对象的属性。
2. __str__(self): 定义对象的字符串表示形式，可通过str(object)或print(object)调用。例如，您可以返回一个字符串，描述对象的属性。
3. __repr__(self): 定义对象的“官方”字符串表示形式，通常用于调试。可通过repr(object)调用。
4. __len__(self): 定义对象的长度，可通过len(object)调用。通常在自定义容器类中使用。
5. __getitem__(self, key): 定义对象的索引操作，使对象可被像列表或字典一样索引。例如，object[key]。
6. __setitem__(self, key, value): 定义对象的赋值操作，使对象可像列表或字典一样赋值。例如，object[key] = value。
7. __delitem__(self, key): 定义对象的删除操作，使对象可像列表或字典一样删除元素。例如，del object[key]。
8. __add__(self, other): 定义对象相加的行为，使对象可以使用+运算符相加。例如，object1 + object2。
9. __sub__(self, other): 定义对象相减的行为，使对象可以使用-运算符相减。
10. __eq__(self, other): 定义对象相等性的行为，使对象可以使用==运算符比较。
11. __lt__(self, other): 定义对象小于其他对象的行为，使对象可以使用<运算符比较。
12. __gt__(self, other): 定义对象大于其他对象的行为，使对象可以使用>运算符比较。

class list:
	# 初始化方法，对自动执行
    def __init__(self,value):
        self.name = value
        
    def append(self,value):
        self.name += [value]
        
    def __repr__(self):
        return "list(%s)" % self.name
        
    def __len__(self):
        return len(self.name)
    
    def __getitem__(self,index):
        return self.name[index]
    
    def __delitem__(self, name):
        del self.name[name]
        
    def __setitem__(self, index, value):
        self.name[index] = value
    
l1 = list([1,2,3,52,66,400,100])
print(len(l1))
del l1[2]
print(l1)
l1[2] = 3
print(l1)
l1[3] = 50
print(l1)

#7
#list([1, 2, 52, 66, 400, 100])
#list([1, 2, 3, 66, 400, 100])
#list([1, 2, 3, 50, 400, 100])

这些魔术方法主要还是在对象编程时可以更加方便一些。定义好魔术方法后，就可以简单的打印出更加友好的输出内容。