python的类

Python 支持类（Class），并且是一种面向对象（OOP）编程语言，类是 Python 中实现面向对象编程的核心载体，用于封装数据（属性）和行为（方法）。下面从类的定义、使用、核心特性等方面展开详细说明：

一、Python 类的基础定义与使用

1. 类的定义：class 关键字

Python 使用 class 关键字定义类，语法格式如下：

# 基本类定义
class 类名:
    # 类属性（所有实例共享）
    类属性名 = 类属性值
    
    # 构造方法：初始化实例属性（self 必须作为第一个参数，指代当前实例）
    def __init__(self, 参数1, 参数2, ...):
        # 实例属性（每个实例独立拥有）
        self.实例属性名1 = 参数1
        self.实例属性名2 = 参数2
    
    # 实例方法（self 必须作为第一个参数）
    def 方法名(self, 参数...):
        方法体
        [return 返回值]

2. 核心概念：类（Class）与实例（Instance）

• 类：是对象的模板，定义了对象的共同属性和方法（如 "人" 类，定义了姓名、年龄等属性，吃饭、走路等方法）。
• 实例：是类的具体对象，由类创建而来，每个实例拥有独立的实例属性（如 "小明""小红" 是 "人" 类的两个实例）。

3. 完整示例：定义并使用类

# 定义一个"学生"类
class Student:
    # 类属性：所有学生共享的学校名称
    school = "第一中学"
    
    # 构造方法：初始化学生的姓名、年龄、成绩
    def __init__(self, name, age, score):
        # 实例属性：每个学生独立拥有
        self.name = name
        self.age = age
        self.score = score
    
    # 实例方法：打印学生信息
    def show_info(self):
        print(f"姓名：{self.name}，年龄：{self.age}，成绩：{self.score}，学校：{self.school}")
    
    # 实例方法：提升成绩
    def improve_score(self, add_score):
        self.score += add_score
        print(f"{self.name}成绩提升{add_score}分，当前成绩：{self.score}")

# 1. 创建类的实例（对象）
student1 = Student("小明", 18, 90)
student2 = Student("小红", 17, 85)

# 2. 访问实例属性
print(student1.name)  # 输出：小明
print(student2.age)   # 输出：17

# 3. 访问类属性（实例和类均可访问）
print(student1.school)  # 输出：第一中学
print(Student.school)   # 输出：第一中学

# 4. 调用实例方法
student1.show_info()  # 输出：姓名：小明，年龄：18，成绩：90，学校：第一中学
student2.improve_score(5)  # 输出：小红成绩提升5分，当前成绩：90

二、Python 类的核心特性（面向对象三大特性）

1. 封装：隐藏内部细节，对外提供接口

封装是将类的属性和方法封装在类内部，外部无法直接访问私有属性 / 方法，只能通过类提供的公共方法操作，保证数据安全性。

• 私有属性 / 方法：以双下划线 __ 开头（如 __private_attr、__private_method），仅能在类内部访问。
• 公共方法：用于操作私有属性，提供对外访问接口。

class Person:
    def __init__(self, name, age):
        self.name = name  # 公共实例属性
        self.__age = age  # 私有实例属性（双下划线开头）
    
    # 公共方法：获取私有属性
    def get_age(self):
        return self.__age
    
    # 公共方法：修改私有属性（可添加校验逻辑）
    def set_age(self, new_age):
        if 0 < new_age < 150:
            self.__age = new_age
        else:
            print("年龄输入无效")
    
    # 私有方法：仅类内部可调用
    def __say_secret(self):
        print(f"{self.name}的秘密：今年{self.__age}岁")
    
    # 公共方法：间接调用私有方法
    def tell_secret(self):
        self.__say_secret()

# 创建实例
p = Person("小李", 25)

# 访问公共属性
print(p.name)  # 输出：小李

# 无法直接访问私有属性（报错）
# print(p.__age)

# 通过公共方法访问/修改私有属性
print(p.get_age())  # 输出：25
p.set_age(30)
print(p.get_age())  # 输出：30
p.set_age(200)  # 输出：年龄输入无效

# 无法直接调用私有方法（报错）
# p.__say_secret()

# 通过公共方法间接调用私有方法
p.tell_secret()  # 输出：小李的秘密：今年30岁

2. 继承：复用父类代码，实现类的扩展

继承允许一个类（子类 / 派生类）继承另一个类（父类 / 基类）的属性和方法，子类可复用父类代码，也可重写父类方法或添加新方法。无显式继承方式，默认 "公有继承"

• 语法：class 子类名(父类名1, 父类名2, ...):（Python 支持多继承）
• 关键字 super()：用于调用父类的方法（如构造方法、实例方法）。

# 父类：动物
class Animal:
    def __init__(self, name):
        self.name = name
    
    def eat(self):
        print(f"{self.name}正在进食")
    
    def sleep(self):
        print(f"{self.name}正在睡觉")

# 子类：狗（继承 Animal 类）
class Dog(Animal):
    # 重写父类构造方法（如需添加子类独有属性）
    def __init__(self, name, breed):
        # 调用父类构造方法
        super().__init__(name)
        # 子类独有属性
        self.breed = breed
    
    # 重写父类方法
    def eat(self):
        print(f"{self.name}（{self.breed}）正在啃骨头")
    
    # 子类新增方法
    def bark(self):
        print(f"{self.name}正在汪汪叫")

# 创建子类实例
dog = Dog("旺财", "金毛")

# 调用继承自父类的方法
dog.sleep()  # 输出：旺财正在睡觉

# 调用重写后的方法
dog.eat()  # 输出：旺财（金毛）正在啃骨头

# 调用子类新增方法
dog.bark()  # 输出：旺财正在汪汪叫

# 访问父类属性和子类属性
print(dog.name, dog.breed)  # 输出：旺财 金毛

3. 多态：同一方法，不同实例有不同表现

多态指子类继承父类后，重写父类方法，使得不同子类的实例调用同一父类方法时，呈现不同的行为，提高代码灵活性。

# 父类：动物
class Animal:
    def __init__(self, name):
        self.name = name
    
    # 父类统一方法
    def make_sound(self):
        print(f"{self.name}发出声音")

# 子类1：猫
class Cat(Animal):
    # 重写 make_sound 方法
    def make_sound(self):
        print(f"{self.name}喵喵叫")

# 子类2：鸟
class Bird(Animal):
    # 重写 make_sound 方法
    def make_sound(self):
        print(f"{self.name}叽叽喳喳叫")

# 统一函数：接收 Animal 类或其子类实例
def animal_sound(animal):
    animal.make_sound()

# 创建不同实例
cat = Cat("咪咪")
bird = Bird("小鸟")
animal = Animal("普通动物")

# 调用同一函数，呈现不同行为（多态）
animal_sound(animal)  # 输出：普通动物发出声音
animal_sound(cat)     # 输出：咪咪喵喵叫
animal_sound(bird)    # 输出：小鸟叽叽喳喳叫

三、Python 类的其他重要特性

1. 类方法与静态方法

除了实例方法，Python 类还支持类方法和静态方法，无需创建实例即可调用。

• 类方法：用 @classmethod 装饰，第一个参数为 cls（指代类本身），可操作类属性。
• 静态方法：用 @staticmethod 装饰，无默认参数，与类和实例无关，仅作为类的工具方法。

class Calculator:
    # 类属性
    version = "1.0"
    
    # 实例方法
    def __init__(self, num):
        self.num = num
    
    # 类方法
    @classmethod
    def show_version(cls):
        print(f"计算器版本：{cls.version}")
    
    # 静态方法
    @staticmethod
    def add(a, b):
        return a + b

# 调用类方法（无需创建实例）
Calculator.show_version()  # 输出：计算器版本：1.0

# 调用静态方法（无需创建实例）
print(Calculator.add(3, 5))  # 输出：8

# 创建实例后也可调用类方法和静态方法
calc = Calculator(10)
calc.show_version()  # 输出：计算器版本：1.0
print(calc.add(2, 4))  # 输出：6

2. 属性装饰器 @property

用于将类的方法伪装成属性，无需加括号即可访问，简化属性访问逻辑，同时可添加属性的读取 / 修改限制。

class Book:
    def __init__(self, title, price):
        self.title = title
        self.__price = price  # 私有价格属性
    
    # 将方法伪装成只读属性
    @property
    def price(self):
        return f"¥{self.__price:.2f}"
    
    # 允许修改 price 属性（需搭配 @price.setter）
    @price.setter
    def price(self, new_price):
        if new_price > 0:
            self.__price = new_price
        else:
            print("价格必须大于0")

# 创建实例
book = Book("Python 编程", 59.9)

# 访问 price（伪装成属性，无需加括号）
print(book.price)  # 输出：¥59.90

# 修改 price（通过 setter 方法）
book.price = 69.9
print(book.price)  # 输出：¥69.90

# 无效修改
book.price = -10  # 输出：价格必须大于0

总结

1. Python 支持类（class 关键字定义），是面向对象编程语言，类是封装属性和方法的模板，实例是类的具体对象。
2. 类的核心要素：构造方法 __init__（初始化实例）、实例属性（独立拥有）、类属性（共享）、实例方法（需 self 参数）。
3. 面向对象三大特性：封装（私有属性 / 方法）、继承（super() 调用父类）、多态（子类重写父类方法）。
4. 扩展特性：类方法（@classmethod）、静态方法（@staticmethod）、@property 装饰器（伪装属性访问）。