深色模式
第 7 章:函数(上):定义与调用
知识链位置:第 0~6 章讲了环境、变量、运算符、输入输出、import、条件和循环,已经能写出完整的单段程序。本章开始把程序拆成一块块可以重复使用的"函数",这是组织代码的第一步。
本章能学到什么
- 从初中一次函数
理解"输入、规则、输出"的确定对应 - Python 的
def:定义函数与调用函数,以及函数的四个零件 - 多个参数、返回值参与继续计算
- 为什么要有函数:不重复、好修改、好读懂
- Python 的特点:
def即定义,调用即执行
从一个游戏场景说起
想象一个扑克牌小游戏。每一局开始要"发牌",玩家每次赢牌要"计分"。这两个动作在一局游戏里会出现很多次:发牌五次、计分十几次都很正常。
如果每用一次就把同样的代码抄一遍,会出现两个问题:程序变得很长;哪天发牌规则改了,要找到每一处抄写的地方挨个改,漏掉一处就出 bug。
程序需要一个办法:把一段动作只写一次,起一个名字,用到的时候喊这个名字。这个办法就是函数。
回到数学课:一次函数
初中数学里学过函数,比如:
它包含三件事:
| 部分 | 含义 | 在 |
|---|---|---|
| 输入 | 交给函数的东西 | |
| 规则 | 对输入做什么处理 | 加 1 |
| 输出 | 算出来的结果 |
数学里还有 f 是函数的名字,括号里的 x 是输入。看到
编程里的函数也是这三件事
编程里的函数和数学函数结构相同,只是换了名字:
| 数学里的说法 | 编程里的说法 |
|---|---|
| 输入 | 参数(parameter) |
| 规则 | 函数体里的代码 |
| 输出 | 返回值(return value) |
下面写一个 Python 函数,它和
python
# 定义函数 add_one:输入一个数,返回这个数加 1
def add_one(x):
y = x + 1 # 规则:加 1
return y # 输出结果
print(add_one(2)) # 输入 2,输出 3
print(add_one(5)) # 输入 5,输出 6text
3
6def add_one(x): 这一行说明:函数名叫 add_one,参数是 x。return y 把结果交还给调用它的地方,就像数学里"代入求值"得到的那个数。
注意函数体每行前面有 4 个空格的缩进,这是 Python 表示"这几行属于这个函数"的方式,和第 5、6 章里 if、for 的缩进规则一样。
对照姊妹册:《C++ 从入门到精通》第 7 章 用 C++ 写同一个函数。
函数的四个零件
一个 Python 函数由四个零件组成:
| 零件 | 在 def add_one(x): 里 | 作用 |
|---|---|---|
| 定义关键字 | def | 告诉 Python"下面是一个函数" |
| 函数名 | add_one | 调用时喊的名字 |
| 参数列表 | (x) | 说明要收什么输入 |
| 函数体 | 缩进的若干行 | 规则,真正干活的代码 |
没有输入的函数,参数列表写空括号 ()。没有 return 的函数,Python 让它返回一个特殊的"空值" None。和 C++ 不同,Python 不用提前说明返回值是什么类型。
调用:函数不会自己跑
函数定义好之后不会自动执行。只有调用它——写上函数名、括号和参数——它才执行。调用可以发生任意多次,每次传入的参数可以不同。
回到游戏的例子,把"发牌"和"计分"各写成一个函数:
python
# 发一张牌:不需要参数,也不返回结果
def deal_card():
print("发一张牌")
# 计分:需要一个参数表示加多少分
def add_score(points):
print("加分", points, "分")
deal_card() # 第一次发牌
deal_card() # 第二次发牌
add_score(10) # 加 10 分
deal_card() # 再发一张
add_score(20) # 加 20 分text
发一张牌
发一张牌
加分 10 分
发一张牌
加分 20 分有的函数只做事、不交还结果,比如 deal_card 只是打印一行字。这种函数不写 return 就可以。
调用的写法是统一的:函数名加括号,括号里放参数,没有参数就留空。调用一次,函数体就跑一遍。
参数可以有多个
数学里有二元函数,比如
python
# 收两个数,返回较大的那个
def bigger(a, b):
if a > b:
return a
return b
print(bigger(3, 7)) # 7
print(bigger(9, 2)) # 9text
7
9调用时参数按位置一一对应:bigger(3, 7) 里 3 交给 a,7 交给 b。顺序不能乱,bigger(3, 7) 和 bigger(7, 3) 是两回事。
返回值可以继续参与计算
return 交还的结果是一个普通的值,可以赋给变量,也可以直接放进表达式继续算:
python
def add_one(x):
return x + 1
a = add_one(2) # 返回值存进变量:a = 3
b = add_one(add_one(0)) # 嵌套调用:add_one(0) 得 1,再 add_one(1) 得 2
print(a)
print(b)
print(add_one(10) * 2) # 返回值直接乘 2text
3
2
22add_one(add_one(0)) 和数学里的复合函数
为什么要有函数
| 好处 | 说明 |
|---|---|
| 不重复 | 同一段代码只写一遍,用的时候喊名字 |
| 好修改 | 规则变了只改函数这一处,所有调用同时生效 |
| 好读懂 | 函数名说明意图,读主程序像读一份提纲 |
这三个好处对应程序变长之后的三个真实麻烦:抄来抄去的重复代码、改一处漏三处的修改、看不懂整体结构的长文件。函数恰好各治一种。
举例:游戏规则改成"得分翻倍"。不用函数的话,要找到每一处加分代码修改;用了函数,只改 add_score 里的一行,所有调用它的地方自动使用新规则。
再看"好读懂"。下面这个程序不看函数内部,也知道它在做什么:
python
def deal_card():
print("发一张牌")
def add_score(points):
print("加分", points, "分")
def show_winner():
print("公布赢家")
deal_card()
deal_card()
add_score(10)
show_winner()text
发一张牌
发一张牌
加分 10 分
公布赢家名字本身就是说明。这是函数带来的阅读能力。
给函数起个好名字
函数名是给人看的。好的名字让人不看函数体也知道它做什么:
| 好名字 | 差名字 | 原因 |
|---|---|---|
add_score | as | 看得出是"加分" |
deal_card | func1 | 看得出是"发牌" |
bigger | my_func | 看得出是"比大小" |
Python 的习惯写法是全小写、单词之间用下划线连接,如 add_score、show_winner。名字里不能有中文标点,不能以数字开头。
Python 的特点:def 即定义,调用即执行
Python 是边读边执行的语言。解释器读到 def 这一行时,就"登记"了这个函数——名字有了,内容也记下了。之后任何地方调用这个名字,解释器就找到登记的内容去执行。
这条规则带来一个顺序要求:def 必须出现在调用之前。下面的写法会出错:
python
greet() # 错误:此时还没有 greet 这个名字
def greet():
print("你好,欢迎来玩!")把 def 挪到前面就正常了:
python
def greet():
print("你好,欢迎来玩!")
greet() # 先定义,后调用text
你好,欢迎来玩!和 C++ 的区别在这里:C++ 允许先写一句"声明"再在后面补定义;Python 没有单独的声明,def 本身就是完整定义,只要它先被读到即可。
主程序:没有 main 的入口
Python 没有强制要求 main 函数。写在所有 def 之外的代码,从上到下依次执行,就是主程序。
python
def add_score(points):
print("加分", points, "分")
# 主程序从这里开始
add_score(10)
add_score(20)text
加分 10 分
加分 20 分可以把程序想象成一节课:主程序是老师,一进教室就开始讲课;各个 def 函数是坐在座位上的同学,老师点到名字才站起来回答。这一点和 C++ 的 main 地位相同,只是 Python 不需要把这个入口包进函数里。
有些 Python 程序会把主程序也写进一个 main() 函数里,再在末尾调用它,这是为了和其他语言的习惯对齐。初学阶段直接写主程序即可,两种写法效果一样。
参数的个数要对上
调用时给的实参个数,要和定义时的形参个数一致:
python
def show_info(name, age): # 收 2 个参数
print(name, ",", age, " 岁")
show_info("小明", 12) # 给 2 个,正确
# show_info("小明") # 错误:少给 1 个text
小明 , 12 岁多给或少给都会报 TypeError,错误信息里会写明"需要 2 个参数"。
函数与循环的组合
函数和循环可以套着用:函数负责"做一件事",循环负责"做很多遍"。打印一个星号三角形:
python
# 打印一行 n 个星号
def print_stars(n):
for i in range(n):
print("*", end="")
print()
for i in range(1, 5):
print_stars(i) # 第 i 行打印 i 个星号text
*
**
***
****外层循环管"第几行",函数管"这一行怎么打"。分工清楚,各自都好读。
调用的执行过程
程序跑到一次调用时,发生了什么?分三步:
| 步骤 | 动作 |
|---|---|
| 1 | 把实参的值填进形参 |
| 2 | 跳到函数体,从头开始执行 |
| 3 | 遇到 return(或函数体结束),带着结果跳回调用处,继续往下走 |
用一段带打印的程序观察这个过程:
python
def add_one(x):
print(" 进入 add_one,x =", x)
return x + 1
print("调用前")
r = add_one(2)
print("调用后,结果 =", r)text
调用前
进入 add_one,x = 2
调用后,结果 = 3输出顺序说明:程序确实"跳进"函数里执行完,再"跳回"原来的位置继续往下走。调用几次,就跳进去几次。
只做事不交还的函数
类比值日生:老师喊"小明擦黑板",小明做完就完了,不需要交还一个"结果"。不写 return 的函数就是这种"做事型"函数。
| 函数种类 | 类比 | 写法 |
|---|---|---|
| 计算型 | 问同学一道题,他给答案 | 用 return 交还结果 |
| 做事型 | 让值日生擦黑板,做完即止 | 不写 return,或写光秃秃的 return |
计算型函数的结果可以继续参与运算;做事型函数没有结果,print(deal_card()) 会打出一个 None,因为函数交还的是空值。
不写函数会怎样
假设欢迎语要显示三次,不用函数的写法是复制三遍:
python
print("====================")
print(" 欢迎来到单词接龙 ")
print("====================")
print("====================")
print(" 欢迎来到单词接龙 ")
print("====================")
print("====================")
print(" 欢迎来到单词接龙 ")
print("====================")用函数,同样的效果:
python
def show_welcome():
print("====================")
print(" 欢迎来到单词接龙 ")
print("====================")
show_welcome()
show_welcome()
show_welcome()text
====================
欢迎来到单词接龙
====================
====================
欢迎来到单词接龙
====================
====================
欢迎来到单词接龙
====================两个程序输出一样。区别在于:第一种写法里改欢迎语要改三处,第二种只改 show_welcome 一处。程序越长,这个差别越大。
一个小游戏的完整骨架
把本章的零件组合起来,看看一个游戏的"骨架程序"长什么样:
python
def show_welcome():
print("欢迎来到单词接龙")
def play_round(round_num):
print("第", round_num, "回合开始")
def show_score(score):
print("当前得分:", score)
show_welcome()
score = 0
for round_num in range(1, 4):
play_round(round_num)
score += 10 # 假设每回合都得 10 分
show_score(score)
print("游戏结束")text
欢迎来到单词接龙
第 1 回合开始
当前得分: 10
第 2 回合开始
当前得分: 20
第 3 回合开始
当前得分: 30
游戏结束读主程序就能看懂整个游戏的流程:欢迎、三回合、结束。每个回合的细节藏在各自的函数里。这就是函数带来的"提纲式"阅读体验。
常见错误
| 错误写法 | 后果 | 正确做法 |
|---|---|---|
def 行末忘写冒号 | 语法错误 | def greet(): 以冒号结尾 |
| 函数体没有缩进 | 语法错误 | 函数体每行缩进 4 格 |
调用时忘写括号 greet | 函数没有执行 | 调用必须有括号 greet() |
调用写在 def 之前 | NameError 名字未定义 | 先定义,后调用 |
动手实验
- 写函数
triple(x),返回x的 3 倍。调用triple(4)和triple(7),打印结果。
💡 查看答案
python
def triple(x):
return x * 3 # 规则:乘 3
print(triple(4)) # 12
print(triple(7)) # 21text
12
21- 写函数
print_line(),打印一行 20 个星号。调用 3 次,组成三条分隔线。
💡 查看答案
python
def print_line():
print("*" * 20) # 星号重复 20 次
print_line()
print_line()
print_line()text
********************
********************
********************- 故意把
print_line()的调用写在def之前,运行并观察报错信息;再把顺序改回来,确认恢复正常。
💡 查看答案
调用在前时,Python 报 NameError: name 'print_line' is not defined,意思是"这个名字还没登记"。把 def print_line(): 整块移到调用之前,输出与第 2 题相同。
本章小结
| 概念 | 一句话 |
|---|---|
| 函数 | 一段有名字的代码,喊名字就执行 |
| 参数 | 函数的输入,对应数学里的自变量 |
| 返回值 | 函数的输出,对应数学里的函数值 |
def | 定义函数的关键字,执行到才登记 |
| 调用 | 函数名加括号,调用一次执行一遍 |
| 主程序 | 写在 def 之外的代码,从上往下执行 |
下一章深入函数的三个细节:参数怎么传、返回值怎么交还、变量在什么范围内有效。
