Python快速入门专业版（四十五）：Python类的属性：实例属性、类属性与属性访问控制（封装特性）

原创于 2025-09-25 17:27:36 发布 · 696 阅读

20 ·

CC 4.0 BY-SA版权

文章标签：

#python #开发语言

Python快速入门专业版专栏收录该内容

55 篇文章

订阅专栏

部署运行你感兴趣的模型镜像

在这里插入图片描述

引
一、实例属性：单个对象的“专属特征”
二、类属性：所有对象的“共享特征”
三、属性访问控制：封装特性的实现（私有属性与公有方法）
四、`property`装饰器：将方法伪装成属性（简化访问）
五、综合案例：学生成绩管理（封装与属性控制）
六、常见误区与最佳实践
七、总结

引

在Python面向对象编程中，“属性”是类与对象的核心组成部分，用于描述对象的特征（如学生的姓名、年龄，汽车的品牌、颜色）。根据归属范围，属性可分为实例属性（单个对象独有）和类属性（所有对象共享）；根据访问权限，通过“私有属性+公有方法”的组合可实现属性访问控制，体现面向对象的“封装”特性。

本文将系统讲解实例属性与类属性的定义、区别及使用场景，深入剖析属性访问控制的实现方式（私有属性、公有方法），并介绍property装饰器如何简化属性访问，帮助你掌握类属性的精细化管理。

一、实例属性：单个对象的“专属特征”

实例属性是属于单个对象的属性，每个对象的实例属性独立存储，修改一个对象的实例属性不会影响其他对象。它通常在类的__init__方法中通过self.属性名定义，用于描述对象的个性化特征。

1. 实例属性的定义与使用

实例属性的核心特点：

定义位置：类的__init__方法内，通过self.属性名 = 值绑定到当前对象。
存储方式：每个对象独立存储，占用不同的内存空间。
访问方式：对象名.属性名（仅当前对象可访问）。

代码示例：Student类的实例属性

class Student:
    def __init__(self, name, age):
        # 实例属性：每个学生对象独有的姓名和年龄
        self.name = name  # 姓名（实例属性）
        self.age = age    # 年龄（实例属性）
    
    def show_info(self):
        # 实例方法中通过self访问实例属性
        print(f"姓名：{self.name}，年龄：{self.age}")

# 创建两个Student对象（实例）
stu1 = Student("小明", 18)
stu2 = Student("小红", 19)

# 1. 访问实例属性
print("stu1的初始信息：", end="")
stu1.show_info()  # 输出：姓名：小明，年龄：18
print("stu2的初始信息：", end="")
stu2.show_info()  # 输出：姓名：小红，年龄：19

# 2. 修改stu1的实例属性（仅影响stu1，不影响stu2）
stu1.age = 20  # 修改stu1的年龄为20
print("\n修改后stu1的信息：", end="")
stu1.show_info()  # 输出：姓名：小明，年龄：20
print("修改后stu2的信息：", end="")
stu2.show_info()  # 输出：姓名：小红，年龄：19（无变化）

# 3. 给stu1新增实例属性（仅stu1拥有，stu2无此属性）
stu1.gender = "男"  # 动态新增实例属性
print("\nstu1的性别：", stu1.gender)  # 输出：stu1的性别：男
# print(stu2.gender)  # 报错：'Student' object has no attribute 'gender'（stu2无此属性）

2. 实例属性的关键特性

动态性：可在对象创建后动态新增实例属性（如stu1.gender = "男"），但不推荐（破坏类的结构一致性，建议在__init__中统一定义）。
独立性：每个对象的实例属性互不干扰，修改一个对象的属性不会影响其他对象。
内存占用：每个对象都存储一份实例属性，若对象数量庞大，会占用更多内存（类属性可解决此问题）。

二、类属性：所有对象的“共享特征”

类属性是属于类本身的属性，所有对象共享同一份数据，修改类属性会影响所有对象。它在类体中直接定义（ outside __init__方法），用于描述所有对象的共同特征（如所有学生的学校、所有汽车的类型）。

1. 类属性的定义与使用

类属性的核心特点：

定义位置：类体中，__init__方法外，直接通过“属性名 = 值”定义。
存储方式：仅存储一份，所有对象共享，节省内存。
访问方式：类名.属性名（推荐，清晰区分类属性）或对象名.属性名（不推荐，易混淆实例属性）。

代码示例：Student类的类属性

class Student:
    # 类属性：所有学生共享的学校名称（在__init__外定义）
    school = "北京大学"
    
    def __init__(self, name, age):
        # 实例属性：每个学生独有的姓名和年龄
        self.name = name
        self.age = age
    
    def show_info(self):
        # 实例方法中访问类属性（通过类名或self均可，推荐类名）
        print(f"姓名：{self.name}，年龄：{self.age}，学校：{Student.school}")

# 创建两个Student对象
stu1 = Student("小明", 18)
stu2 = Student("小红", 19)

# 1. 访问类属性（推荐：类名.属性名）
print("初始学校（通过类名访问）：", Student.school)  # 输出：初始学校（通过类名访问）：北京大学
print("stu1的学校（通过对象访问）：", stu1.school)  # 输出：stu1的学校（通过对象访问）：北京大学

# 2. 修改类属性（仅需通过类名修改，所有对象均受影响）
Student.school = "清华大学"  # 修改类属性
print("\n修改后学校（通过类名访问）：", Student.school)  # 输出：修改后学校（通过类名访问）：清华大学
print("stu1的信息：", end="")
stu1.show_info()  # 输出：姓名：小明，年龄：18，学校：清华大学
print("stu2的信息：", end="")
stu2.show_info()  # 输出：姓名：小红，年龄：19，学校：清华大学（均变化）

# 3. 误区：通过对象修改类属性（实际是给对象新增实例属性，而非修改类属性）
stu1.school = "复旦大学"  # 错误：给stu1新增实例属性school，覆盖类属性的访问
print("\nstu1的学校（对象修改后）：", stu1.school)  # 输出：stu1的学校（对象修改后）：复旦大学
print("stu2的学校（不受影响）：", stu2.school)  # 输出：stu2的学校（不受影响）：清华大学
print("类属性（未被修改）：", Student.school)  # 输出：类属性（未被修改）：清华大学

2. 类属性与实例属性的核心区别

为避免混淆，下表清晰对比两者的差异：

对比维度	实例属性（Instance Attribute）	类属性（Class Attribute）
归属对象	单个对象	类本身（所有对象共享）
定义位置	`__init__`方法内，`self.属性名 = 值`	类体中，`__init__`外，`属性名 = 值`
存储方式	每个对象独立存储，多份数据	类统一存储，仅一份数据
访问方式	`对象名.属性名`	`类名.属性名`（推荐）、`对象名.属性名`（不推荐）
修改影响范围	仅影响当前对象	影响所有对象（通过类名修改时）
适用场景	描述对象的个性化特征（如姓名、年龄）	描述所有对象的共同特征（如学校、类型）

3. 类属性的典型应用场景

共享配置：如所有用户的默认权限（User.default_role = "guest"）、所有文件的默认编码（File.default_encoding = "utf-8"）。

计数器：统计类的实例创建数量（如Student.count = 0，__init__中Student.count += 1）。

class Student:
    count = 0  # 类属性：统计实例数量
    
    def __init__(self, name):
        self.name = name
        Student.count += 1  # 每次创建实例，计数器+1

# 测试
stu1 = Student("小明")
stu2 = Student("小红")
print(f"共创建了{Student.count}个Student对象")  # 输出：共创建了2个Student对象

三、属性访问控制：封装特性的实现（私有属性与公有方法）

“封装”是面向对象的三大特性之一，核心思想是“隐藏内部细节，暴露安全接口”——通过将属性设为“私有”（仅类内部可访问），外部需通过“公有方法”（如get_xxx()、set_xxx()）操作属性，同时在方法中添加数据校验，确保数据安全。

1. 私有属性的定义：双下划线`__`前缀

Python中，通过在属性名前加双下划线__ 定义私有属性，这类属性会被Python自动“名称修饰”（Name Mangling），外部无法直接访问（本质是将__属性名改为_类名__属性名，并非真正“私有”，但约定上视为不可外部访问）。

代码示例：Person类的私有属性`__age`

class Person:
    def __init__(self, name, age):
        self.name = name          # 公有属性（外部可直接访问）
        self.__age = age          # 私有属性（外部不可直接访问）
    
    # 公有方法：获取私有属性__age（读接口）
    def get_age(self):
        return self.__age
    
    # 公有方法：修改私有属性__age（写接口，带数据校验）
    def set_age(self, new_age):
        # 数据校验：确保年龄是0-150的整数
        if isinstance(new_age, int) and 0 <= new_age <= 150:
            self.__age = new_age
            print(f"年龄修改成功，新年龄：{self.__age}")
        else:
            print(f"无效年龄：{new_age}，年龄必须是0-150的整数")
    
    def show_info(self):
        # 类内部可直接访问私有属性
        print(f"姓名：{self.name}，年龄：{self.__age}")

# 创建Person对象
person = Person("张三", 25)

# 1. 访问公有属性（正常）
print("姓名（公有属性）：", person.name)  # 输出：姓名（公有属性）：张三

# 2. 直接访问私有属性（报错，外部不可见）
# print("年龄（私有属性）：", person.__age)  # 错误：AttributeError: 'Person' object has no attribute '__age'

# 3. 通过公有方法访问私有属性（正确方式）
print("年龄（通过get_age()）：", person.get_age())  # 输出：年龄（通过get_age()）：25

# 4. 通过公有方法修改私有属性（带校验）
person.set_age(30)  # 输出：年龄修改成功，新年龄：30
person.set_age(200) # 输出：无效年龄：200，年龄必须是0-150的整数（校验生效）

# 5. 类内部访问私有属性（正常）
print("\n个人信息：", end="")
person.show_info()  # 输出：姓名：张三，年龄：30

# （进阶）通过“_类名__属性名”强制访问私有属性（不推荐，破坏封装）
print("\n强制访问私有属性：", person._Person__age)  # 输出：强制访问私有属性：30

2. 封装的核心优势

数据安全：通过set_xxx()方法添加校验逻辑（如年龄范围、字符串非空），避免无效数据进入对象。
接口统一：外部只需调用get_xxx()和set_xxx()，无需关心内部实现，后续修改属性逻辑（如调整校验规则）时，外部代码无需改动。
隐藏细节：将复杂的属性处理逻辑（如密码加密）封装在类内部，外部只需使用接口，降低使用复杂度。

3. 私有属性的命名规范

双下划线__：用于“强私有”属性，触发名称修饰，外部无法直接访问（推荐用于核心属性，如密码、年龄）。

单下划线_：用于“弱私有”属性，仅为约定（不触发名称修饰），提醒开发者“不建议外部直接访问”（如self._gender）。

class Test:
    def __init__(self):
        self._weak_private = "弱私有属性"  # 约定不外部访问，实际可访问
        self.__strong_private = "强私有属性"  # 触发名称修饰，外部不可直接访问

t = Test()
print(t._weak_private)  # 输出：弱私有属性（可访问，但不推荐）
# print(t.__strong_private)  # 报错：AttributeError

四、`property`装饰器：将方法伪装成属性（简化访问）

通过get_xxx()和set_xxx()访问私有属性虽安全，但调用方式（如person.get_age()）略显繁琐。Python的property装饰器可将方法“伪装成属性”，外部可通过“对象名.属性名”直接访问和修改，同时保留数据校验逻辑，兼顾简洁性与安全性。

1. `property`装饰器的基本用法

property装饰器的核心作用：

将一个方法（如get_age()）伪装成“只读属性”，外部通过对象名.属性名访问，无需加括号。
配合@属性名.setter装饰器，可实现“可写属性”，外部通过对象名.属性名 = 值修改，自动触发校验逻辑。

代码示例：用`property`优化Person类

class Person:
    def __init__(self, name, age):
        self.name = name
        self.__age = age  # 私有属性
    
    # 1. 用@property装饰get方法，伪装成“age属性”（只读）
    @property
    def age(self):
        print("触发get_age逻辑...")
        return self.__age
    
    # 2. 用@age.setter装饰set方法，允许修改“age属性”（可写）
    @age.setter
    def age(self, new_age):
        print("触发set_age逻辑...")
        # 数据校验（与之前一致）
        if isinstance(new_age, int) and 0 <= new_age <= 150:
            self.__age = new_age
        else:
            raise ValueError(f"无效年龄：{new_age}，必须是0-150的整数")
    
    def show_info(self):
        print(f"姓名：{self.name}，年龄：{self.__age}")

# 创建Person对象
person = Person("李四", 30)

# 1. 访问age属性（实际调用age()方法，无需加括号）
print("当前年龄：", person.age)  # 输出：触发get_age逻辑... → 当前年龄：30

# 2. 修改age属性（实际调用age.setter方法，无需调用set_age()）
person.age = 35  # 输出：触发set_age逻辑...
print("修改后年龄：", person.age)  # 输出：触发get_age逻辑... → 修改后年龄：35

# 3. 传入无效年龄（触发异常）
try:
    person.age = 200
except ValueError as e:
    print("错误：", e)  # 输出：错误：无效年龄：200，必须是0-150的整数

# 4. 查看最终信息
person.show_info()  # 输出：姓名：李四，年龄：35

2. `property`装饰器的进阶用法：只读属性

若只定义@property装饰的get方法，不定义@属性名.setter方法，则该属性为“只读属性”，外部无法修改，否则抛出AttributeError。

class Book:
    def __init__(self, title, author):
        self.__title = title
        self.__author = author
    
    # 只读属性：仅允许访问，不允许修改
    @property
    def title(self):
        return self.__title

# 测试
book = Book("Python编程", "张三")
print("书名：", book.title)  # 输出：书名：Python编程

# 尝试修改只读属性（报错）
try:
    book.title = "Python高级编程"
except AttributeError as e:
    print("错误：", e)  # 输出：错误：can't set attribute

3. `property`的优势：简洁与安全兼顾

调用简洁：外部代码像访问普通属性一样操作（person.age而非person.get_age()），降低使用成本。
逻辑隐藏：内部的校验、计算逻辑（如年龄范围、密码加密）被隐藏，外部无需感知。
向后兼容：若后续需将普通属性改为带逻辑的属性，用property装饰后，外部代码无需修改调用方式。

五、综合案例：学生成绩管理（封装与属性控制）

结合实例属性、类属性、私有属性和property装饰器，实现一个“学生成绩管理类”，支持成绩录入、修改、查询，且成绩必须在0-100之间。

class StudentScore:
    # 类属性：所有学生的成绩范围（共享配置）
    MIN_SCORE = 0
    MAX_SCORE = 100
    
    def __init__(self, name):
        self.name = name  # 公有属性：姓名
        self.__scores = {}  # 私有属性：存储科目-成绩的字典（如{"数学": 90, "语文": 85}）
    
    # 1. 公有方法：添加科目成绩（带校验）
    def add_score(self, subject, score):
        if self._is_valid_score(score):
            self.__scores[subject] = score
            print(f"添加成功：{subject}={score}")
        else:
            print(f"无效成绩：{score}，{subject}成绩必须在{self.MIN_SCORE}-{self.MAX_SCORE}之间")
    
    # 2. 私有方法：成绩校验（内部使用，不对外暴露）
    def _is_valid_score(self, score):
        return isinstance(score, (int, float)) and self.MIN_SCORE <= score <= self.MAX_SCORE
    
    # 3. property：获取所有成绩（只读）
    @property
    def all_scores(self):
        if not self.__scores:
            return f"{self.name}暂无成绩"
        return {self.name: self.__scores}
    
    # 4. property：获取平均成绩（只读，动态计算）
    @property
    def average_score(self):
        if not self.__scores:
            return f"{self.name}暂无成绩，无法计算平均分"
        total = sum(self.__scores.values())
        return round(total / len(self.__scores), 1)  # 保留1位小数

# 测试学生成绩管理
if __name__ == "__main__":
    # 创建学生对象
    stu = StudentScore("王五")
    
    # 添加成绩
    stu.add_score("数学", 92)
    stu.add_score("语文", 88.5)
    stu.add_score("英语", 105)  # 输出：无效成绩：105，英语成绩必须在0-100之间
    
    # 访问所有成绩
    print("\n所有成绩：", stu.all_scores)  # 输出：所有成绩：{'王五': {'数学': 92, '语文': 88.5}}
    
    # 访问平均成绩
    print("平均成绩：", stu.average_score)  # 输出：平均成绩：90.3