Python类完全指南:从新手到熟练

面向对象编程（OOP）是Python的核心范式之一，而class（类）则是实现OOP的基石。

1. 什么是类（Class）

类可以看作是一个蓝图或模板，它描述了某一类对象所具有的属性（数据）和方法（行为）。而对象则是根据这个蓝图创建出来的具体实例。

举个现实例子：
“汽车设计图”就是类，它规定了汽车应该有轮子、方向盘、能加速、能刹车。
根据设计图造出来的每一辆真实汽车，就是对象。每辆车都有自己的颜色、速度，但都遵循设计图的行为规则。

2. 第一个类：基本定义与实例化

# 定义一个简单的类，类名通常使用大写字母开头的驼峰命名法
classDog:
"""一个简单的狗类"""

# 方法：类中定义的函数称为方法
defbark(self):
"""狗叫 这是行为，也是就是类的方法"""
        print("汪汪～")

# 实例化：通过类名加括号创建对象
my_dog = Dog()
# 调用对象的方法
my_dog.bark()  # 输出：汪汪～

关键点：

• class 关键字 + 类名 + 冒号。
• 类中的所有方法第一个参数必须是 self，它代表实例本身。
• 创建实例：实例名 = 类名()。

3. 构造函数 __init__() 与实例属性

__init__() 方法用于初始化对象的属性。它是 Python 类中最重要、最常用的特殊方法（magic method）。它在一个新对象被创建后、返回给使用者之前自动调用，用于初始化对象的属性，因此通常被称为构造函数（更准确地说，它是初始化方法，真正的构造是 __new__()，但日常开发中我们只需关注 __init__）。

classDog:
"""带名字和年龄的狗类"""

def__init__(self, name, age):
"""构造（初始化）方法：在创建对象时自动执行"""
        self.name = name   # 实例属性
        self.age = age     # 实例属性
        print(f"名字叫{self.name}，年龄｛self.age｝岁的狗狗被创建出来了！")

defsayhi(self):
"""自我介绍的方法"""
        print(f"我是{self.name}，今年{self.age}岁了。")

defbark(self):
        print(f"{self.name}汪汪叫！")

# 创建对象时必须传入 __init__ 要求的参数
dog1 = Dog("旺财", 3)   # 输出：名字叫旺财，年龄3岁的狗狗被创建出来了！
dog1.intro()           # 输出：我是旺财，今年3岁了。
dog1.bark()            # 输出：旺财汪汪叫！

# 每个对象的属性独立
dog2 = Dog("小白", 1)
dog2.intro()           # 输出：名字叫小白，年龄1岁的狗狗被创建出来了。

说明：

• self.name = name 将外部参数保存到实例的属性中，该属性属于当前创建的对象。
• 不同对象之间的同名属性互不影响。

4. 类属性 vs 实例属性

• 实例属性：属于具体类的某个对象，通过 self.属性名 定义。
• 类属性：属于类本身，被所有实例共享，直接定义在类内部、方法外部。

classStudent:
# 类属性：所有学生共有的属性，例如学校名称
    school = "XX市第一中学"

def__init__(self, name, score):
        self.name = name      # 实例属性：每个学生名字不同
        self.score = score    # 实例属性：每个学生分数不同

# 通过类名访问类属性
print(Student.school)   # 输出：XX市第一中学

# 创建实例
s1 = Student("小明", 90)
s2 = Student("小红", 85)

# 实例可以访问类属性（除非实例自己也有同名属性）
print(s1.school)   # 输出：XX市第一中学
print(s2.school)   # 输出：XX市第一中学

# 修改类属性会影响所有实例
Student.school = "实验中学"
print(s1.school)   # 输出：实验中学
print(s2.school)   # 输出：实验中学

# 通过实例修改类属性，会创建一个同名的实例属性，掩盖类属性
s1.school = "外国语学校"# 这不是修改类属性，而是为s1新增实例属性
print(s1.school)         # 输出：外国语学校   --这是实例属性
print(s2.school)         # 输出：实验中学  --这是类属性
print(Student.school)    # 输出：实验中学  --这还是类属性

5. 实例方法、类方法、静态方法

5.1 实例方法

• 第一个参数为 self，可以访问实例属性和其他实例方法。
• 最常用的方法。

5.2 类方法

• 使用装饰器 @classmethod，第一个参数为 cls（代表类本身）。
• 可以访问和修改类属性，但不能访问实例属性。
• 可以通过类名或实例调用。

5.3 静态方法

• 使用装饰器 @staticmethod，没有特殊的第一参数。
• 本质上就是普通函数，但放在类的命名空间中组织代码。
• 不能访问类属性或实例属性（除非通过传参）。

classCalculator:
# 类属性
    pi = 3.14159

def__init__(self, value):
        self.value = value   # 实例属性

# 实例方法：需要 self
defsquare(self):
return self.value ** 2

# 类方法：通过 cls 操作类属性
    @classmethod
defcircle_area(cls, radius):
"""计算圆的面积，使用类属性 pi"""
return cls.pi * radius ** 2

# 静态方法：不需要 self 或 cls，工具函数
    @staticmethod
defis_positive(number):
return number > 0

# 调用实例方法
calc = Calculator(5)
print(calc.square())       # 输出：25

# 调用类方法：可以直接用类名调用
print(Calculator.circle_area(10))   # 输出：314.159

# 调用静态方法
print(Calculator.is_positive(-3))   # 输出：False
print(calc.is_positive(8))          # 也可以实例调用，输出：True

6. 继承（Inheritance）

继承允许我们创建一个新类（子类）从现有类（父类）获得属性和方法，实现代码复用和扩展。

# 父类（基类）
classAnimal:
def__init__(self, name):
        self.name = name

defeat(self):
        print(f"{self.name}吃东西。")

defsleep(self):
        print(f"{self.name}睡觉。")

# 子类1：Dog 继承 Animal
classDog(Animal):
defbark(self):
        print(f"{self.name}汪汪叫！")

# 重写（override）父类方法
defeat(self):
        print(f"{self.name}吃狗粮。")

# 子类2：Cat 继承 Animal
classCat(Animal):
defjiao(self):
        print(f"{self.name}喵喵叫！")

# 使用子类
dog = Dog("旺财")
dog.eat()      # 输出：旺财吃狗粮。--子类重写后的方法
dog.sleep()    # 输出：旺财睡觉。--继承自父类
dog.bark()     # 输出：旺财汪汪叫！

cat = Cat("花花")
cat.eat()      # 输出：花花吃东西。--父类方法
cat.jiao()     # 输出：花花喵喵叫！

6.1 super() 调用父类方法

当子类需要扩展而非完全重写父类方法时，可以先调用父类方法。

classDog(Animal):
def__init__(self, name, kind):
# 调用父类的 __init__ 来初始化 name
        super().__init__(name)
        self.kind = kind # 子类新增属性

defeat(self):
        super().eat() # 先执行父类的 eat 行为
        print(f"{self.name}啃了个骨头。")

dog = Dog("旺财", "金毛")
dog.eat()
# 输出：
# 旺财吃东西。    --来自父类 eat
# 旺财啃了个骨头。 ---来自子类扩展
print(dog.kind) # 输出：金毛

7. 多态（Polymorphism）

多态指同一个方法在不同类中表现不同行为。Python是动态类型语言，天然支持多态，只要对象拥有所需的方法，就可以调用，不关心对象的类型。

classDog:
defspeak(self):
return"汪汪"

classCat:
defspeak(self):
return"喵喵"

classDuck:
defspeak(self):
return"嘎嘎"

# 多态函数：接收任何有 speak 方法的对象
defanimal_sound(animal):
    print(animal.speak())

# 不同对象传入，表现出不同行为
animal_sound(Dog())    # 输出：汪汪
animal_sound(Cat())    # 输出：喵喵
animal_sound(Duck())   # 输出：嘎嘎

8. 封装与访问控制

Python没有严格的私有访问修饰符，但通过命名约定和名称修饰实现一定程度的封装。

8.1 单下划线 _：约定受保护的属性

• 表示“内部使用，请不要直接访问”，但不强制阻止。只是约定，规范使用你应该这么去做。

8.2 双下划线 __：名称修饰

• 属性名变为 _类名__属性名，避免子类意外覆盖，但依然可以访问（不推荐）。

classBankAccount:
def__init__(self, owner, balance):
        self.owner = owner          # 公有属性
        self._password = "123456"# 受保护（约定）
        self.__balance = balance    # 私有（名称修饰）

defdeposit(self, amount):
if amount > 0:
            self.__balance += amount
            print(f"存入{amount}，当前余额：{self.__balance}")

defget_balance(self):
"""通过公开方法访问私有属性"""
return self.__balance

acc = BankAccount("张三", 1000)
print(acc.owner)          # 输出：张三
print(acc._password)      # 输出：123456（可以访问，但不推荐）
# print(acc.__balance)    # 报错：AttributeError
print(acc.get_balance())  # 输出：1000（推荐方式）

# 访问私有属性的方法（仅了解，不建议这么做）
print(acc._BankAccount__balance)  # 输出：1000

9. 属性装饰器 @property

@property 让你可以把方法当作属性来访问，同时可以在获取或设置时加入逻辑（如校验），实现更优雅的封装。

classTemperature:
def__init__(self, celsius):
        self._celsius = celsius

    @property
defcelsius(self):
"""获取摄氏温度，相当于getter方法"""
return self._celsius

    @celsius.setter
defcelsius(self, value):
"""设置摄氏温度，带校验  就是setter方法"""
if value < -273.15:
raise ValueError("温度不能低于绝对零度！")
        self._celsius = value

    @property
deffahrenheit(self):
"""只读属性：根据摄氏温度计算华氏温度"""
return self._celsius * 9/5 + 32

temp = Temperature(25)
print(temp.celsius)      # 输出：25（像属性一样访问，不需要括号）
print(temp.fahrenheit)   # 输出：77.0

temp.celsius = 30# 调用 setter
print(temp.celsius)      # 输出：30

# temp.celsius = -300    # 抛出 ValueError

10. 常用特殊方法（Magic Methods）

特殊方法前后都有双下划线，用于定义类的特定行为，例如字符串表示、长度、迭代等。

classBook:
def__init__(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages

def__str__(self):
"""用户友好显示"""
returnf"《{self.title}》 作者：{self.author}"

def__repr__(self):
"""开发时精确表示，尽量包含足够信息"""
returnf"Book('{self.title}', '{self.author}', {self.pages})"

def__len__(self):
return self.pages

def__add__(self, other):
"""定义两本书总页数"""
if isinstance(other, Book):
return self.pages + other.pages
returnNotImplemented

book1 = Book("Python入门", "小明", 300)
book2 = Book("进阶指南", "小红", 250)

print(book1)           # 输出：《Python入门》 作者：小明（调用 __str__）
print(repr(book1))     # 输出：Book('Python入门', '小明', 300)
print(len(book1))      # 输出：300
print(book1 + book2)   # 输出：550

11. 类的最佳实践与注意事项

1. 类名使用驼峰命名法（如 MyClass），方法名和属性名使用小写加下划线（如 my_method）。
2. 避免在类属性中存放可变对象（如列表、字典），除非你明确需要被所有实例共享。否则修改它会影响所有实例。

   classWrong:
       items = []   # 所有实例共享同一个列表！
   
   a = Wrong()
   b = Wrong()
   a.items.append(1)
   print(b.items)   # 输出：[1] —— 影响了b！
   

   正确的做法：在 __init__ 中初始化可变对象。
3. 合理使用继承，不要为了复用而滥用深层继承，优先考虑组合。
4. 善用 @property 代替直接暴露属性，以便后续增加校验或计算。
5. 文档字符串：在类和方法下添加三引号字符串，说明用途。

classCar:
"""表示一辆汽车的类"""
def__init__(self, brand, speed):
        self.brand = brand
        self.speed = speed

defadd_speed(self):
"""加速：速度增加10"""
        self.speed += 10

结语

• 类的基本定义与实例化
• 构造方法与属性（实例属性 vs 类属性）
• 实例方法、类方法、静态方法
• 继承与 super()
• 多态
• 封装与属性修饰
• @property 优雅封装
• 常用特殊方法
• 类的注意事项