Python 方法类对象
面向对象编程的核心基石 · 深度解析 · 实战指南
面向对象编程的核心基石 · 深度解析 · 实战指南
在 Python 的世界里,方法、类与对象构成了面向对象编程(OOP)的三大支柱。它们不是孤立的概念,而是一个层层递进、协同工作的有机整体:
Python 的 OOP 并非强制要求,但却是构建大型、可维护、可扩展系统的核心范式。与 Java 或 C++ 不同,Python 的类机制更轻量、动态,支持多重继承、鸭子类型、元编程等特性,使得其在保持简洁的同时具备极强表达力。
“在 Python 中,万物皆对象——整数、字符串、函数、类本身,甚至类的定义过程,都是对象在运行时动态生成的结果。”
理解 方法、类、对象 的关系,是掌握 Python 高级特性的前提。从 __init__ 初始化到 __str__ 字符串表示,从 self 实例引用到类方法 @classmethod,每一个设计都服务于一个目标:让代码更清晰、更可复用、更易调试。
Python 中的方法分为三类:
self,代表实例自身,用于操作实例属性;@classmethod 装饰器,第一个参数为 cls,代表类本身,常用于工厂模式或类级操作;@staticmethod 装饰器,无 self 或 cls 参数,逻辑上属于类但不依赖类或实例状态,可独立调用。实例方法是使用最广泛的方法类型。其调用依赖于实例,例如:
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def introduce(self): # 实例方法
return f"我是 {self.name},今年 {self.age} 岁。"
p = Person("张三", 28)
print(p.introduce()) # 输出:我是 张三,今年 28 岁。
注意:方法定义中 self 是惯例命名,可改为其他名称,但必须作为第一个参数。Python 解释器会自动将实例传入该参数。
| 类型 | 装饰器 | 首参 | 访问对象 | 典型用途 |
|---|---|---|---|---|
| 实例方法 | 无 | self | 实例属性 | 操作实例状态 |
| 类方法 | @classmethod | cls | 类属性 | 创建替代构造器 |
| 静态方法 | @staticmethod | 无 | 无 | 辅助功能/工具函数 |
以双下划线开头和结尾的方法(如 __init__、__len__)具有特殊语义,由 Python 解释器在特定操作中自动调用。例如:
class Vector:
def __init__(self, x, y):
self.x, self.y = x, y
def __len__(self): # 支持 len() 调用
return 2
def __repr__(self): # 定义对象的字符串表示
return f"Vector({self.x}, {self.y})"
v = Vector(3, 4)
print(len(v)) # 输出:2
print(repr(v)) # 输出:Vector(3, 4)
这些方法让自定义类能完美融入 Python 内置操作体系,是实现“优雅代码”的关键。
类使用 class 关键字定义,其主体可包含类属性、实例方法、类方法、静态方法及嵌套类等:
class Student:
school = "Python大学" # 类属性(所有实例共享)
def __init__(self, name, score): # 构造器
self.name = name # 实例属性
self.score = score
def get_grade(self): # 实例方法
return 'A' if self.score >= 90 else 'B'
类定义后即生成一个类对象,可被实例化多次,每次生成独立的实例对象。
理解两者的区别至关重要:
__init__ 或其他方法中通过 self.xxx 定义,仅属于当前实例。错误示例:
class BadCounter:
count = 0 # 类属性,所有实例共享!
def __init__(self):
BadCounter.count += 1
正确做法(若需独立计数):
class GoodCounter:
def __init__(self):
self.count = 0 # 实例属性,独立计数
Python 的类是动态对象,允许运行时动态添加属性或方法:
class Dog:
pass
def bark(self):
return "汪汪!"
Dog.bark = bark # 动态添加方法
d = Dog()
print(d.bark()) # 输出:汪汪!
但此特性需谨慎使用,易导致代码不可维护。生产环境中推荐在类定义中静态声明所有成员。
对象创建 → 活跃使用 → 引用计数归零 → 垃圾回收(GC):
obj = MyClass()),触发 __new__(分配内存)和 __init__(初始化);可使用 del obj 删除引用,但不保证立即释放内存——GC 在后台运行。
Python 中对象有三重属性:
比较操作:
a is b:比较身份(是否同一对象);a == b:比较值(默认调用 __eq__ 方法)。示例:
a = [1, 2]
b = [1, 2]
c = a
print(a is b) # False(不同对象)
print(a == b) # True(值相同)
print(a is c) # True(同一对象)
对象可分为两类:
陷阱示例:
def append_item(lst=[], item=None):
lst.append(item)
return lst
print(append_item()) # [None]
print(append_item()) # [None, None]!默认参数只初始化一次
正确写法:
def append_item(lst=None, item=None):
if lst is None:
lst = []
lst.append(item)
return lst
Python 支持单继承与多继承:
class Animal:
def speak(self):
return "声音"
class Dog(Animal): # 单继承
def speak(self):
return "汪汪!"
class Flyable:
def fly(self):
return "飞翔"
class Bird(Animal, Flyable): # 多继承
pass
多继承下,方法解析顺序(MRO)由 C3 线性化算法决定,可通过 ClassName.__mro__ 查看:
print(Bird.__mro__) # (, , , )
super() 并非仅用于调用父类方法,而是遵循 MRO 链调用下一个类的方法:
class A:
def __init__(self):
print("A init")
class B(A):
def __init__(self):
super().__init__() # 调用 A.__init__
print("B init")
class C(A):
def __init__(self):
super().__init__() # 调用 A.__init__
print("C init")
class D(B, C):
def __init__(self):
super().__init__() # 调用 B.__init__
print("D init")
D()
# 输出:
# A init
# C init
# B init
# D init
注意:MRO 为 D → B → C → A → object,因此 super() 在 B 中会跳转到 C,而非 A。
⚠️ 避免钻石继承问题:多继承时若各父类共享同一祖先,需确保祖先方法仅被调用一次——super() 正是为此设计。
Python 的多态不依赖继承,而依赖“鸭子类型”——“如果它走起来像鸭子,叫起来像鸭子,那它就是鸭子”:
class Cat:
def speak(self):
return "喵~"
class RobotCat:
def speak(self):
return "电子喵~"
def make_speak(obj):
print(obj.speak())
make_speak(Cat()) # 喵~
make_speak(RobotCat()) # 电子喵~
二者无继承关系,但只要实现 speak() 方法即可统一调用——这是动态类型语言的灵活性体现。
Python 通过 abc 模块支持抽象基类,强制子类实现特定方法:
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
pass
class Circle(Shape):
def __init__(self, r):
self.r = r
def area(self): # 必须实现
return 3.14 * self.r ** 2
# Shape() # TypeError: Can't instantiate abstract class
c = Circle(2)
print(c.area()) # 12.56
抽象基类确保接口契约,是大型项目中实现模块解耦的关键。
| 方法 | 触发场景 | 示例 |
|---|---|---|
__init__ | 实例创建后初始化 | obj = MyClass() |
__str__ | str(obj) 或 print(obj) | 自定义打印内容 |
__repr__ | repr(obj) 或交互式显示 | 调试用精确表示 |
__len__ | len(obj) | 自定义长度逻辑 |
__getitem__ | obj[key] | 支持下标访问 |
__call__ | obj() | 使对象可调用 |
__enter__/__exit__ | with 语句 | 上下文管理 |
class MyDict:
def __init__(self):
self._data = {}
def __setitem__(self, key, value):
self._data[key] = value
def __getitem__(self, key):
return self._data[key]
def __delitem__(self, key):
del self._data[key]
def __len__(self):
return len(self._data)
def __iter__(self):
return iter(self._data)
def __contains__(self, key):
return key in self._data
def __repr__(self):
return f"MyDict({self._data})"
md = MyDict()
md['name'] = 'Alice'
print(md['name']) # Alice
print(len(md)) # 1
print('name' in md) # True
print(md) # MyDict({'name': 'Alice'})
通过实现这些魔术方法,MyDict 几乎具备原生 dict 的全部行为。
装饰器是接受函数并返回新函数的高阶函数:
def log_decorator(func):
def wrapper(*args, **kwargs):
print(f"调用 {func.__name__}")
return func(*args, **kwargs)
return wrapper
@log_decorator
def greet(name):
return f"你好,{name}!"
print(greet("小明"))
输出:
调用 greet 你好,小明!
结合类方法使用:
import functools
def log_method(func):
@functools.wraps(func) # 保留原函数名和文档
def wrapper(self, *args, **kwargs):
print(f"[{self.__class__.__name__}] 调用 {func.__name__}")
return func(self, *args, **kwargs)
return wrapper
class Logger:
@log_method
def info(self, msg):
print(f"INFO: {msg}")
log = Logger()
log.info("系统启动")
输出:
[Logger] 调用 info INFO: 系统启动
多个装饰器按从下到上顺序应用:
@decorator_a
@decorator_b
def func():
pass
等价于 func = decorator_a(decorator_b(func))。顺序影响执行流程,需谨慎安排。
在 Python 中,类也是对象,由元类(metaclass)创建。默认元类是 type:
class MyClass:
pass
print(type(MyClass)) #
print(type(type)) # (type 是自己的元类)
可通过自定义元类控制类的创建过程。
强制所有方法名小写:
class LowercaseMeta(type):
def __new__(cls, name, bases, namespace):
new_ns = {}
for key, value in namespace.items():
if callable(value) and not key.startswith('__'):
new_ns[key.lower()] = value
else:
new_ns[key] = value
return super().__new__(cls, name, bases, new_ns)
class MyClass(metaclass=LowercaseMeta):
def Hello(self):
return "Hello World"
obj = MyClass()
print(obj.hello()) # Hello World
# print(obj.Hello()) # AttributeError
元类是 Python 最高级特性,慎用!除非确实需要控制类的创建逻辑,否则优先使用装饰器或类装饰器。