Python函数与OOP实战：默认参数坑、MRO与魔术方法

脚本专家

前言
Python 的函数比 Java 灵活，默认参数、关键字参数、lambda 能替代不少重载和接口写法；面向对象上，多继承、MRO、动态属性又与 Java 差异明显。下面按函数、类、继承与 MRO 的顺序，把原文涉及的语法、代码和易错点整理成可直接在解释器里验证的实践笔记。

一、函数定义、返回值和默认参数陷阱
Python 用 def 定义函数，不强制声明返回类型和参数类型，但支持类型注解。函数是一等公民，可赋值、传参、返回；Java 的方法必须属于类。返回多个值本质是返回元组，调用处可解包。

2. def add(a: int, b: int) -> int:
3.     '''两数相加'''
4.     return a + b
6. result = add(1, 2)
7. print(result)  # 3
9. def divide(a, b):
10.     quotient = a // b
11.     remainder = a % b
12.     return quotient, remainder
14. q, r = divide(10, 3)
15. print(f'商: {q}, 余: {r}')  # 商: 3, 余: 1

复制代码

默认参数最容易踩的坑是使用可变对象。默认参数在函数定义时只创建/求值一次，不是每次调用重新创建：

2. def append_to(item, lst=[]):
3.     lst.append(item)
4.     return lst
6. print(append_to(1))  # [1]
7. print(append_to(2))  # [1, 2]
8. print(append_to(3))  # [1, 2, 3]
10. def append_to_fixed(item, lst=None):
11.     if lst is None:
12.         lst = []
13.     lst.append(item)
14.     return lst

复制代码

正确写法是用 None 作为哨兵，在函数体内再创建列表。

二、位置参数、关键字参数与 *args/**kwargs
默认参数可以替代 Java 中多个重载方法。调用时，位置参数按顺序传，关键字参数按名字传，顺序随意；混合使用时位置参数在前，关键字参数在后。Python 3.8+ 还支持 / 和 * 来强制位置参数、强制关键字参数：

2. def greet(name: str, greeting: str = 'Hello', punctuation: str = '!') -> str:
3.     return f'{greeting}, {name}{punctuation}'
5. print(greet('Alice'))                   # Hello, Alice!
6. print(greet('Bob', 'Hi'))               # Hi, Bob!
7. print(greet('Charlie', 'Hey', '.'))     # Hey, Charlie.
9. def create_user(name, age, city='Unknown'):
10.     print(f'{name}, {age}岁, 来自{city}')
12. create_user('Alice', 25, 'Beijing')
13. create_user('Bob', city='Shanghai', age=30)
14. create_user('Charlie', 28, city='Shenzhen')
16. def func(a, b, /, c, d, *, e, f):
17.     pass

复制代码

/ 前面的 a、b 只能按位置传；中间的 c、d 位置或关键字都行；* 后面的 e、f 必须用关键字传。
*args 接收任意数量位置参数并打包成元组，**kwargs 接收任意数量关键字参数并打包成字典：

2. def print_info(name, *args, **kwargs):
3.     print(f'Name: {name}')
4.     print(f'Args: {args}')
5.     print(f'Kwargs: {kwargs}')
7. print_info('Alice', 25, 'Beijing', hobby='coding', level='senior')
8. # Args: (25, 'Beijing')
9. # Kwargs: {'hobby': 'coding', 'level': 'senior'}

复制代码

常见错误：func(1, a=2) 会报 TypeError: func() got multiple values for argument 'a'，因为 1 已经赋给 a。另一个容易忽略的点是，func(1, 2, 3, b=4) 中 b=4 不会报未知参数，而是进入 **kwargs。

三、Lambda 的适用场景与闭包陷阱
lambda 是匿名函数简写，只能写一个表达式，不能写多行逻辑。它最常见的场景是排序 key，例如按字典字段、字符串长度或多条件排序：

2. double = lambda x: x * 2
3. print(double(5))  # 10
5. students = [
6.     {'name': 'Alice', 'age': 25},
7.     {'name': 'Bob', 'age': 20},
8.     {'name': 'Charlie', 'age': 23}
9. ]
10. students.sort(key=lambda s: s['age'])
11. print(students)
13. words = ['banana', 'pie', 'Washington', 'book']
14. words.sort(key=lambda w: len(w))
15. print(words)  # ['pie', 'book', 'banana', 'Washington']
17. students.sort(key=lambda s: (s['age'], s['name']))

复制代码

选择 lambda 还是 def：排序 key、map/filter 回调适合 lambda；逻辑超过一行、需要复用、需要文档字符串或异常处理时用 def。
闭包陷阱要特别注意。下面代码想得到 f(0)=0、f(1)=1……实际全是 4：

2. funcs = [lambda: i for i in range(5)]
3. print([f() for f in funcs])  # [4, 4, 4, 4, 4]
5. funcs = [lambda i=i: i for i in range(5)]
6. print([f() for f in funcs])  # [0, 1, 2, 3, 4]

复制代码

原因是 lambda 捕获的是变量 i 的引用，不是当时的值；循环结束后 i=4。用默认参数 i=i 绑定当前值即可修复。Java 的 lambda 要求捕获 effectively final 变量，因此不会出现同样问题。

四、类、self、实例属性与类属性
Python 用 class 定义类，__init__ 是构造方法，self 类似 Java 的 this，但必须显式写，实例方法第一个参数必须是 self。创建对象不需要 new。

2. class Student:
3.     school = '清华大学'
5.     def __init__(self, name: str, age: int):
6.         self.name = name
7.         self.age = age
8.         self._score = 0
10.     def introduce(self) -> str:
11.         return f'{self.name}, {self.age}岁, 来自{Student.school}'
13.     def study(self, course: str):
14.         print(f'{self.name}正在学习{course}')
16. stu = Student('Alice', 20)
17. print(stu.introduce())
18. stu.study('Python')

复制代码

类属性由所有实例共享，实例属性每个实例独有。读属性时先找实例再找类；但通过实例赋值不会修改类属性，而是创建同名实例属性，产生遮蔽：

2. class Counter:
3.     count = 0
5.     def __init__(self, name):
6.         self.name = name
7.         Counter.count += 1
9. c1 = Counter('A')
10. c2 = Counter('B')
11. print(Counter.count)  # 2
12. print(c1.count)       # 2
13. print(c2.count)       # 2
15. c1.count = 100
16. print(c1.count)       # 100，实例属性
17. print(c2.count)       # 2，类属性未变
18. print(Counter.count)  # 2，类属性未变

复制代码

忘记写 self 的典型报错是 TypeError: wrong_method() takes 0 positional arguments but 1 was given。因为 Python 自动把实例作为第一个参数传入，但函数没有接收。

五、@staticmethod、@classmethod 与 @property
@staticmethod 不需要 self 或 cls，适合纯工具方法；@classmethod 第一个参数是 cls，可访问类属性，常用于工厂方法，并且在继承时 cls 会变成子类：

2. class MathUtil:
3.     @staticmethod
4.     def add(a: int, b: int) -> int:
5.         return a + b
7.     @staticmethod
8.     def is_even(n: int) -> bool:
9.         return n % 2 == 0
11. print(MathUtil.add(1, 2))     # 3
12. print(MathUtil.is_even(4))    # True
14. class Date:
15.     def __init__(self, year: int, month: int, day: int):
16.         self.year = year
17.         self.month = month
18.         self.day = day
20.     @classmethod
21.     def from_string(cls, date_str: str) -> 'Date':
22.         year, month, day = map(int, date_str.split('-'))
23.         return cls(year, month, day)
25.     def __str__(self):
26.         return f'{self.year}-{self.month:02d}-{self.day:02d}'
28. d1 = Date.from_string('2026-09-18')
29. print(d1)  # 2026-09-18

复制代码

实例方法能访问实例属性和类属性；@classmethod 能访问类属性；@staticmethod 都不能直接访问。Java 的 static 方法大致对应 @staticmethod，@classmethod 在 Java 中没有直接对应。
@property 把方法变成属性访问，适合在赋值时加校验、暴露只读计算属性：

2. class Student:
3.     def __init__(self, name: str, score: int):
4.         self.name = name
5.         self._score = score
7.     @property
8.     def score(self) -> int:
9.         print(' [调用getter]')
10.         return self._score
12.     @score.setter
13.     def score(self, value: int):
14.         if not 0 <= value <= 100:
15.             raise ValueError('分数必须在0-100之间')
16.         self._score = value
18.     @property
19.     def grade(self) -> str:
20.         if self._score >= 90:
21.             return 'A'
22.         elif self._score >= 80:
23.             return 'B'
24.         elif self._score >= 60:
25.             return 'C'
26.         else:
27.             return 'D'
29. stu = Student('Alice', 85)
30. print(stu.score)   # 85
31. stu.score = 92
32. print(stu.grade)   # A

复制代码

只提供 getter 不提供 setter 的属性是只读的，对 stu.grade 赋值会触发 AttributeError。

六、继承、多继承与 MRO
Python 继承用 class Dog(Animal)，子类通过 super().__init__(name) 调用父类构造，方法覆盖与 Java 类似：

2. class Animal:
3.     def __init__(self, name: str):
4.         self.name = name
6.     def speak(self) -> str:
7.         return f'{self.name} makes a sound'
9.     def __str__(self):
10.         return f'Animal({self.name})'
12. class Dog(Animal):
13.     def __init__(self, name: str, breed: str):
14.         super().__init__(name)
15.         self.breed = breed
17.     def speak(self) -> str:
18.         return f'{self.name} barks: Woof!'
20.     def fetch(self, item: str):
21.         return f'{self.name} fetches {item}'
23. dog = Dog('Buddy', 'Golden Retriever')
24. print(dog.speak())      # Buddy barks: Woof!
25. print(dog.fetch('ball'))# Buddy fetches ball
26. print(dog)              # Animal(Buddy)

复制代码

Python 支持多继承，Java 只能单继承和多个接口：

2. class Flyable:
3.     def fly(self):
4.         return f'{self.__class__.__name__} is flying'
6. class Swimmable:
7.     def swim(self):
8.         return f'{self.__class__.__name__} is swimming'
10. class Duck(Flyable, Swimmable):
11.     def quack(self):
12.         return 'Quack! Quack!'
14. duck = Duck()
15. print(duck.fly())
16. print(duck.swim())
17. print(duck.quack())

复制代码

多继承下同名方法的查找顺序由 MRO 决定，Python 使用 C3 线性化算法：

2. class A:
3.     def who(self): return 'A'
4. class B(A):
5.     def who(self): return 'B'
6. class C(A):
7.     def who(self): return 'C'
8. class D(B, C):
9.     pass
11. d = D()
12. print(d.who())      # B
13. print(D.__mro__)    # D, B, C, A, object

复制代码

原文提醒不需要死记 C3 算法细节，关键是理解查找顺序会按 MRO 从左到右、从子类到父类依次解析。私有属性、名称改写与魔术方法在原文目录中列出，但正文提供的代码事实到此为止，本文不额外编造未给出的实现。

结尾实践建议
默认参数不要用可变对象；需要多返回值用元组解包；lambda 仅适合一行表达式；类属性修改建议用类名；通过实例赋值会遮蔽类属性；工厂方法优先用 @classmethod；继承层级复杂时用 __mro__ 确认调用顺序。这些都是原文代码能直接推导出的结论，也是面试和实际脚本开发中最容易出错的地方。