Python 面向对象编程（OOP）将数据和操作封装为对象，适合开发复杂项目。本文详解类与对象定义、属性分类、三种方法类型，深入剖析封装、继承、多态三大特性，并介绍魔术方法与模块化编程。通过实战示例展示私有属性保护、super 调用及自定义运算，帮助读者掌握 OOP 核心思维与工程实践。
Python 是一门纯面向对象的语言，一切皆对象（数字、字符串、列表等本质都是对象）。本文将从零基础视角，系统讲解 Python 面向对象编程的核心概念：类与对象、封装 / 继承 / 多态三大特性，以及魔术方法、模块与包的实用知识，帮你彻底掌握 OOP 编程思维。
面向对象的核心是类和对象，类是对象的'模板'，对象是类的'实例'——就像'汽车'是一个类，而你家的特斯拉、楼下的宝马，都是这个类的具体对象。
类是对一组具有相同属性（特征）和方法（行为）的对象的抽象描述，通过 class 关键字定义，语法如下：
class 类名 (父类):
"""类的文档字符串：说明类的功能"""
# 类的属性：分为类属性和实例属性
类属性 = 初始值
# 构造方法：初始化实例属性
def __init__(self, 参数 1, 参数 2, ...):
self.实例属性 1 = 参数 1
self.实例属性 2 = 参数 2
# 类的方法：第一个参数必须是 self（代表实例本身）
def 方法名 (self, 参数):
方法体
命名规范：类名采用大驼峰命名法（每个单词首字母大写，无下划线），如 Person、Student、Car；属性和方法采用小写字母 + 下划线的命名法，如 user_name、get_info。
对象是类的具体实例，通过类名 () 创建，创建过程也叫实例化；创建后可通过 对象。属性 访问属性，通过 对象。方法 () 调用方法。
# 定义 Person 类
class Person:
"""人类：包含姓名、年龄属性，以及说话、跑步方法"""
# 类属性：所有实例共享的属性
species = "人类"
# 构造方法__init__：创建实例时自动执行，初始化实例属性
def __init__(self, name, age):
# self 代表当前实例，self.name、self.age 为实例属性（每个实例独有）
self.name = name
self.age = age
# 实例方法：第一个参数必须是 self
def speak(self, content):
"""说话方法"""
print(f"{self.name}说：{content}")
def run(self):
"""跑步方法"""
print(f"{self.name}今年{self.age}岁，正在跑步！")
# 实例化：创建 Person 类的两个对象
p1 = Person("张三", 25)
p2 = Person("李四", 30)
# 访问对象的属性：实例属性 + 类属性
print(p1.name) # 实例属性：张三
print(p2.age) # 实例属性：30
print(p1.species) # 类属性：人类
print(Person.species) # 类也可直接访问类属性：人类
# 调用对象的方法
p1.speak("Python 面向对象编程真有趣！") # 张三说：Python 面向对象编程真有趣！
p2.run() # 李四今年 30 岁，正在跑步！
类属性和实例属性是 OOP 的基础概念，核心区别在于作用范围和归属，具体对比如下：
| 类型 | 定义位置 | 归属 | 作用范围 | 访问方式 |
|---|---|---|---|---|
| 类属性 | 类内部、方法外 | 类本身 | 所有实例共享 | 类。属性 / 对象。属性 |
| 实例属性 | init 方法内 | 具体实例 | 仅当前实例独有 | 仅对象。属性 |
注意：若通过 对象。类属性 = 新值 赋值，不会修改类本身的类属性，而是为该对象创建一个同名的实例属性，后续该对象访问此属性时，优先读取自己的实例属性。
# 为 p1 创建同名实例属性 species，覆盖类属性（仅对 p1 生效）
p1.species = "智人"
print(p1.species) # 实例属性：智人
print(p2.species) # 类属性：人类
print(Person.species) # 类属性：人类
类中的方法分为三种，分别适用于不同场景，核心区别在于参数要求和调用方式，均通过 def 定义，配合装饰器区分：
self，代表实例本身；@classmethod 装饰器修饰；cls，代表类本身；@staticmethod 装饰器修饰；class Student:
"""学生类：演示三种方法"""
# 类属性
school = "北京大学"
def __init__(self, name, score):
# 实例属性
self.name = name
self.score = score
# 1. 实例方法
def get_score(self):
return f"{self.name}的成绩是：{self.score}"
# 2. 类方法：修改类属性
@classmethod
def change_school(cls, new_school):
cls.school = new_school
print(f"学校已修改为：{cls.school}")
# 3. 静态方法：独立功能，与类/实例属性无关
@staticmethod
def is_pass(score):
if score >= 60:
return "及格"
else:
return "不及格"
# 实例化
s = Student("王五", 88)
# 实例方法：对象调用
print(s.get_score()) # 王五的成绩是：88
# 类方法：类调用（推荐）/ 对象调用
Student.change_school("清华大学") # s.change_school("复旦大学")
print(Student.school) # 清华大学
# 静态方法：类调用（推荐）/ 对象调用
print(Student.is_pass(59)) # 不及格
print(s.is_pass(s.score)) # 及格
封装、继承、多态是面向对象编程的三大支柱，也是 OOP 思想的核心体现，通过这三个特性，能实现代码的高复用、高扩展、低耦合。
封装的核心思想是：将类的属性和方法隐藏起来，不允许外部直接访问或修改，而是通过类提供的公共方法实现对属性的操作，从而保证数据的安全性和一致性。
简单来说，就是'把内部细节藏起来，只留门让外部访问'——比如手机的内部电路是封装的，外部仅通过屏幕、按键等接口操作。
Python 没有专门的关键字（如 Java 的 private、public）实现封装，而是通过命名规范和属性装饰器实现：
_属性/方法：单下划线，代表受保护的，建议外部不要直接访问，仅允许类和子类访问；__属性/方法：双下划线，代表私有的，Python 会对其进行名称改写，外部无法直接访问，仅允许类内部访问。class Phone:
"""手机类：演示封装"""
def __init__(self, brand, price):
self.brand = brand # 公共属性
self.__price = price # 私有属性：双下划线开头
# 公共方法：对外提供访问私有属性的接口
def get_price(self):
return f"手机价格：{self.__price}元"
# 公共方法：对外提供修改私有属性的接口，可添加校验逻辑
def set_price(self, new_price):
if isinstance(new_price, int) and new_price > 0:
self.__price = new_price
print("价格修改成功")
else:
print("价格格式错误，必须是正整数")
# 私有方法：双下划线开头
def __call_phone(self):
print("正在拨打电话...")
# 公共方法：调用私有方法
def call(self):
self.__call_phone()
# 实例化
p = Phone("华为", 5999)
# 访问公共属性：正常
print(p.brand) # 华为
# 访问私有属性：直接访问报错（名称改写）
# print(p.__price) # 报错：AttributeError
# 名称改写后的实际名称：_类名__属性名
print(p._Phone__price) # 5999（不建议这样访问，破坏封装）
# 通过公共方法访问/修改私有属性
print(p.get_price()) # 手机价格：5999 元
p.set_price(6999) # 价格修改成功
p.set_price(-100) # 价格格式错误，必须是正整数
# 调用私有方法：直接调用报错
# p.__call_phone() # 报错：AttributeError
# 通过公共方法调用私有方法
p.call() # 正在拨打电话...
property 装饰器可以将获取属性的方法伪装成属性，配合 @属性名.setter 装饰器，将修改属性的方法也伪装成属性，使用时无需加括号，更简洁。
class Person:
def __init__(self, name, age):
self.name = name
self.__age = age # 私有年龄属性
# property 装饰器：将 get_age 方法伪装成属性 age
@property
def age(self):
return self.__age
# @age.setter：为伪装后的 age 属性设置修改方法
@age.setter
def age(self, new_age):
if isinstance(new_age, int) and 0 < new_age < 150:
self.__age = new_age
else:
raise ValueError("年龄必须是 0-150 之间的正整数")
# 实例化
p = Person("赵六", 28)
# 访问 age：直接用对象.age，无需加括号
print(p.age) # 28
# 修改 age：直接赋值，无需调用方法
p.age = 30
print(p.age) # 30
# 赋值非法年龄：触发异常
# p.age = 200 # 报错：ValueError: 年龄必须是 0-150 之间的正整数
继承的核心思想是：让一个子类（派生类） 继承另一个父类（基类 / 超类） 的属性和方法，子类可直接使用父类的功能，也可根据需求重写父类方法或添加新的属性 / 方法，从而实现代码的最大化复用。
简单来说，就是'子类站在父类的肩膀上，不用重复造轮子'——比如'学生'和'老师'都是'人'的子类，可继承'人'的姓名、年龄属性和说话方法，再各自添加专属的属性（如学生的成绩、老师的工号）和方法。
# 单继承：子类继承一个父类
class 子类名 (父类名):
# 子类的__init__方法（可选，若不写则继承父类的__init__）
def __init__(self, 父类参数，子类参数):
# 调用父类的__init__方法，初始化父类的属性
super().__init__(父类参数)
# 初始化子类的专属属性
self.子类参数 = 子类参数
# 子类的专属方法（可选）
def 子类方法 (self):
方法体
# 重写父类方法（可选）：子类方法名与父类一致，覆盖父类功能
def 父类方法 (self):
重写后的方法体
# 多继承：子类继承多个父类（Python 支持，慎用）
class 子类名 (父类 1, 父类 2, ...):
类体
关键：子类的构造方法中，需通过 super().__init__() 调用父类的构造方法，否则父类的实例属性无法被初始化。
# 父类：Person 类（已定义，包含 name、age 属性，speak 方法）
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def speak(self):
print(f"{self.name}今年{self.age}岁")
# 子类：Student 类，继承 Person 类
class Student(Person):
def __init__(self, name, age, score):
# 调用父类的__init__方法，初始化 name 和 age
super().__init__(name, age)
# 子类专属属性：成绩
self.score = score
# 子类专属方法：打印成绩
def show_score(self):
print(f"{self.name}的成绩是：{self.score}")
# 重写父类的 speak 方法：覆盖父类功能
def speak(self):
print(f"{self.name}今年{self.age}岁，成绩为{self.score}")
# 子类：Teacher 类，继承 Person 类
class Teacher(Person):
def __init__(self, name, age, job_num):
super().__init__(name, age)
# 子类专属属性：工号
self.job_num = job_num
# 子类专属方法：打印工号
def show_job_num(self):
print(f"{self.name}的工号是：{self.job_num}")
# 实例化子类
s = Student("小明", 18, 95)
t = Teacher("李老师", 35, "T001")
# 子类调用继承的父类属性/方法
print(s.name) # 继承的属性：小明
t.speak() # 继承的方法：李老师今年 35 岁
# 子类调用专属属性/方法
s.show_score() # 小明的成绩是：95
t.show_job_num() # 李老师的工号是：T001
# 子类调用重写后的方法
s.speak() # 重写后：小明今年 18 岁，成绩为 95
super().父类方法 () 实现。class Person:
def eat(self):
print("人在吃饭")
class Student(Person):
def eat(self):
# 先调用父类的 eat 方法
super().eat()
# 再添加子类的专属逻辑
print("学生吃完饭要写作业")
s = Student()
s.eat() # 输出：
# 人在吃饭
# 学生吃完饭要写作业
Python 支持子类同时继承多个父类，语法为 class 子类 (父类 1, 父类 2)，但多继承会带来菱形问题（多个父类继承自同一个基类，子类调用方法时可能出现歧义），实际开发中慎用，优先使用单继承 + 组合的方式。
多态的核心思想是：同一个方法，作用在不同的对象上，会产生不同的执行结果 —— 即'一个接口，多种实现'，多态的实现依赖于继承和方法重写。
多态能让代码更灵活、更易扩展，调用方法时无需关注对象的具体类型，只需保证对象实现了对应的方法即可。
# 父类：Animal 类
class Animal:
def __init__(self, name):
self.name = name
# 父类定义方法，由子类重写
def cry(self):
pass # 空方法，仅作为接口
# 子类 1：Dog 类，重写 cry 方法
class Dog(Animal):
def cry(self):
print(f"{self.name}：汪汪汪！")
# 子类 2：Cat 类，重写 cry 方法
class Cat(Animal):
def cry(self):
print(f"{self.name}：喵喵喵！")
# 子类 3：Duck 类，重写 cry 方法
class Duck(Animal):
def cry(self):
print(f"{self.name}：嘎嘎嘎！")
# 统一的调用函数：接收 Animal 类的任意子类对象
def animal_cry(animal):
animal.cry()
# 实例化不同子类
dog = Dog("大黄")
cat = Cat("小白")
duck = Duck("唐老鸭")
# 调用同一个函数，传入不同对象，产生不同结果（多态）
animal_cry(dog) # 大黄：汪汪汪！
animal_cry(cat) # 小白：喵喵喵！
animal_cry(duck) # 唐老鸭：嘎嘎嘎！
上述示例中，animal_cry 函数是一个统一的接口，无需关注传入的是 Dog、Cat 还是 Duck 对象，只要对象实现了 cry 方法，就能正常执行，这就是多态的魅力。
在 Python 中，以双下划线开头和结尾的方法被称为魔术方法（也叫特殊方法），如 __init__、__str__、__add__ 等。魔术方法无需手动调用，会在特定场景下自动触发，是实现 Python 对象特性的核心。
魔术方法丰富了类的功能，能让我们自定义对象的行为，比如自定义对象的打印格式、实现对象的加法运算等。以下介绍开发中最常用的魔术方法。
<__main__.类名 object at 内存地址>，可重写自定义格式；__str__ 类似，在终端直接输入对象名回车时触发，若未重写 __str__，则 print() 会调用 __repr__。class Person:
def __init__(self, name, age):
self.name = name
self.age = age
# 重写__str__：自定义打印对象的格式
def __str__(self):
return f"Person(name={self.name}, age={self.age})"
p = Person("张三", 25)
print(p) # 自动调用__str__：Person(name=张三，age=25)
用于自定义对象的算术运算，如 __add__（+）、__sub__（-）、__mul__（*）等，让对象可以像数字一样进行运算。
class Point:
"""点类：实现两个点的坐标相加"""
def __init__(self, x, y):
self.x = x
self.y = y
# 重写__add__：定义对象的加法运算
def __add__(self, other):
# other 为另一个 Point 对象
new_x = self.x + other.x
new_y = self.y + other.y
return Point(new_x, new_y)
def __str__(self):
return f"Point({self.x}, {self.y})"
# 两个 Point 对象相加
p1 = Point(1, 2)
p2 = Point(3, 4)
p3 = p1 + p2 # 自动调用__add__方法
print(p3) # Point(4, 6)
若想让自定义类的对象像列表、字典一样支持索引访问（obj[index]）、获取长度（len(obj)），可重写容器相关魔术方法：
obj[index]；len(obj) 时触发，返回对象的长度。class MyList:
"""自定义列表类：模拟列表的索引和长度功能"""
def __init__(self, data):
self.data = data
# 重写__getitem__：索引访问
def __getitem__(self, index):
return self.data[index]
# 重写__len__：获取长度
def __len__(self):
return len(self.data)
ml = MyList([1, 2, 3, 4, 5])
print(ml[2]) # 自动调用__getitem__：3
print(len(ml)) # 自动调用__len__：5
当代码量越来越大时，将所有代码写在一个文件中会导致代码难以维护、复用性差；而模块化编程是将代码按功能拆分为多个文件（模块），再通过包组织多个模块，从而实现代码的高复用、高维护。
模块就是一个以 .py 为后缀的 Python 文件，文件中包含变量、函数、类等代码，其他文件可通过 import 语句导入模块，使用其中的内容。
模块分为三种：
math、random、os，可直接导入使用；numpy、pandas，需先通过 pip install 安装，再导入；.py 文件，作为模块供其他文件调用。导入模块的四种方式：
# 方式 1：导入整个模块，使用时需加「模块名。」
import 模块名
import 模块名 as 别名 # 为模块起别名，简化使用
# 方式 2：从模块中导入指定的函数/类/变量，使用时无需加模块名
from 模块名 import 函数名/类名/变量名
from 模块名 import 函数名 as 别名
# 方式 3：从模块中导入所有内容（不推荐，易命名冲突）
from 模块名 import *
# 方式 4：导入包中的模块
from 包名 import 模块名
from 包名。模块名 import 函数名
mymodule.py：# mymodule.py：自定义模块
name = "Python 面向对象"
def add(a, b):
return a + b
class Person:
def __init__(self, name):
self.name = name
def say(self):
print(f"你好，{self.name}")
main.py，导入并使用 mymodule：# main.py：主文件
# 导入自定义模块
import mymodule as mm
from mymodule import add, Person
# 使用模块中的变量
print(mm.name) # Python 面向对象
# 使用模块中的函数
print(add(3, 5)) # 8
# 使用模块中的类
p = Person("张三")
p.say() # 你好，张三
包是一个包含 __init__.py 文件的文件夹，用于组织多个相关的模块，解决模块命名冲突的问题。简单来说，包就是'模块的文件夹'，而 __init__.py 是包的标识文件（即使为空也必须存在）。
my_package/ # 包名
__init__.py # 包的标识文件
module1.py # 模块 1
module2.py # 模块 2
main.py # 主文件，位于包外
在 main.py 中导入包中的模块：
# 方式 1：导入包中的模块
import my_package.module1 as m1
import my_package.module2 as m2
# 方式 2：从包中导入指定模块
from my_package import module1, module2
# 方式 3：从包的模块中导入指定内容
from my_package.module1 import 函数名/类名
__init__.py 文件不仅是包的标识，还可在其中定义 __all__ 变量，指定 from 包名 import * 时要导入的模块，实现批量导入：
# my_package/__init__.py
__all__ = ["module1", "module2"] # 指定*导入的模块
之后在主文件中可通过 from my_package import * 导入 module1 和 module2。
Python 导入模块时，会按以下顺序搜索模块文件：
PYTHONPATH 指定的目录。可通过 sys.path 查看 Python 的模块搜索路径：
import sys
print(sys.path)
本文系统讲解了 Python 面向对象编程的核心知识，从基础的类与对象，到核心的封装、继承、多态三大特性，再到进阶的魔术方法和模块化编程的模块与包，核心要点总结如下：
self 代表实例本身，cls 代表类本身。super() 调用父类方法，可重写方法实现扩展，实现代码复用；.py 文件，包是含 __init__.py 的文件夹，通过 import 导入，实现代码的模块化和高维护。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online