Skip to content

第 7 章:函数(上):定义与调用 ​

知识链位置:第 0~6 章讲了环境、变量、运算符、输入输出、import、条件和循环,已经能写出完整的单段程序。本章开始把程序拆成一块块可以重复使用的"函数",这是组织代码的第一步。

本章能学到什么 ​

  • 从初中一次函数 y=x+1 理解"输入、规则、输出"的确定对应
  • Python 的 def:定义函数与调用函数,以及函数的四个零件
  • 多个参数、返回值参与继续计算
  • 为什么要有函数:不重复、好修改、好读懂
  • Python 的特点:def 即定义,调用即执行

从一个游戏场景说起 ​

想象一个扑克牌小游戏。每一局开始要"发牌",玩家每次赢牌要"计分"。这两个动作在一局游戏里会出现很多次:发牌五次、计分十几次都很正常。

如果每用一次就把同样的代码抄一遍,会出现两个问题:程序变得很长;哪天发牌规则改了,要找到每一处抄写的地方挨个改,漏掉一处就出 bug。

程序需要一个办法:把一段动作只写一次,起一个名字,用到的时候喊这个名字。这个办法就是函数。

回到数学课:一次函数 ​

初中数学里学过函数,比如:

y=x+1

它包含三件事:

部分含义在 y=x+1 里
输入交给函数的东西x
规则对输入做什么处理加 1
输出算出来的结果y

x=2 时 y=3,x=5 时 y=6。同一个输入永远得到同一个输出。这种"确定的对应关系"就是函数的核心。

数学里还有 f(x) 这种写法,f 是函数的名字,括号里的 x 是输入。看到 f(2),意思是"把 2 交给 f,按规则算出结果"。编程里的函数调用写法就是从这儿来的。

编程里的函数也是这三件事 ​

编程里的函数和数学函数结构相同,只是换了名字:

数学里的说法编程里的说法
输入参数(parameter)
规则函数体里的代码
输出返回值(return value)

下面写一个 Python 函数,它和 y=x+1 完全对应:

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,输出 6
text
3
6

def 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 就可以。

调用的写法是统一的:函数名加括号,括号里放参数,没有参数就留空。调用一次,函数体就跑一遍。

参数可以有多个 ​

数学里有二元函数,比如 z=x+y。编程里的函数同样可以收多个参数,用逗号隔开:

python
# 收两个数,返回较大的那个
def bigger(a, b):
    if a > b:
        return a
    return b

print(bigger(3, 7))   # 7
print(bigger(9, 2))   # 9
text
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)      # 返回值直接乘 2
text
3
2
22

add_one(add_one(0)) 和数学里的复合函数 f(f(x)) 是同一个意思:先算里面的,把结果交给外面。

为什么要有函数 ​

好处说明
不重复同一段代码只写一遍,用的时候喊名字
好修改规则变了只改函数这一处,所有调用同时生效
好读懂函数名说明意图,读主程序像读一份提纲

这三个好处对应程序变长之后的三个真实麻烦:抄来抄去的重复代码、改一处漏三处的修改、看不懂整体结构的长文件。函数恰好各治一种。

举例:游戏规则改成"得分翻倍"。不用函数的话,要找到每一处加分代码修改;用了函数,只改 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_scoreas看得出是"加分"
deal_cardfunc1看得出是"发牌"
biggermy_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 名字未定义先定义,后调用

动手实验 ​

  1. 写函数 triple(x),返回 x 的 3 倍。调用 triple(4) 和 triple(7),打印结果。
💡 查看答案
python
def triple(x):
    return x * 3   # 规则:乘 3

print(triple(4))  # 12
print(triple(7))  # 21
text
12
21
  1. 写函数 print_line(),打印一行 20 个星号。调用 3 次,组成三条分隔线。
💡 查看答案
python
def print_line():
    print("*" * 20)   # 星号重复 20 次

print_line()
print_line()
print_line()
text
********************
********************
********************
  1. 故意把 print_line() 的调用写在 def 之前,运行并观察报错信息;再把顺序改回来,确认恢复正常。
💡 查看答案

调用在前时,Python 报 NameError: name 'print_line' is not defined,意思是"这个名字还没登记"。把 def print_line(): 整块移到调用之前,输出与第 2 题相同。

本章小结 ​

概念一句话
函数一段有名字的代码,喊名字就执行
参数函数的输入,对应数学里的自变量
返回值函数的输出,对应数学里的函数值
def定义函数的关键字,执行到才登记
调用函数名加括号,调用一次执行一遍
主程序写在 def 之外的代码,从上往下执行

下一章深入函数的三个细节:参数怎么传、返回值怎么交还、变量在什么范围内有效。