Python 面向对象编程（OOP）完全指南：从零到入门的保姆级教程
·
前言
很多 Python 初学者学到面向对象（OOP）阶段都会陷入困惑：
class和object二者到底是什么关联？self参数意义是什么，编写代码时为什么必须固定写上？__init__方法为什么创建实例对象时会自动执行？- 继承、方法重写的实际业务价值在哪里？
不用焦虑。本篇文章结合通俗化讲解、流程拆解、可运行实战代码，从零开始完整拆解 Python 面向对象编程，吃透整套核心逻辑。
一、什么是面向对象？一句话看懂核心逻辑
面向对象（OOP）= 依托现实实物思维编写代码。
| 编程思想 | 核心描述 | 生活化举例 |
|---|---|---|
| 面向过程 | 按固定步骤串行执行任务 | 洗菜→切菜→炒菜→装盘 |
| 面向对象 | 划分不同角色，各自处理自身职责 | 厨师负责炒菜、服务员负责上菜、顾客用餐 |
OOP 核心宗旨：将数据与操作该数据的函数打包封装进同一个对象内部。
二、类（Class）和对象（Object）基础认知
2.1 简易公式牢记二者关系
- 类（Class）：设计图纸、通用模板、标准化方案
- 对象（Object）：依托模板实例化出来的真实个体
2.2 现实场景举例对照
| 类（Class）模板 | 实例化后的具体对象（Object） |
|---|---|
| 汽车生产设计图纸 | 你家里专属的那一辆私家车 |
| 月饼成型模具 | 一个个做好的独立月饼 |
| 学生信息登记模板 | 张三、李四单独的个人档案 |
核心要点：一个类可以实例化生成成千上万个独立对象。
三、编写第一个自定义类
class Dog:
pass # pass占位符，代表当前类内部暂时不编写逻辑
# 根据Dog类创建实例对象
my_dog = Dog()| 代码片段 | 含义解释 |
|---|---|
class Dog: |
定义名称为 Dog 的自定义类 |
pass |
占位关键字，无实际逻辑，保证语法不报错 |
my_dog = Dog() |
调用类完成实例化，生成一个 Dog 类型对象 |
四、__init__ 初始化方法（重中之重）
4.1 __init__ 基础作用
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
# 实例化并传入初始化参数
dog1 = Dog("旺财", 3)
print(dog1.name) # 旺财
print(dog1.age) # 3
__init__ 是 Python 内置特殊方法，也被称作构造方法：
- 创建对象的一瞬间自动触发执行
- 专门用于给对象绑定初始属性数据
4.2 内部完整执行流程拆解
执行 dog1 = Dog("旺财", 3) 时 Python 底层自动执行四步：
┌──────────────────────────────────────┐
│ 1. 在内存开辟空间，创建空对象 dog1 │
│ 2. 自动调用 __init__(dog1, "旺财", 3) │
│ 3. 执行 dog1.name = "旺财" │
│ 4. 执行 dog1.age = 3 │
└──────────────────────────────────────┘最终内存中的 dog1 对象结构：
┌──────────────┐
│ dog1 对象 │
│──────────────│
│ name = "旺财" │
│ age = 3 │
└──────────────┘五、属性：给对象绑定专属数据标签
属性即存储在对象内部的专属数据，不同实例可以拥有不一样的属性值。
class Student:
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
# 实例化两个学生对象
s1 = Student("张三", 20, 85)
print(s1.name) # 张三
print(s1.age) # 20
print(s1.score) # 85内存中两个独立对象存储结构：
s1 对象 s2 对象
┌────────────────┐ ┌────────────────┐
│ name = "张三" │ │ name = "李四" │
│ age = 20 │ │ age = 21 │
│ score = 85 │ │ score = 55 │
└────────────────┘ └────────────────┘六、方法：赋予对象执行动作的能力
6.1 类中方法 = 定义在类内部的函数
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
# 小狗叫唤
def bark(self):
print(f"{self.name}: 汪汪汪！")
# 小狗坐下
def sit(self):
print(f"{self.name}: 坐下了")
# 打印自身信息
def info(self):
print(f"名字: {self.name}, 年龄: {self.age}岁")
dog1 = Dog("旺财", 3)
dog1.bark() # 旺财: 汪汪汪！
dog1.sit() # 旺财: 坐下了
dog1.info() # 名字: 旺财, 年龄: 3岁
6.2 类方法 VS 普通函数对比
| 对比维度 | 普通函数 | 类内部方法 |
|---|---|---|
| 定义位置 | 类外部全局区域 | 类代码块内部 |
| 首个参数 | 无强制要求 | 第一个参数必须为 self |
| 调用方式 | func() |
对象.方法名() |
| 访问对象数据 | 无法直接获取对象属性 | 通过 self 直接访问自身属性 |
七、深度解析 self（高频面试考点）
7.1 一句话理解 self
self = 当前调用该方法时，点号前面的那个实例对象本身。
class Dog:
def __init__(self, name):
self.name = name
def who_am_i(self):
print(f"我是{self.name}，当前对象内存地址：{id(self)}")
dog1 = Dog("旺财")
dog2 = Dog("小白")
dog1.who_am_i() # self 等价于 dog1 对象 → 输出旺财信息
dog2.who_am_i() # self 等价于 dog2 对象 → 输出小白信息
dog1.who_am_i() 等价于底层写法：Dog.who_am_i(dog1)，Python 会自动把调用者传入 self。
7.2 强制使用 self 的核心原因
class Dog:
def __init__(self, name):
self.name = name # 绑定为对象全局属性，对象生命周期内永久保存
# name # 仅局部变量，__init__执行结束立刻销毁
def bark(self):
print(self.name) # ✅ 通过self正常读取对象属性
# print(name) # ❌ 直接访问局部变量，代码直接报错
self 是打通类方法与对象自身属性数据的桥梁。
八、继承：高效复用已有代码
8.1 继承基本概念
子类自动全盘继承父类已有的属性与方法，无需重复编写相同逻辑。
# 父类：通用动物类
class Animal:
def __init__(self, name):
self.name = name
def eat(self):
print(f"{self.name}在吃东西")
def sleep(self):
print(f"{self.name}在睡觉")
# 子类Dog继承Animal
class Dog(Animal):
def bark(self):
print(f"{self.name}: 汪汪汪！")
# 子类Cat继承Animal
class Cat(Animal):
def meow(self):
print(f"{self.name}: 喵喵喵！")
8.2 继承层级结构
┌─────────────┐
│ Animal │ ← 父类
│─────────────│
│ name │
│ eat() │
│ sleep() │
└──────┬──────┘
│ 继承传递
┌────────┴────────┐
▼ ▼
┌──────────┐ ┌──────────┐
│ Dog │ │ Cat │ ← 子类
│──────────│ │──────────│
│ bark() │ │ meow() │
└──────────┘ └──────────┘
- Dog 实例：同时拥有
eat()、sleep()、bark() - Cat 实例：同时拥有
eat()、sleep()、meow()
8.3 继承的核心优势
| 不使用继承 | 使用继承 |
|---|---|
Dog、Cat 各自重复编写 eat()、sleep()，代码大量冗余 |
子类直接继承父类方法，不用重复写代码 |
| 公共逻辑要改时，所有子类挨个修改，麻烦还容易漏改 | 只修改父类代码，全部子类自动同步更新，维护简单 |
九、方法重写：同一行为，差异化实现
9.1 重写定义
子类定义与父类名称完全一致的方法，子类方法会优先覆盖父类同名方法。
class Animal:
def speak(self):
print(f"{self.name}发出声音")
class Dog(Animal):
# 重写父类speak方法
def speak(self):
print(f"{self.name}: 汪汪汪！")
class Cat(Animal):
# 重写父类speak方法
def speak(self):
print(f"{self.name}: 喵喵喵！")9.2 重写前后效果对比
# 未重写：所有动物调用效果完全一致
dog.speak() # 旺财发出声音
cat.speak() # 小花发出声音
# 重写之后：不同动物各自专属叫声
dog.speak() # 旺财: 汪汪汪！
cat.speak() # 小花: 喵喵喵！9.3 重写核心价值：统一接口调用
# 列表存放不同动物实例
animals = [Dog("旺财"), Cat("小花")]
# 统一调用speak，自动执行对应子类的重写方法
for animal in animals:
animal.speak()
# 输出：
# 旺财: 汪汪汪！
# 小花: 喵喵喵！十、综合实战：简易学生成绩管理系统
10.1 完整可运行源码
class Student:
"""学生信息管理类"""
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
def info(self):
"""打印当前学生完整信息"""
print(f"姓名: {self.name}, 年龄: {self.age}, 成绩: {self.score}")
def is_pass(self):
"""判断成绩是否及格（60分及格线）"""
return self.score >= 60
# 实例化三名学生
s1 = Student("张三", 20, 85)
s2 = Student("李四", 21, 55)
s3 = Student("王五", 19, 72)
# 调用类方法测试
s1.info()
print(s1.is_pass())
s2.info()
print(s2.is_pass())
# 统一存放所有学生对象
students = [s1, s2, s3]
# 统计及格总人数
pass_count = sum(1 for s in students if s.is_pass())
print(f"及格总人数: {pass_count}")
# 批量遍历打印全部学生信息
print("=====全部学生信息汇总=====")
for s in students:
s.info()
10.2 程序运行结果
姓名: 张三, 年龄: 20, 成绩: 85
True
姓名: 李四, 年龄: 21, 成绩: 55
False
及格总人数: 2
=====全部学生信息汇总=====
姓名: 张三, 年龄: 20, 成绩: 85
姓名: 李四, 年龄: 21, 成绩: 55
姓名: 王五, 年龄: 19, 成绩: 72
10.3 核心代码拆解解析
pass_count = sum(1 for s in students if s.is_pass())
等价基础循环写法：
count = 0
for s in students:
if s.is_pass():
count += 1
执行逻辑：
- 遍历列表中每一位学生对象
- 调用
is_pass()判断是否及格 - 及格则计数 + 1，最终统计总及格人数
核心知识点速查表
| 核心概念 | 关键字 | 一句话精简总结 |
|---|---|---|
| 定义类 | class |
创建对象的通用模板、设计图纸 |
| 实例对象 | 类名() |
根据模板生成的具体独立实例 |
| 初始化构造 | __init__ |
创建对象时自动执行，初始化属性 |
| self 参数 | self |
代表当前正在调用方法的实例对象自身 |
| 对象属性 | self.xxx |
绑定在对象身上的专属数据 |
| 类方法 | def func(self) |
定义在类内部，对象可调用的动作逻辑 |
| 继承 | class 子类(父类) |
子类复用父类已有属性、方法 |
| 方法重写 | 子类同名方法 | 子类覆盖父类方法，实现个性化逻辑 |
Agent 垂直技术社区，欢迎活跃、内容共建。
更多推荐
15
0- 0
已为社区贡献4条内容
所有评论(0)