Python系列进阶教程（一）Python 面向对象

前言

面向对象是Python的核心编程范式，也是大型项目开发的基础，掌握它能让你从"编写零散代码"过渡到"构建结构化、可复用的代码"。本节课将从面向过程与面向对象的核心差异入手，逐步讲解类与对象的基础概念、属性与方法的定义使用，最终通过实战案例巩固核心知识点。

一、面向过程 vs 面向对象核心区别与适用场景

编程的核心是解决问题，两种范式的核心差异在于"思考问题的角度"：

• 面向过程：以"步骤"为核心，把解决问题的过程拆分成若干个函数/步骤，按顺序执行。适合简单、线性的任务（如计算圆的面积、批量处理文本）。
• 面向对象：以"对象"为核心，把问题中的实体抽象成"对象"，对象包含"属性（特征）"和"方法（行为）"，通过对象之间的交互解决问题。适合复杂、可扩展、需要复用的场景（如学生管理系统、电商平台）。

示例对比（计算矩形面积）：

# 面向过程实现
def calculate_rect_area(width, height):
    return width * height

# 调用：按步骤传参计算
area = calculate_rect_area(5, 3)
print("矩形面积：", area)

# 面向对象思路（预览）：把矩形抽象成对象，包含宽、高属性和计算面积的方法
# 后续会完整实现

二、类的基础概念与命名规范

• 类（class）：是对一类具有相同特征和行为的实体的抽象描述，相当于"模板"。比如"学生类"是对所有学生的特征（姓名、年龄）和行为（学习、考试）的抽象。
• 命名规范 ：Python中类名遵循"大驼峰命名法"（每个单词首字母大写，无下划线），如Student、Rectangle（区别于函数的小写+下划线命名）。

三、类的定义与对象的实例化

1. 类的定义语法

# 定义类的基本语法
class 类名:
    # 类的内容（属性、方法）
    pass

2. 对象实例化

对象（instance）是类的具体实例，相当于"模板造出来的具体物品"。实例化就是通过类创建对象的过程。

# 定义矩形类（空类，先占位）
class Rectangle:
    pass

# 实例化：创建具体的矩形对象
rect1 = Rectangle()  # rect1是Rectangle类的一个实例（对象）
rect2 = Rectangle()  # rect2是另一个独立的实例

# 验证对象类型
print(type(rect1))  # 输出：<class '__main__.Rectangle'>
print(isinstance(rect1, Rectangle))  # 输出：True（判断是否是指定类的实例）

四、实例属性：定义、赋值与访问

实例属性是对象的"特征"，每个实例的属性可以不同（如rect1宽5，rect2宽8）。

1. 直接赋值方式（入门级）

class Rectangle:
    pass

# 给实例添加属性
rect1 = Rectangle()
rect1.width = 5   # 宽属性
rect1.height = 3  # 高属性

rect2 = Rectangle()
rect2.width = 8
rect2.height = 4

# 访问属性
print(rect1.width)  # 输出：5
print(rect2.height)  # 输出：4
# 计算面积
print(rect1.width * rect1.height)  # 输出：15

2. 问题说明

直接赋值的方式不够规范，无法保证每个实例都有必要的属性（比如漏加width），因此需要用构造方法统一初始化。

五、构造方法 __init__：初始化实例属性

__init__ 是Python的内置构造方法，创建对象时会自动调用，用于统一初始化实例属性，确保每个对象都有完整的特征。

1. 基本语法

class 类名:
    def __init__(self, 参数1, 参数2, ...):
        # 初始化属性：self.属性名 = 参数
        self.参数1 = 参数1
        self.参数2 = 参数2

2. 矩形类改造（用__init__初始化）

class Rectangle:
    # 构造方法：创建对象时自动调用，width和height是必传参数
    def __init__(self, width, height):
        self.width = width  # 实例属性：宽
        self.height = height  # 实例属性：高

# 实例化时必须传width和height，否则报错
rect1 = Rectangle(5, 3)
rect2 = Rectangle(8, 4)

# 访问属性（结果和之前一致）
print(rect1.width * rect1.height)  # 15
print(rect2.width * rect2.height)  # 32

六、self关键字的含义与使用规则

self 是实例方法的第一个参数，核心作用是指代当前实例对象：

1. self 由Python自动传递，调用方法时无需手动传参；
2. 在类内部，通过self.属性名访问实例属性，通过self.方法名()调用实例方法；
3. self 不是关键字，可替换为其他名称（如this），但行业通用self，不建议修改。

示例验证self：

class Rectangle:
    def __init__(self, width, height):
        # self指代当前创建的实例
        print("self对应的对象：", self)
        self.width = width
        self.height = height

# 实例化时，self就是rect1
rect1 = Rectangle(5, 3)
print("rect1对象：", rect1)  # 输出和上面的self地址一致

# 实例化时，self就是rect2
rect2 = Rectangle(8, 4)
print("rect2对象：", rect2)  # 输出和上面的self地址一致

七、实例方法：定义、调用

实例方法是对象的"行为"，必须定义在类内部，第一个参数为self。

1. 定义与调用语法

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    # 定义实例方法：计算面积
    def get_area(self):
        # 方法内部通过self访问实例属性
        return self.width * self.height

# 实例化
rect1 = Rectangle(5, 3)

# 调用实例方法：两种方式
# 方式1（推荐）：实例调用，自动传self
area1 = rect1.get_area()
# 方式2：类调用，手动传实例（self）
area2 = Rectangle.get_area(rect1)

print(area1)  # 15
print(area2)  # 15

八、面向对象封装的基础概念

封装是面向对象的核心特性之一，基础含义是"将属性和方法封装在类的内部，外部通过指定方式访问"，目的是保证数据安全。

• 入门阶段的封装：把相关的属性和方法整合到类中，统一通过实例访问，而非零散的变量/函数；
• 比如矩形类中，把width、height（属性）和get_area（方法）封装在一起，外部只需创建实例、调用方法，无需关心内部计算逻辑。

九、简单类封装实战

1. 学生类实战

需求：定义学生类，包含姓名、年龄、成绩属性，实现"展示信息"和"计算总分"方法。

class Student:
    def __init__(self, name, age, scores):
        # 封装属性：姓名、年龄、成绩（列表）
        self.name = name
        self.age = age
        self.scores = scores  # 如[85, 90, 95]

    # 封装方法：展示学生信息
    def show_info(self):
        print(f"姓名：{self.name}，年龄：{self.age}")

    # 封装方法：计算总分
    def calculate_total(self):
        return sum(self.scores)

# 实例化并调用方法
stu1 = Student("张三", 18, [85, 90, 95])
stu1.show_info()  # 输出：姓名：张三，年龄：18
print("总分：", stu1.calculate_total())  # 输出：总分：270

2. 矩形类扩展（补充周长方法）

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def get_area(self):
        return self.width * self.height

    # 新增：计算周长
    def get_perimeter(self):
        return 2 * (self.width + self.height)

rect = Rectangle(5, 3)
print("面积：", rect.get_area())  # 15
print("周长：", rect.get_perimeter())  # 16

十、面向对象基础常见错误与避坑

1. 忘记self参数 ：定义实例方法时省略self，调用时会报错TypeError

   class Rectangle:
       def get_area():  # 错误：缺少self
           return self.width * self.height
   rect = Rectangle(5, 3)
   rect.get_area()  # 报错：get_area() takes 0 positional arguments but 1 was given

2. 实例化时漏传构造方法参数 ：__init__ 定义了参数但实例化时不传，报错TypeError

   rect = Rectangle()  # 报错：__init__() missing 2 required positional arguments: 'width' and 'height'

3. 类内部访问属性时省略self ：直接写属性名，会被识别为局部变量，报错NameError

   class Rectangle:
       def __init__(self, width, height):
           self.width = width
           self.height = height
       def get_area(self):
           return width * height  # 错误：缺少self

总结

1. 面向对象以"对象"为核心，通过类封装属性（特征）和方法（行为），区别于面向过程的"步骤化"编程；
2. 类是模板，对象是类的具体实例，__init__ 构造方法用于统一初始化实例属性，self指代当前实例；
3. 实例方法必须以self为第一个参数，内部通过self访问属性/方法，外部通过实例调用方法（无需传self）；
4. 封装的基础是将属性和方法整合到类中，保证代码的结构化和可复用性。