作 为Python 入门者，你可能已经写过不少函数和脚本，但当代码量越来越大时，会发现重复的逻辑越来越多 —— 比如描述不同学生的信息，每次都要写相似的变量和打印语句；或者处理不同类型的商品，要复制粘贴几乎一样的计算逻辑。
这时候，类与对象就是你的 “救星”。它是 Python 面向对象编程（OOP）的核心，能帮你把代码结构化、复用化，让你的代码像搭积木一样清晰。
本文将用生活化的比喻 + 可运行的代码样例，带你从 0 到 1 掌握类与对象的所有核心知识点，看完就能写出整洁、可维护的 Python 代码。
一、类与对象：用 “蓝图” 和 “实物” 理解核心概念
1.1 什么是类？
类（Class）是一种模板或蓝图，用来描述一类事物的共同特征和行为。比如：
- “学生类”：所有学生都有姓名、年龄、学校这些特征，都有学习、自我介绍这些行为；
- “汽车类”：所有汽车都有品牌、颜色、价格这些特征，都有启动、加速这些行为。
用生活化的比喻：类就像房子的设计图，它规定了房子有几个房间、多大面积、用什么材料，但它本身不是一个可以住的房子。
1.2 什么是对象？
对象（Object）是类的具体实例，是根据蓝图创建出来的 “实物”。比如：
- 根据 “学生类” 创建出 “张三”“李四” 这两个具体的学生对象；
- 根据 “汽车类” 创建出 “特斯拉 Model 3”“比亚迪汉” 这两个具体的汽车对象。
比喻延伸：对象就是按照设计图盖出来的房子，每个房子都符合设计图的要求，但可以有自己的装修风格、家具摆放。
1.3 第一个类与对象代码样例
我们先写一个最简单的 “学生类”，然后创建具体的学生对象：
# 1. 定义类：用class关键字，类名首字母大写（Python约定）
class Student:
# 类属性：所有学生共享的特征（比如学校名称）
school = "北京大学"
# 实例方法：学生的行为（自我介绍）
def introduce(self):
print(f"大家好，我叫{self.name}，今年{self.age}岁，来自{self.school}。")
# 2. 创建对象（实例化）：类名+()
zs = Student()
ls = Student()
# 3. 给对象添加实例属性：每个对象独有的特征
zs.name = "张三"
zs.age = 20
ls.name = "李四"
ls.age = 21
# 4. 调用对象的方法
zs.introduce() # 输出：大家好，我叫张三，今年20岁，来自北京大学。
ls.introduce() # 输出：大家好，我叫李四，今年21岁，来自北京大学。
代码解释：
class Student:：定义一个名为 Student 的类；school = "北京大学"：类属性，所有 Student 对象共享这个值；def introduce(self):：实例方法，self是必须的第一个参数，代表当前对象本身（相当于 Java 里的this）；zs = Student()：创建一个名为 zs 的 Student 对象；zs.name = "张三"：给 zs 对象添加实例属性 name；zs.introduce()：调用 zs 对象的 introduce 方法，会自动把 zs 作为 self 传入。
二、核心知识点拆解：从基础到进阶
2.1 构造函数：创建对象时自动初始化属性
上面的代码中，我们需要手动给每个对象添加 name 和 age 属性，非常麻烦。这时候可以用构造函数__init__，它会在创建对象时自动调用，帮我们初始化属性。
class Student:
school = "北京大学"
# 构造函数：创建对象时自动调用，self是必须的，后面是自定义参数
def __init__(self, name, age):
# 给当前对象绑定实例属性
self.name = name
self.age = age
def introduce(self):
print(f"大家好，我叫{self.name}，今年{self.age}岁，来自{self.school}。")
# 创建对象时直接传入参数，自动初始化属性
zs = Student("张三", 20)
ls = Student("李四", 21)
zs.introduce() # 输出：大家好，我叫张三，今年20岁，来自北京大学。
ls.introduce() # 输出：大家好，我叫李四，今年21岁，来自北京大学。
注意：构造函数的名字是固定的__init__（前后各两个下划线），不能写错；self必须是第一个参数，代表当前对象。
2.2 类属性 vs 实例属性：共享与独有的区别
在类中，属性分为两种：类属性和实例属性，它们的作用范围完全不同。
类属性：所有对象共享
类属性定义在类的内部、方法的外部，所有对象共享同一个值：
class Student:
# 类属性：所有学生共享
school = "北京大学"
def __init__(self, name, age):
self.name = name
self.age = age
zs = Student("张三", 20)
ls = Student("李四", 21)
# 所有对象访问类属性，结果一致
print(zs.school) # 北京大学
print(ls.school) # 北京大学
# 修改类属性，所有对象都会受到影响（除非对象自己覆盖了实例属性）
Student.school = "复旦大学"
print(zs.school) # 复旦大学
print(ls.school) # 复旦大学
实例属性：每个对象独有
实例属性定义在构造函数或实例方法中，每个对象有自己独立的副本：
zs = Student("张三", 20)
ls = Student("李四", 21)
# 修改zs的实例属性，不会影响ls
zs.age = 22
print(zs.age) # 22
print(ls.age) # 21
# 如果对象自己定义了和类属性同名的实例属性，会优先使用实例属性
zs.school = "清华大学"
print(zs.school) # 清华大学（使用实例属性）
print(ls.school) # 复旦大学（使用类属性）
2.3 三种方法：实例方法、类方法、静态方法
类中的方法分为三种，分别对应不同的使用场景：
1. 实例方法：操作对象的属性
最常用的方法，第一个参数必须是self，用来操作当前对象的实例属性：
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
# 实例方法：判断学生是否成年
def is_adult(self):
return self.age >= 18
zs = Student("张三", 20)
print(zs.is_adult()) # True
2. 类方法：操作类的属性
用@classmethod装饰器标记，第一个参数是cls（代表类本身），用来操作类属性：
class Student:
school = "北京大学"
def __init__(self, name, age):
self.name = name
self.age = age
# 类方法：修改所有学生的学校
@classmethod
def change_school(cls, new_school):
cls.school = new_school
Student.change_school("复旦大学")
zs = Student("张三", 20)
print(zs.school) # 复旦大学
3. 静态方法：独立的工具函数
用@staticmethod装饰器标记，不需要self或cls参数，相当于类内部的普通函数，和类或对象的属性无关：
class Student:
# 静态方法：计算两个学生的年龄差
@staticmethod
def calculate_age_diff(student1, student2):
return abs(student1.age - student2.age)
zs = Student("张三", 20)
ls = Student("李四", 21)
print(Student.calculate_age_diff(zs, ls)) # 1
2.4 继承：复用代码的终极武器
继承是面向对象编程的核心特性之一，它允许一个类（子类）继承另一个类（父类）的属性和方法，从而避免重复代码。
比如我们要定义一个 “研究生类”，它和 “学生类” 有很多共同的属性和方法，这时候就可以让研究生类继承学生类：
# 父类：学生类
class Student:
school = "北京大学"
def __init__(self, name, age):
self.name = name
self.age = age
def introduce(self):
print(f"大家好，我叫{self.name}，今年{self.age}岁，来自{self.school}。")
# 子类：研究生类，继承自Student
class GraduateStudent(Student):
# 子类的构造函数，调用父类构造函数初始化共同属性
def __init__(self, name, age, thesis_title):
super().__init__(name, age) # super()代表父类，调用父类的__init__方法
self.thesis_title = thesis_title # 子类独有的属性
# 重写父类的方法：实现自己的逻辑
def introduce(self):
super().introduce() # 先调用父类的自我介绍
print(f"我是研究生，我的论文题目是《{self.thesis_title}》。")
# 创建研究生对象
gs = GraduateStudent("王五", 24, "Python面向对象编程研究")
gs.introduce()
运行结果：
大家好，我叫王五，今年24岁，来自北京大学。
我是研究生，我的论文题目是《Python面向对象编程研究》。
核心知识点：
class GraduateStudent(Student):：GraduateStudent 类继承自 Student 类；super().__init__(name, age)：调用父类的构造函数，复用父类的属性初始化逻辑；- 重写（Override）：子类可以重新定义父类的方法，实现自己的业务逻辑，比如上面的
introduce方法。
2.5 多态：同一个方法，不同对象有不同表现
多态是指同一个方法调用，不同对象会有不同的执行结果。它依赖于继承和方法重写，能让代码更加灵活。
比如我们定义一个 “打印所有学生信息” 的函数，不管是普通学生还是研究生，都能统一处理：
def print_student_info(student):
student.introduce() # 调用对象的introduce方法，具体执行逻辑由对象类型决定
# 创建不同类型的学生对象
zs = Student("张三", 20)
gs = GraduateStudent("王五", 24, "Python面向对象编程研究")
# 统一调用函数，自动适配不同对象
print_student_info(zs)
print_student_info(gs)
运行结果：
大家好，我叫张三，今年20岁，来自北京大学。
大家好，我叫王五，今年24岁，来自北京大学。
我是研究生，我的论文题目是《Python面向对象编程研究》。
这种 “一个接口，多种实现” 的方式，就是多态的核心思想，能大幅提高代码的扩展性 —— 以后如果新增 “博士生类”，只需要继承 Student 类并重写 introduce 方法，print_student_info 函数完全不需要修改。
三、实战案例：用类与对象实现学生管理系统
现在我们把前面的知识点整合起来，实现一个简单的学生管理系统，包含添加学生、显示所有学生信息、计算平均年龄三个功能：
# 父类：学生类
class Student:
school = "北京大学"
def __init__(self, name, age):
self.name = name
self.age = age
def introduce(self):
print(f"姓名：{self.name}，年龄：{self.age}，身份：普通学生，学校：{self.school}")
# 子类：研究生类
class GraduateStudent(Student):
def __init__(self, name, age, thesis_title):
super().__init__(name, age)
self.thesis_title = thesis_title
def introduce(self):
print(f"姓名：{self.name}，年龄：{self.age}，身份：研究生，学校：{self.school}，论文题目：{self.thesis_title}")
# 学生管理类：封装管理逻辑
class StudentManager:
def __init__(self):
self.students = [] # 存储所有学生对象
# 添加学生
def add_student(self, student):
self.students.append(student)
print(f"成功添加学生：{student.name}")
# 显示所有学生信息
def show_all_students(self):
if not self.students:
print("暂无学生信息")
return
print("\n=== 所有学生信息 ===")
for student in self.students:
student.introduce()
# 计算学生平均年龄
def calculate_average_age(self):
if not self.students:
return 0
total_age = sum(student.age for student in self.students)
return round(total_age / len(self.students), 2)
# 测试系统
if __name__ == "__main__":
manager = StudentManager()
# 添加普通学生
zs = Student("张三", 20)
manager.add_student(zs)
# 添加研究生
gs = GraduateStudent("王五", 24, "Python面向对象编程研究")
manager.add_student(gs)
# 显示所有学生信息
manager.show_all_students()
# 计算平均年龄
avg_age = manager.calculate_average_age()
print(f"\n学生平均年龄：{avg_age}岁")
运行结果：
成功添加学生：张三
成功添加学生：王五
=== 所有学生信息 ===
姓名：张三，年龄：20，身份：普通学生，学校：北京大学
姓名：王五，年龄：24，身份：研究生，学校：北京大学，论文题目：Python面向对象编程研究
学生平均年龄：22.0岁
这个案例完美体现了类与对象的优势：
- 封装：学生的属性和行为封装在 Student 类中，管理逻辑封装在 StudentManager 类中，代码结构清晰；
- 继承：GraduateStudent 类复用了 Student 类的属性和方法，避免重复代码；
- 多态：show_all_students 函数只需要调用 introduce 方法，不需要关心对象是普通学生还是研究生；
- 可扩展：以后新增 “博士生类”“留学生类”，只需要继承 Student 类，StudentManager 完全不需要修改。
四、入门者常见误区避坑
误区 1：忘记在实例方法中加 self 参数
如果实例方法没有写 self 参数，调用时会报错：
class Student:
def introduce(): # 错误：没有self参数
print("大家好")
zs = Student()
zs.introduce() # 报错：TypeError: Student.introduce() takes 0 positional arguments but 1 was given
原因：调用实例方法时，Python 会自动把对象作为第一个参数传入，所以方法必须定义 self 参数来接收。
误区 2：混淆类属性和实例属性
如果想修改类属性，直接通过类名修改，不要通过对象修改（除非你想给对象添加实例属性）：
class Student:
school = "北京大学"
zs = Student()
zs.school = "清华大学" # 这是给zs对象添加实例属性，不是修改类属性
print(Student.school) # 北京大学（类属性没变化）
误区 3：构造函数中忘记调用父类构造函数
子类继承父类时，如果自己定义了构造函数，必须调用父类的构造函数，否则父类的属性不会被初始化：
class GraduateStudent(Student):
def __init__(self, name, age, thesis_title):
# 错误：没有调用super().__init__，父类的name和age属性不会被初始化
self.thesis_title = thesis_title
gs = GraduateStudent("王五", 24, "Python研究")
print(gs.name) # 报错：AttributeError: 'GraduateStudent' object has no attribute 'name'
五、总结：类与对象的核心价值
对于 Python 入门者来说，类与对象的核心价值在于：
- 代码复用：通过继承避免重复编写相似逻辑；
- 代码结构化：把相关的属性和方法封装在类中，代码更易读、易维护；
- 扩展性强：新增功能只需要新增类或方法，不需要修改原有代码；
- 逻辑清晰：用 “事物 - 特征 - 行为” 的方式建模，更符合人类的思维习惯。
学习类与对象的步骤建议：
- 先掌握类的定义、对象的创建、构造函数、实例方法这些基础知识点；
- 再学习类属性、类方法、静态方法，理解不同属性和方法的区别；
- 最后深入继承、多态，并通过实战案例巩固知识点。
现在就打开你的 Python 编辑器，把本文的代码敲一遍，你会发现：原来面向对象编程并没有想象中那么难！
3866
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
