函数 · 让代码长成模块

第16章 参数进阶

默认/关键字/lambda

第 16 章 参数进阶:默认参数、关键字参数、lambda

📖 本章目标:掌握默认参数、关键字参数、*args/**kwargs 和 lambda。
学完本章,你的函数会变得更灵活——能自动补默认值、能接任意多的参数、还能"一行定义小函数"。
上一章的函数是"标准款",这一章给函数装"扩展包"。装完这几个,你写的函数基本就到顶配了。


【开场小剧场】越来越讲究的投料

学生: 皮皮,咖啡机要是你不投糖,它也能给杯"默认无糖"的,行不行?

皮皮: 行啊,那就是默认参数——你不说,我就用默认的。

学生: 那要是我一次性想投"十包豆子"呢?

皮皮: 那就是 *args,接多少都行,来者不拒。

学生: 要不……再来个不用起名字的小函数?

皮皮: (叹气)你今天是来进货的吧?lambda 就是你要的那个。行,一次教完。

学生: 那要是我想"点名"投料,不按顺序来呢?

皮皮: 那也是关键字参数的活儿。行,今天你把参数界的花活全学一遍。


16.1 默认参数:不投料就用默认值

定义参数时给它一个默认值,调用时不传就自动用默认:

def greet(name, greeting="你好"):
    print(f"{greeting}, {name}!")

greet("皮皮")              # 你好, 皮皮!(用默认问候语)
greet("小美", "早上好")     # 早上好, 小美!(自定义问候语)

运行结果:

你好, 皮皮!
早上好, 小美!

逐行拆解:
- def greet(name, greeting="你好"):greeting 有一个默认值 "你好";
- greet("皮皮"):只传了 name,没传 greeting,于是用默认的;
- greet("小美", "早上好"):传了 greeting,覆盖默认值。

语法格式:

def 函数名(非默认参数, 默认参数=默认值):
    ...

注意顺序: 默认参数必须放在非默认参数后面。def f(a, b=1) 对,def f(a=1, b) 报错——因为 Python 分不清你调用 f(5) 时 5 是给谁的。

⚠️ 可变默认参数的陷阱(经典中的经典):

❌ 错误示范:

def add_item(item, box=[]):     # 默认值是个列表!
    box.append(item)
    return box

print(add_item("苹果"))     # ['苹果']
print(add_item("香蕉"))     # ['苹果', '香蕉']  ← 第一次的结果被记住了!
print(add_item("橘子"))     # ['苹果', '香蕉', '橘子']

惊不惊喜? 不传 box 时,三次调用用的都是同一个列表——上一次的"苹果"还在里面!

原因: 默认值 [] 在函数定义时就创建了,之后每次不传参数都复用同一个列表。这可不是你想要的"每次都从空盒子开始"。

✅ 正确写法(默认值用 None,函数里再判断):

def add_item(item, box=None):
    if box is None:
        box = []
    box.append(item)
    return box

print(add_item("苹果"))     # ['苹果']
print(add_item("香蕉"))     # ['香蕉']  每次都从空盒子开始!

🐍"皮皮注:记住一句话——可变对象(列表、字典、集合)别当默认参数。要用就 None + 函数内判断。这条规则面试爱考,写代码更爱考(因为坑真的人人踩过)。"

配套代码文件:code/ch16/log_demo.py。


16.2 关键字参数:点名投料

调用函数时,可以用 参数名=值 的方式"点名"传参,这叫关键字参数:

def introduce(name, age, city):
    print(f"{name}, {age} 岁,来自{city}")

# 位置参数(按顺序)
introduce("皮皮", 30, "上海")

# 关键字参数(点名,顺序随意!)
introduce(city="杭州", name="小美", age=28)

运行结果:

皮皮, 30 岁,来自上海
小美, 28 岁,来自杭州

逐行拆解:
- introduce("皮皮", 30, "上海"):位置参数,按顺序一一对应;
- introduce(city="杭州", name="小美", age=28):关键字参数,点名传参,顺序随便打乱都行,Python 按名字对应。

关键字参数最大的好处:不用记顺序,尤其参数多的时候,introduce(city="杭州", name="小美", age=28) 一眼看懂谁是谁。

换例加深:混用

introduce("皮皮", city="上海", age=30)     # ✅ 位置在前,关键字在后

💡 位置参数和关键字参数可以混用,但位置参数必须在前面。introduce("皮皮", age=30, city="上海") 合法;introduce(name="皮皮", 30, "上海") 报错。


16.3 *args:接任意多的位置参数

如果函数想"来多少收多少",用 *args——它会把所有多余的位置参数收集成一个元组:

def sum_all(*args):
    total = 0
    for n in args:
        total += n
    return total

print(sum_all(1, 2, 3))          # 6
print(sum_all(1, 2, 3, 4, 5))    # 15
print(sum_all(100))              # 100

逐行拆解:
- def sum_all(*args):不管调用时传几个数,全部收进 args;
- for n in args:遍历这个"收到的袋子";
- 所以同一个函数,传 3 个数、5 个数、1 个数都能算。

args 只是个约定俗成的名字,真正起作用的是那个 *。函数内部的 args 就是一个元组:

def show(*args):
    print(args)

show(1, 2, 3)     # (1, 2, 3)

经典场景: 日志函数——不管外面传来几条消息,全部打出来:

def log(*messages):
    for m in messages:
        print("[日志]", m)

log("启动", "读取配置", "加载完成")

*args 可以和普通参数配合:

def register(user, *roles):
    print(f"用户: {user}")
    print(f"角色: {roles}")

register("皮皮", "管理员", "会员")    # user="皮皮", roles=('管理员', '会员')

配套代码文件:code/ch16/sum_all.py。


16.4 **kwargs:接任意多的关键字参数

*args 收位置参数,**kwargs 收关键字参数——收集成一个字典:

def show_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key} = {value}")

show_info(name="皮皮", age=30, city="上海")

运行结果:

name = 皮皮
age = 30
city = 上海

kwargs 里存的就是 {"name": "皮皮", "age": 30, "city": "上海"}。

逐行拆解:
- def show_info(**kwargs):凡是"点名传参"的,全收进 kwargs;
- for key, value in kwargs.items():第 13 章学的字典遍历;
- show_info(name="皮皮", age=30, city="上海"):三个关键字参数,被收成三个键值对。

*args 和 **kwargs 合体——最全能的"来者不拒"函数:

def register(*args, **kwargs):
    print("位置参数:", args)
    print("关键字参数:", kwargs)

register("用户001", "VIP", name="皮皮", level=9)
# 位置参数: ('用户001', 'VIP')
# 关键字参数: {'name': '皮皮', 'level': 9}

💡 记住这对黄金搭档:*args 收位置参数成元组,**kwargs 收关键字参数成字典。 你以后读别人的代码,看到 def foo(*args, **kwargs) 就知道它是"万能中转站"。


16.5 lambda:不要名字的小函数

有些函数太简单,起名字都嫌浪费,这时候用 lambda(匿名函数):

# 传统写法
def double(x):
    return x * 2

# lambda 写法
double = lambda x: x * 2

语法格式:

lambda 参数: 返回值表达式

lambda 参数: 返回值——一句话定义,: 左边是参数,右边是返回的表达式。

逐行拆解: lambda x: x * 2——一个无名函数,吃进 x,吐出 x * 2。: 右边自动就是返回值,不需要也不能写 return。

lambda 最常见的舞台:配合 sorted 的 key 参数排序。

给字典列表按"成绩"排序:

students = [
    {"name": "皮皮", "score": 95},
    {"name": "小美", "score": 88},
    {"name": "阿强", "score": 73},
]

# 按成绩从小到大排序
students.sort(key=lambda s: s["score"])
print(students)

运行结果:

[{'name': '阿强', 'score': 73}, {'name': '小美', 'score': 88}, {'name': '皮皮', 'score': 95}]

key=lambda s: s["score"] 的意思是:"排序时,每个学生取它的 score 来比较。" 不写 key,Python 根本不知道该按哪个字段排。

逐行拆解:
- key=:sorted/sort 的特殊参数,决定"按什么比";
- lambda s: s["score"]:给每个学生 s,返回它的 score——排序就按这个值比;
- 于是三个学生按 73、88、95 排好。

倒序加个参数:

students.sort(key=lambda s: s["score"], reverse=True)   # 按成绩从高到低

换例加深:lambda 也能接受多个参数

area = lambda w, h: w * h
print(area(3, 4))     # 12

🐍"皮皮注:lambda 别贪多。超过一行逻辑(比如有 if/for),就老实写 def。lambda 是'贴纸条',def 是'立碑'——字少用纸条,字多用碑。"

配套代码文件:code/ch16/lambda_sort.py。


【皮皮小课堂】本章要点


【翻车现场】本章的坑

坑 1:可变默认参数

见 16.1,def add_item(item, box=[]) 的列表会被所有调用共享。记住口诀:可变对象别当默认值。

坑 2:默认参数放前面

def f(a=1, b):     # ❌ SyntaxError: non-default argument follows default argument

默认参数必须放非默认参数后面。报错信息本身就说明了原因,照做即可。

坑 3:位置参数和关键字参数顺序错

introduce(name="皮皮", 30)     # ❌ 关键字参数后面不能跟位置参数
introduce("皮皮", age=30)      # ✅

规则:位置参数必须在前,关键字参数在后。

坑 4:lambda 忘了返回值 / 写了 return

f = lambda x: return x * 2    # ❌ 语法错误
f = lambda x: x * 2           # ✅ 右边自动就是返回值

lambda 的 : 右边自动就是返回值,不需要也不能写 return。

坑 5:args 和 kwargs 星号位置写错

*args、**kwargs 是约定俗成,但写法必须是 * / ** 加一个名字。写成 args* 或 kwarg*s 直接语法错误。星号在最前,名字在后。

坑 6:以为 *args 是列表,其实是元组

def f(*args):
    args.append(1)    # ❌ 元组不能 append!

def f(*args):
    lst = list(args)  # ✅ 先转列表再改

*args 收集成的是元组(不可变)。想增删,先 list(args)。同理 **kwargs 是字典(可变,可以直接改)。


【本章习题】

一、选择题

1. (★) 运行 def f(a, b=2): return a + b,然后 print(f(3)) 的结果是?

2. (★★) 运行 def f(*args): return sum(args),然后 print(f(1, 2, 3, 4)) 的结果是?

3. (★★) 下列哪个 lambda 定义是正确的?

4. (★★ 多选) 关于默认参数,下列说法正确的是?

5. (★★ 多选) 关于 *args 和 **kwargs,下列说法正确的是?

二、判断题

1. (★) def f(a=1, b=2): 调用 f(b=5) 时,a 用默认值 1。( )

2. (★★) **kwargs 会把关键字参数收集成一个列表。( )

3. (★★) sorted(list, key=lambda x: x) 中的 lambda 用来指定"按什么排序"。( )

4. (★★) def f(*args, **kwargs): 是一个合法的函数定义。( )

三、代码纠错题

1. (★★) 下面的函数想"每次从空列表开始添加",但结果却是累加的。请指出问题并改正:

def add_item(item, box=[]):
    box.append(item)
    return box

print(add_item("苹果"))    # 期望 ['苹果']
print(add_item("香蕉"))    # 期望 ['香蕉']

2. (★★) 下面代码报错,请指出原因并改正:

def introduce(name, age, city):
    print(f"{name}, {age} 岁,来自{city}")

introduce(city="杭州", "小美", 28)

四、编程实战题

1. (基础 ★) 写一个函数 make_drink(name, size="中杯"),输出 "给你一杯 {size}{name}"。分别用默认参数和自定义参数调用两次。

2. (基础 ★★) 写一个函数 average(*args),接收任意多个数字,返回它们的平均分。如果没有传任何数字,返回 0(提示:先判断 len(args))。

3. (基础 ★★) 写一个函数 combine(**kwargs),把收到的关键字参数拼成一句话输出,格式 "键1=值1, 键2=值2, ..."(提示:遍历 kwargs.items(),用 join 拼接)。

4. (挑战 ★★★) 有一个学生列表(字典),用 lambda 分别按"成绩从高到低"和"名字"排序,并输出排序结果。列表:皮皮 95、小美 88、阿强 73、小明 100。



【参考答案与解析】

一、选择题

1. 答案:B
b 有默认值 2,调用 f(3) 时 a=3、b=2,返回 3+2=5。

2. 答案:B
*args 把 1、2、3、4 收成元组 (1,2,3,4),sum 求和得 10。

3. 答案:B
lambda 的 : 右边自动是返回值,不能写 return。所以 B 正确。C 用了未定义的 x;D 少了冒号和返回值。

4. 答案:A、B、D
A 对;B 对:能用但有坑;C 错:默认参数必须放非默认参数后面;D 对:可变默认值用 None 是好习惯。

5. 答案:A、B、C
A 对:*args 收元组;B 对:**kwargs 收字典;C 对:可以合体;D 错:*args 收的是元组,不是列表(想改得先 list())。

二、判断题

1. 正确(√)。只传了 b,a 用默认值 1。

2. 错误(×)。**kwargs 收集成字典。收集成元组的是 *args。

3. 正确(√)。key 参数指定排序依据,lambda 返回"用来比较的值"。

4. 正确(√)。def f(*args, **kwargs): 是合法的"万能中转站"定义。

三、代码纠错题

1. 解析: 默认值 [] 在定义时创建一次,之后每次不传 box 都复用同一个列表。改正——用 None + 函数内判断:

def add_item(item, box=None):
    if box is None:
        box = []
    box.append(item)
    return box

print(add_item("苹果"))    # ['苹果']
print(add_item("香蕉"))    # ['香蕉']

2. 解析: 关键字参数 city="杭州" 后面不能再跟位置参数 "小美", 28(位置参数必须在前)。改成:

introduce("小美", 28, city="杭州")     # ✅ 位置在前,关键字在后

四、编程实战题

1. 参考代码:

def make_drink(name, size="中杯"):
    print(f"给你一杯 {size}{name}")

make_drink("咖啡")                # 给你一杯 中杯咖啡
make_drink("奶茶", "大杯")        # 给你一杯 大杯奶茶

2. 参考代码:

def average(*args):
    if len(args) == 0:
        return 0
    return sum(args) / len(args)

print(average(1, 2, 3))      # 2.0
print(average(10, 20))       # 15.0
print(average())             # 0

3. 参考代码:

def combine(**kwargs):
    parts = [f"{k}={v}" for k, v in kwargs.items()]
    return ", ".join(parts)

print(combine(name="皮皮", age=30, city="上海"))
# name=皮皮, age=30, city=上海

4. 参考代码:

students = [
    {"name": "皮皮", "score": 95},
    {"name": "小美", "score": 88},
    {"name": "阿强", "score": 73},
    {"name": "小明", "score": 100},
]

# 按成绩从高到低
by_score = sorted(students, key=lambda s: s["score"], reverse=True)
print("按成绩从高到低:")
for s in by_score:
    print(f"  {s['name']}: {s['score']}")

# 按名字排序
by_name = sorted(students, key=lambda s: s["name"])
print("按名字排序:")
for s in by_name:
    print(f"  {s['name']}: {s['score']}")

🐍"皮皮注:看到没,key=lambda s: s['score'] 就是'按下标的哪个字段排'。以后做排行榜、成绩单,这套写法直接抄作业。"


📖 下一章,讲讲变量的"邻里关系"——作用域。函数里改不到外面的变量?这是有原因的。

📦 本章配套代码

运行方式:命令行进入目录后执行 py 文件名.py(Windows)或 python3 文件名.py(Mac/Linux)