本文深入讲解 Python 面向对象编程（OOP）的核心概念。涵盖类与对象的基础定义、内存布局、三大特性（封装、继承、多态）。详细解析方法解析顺序（MRO）、描述符机制及其与 property 的关系、属性查找流程。此外，还介绍了元类的原理与应用，以及魔法方法的使用。最后通过 RPG 战斗系统示例综合实践，并给出避免过度设计和合理使用继承的建议。
面向对象编程（Object-Oriented Programming, OOP）不是为了把简单的事情搞复杂，而是为了在大规模协作时，代码不至于变成一团乱麻。
本文将探讨如何从编写步骤转变为设计对象。
class Robot:
def __init__(self, name, version):
# self 就是对象自己，像是每个人的身份证
self.name = name
self.version = version
def say_hello(self):
print(f"你好！我是机器人 {self.name}，版本号：{self.version}")
# 造两个机器人
r1 = Robot("小爱", "v1.0")
r2 = Robot("小度", "v2.0")
r1.say_hello()
r2.say_hello()
self 的作用self 就像是函数里的一个占位符。当你喊 r1.say_hello() 时，Python 自动把 r1 这个实例传给了 self。这样函数才知道该打印"小爱"还是"小度"。
理解内存布局是掌握面向对象的关键。让我们看看 Python 中类和对象是如何在内存中存储的：
class Person:
species = "Homo sapiens" # 类属性（存在类对象中）
def __init__(self, name, age):
self.name = name # 实例属性（存在实例对象中）
self.age = age
def greet(self): # 实例方法
return f"Hello, I'm {self.name}"
# 内存布局分析
p1 = Person("Alice", 25)
p2 = Person("Bob", 30)
# 类属性是所有实例共享的
print(Person.species) # Homo sapiens
print(p1.species) # Homo sapiens（通过实例访问类属性）
print(p2.species) # Homo sapiens
# 修改类属性会影响所有实例
Person.species = "Human"
print(p1.species) # Human
# 但给实例赋值会创建实例属性，不影响其他实例
p1.species = "Modified"
print(p1.species) # Modified（实例属性遮蔽类属性）
print(p2.species) # Human（仍然访问类属性）
print(Person.species) # Human
内存布局要点：
__class__ 引用找到方法你不希望别人随便改你的内部数据。在 Python 里，用双下划线 __ 就能把变量藏起来。
class BankAccount:
def __init__(self, balance):
self.__balance = balance # 私有变量，外面看不到
def deposit(self, amount):
if amount > 0:
self.__balance += amount
print(f"存入成功，当前余额：{self.__balance}")
def get_balance(self):
return self.__balance
account = BankAccount(1000)
# print(account.__balance) # 这行会报错！
print(account.get_balance()) # 只能通过我给你的接口来查
如果你要写"猫"和"狗"，它们都有"吃"和"睡"的功能，那就先写个"动物"类。
class Animal:
def eat(self):
print("正在吃东西...")
class Dog(Animal): # 狗继承了动物
def bark(self):
print("汪汪汪！")
my_dog = Dog()
my_dog.eat() # 继承来的
my_dog.bark() # 自己有的
Python 的多态特别灵活。只要你长得像鸭子，叫起来也像鸭子，那我就把你当鸭子。
当类存在多重继承时，Python 如何决定调用哪个方法？这就是 MRO（Method Resolution Order）要解决的问题。
MRO 定义了 Python 查找方法和属性的顺序。Python 3 使用 C3 线性化算法 来计算 MRO。
class A:
def method(self):
print("A.method")
class B(A):
def method(self):
print("B.method")
class C(A):
def method(self):
print("C.method")
class D(B, C): # 多重继承
pass
# 查看 MRO
print(D.__mro__) # 输出：(<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>)
# 复杂继承示例
class Base:
def greet(self):
print("Base greet")
class Mixin1(Base):
def greet(self):
print("Mixin1 greet")
super().greet()
class Mixin2(Base):
def greet(self):
print("Mixin2 greet")
super().greet()
class Combined(Mixin1, Mixin2):
def greet(self):
print("Combined greet")
super().greet()
# MRO: Combined -> Mixin1 -> Mixin2 -> Base -> object
c = Combined()
c.greet()
# 输出：
# Combined greet
# Mixin1 greet
# Mixin2 greet
# Base greet
super() 不是调用父类，而是按照 MRO 顺序调用下一个类。
class A:
def __init__(self):
print("A.__init__")
super().__init__()
class B(A):
def __init__(self):
print("B.__init__")
super().__init__()
class C(A):
def __init__(self):
print("C.__init__")
super().__init__()
class D(B, C):
def __init__(self):
print("D.__init__")
super().__init__()
d = D()
# 输出顺序：D -> B -> C -> A
# 注意：A 的 super() 调用 object.__init__()，什么都不做
描述符是 Python 中实现属性访问控制的核心机制。理解描述符，你就理解了 @property、@staticmethod、@classmethod 的本质。
描述符协议：实现了 __get__、__set__ 或 __delete__ 方法的类就是描述符。
class Validator:
"""一个描述符，用于验证属性值"""
def __init__(self, min_value, max_value):
self.min_value = min_value
self.max_value = max_value
self.name = None
def __set_name__(self, owner, name):
"""当描述符被赋值给类属性时调用"""
self.name = name
self.storage_name = f"_{name}"
def __get__(self, instance, owner):
"""获取属性值时调用"""
if instance is None:
return self
return getattr(instance, self.storage_name, None)
def __set__(self, instance, value):
"""设置属性值时调用"""
if not isinstance(value, (int, float)):
raise TypeError(f"{self.name} must be a number")
if not self.min_value <= value <= self.max_value:
raise ValueError(f"{self.name} must be between {self.min_value} and {self.max_value}")
setattr(instance, self.storage_name, value)
class Person:
age = Validator(0, 150) # age 是一个描述符实例
salary = Validator(0, 1000000)
def __init__(self, name, age, salary):
self.name = name
self.age = age # 触发描述符的 __set__
self.salary = salary # 同上
p = Person("Alice", 25, 50000)
print(p.age) # 25
# p.age = 200 # ValueError: age must be between 0 and 150
# p.salary = "high" # TypeError: salary must be a number
| 类型 | 实现的方法 | 说明 |
|---|---|---|
| 非数据描述符 | 只有 __get__ | 实例属性优先于描述符 |
| 数据描述符 | 有 __set__ 或 __delete__ | 描述符优先于实例属性 |
class NonDataDescriptor:
"""非数据描述符"""
def __get__(self, instance, owner):
return "from descriptor"
class DataDescriptor:
"""数据描述符"""
def __get__(self, instance, owner):
return "from descriptor"
def __set__(self, instance, value):
print("Setting value")
class TestNonData:
attr = NonDataDescriptor()
class TestData:
attr = DataDescriptor()
# 非数据描述符：实例属性优先
t1 = TestNonData()
t1.attr = "from instance"
print(t1.attr) # from instance
# 数据描述符：描述符优先
t2 = TestData()
t2.attr = "from instance" # 触发 __set__
print(t2.attr) # from descriptor（__get__ 仍然被调用）
@property 其实就是用描述符实现的：
# property 的简化版实现
class Property:
def __init__(self, fget=None, fset=None, fdel=None):
self.fget = fget
self.fset = fset
self.fdel = fdel
def __get__(self, instance, owner):
if instance is None:
return self
if self.fget is None:
raise AttributeError("can't get attribute")
return self.fget(instance)
def __set__(self, instance, value):
if self.fset is None:
raise AttributeError("can't set attribute")
self.fset(instance, value)
def setter(self, fset):
self.fset = fset
return self
# 使用自定义 Property
class Circle:
def __init__(self, radius):
self._radius = radius
@Property
def radius(self):
return self._radius
@radius.setter
def radius(self, value):
if value < 0:
raise ValueError("Radius cannot be negative")
self._radius = value
理解 Python 如何查找属性，是掌握面向对象编程的关键。
对于 obj.attr，Python 按以下顺序查找：
obj.__class__ 中查找 attr，如果是数据描述符，返回描述符的值obj.__dict__ 中查找 attrobj.__class__ 及其父类的 __dict__ 中查找 attrobj.__class__ 及其父类的 __dict__ 中查找 attr__getattr__：如果以上都没找到，调用 __getattr__class Descriptor:
"""数据描述符"""
def __get__(self, instance, owner):
return "descriptor value"
def __set__(self, instance, value):
pass
class MyClass:
attr = Descriptor()
def __init__(self):
self.__dict__['attr'] = "instance value"
def __getattr__(self, name):
return f"{name} not found, using getattr"
obj = MyClass()
print(obj.attr) # descriptor value（数据描述符优先于实例属性）
# 如果描述符没有 __set__
class NonDataDescriptor:
def __get__(self, instance, owner):
return "descriptor value"
class MyClass2:
attr = NonDataDescriptor()
def __init__(self):
self.attr = "instance value"
obj2 = MyClass2()
print(obj2.attr) # instance value（实例属性优先于非数据描述符）
class AttributeTracer:
"""追踪所有属性访问"""
def __init__(self):
self._data = {}
def __getattribute__(self, name):
"""拦截所有属性访问"""
if name.startswith('_'):
return object.__getattribute__(self, name)
print(f"Getting: {name}")
return object.__getattribute__(self, '_data').get(name)
def __setattr__(self, name, value):
"""拦截所有属性设置"""
if name.startswith('_'):
object.__setattr__(self, name, value)
else:
print(f"Setting: {name} = {value}")
object.__getattribute__(self, '_data')[name] = value
def __getattr__(self, name):
"""属性不存在时调用"""
print(f"Attribute {name} not found")
return None
obj = AttributeTracer()
obj.x = 10 # Setting: x = 10
print(obj.x) # Getting: x -> 10
print(obj.y) # Getting: y -> Attribute y not found -> None
元类是"类的类"，它控制类的创建过程。理解元类，你就站在了 Python 面向对象编程的顶端。
在 Python 中，一切皆对象。类也是对象，而创建类的"东西"就是元类。默认情况下，所有类都是由 type 创建的。
class MyClass:
pass
# MyClass 是 type 的实例
print(type(MyClass)) # <class 'type'>
# 等价于 MyClass2 = type('MyClass2', (), {})
MyClass2 = type('MyClass2', (), {})
print(type(MyClass2)) # <class 'type'>
通过继承 type，我们可以控制类的创建过程：
class SingletonMeta(type):
"""单例模式元类"""
_instances = {}
def __call__(cls, *args, **kwargs):
"""控制实例创建"""
if cls not in cls._instances:
cls._instances[cls] = super().__call__(*args, **kwargs)
return cls._instances[cls]
class Database(metaclass=SingletonMeta):
"""使用元类实现单例"""
def __init__(self, connection_string):
self.connection_string = connection_string
print(f"Initializing database with {connection_string}")
db1 = Database("postgresql://localhost/db")
db2 = Database("mysql://localhost/db")
print(db1 is db2) # True（同一个实例）
print(db1.connection_string) # postgresql://localhost/db
__new__ 和 __init__class AutoRegisterMeta(type):
"""自动注册子类的元类"""
registry = {}
def __new__(mcs, name, bases, namespace):
"""创建类对象时调用"""
print(f"Creating class: {name}")
# 可以修改类的属性和方法
namespace['created_by'] = 'AutoRegisterMeta'
cls = super().__new__(mcs, name, bases, namespace)
# 注册类（排除元类本身）
if name != 'BaseModel':
mcs.registry[name] = cls
return cls
def __init__(cls, name, bases, namespace):
"""初始化类对象时调用"""
print(f"Initializing class: {name}")
super().__init__(name, bases, namespace)
class BaseModel(metaclass=AutoRegisterMeta):
"""所有模型的基类"""
pass
class User(BaseModel):
pass
class Product(BaseModel):
pass
print(AutoRegisterMeta.registry) # {'User': <class '__main__.User'>, 'Product': <class '__main__.Product'>}
class ORMMeta(type):
"""简化 ORM 模型定义的元类"""
def __new__(mcs, name, bases, namespace):
# 收集所有字段定义
fields = {}
for key, value in list(namespace.items()):
if isinstance(value, Field):
fields[key] = value
value.name = key
namespace['_fields'] = fields
return super().__new__(mcs, name, bases, namespace)
class Field:
"""字段定义"""
def __init__(self, field_type, nullable=True):
self.field_type = field_type
self.nullable = nullable
self.name = None
def __repr__(self):
return f"Field({self.field_type})"
class Model(metaclass=ORMMeta):
"""ORM 基类"""
def __init__(self, **kwargs):
for name, field in self._fields.items():
value = kwargs.get(name)
if value is None and not field.nullable:
raise ValueError(f"{name} is required")
setattr(self, name, value)
def save(self):
"""模拟保存到数据库"""
data = {name: getattr(self, name) for name in self._fields}
print(f"Saving {self.__class__.__name__}: {data}")
class User(Model):
id = Field(int, nullable=False)
name = Field(str, nullable=False)
email = Field(str)
user = User(id=1, name="Alice", email="[email protected]")
user.save() # Saving User: {'id': 1, 'name': 'Alice', 'email': '[email protected]'}
Python 里有很多双下划线开头结尾的方法（Dunder Methods），它们能让你的对象支持 +, -, len() 等操作。
class Book:
def __init__(self, title, pages):
self.title = title
self.pages = pages
def __str__(self): # 当你 print(book) 时，会调用这个
return f"《{self.title}》- 共{self.pages}页"
def __len__(self): # 当你 len(book) 时，会调用这个
return self.pages
def __eq__(self, other): # 比较两个 Book 对象
if not isinstance(other, Book):
return False
return self.title == other.title and self.pages == other.pages
def __add__(self, other): # 实现 Book + Book
if isinstance(other, Book):
return Book(f"{self.title} + {other.title}", self.pages + other.pages)
return NotImplemented
my_book = Book("Python 从入门到放弃", 999)
print(my_book)
print(f"这本书厚度：{len(my_book)}")
book2 = Book("Python 从入门到放弃", 999)
print(my_book == book2) # True
combined = my_book + book2
print(combined) # 《Python 从入门到放弃 + Python 从入门到放弃》- 共 1998 页
咱们来个硬核的，用 OOP 写个简单的游戏角色对战逻辑。
import random
class Character:
def __init__(self, name, hp, ad):
self.name = name
self.hp = hp
self.ad = ad # 攻击力
def is_alive(self):
return self.hp > 0
def attack(self, target):
damage = self.ad + random.randint(-5, 5)
print(f"【{self.name}】发起攻击，对【{target.name}】造成了 {damage} 点伤害！")
target.receive_damage(damage)
def receive_damage(self, damage):
self.hp -= damage
if self.hp < 0:
self.hp = 0
print(f"【{self.name}】剩余血量：{self.hp}")
class Warrior(Character):
def __init__(self, name):
super().__init__(name, hp=150, ad=20) # 战士血厚
def receive_damage(self, damage):
# 战士有 20% 几率格挡
if random.random() < 0.2:
print(f"【{self.name}】格挡了攻击！")
damage = damage // 2
super().receive_damage(damage)
class Mage(Character):
def __init__(self, name):
super().__init__(name, hp=80, ad=45) # 法师攻高
def attack(self, target):
# 法师有 30% 几率暴击
if random.random() < 0.3:
damage = int(self.ad * 1.5) + random.randint(-5, 5)
print(f"【{self.name}】发动暴击！")
else:
damage = self.ad + random.randint(-5, 5)
print(f"【{self.name}】发起攻击，对【{target.name}】造成了 {damage} 点伤害！")
target.receive_damage(damage)
# 开始战斗
p1 = Warrior("盖伦")
p2 = Mage("拉克丝")
print("--- 战斗开始 ---")
while p1.is_alive() and p2.is_alive():
p1.attack(p2)
if not p2.is_alive():
print(f"\n恭喜【{p1.name}】获得胜利！")
break
p2.attack(p1)
if not p1.is_alive():
print(f"\n恭喜【{p2.name}】获得胜利！")
break
self 别漏写：在类的方法里访问属性，必须带 self.，这是新手最容易犯的低级错误。OOP 是设计出来的，不是写出来的。动动手，感受一下全局视角。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 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