Python 面向对象编程（OOP）完全指南：从零到入门的保姆级教程

前言

很多 Python 初学者学到面向对象（OOP）阶段都会陷入困惑：

• class 和 object 二者到底是什么关联？
• self 参数意义是什么，编写代码时为什么必须固定写上？
• __init__ 方法为什么创建实例对象时会自动执行？
• 继承、方法重写的实际业务价值在哪里？

不用焦虑。本篇文章结合通俗化讲解、流程拆解、可运行实战代码，从零开始完整拆解 Python 面向对象编程，吃透整套核心逻辑。

一、什么是面向对象？一句话看懂核心逻辑

面向对象（OOP）= 依托现实实物思维编写代码。

OOP 核心宗旨：将数据与操作该数据的函数打包封装进同一个对象内部。

二、类（Class）和对象（Object）基础认知

2.1 简易公式牢记二者关系

• 类（Class）：设计图纸、通用模板、标准化方案
• 对象（Object）：依托模板实例化出来的真实个体

2.2 现实场景举例对照

核心要点：一个类可以实例化生成成千上万个独立对象。

三、编写第一个自定义类

class Dog:
pass # pass占位符，代表当前类内部暂时不编写逻辑

# 根据Dog类创建实例对象
my_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（高频面试考点）

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 继承的核心优势

九、方法重写：同一行为，差异化实现

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

执行逻辑：

核心知识点速查表