python---类

类是 Python 面向对象编程（OOP）的核心概念，它允许你创建自定义的数据结构，包含数据（属性）和功能（方法）。

基本语法

类中分为属性和方法。属性可以理解为变量，方法可以理解为函数。

class ClassName:"""类的文档字符串"""# 类属性（所有实例共享）class_attribute = "我是类属性"def __init__(self, param1, param2):"""初始化方法（构造函数）"""self.param1 = param1  # 实例属性self.param2 = param2  # 实例属性def instance_method(self):"""实例方法"""return f"参数1: {self.param1}, 参数2: {self.param2}"

创建对象（实例化对象）

语法：对象名 = 类名()
实例是相互独立的，实例属性也是相互独立的,但是实例中的类属性是所有实例共享的。

class Dog:"""表示狗的类"""# 类属性species = "哺乳动物"def __init__(self, name, age):"""初始化方法"""self.name = name  # 实例属性self.age = age    # 实例属性def bark(self):"""狗叫的方法"""return f"{self.name} 在汪汪叫!"def get_info(self):"""获取狗的信息"""return f"{self.name} 是一只 {self.age} 岁的狗"# 创建对象（实例化）
my_dog = Dog("旺财", 3) 
your_dog = Dog("小白", 2)print(my_dog)   # <__main__.Dog object at 0x012F8B50>
print(your_dog) # <__main__.Dog object at 0x012F8B30># 访问属性
print(my_dog.name)      # 输出: 旺财
print(my_dog.age)       # 输出: 3
print(my_dog.species)   # 输出: 哺乳动物# 调用方法
print(my_dog.bark())    # 输出: 旺财 在汪汪叫!
print(my_dog.get_info()) # 输出: 旺财 是一只 3 岁的狗# 实例是相互独立的，实例属性也是相互独立的,但是实例中的类属性是所有实例共享的
print(id(my_dog) == id(your_dog)) # 输出: Faclass Dog:# 类属性species = "Canis familiaris"  # 所有狗狗共享的物种属性scientific_name = "Canis lupus familiaris"  # 另一个类属性def __init__(self, name, age):# 实例属性self.name = nameself.age = agelse
print(id(my_dog) == id(Dog)) # 输出: False
print(id(my_dog.age) == id(your_dog.age)) # 输出: False
print(id(my_dog.species) == id(Dog.species)) # 输出: TRUE
my_dog.age = 7  # 修改实例属性
print(my_dog.age)   # 输出: 7
print(your_dog.age) # 输出: 2

类属性

类属性是属于类本身的属性，而不是属于类的某个特定实例（对象）。它在内存中只存储一份，被该类的所有实例所共享。
类属性直接在类内部、但在任何方法（如 init）之外进行定义。

class Dog:# 类属性species = "Canis familiaris"  # 所有狗狗共享的物种属性scientific_name = "Canis lupus familiaris"  # 另一个类属性def __init__(self, name, age):# 实例属性self.name = nameself.age = age

在这个例子中：
species 和 scientific_name 是类属性。
name 和 age 是实例属性（使用 self. 定义）。

类属性访问

通过类名访问（推荐且明确的方式）：

print(Dog.species)  # 输出: Canis familiaris
print(Dog.scientific_name)  # 输出: Canis lupus familiaris

通过实例访问：

my_dog = Dog("Buddy", 5)
your_dog = Dog("Miles", 3)print(my_dog.species)  # 输出: Canis familiaris
print(your_dog.species) # 输出: Canis familiaris
# 它们都访问到同一个内存地址的值

类属性修改

要修改类属性，最好通过类名本身来修改。
通过类名修改类属性会影响所有实例，但通过实例修改类属性只会影响该实例。
如果你尝试通过一个实例去给一个类属性赋值，你并不会修改类属性，而是会给这个实例创建一个新的同名实例属性，这个实例属性会“遮蔽”掉类属性。

'''
修改类属性
通过类名修改类属性会影响所有实例，但通过实例修改类属性只会影响该实例
（实际上会创建一个同名的实例属性）
'''
print("============")
print(id(Dog.species) == id(your_dog.species)) # 输出: True
print(id(Dog.species) == id(my_dog.species))    # 输出: True
print(id(your_dog.species) == id(my_dog.species))   # 输出: True
print(id(Dog.scientific_name) == id(your_dog.scientific_name))  # 输出: True
print(id(Dog.scientific_name) == id(my_dog.scientific_name))    # 输出: True
print(id(your_dog.scientific_name) == id(my_dog.scientific_name))   # 输出: True
# 通过类名修改类属性会影响所有实例
Dog.species = "人类伴侣"
print(your_dog.species) # 输出: 人类伴侣
print(my_dog.species)   # 输出: 人类伴侣
print(Dog.species)      # 输出: 人类伴侣    print(id(Dog.species) == id(your_dog.species)) # 输出: True
print(id(Dog.species) == id(my_dog.species))    # 输出: True
print(id(your_dog.species) == id(my_dog.species))   # 输出: True
print(id(Dog.scientific_name) == id(your_dog.scientific_name))  # 输出: True
print(id(Dog.scientific_name) == id(my_dog.scientific_name))    # 输出: True
print(id(your_dog.scientific_name) == id(my_dog.scientific_name))   # 输出: True
# 通过实例修改类属性只会影响该实例
my_dog.species = "人类伴侣1"
print(your_dog.species) # 输出: 人类伴侣
print(my_dog.species)   # 输出: 人类伴侣1
print(Dog.species)      # 输出: 人类伴侣print(id(Dog.species) == id(your_dog.species)) # 输出: True
print(id(Dog.species) == id(my_dog.species))    # 输出: False
print(id(your_dog.species) == id(my_dog.species))   # 输出: False
print(id(Dog.scientific_name) == id(your_dog.scientific_name))  # 输出: True
print(id(Dog.scientific_name) == id(my_dog.scientific_name))    # 输出: True
print(id(your_dog.scientific_name) == id(my_dog.scientific_name))   # 输出: True

类属性常见用途

1、定义常量：例如，数学类中的 PI。

class MathConstants:PI = 3.14159E = 2.71828

2、统计实例数量：在 init 中修改一个类属性计数器。

class Dog:num_of_dogs = 0 # 类属性计数器def __init__(self, name):self.name = nameDog.num_of_dogs += 1 # 通过类名修改类属性print(Dog.num_of_dogs) # 输出: 0
dog1 = Dog("Buddy")
dog2 = Dog("Miles")
print(Dog.num_of_dogs) # 输出: 2

3、提供类的默认值：为所有实例提供一个共同的初始值。

class Employee:raise_percentage = 1.04 # 默认加薪4%def __init__(self, name, salary):self.name = nameself.salary = salarydef apply_raise(self):# 使用 self.raise_percentage 允许实例将来可以有自己的比例self.salary = int(self.salary * self.raise_percentage)

实例属性 (Instance Attributes)

实例属性是绑定到某个特定实例的变量。它们定义了对象的状态或特征。

实例属性的定义和调用

实例属性通常在类的特殊方法 init（构造函数）中定义，使用 self.attribute_name = value 的语法。
实例属性无法通过类名访问。实例属性属于对象不属于累。

class Dog:# 类的构造函数，在创建新实例时自动调用def __init__(self, name, age):# 定义两个实例属性：name 和 age# self 代表当前正在创建的实例本身self.name = name   # 将传入的name参数赋值给实例的name属性self.age = age     # 将传入的age参数赋值给实例的age属性# 创建 Dog 类的两个实例（对象）
my_dog = Dog("Buddy", 5)
your_dog = Dog("Lucy", 3)# 访问实例属性：使用 实例名.属性名
print(my_dog.name)    # 输出: Buddy
print(my_dog.age)     # 输出: 5print(your_dog.name)  # 输出: Lucy
print(your_dog.age)   # 输出: 3

my_dog 和 your_dog 是两个独立的实例，它们的 name 和 age 属性值互不影响。
只为某个实例单独添加属性。
你也可以在类的外部为实例动态添加属性（但这通常不是推荐的做法）：

my_dog.breed = "Golden Retriever" # 动态添加一个breed属性
print(my_dog.breed) # 输出: Golden Retriever
# your_dog 仍然没有 breed 属性

实例方法 (Instance Methods)

实例方法是定义在类中的函数，用于对实例的属性进行操作或执行与实例相关的任务。它们的第一个参数永远是 self，通过 self 可以访问和操作调用该方法的实例的所有属性。

实例方法的定义和调用

class Dog:def __init__(self, name, age):self.name = nameself.age = age# 定义一个实例方法：sitdef sit(self):# 通过self访问当前实例的name属性print(f"{self.name} is now sitting.")# 定义另一个实例方法：roll_overdef roll_over(self):print(f"{self.name} rolled over!")# 实例方法也可以修改实例的属性def have_birthday(self):self.age += 1print(f"Happy Birthday! {self.name} is now {self.age} years old.")def get_self(self):return self# 创建实例
my_dog = Dog("Buddy", 5)# 调用实例方法：使用 实例名.方法名()
# 注意：不需要为 self 参数传递值，Python 会自动将 my_dog 实例传递给它。
my_dog.sit()            # 输出: Buddy is now sitting.
my_dog.roll_over()      # 输出: Buddy rolled over!print(f"Before birthday: {my_dog.age}") # 输出: Before birthday: 5
my_dog.have_birthday()  # 输出: Happy Birthday! Buddy is now 6 years old.
print(f"After birthday: {my_dog.age}")  # 输出: After birthday: 6# 下面两个输出结果一致，说明 my_dog1实例与self是同一个对象
print(my_dog1.get_self())
print(my_dog1)

1、self 是对实例本身的引用。当 my_dog.sit() 被调用时，self 在方法内部自动指向 my_dog。
2、通过 self，方法可以读取 self.name，修改 self.age，或者调用其他方法如 self.other_method()。
3、调用方法时，你只需要提供 self 之后的参数。