深色模式
第 8 章:函数(下):参数、返回值、作用域
知识链位置:第 7 章讲了函数的定义与调用,本章深入函数的三个细节:参数怎么传、返回值怎么交还、变量在什么范围内有效。
本章能学到什么
- 形参与实参的区别,实参可以是表达式
return之后函数立刻结束- 局部变量与全局变量,用"教室里的座位号"理解作用域
- 【跨语言对照】
def即定义 vs 声明与定义分离;可变与不可变对象传参 vs 值/引用传递;默认参数
形参与实参
调用函数时,参数在两处出现:
| 名字 | 位置 | 含义 |
|---|---|---|
| 形参(形式参数) | 定义函数时括号里写的名字 | 一个占位符,等待被填入 |
| 实参(实际参数) | 调用函数时括号里给的值 | 真正填进去的内容 |
python
# x 是形参:定义时还不知道它是多少
def add_one(x):
return x + 1
print(add_one(2)) # 2 是实参:真正传进去的值
score = 5
print(add_one(score)) # score 也是实参text
3
6可以把形参看成作业本上的"姓名:______",实参是具体填上去的那个名字。定义时只有空位,调用时才填内容。
实参不一定是一个现成的数,任何能算出结果的表达式都可以当实参:
python
def add_one(x):
return x + 1
print(add_one(1 + 1)) # 实参是算式:先算 1+1,再传入 2
print(add_one(add_one(0))) # 实参是另一次调用text
3
2规则是:先把实参算成一个值,再把这个值填进形参。和数学里"代入"完全相同。
返回值:return 之后函数结束
return 做两件事:把结果交还给调用者;让函数立刻结束。return 后面的代码不会执行。
python
def check_score(score):
if score >= 60:
return 1 # 及格,返回 1,函数到此结束
return 0 # 只有没及格的才会走到这里
print(check_score(80)) # 1
print(check_score(45)) # 0text
1
0score = 80 时,第一个 return 执行,函数立即交还 1 并结束,后面的 return 0 不会执行。利用这个特点,可以在函数中间随时"交卷离场"。
没有结果要交还时,也可以用光秃秃的 return 提前结束:
python
def print_positive(n):
if n <= 0:
return # 不是正数,直接结束
print(n)
print_positive(5) # 打印 5
print_positive(-3) # 什么也不打印text
5函数完全不写 return 时,Python 让它返回 None(空值)。print(check_score(80)) 打印的是函数交还的结果;如果函数没有 return,打印出来的就是 None。
作用域:教室里的座位号
学校里每个班都有自己的"1 号"。一班的 1 号和二班的 1 号是两个不同的人,互相不影响;走出教室,"1 号"这个说法就没有意义了。
函数就像教室,函数里定义的变量就像教室里的座位号:
| 概念 | 教室类比 | 编程里的规则 |
|---|---|---|
| 局部变量 | 本班的座位号 | 只在函数内部有效,出了函数就消失 |
| 同名不冲突 | 一班 1 号和二班 1 号互不相干 | 两个函数可以有同名局部变量 |
| 全局变量 | 全校统一的工号 | 定义在所有函数之外,处处可读取 |
python
school_id = 100 # 全局变量:全校统一
def class_a():
seat = 1 # 一班的局部变量
print("一班 seat=", seat, ", 工号=", school_id)
def class_b():
seat = 2 # 二班的局部变量,与一班互不影响
print("二班 seat=", seat, ", 工号=", school_id)
class_a()
class_b()
# print(seat) # 错误:seat 只在自己的"教室"里有效text
一班 seat= 1 , 工号= 100
二班 seat= 2 , 工号= 100两个 seat 互不干扰;school_id 在两个函数里都能读到。一般优先用局部变量,全局变量只放真正需要处处共享的东西——全局变量谁都能改,改错了不容易查到是谁改的。
补一句:函数里能读全局变量,但要改全局变量,需要先在函数里写一句 global school_id 声明"我改的是全校那份"。日常练习里尽量不用它,需要交回结果就用 return。
【跨语言对照】声明、传参与默认参数
本质问题
同一件事,两种语言各自怎么处理?这里看三个问题:函数要不要先"预告"、参数传进去的是复制还是本体、参数能不能有默认值。
各自做法
问题一:def 即定义 vs 声明与定义分离
| Python | C++ | |
|---|---|---|
| 预告机制 | 无:def 即完整定义 | 有:声明(分号结尾,无函数体) |
| 定义位置 | 必须在调用之前执行到 | 可放在调用之后,配合声明 |
| 大规模组织 | 函数写进 .py,用 import 引入 | 声明放进头文件 .h,多人共享 |
Python 解释器读到 def 的那一刻,函数就登记好了,之后调用即可。跨文件使用时,把函数写进另一个 .py 文件,用第 4 章讲过的 import 引入(下面示意两个文件的内容,分别保存在同一文件夹):
python
# 文件 math_utils.py:写定义
def add_one(x):
return x + 1
# 文件 main.py:引入后调用
from math_utils import add_one
print(add_one(2)) # 3运行 python main.py,输出 3。
C++ 的对应做法是把"声明"写进头文件 .h,定义写进 .cpp,用 #include 把声明粘贴进来。第 4 章的 #include <iostream> 就是这个机制的现成例子。
问题二:可变与不可变对象传参 vs 值/引用传递
| Python | C++ | |
|---|---|---|
| 默认行为 | 传入的是对象本身,能否改动取决于对象类型 | 值传递:形参是实参的复制 |
| 改原数据的方式 | 传入可变对象(如列表),在函数内修改其内容 | 引用传递:参数类型写成 int &x |
| 典型现象 | 列表在函数内被 append,函数外看得到 | int &x 改了,main 里的变量跟着变 |
Python 实验,对比不可变对象与可变对象:
python
def change_num(x): # x 是整数(不可变对象)
x = 100 # 只是让 x 指向新数,外面的 a 不受影响
def change_list(lst): # lst 是列表(可变对象)
lst.append(100) # 修改列表本身,外面看得到
a = 1
nums = [1]
change_num(a)
change_list(nums)
print("a=", a)
print("nums=", nums)text
a= 1
nums= [1, 100]C++ 对照实验,对比值传递与引用传递:
cpp
#include <iostream>
using namespace std;
void byValue(int x) { // 值传递:x 是复制品
x = 100; // 只改了复制品
}
void byRef(int &x) { // 引用传递:x 就是本尊
x = 100; // 改了本尊
}
int main() {
int a = 1, b = 1;
byValue(a); // a 不会变
byRef(b); // b 会被改成 100
cout << "a=" << a << endl;
cout << "b=" << b << endl;
return 0;
}text
a=1
b=100两段实验的现象一致:数字传进去,函数内的修改带不出来;换一种"能改本体"的方式(Python 的列表,C++ 的 &),修改就带出来了。
问题三:默认参数
调用时经常给同一个值,可以给参数设默认值,调用时省略它。
| Python | C++ | |
|---|---|---|
| 写法 | def greet(name="同学") | void greet(string name = "同学") |
| 省略效果 | greet() 等价于 greet("同学") | greet() 等价于 greet("同学") |
| 位置限制 | 默认参数靠右放 | 默认参数靠右放 |
python
def greet(name="同学"): # 默认参数
print("你好," + name + "!")
greet() # 用默认值
greet("小明") # 用传入的值text
你好,同学!
你好,小明!cpp
#include <iostream>
#include <string>
using namespace std;
void greet(string name = "同学") { // 默认参数
cout << "你好," << name << "!" << endl;
}
int main() {
greet(); // 用默认值
greet("小明"); // 用传入的值
return 0;
}text
你好,同学!
你好,小明!"默认参数靠右放"的意思是:有默认值的参数要排在没默认值的参数后面。def greet(name="同学", times) 是错的,因为省略 name 后没法按位置对应。
为什么设计不一样
Python 边读边执行,函数的存在与否取决于 def 是否执行过,天然不需要单独的声明。C++ 在编译期要把每个函数的调用检查清楚,所以需要声明机制:编译器读到调用时,先凭一句声明确认"这个函数存在、参数类型对得上",具体定义可以稍后再看,头文件就是这个机制在大项目里的组织方式。
传参上,Python 一律传入对象本身,用"可变/不可变"区分能不能改;C++ 默认复制一份以明确"谁的数据归谁",想改原数据就显式写出 &。两边的默认参数语法不同,但目的相同:让常见调用少写字。
对照姊妹册:《C++ 从入门到精通》第 8 章。
没有参数的函数也可以有返回值
参数和返回值是两回事,可以自由组合。一个不收参数的函数,照样能交还结果:
python
def get_full_mark(): # 不收参数
return 100 # 但交还满分
full = get_full_mark()
print("满分是", full)text
满分是 100四种组合都存在:有参数有返回值(add_one)、有参数无返回值(add_score)、无参数有返回值(get_full_mark)、无参数无返回值(deal_card)。按函数要做的事情选择组合。
get_full_mark 这种"无参数有返回值"的函数,相当于一个会自己计算的常量:调用一次,得到一个确定的结果。把满分、税率这类"全程序统一的数"放进函数里,改规则时只改一处。把满分、税率这类"全程序统一的数"放进函数里,改规则时只改一处。
函数里调用另一个函数
函数之间可以互相调用,像接力。主程序喊 show_result,show_result 再喊 add_one:
python
def add_one(x):
return x + 1
def show_result(x):
r = add_one(x) # 函数里再调用函数
print(x, "加 1 等于", r)
show_result(5)
show_result(9)text
5 加 1 等于 6
9 加 1 等于 10复杂程序就是这样搭起来的:大函数调用小函数,小函数调用更小的函数,每个函数只做一件小事。
什么时候才用全局变量
全局变量处处可见、处处可改,方便但危险。一个经验判断:这个数据是不是真的需要被很多函数共享?
| 情况 | 建议 |
|---|---|
| 数据只在一个函数里用 | 局部变量 |
| 数据要交给另一个函数 | 用参数传,用 return 收 |
| 全校级别的常量(如满分 100) | 可以用全局变量 |
| 想让函数改掉某个值 | 不要用全局变量,改用参数加 return |
局部变量:每次调用都是新的一轮
函数里的局部变量,在每次调用时重新出生,调用结束就消失。两次调用之间,局部变量不会"记住"上次的值:
python
def count_once():
count = 0 # 每次调用都重新从 0 开始
count += 1
print(count)
count_once() # 1
count_once() # 还是 1,不是 2
count_once() # 还是 1text
1
1
1三次打印都是 1。因为每次进入 count_once,count 都是新出生的,和上一次调用的 count 没有任何关系。想跨调用记住东西,就把结果 return 出来,由调用方保管。
用 return 提前结束做判断
判断"一个数是不是两位数",利用"return 之后函数立刻结束",可以写得很直接:
python
def is_two_digit(n):
if n < 10:
return 0 # 太小,直接判 0
if n > 99:
return 0 # 太大,直接判 0
return 1 # 走到这里说明是两位数
print(is_two_digit(5)) # 0
print(is_two_digit(42)) # 1
print(is_two_digit(120)) # 0text
0
1
0每个 return 守住一种情况,后面的代码只处理"剩下的可能"。这种写法叫"提前返回",读的时候从上往下逐个排除,思路清楚。
形参也是局部变量
形参 x 是函数这间"教室"里的一个座位:调用时它被填上值,函数结束时它消失。所以形参遵守局部变量的一切规则——两个函数的形参同名,互不影响。
python
def add_one(x): # 这个 x 属于 add_one
return x + 1
def triple(x): # 这个 x 属于 triple,同名不冲突
return x * 3
print(add_one(2)) # 3
print(triple(2)) # 6text
3
6return 的值就是数学里的函数值
数学里写 add_one(2) 算出的 3 也是函数值,只是交还的方式叫 return。
| 数学 | Python |
|---|---|
def add_one(x): return x + 1 | |
add_one(2) | |
add_one(2) 交还的 3 |
函数值和普通值一样用:能打印、能赋值、能继续运算。这正是"函数可以像积木一样拼接"的原因——一个函数的输出,可以直接当另一个函数的输入。
常见错误
| 错误写法 | 后果 | 正确做法 |
|---|---|---|
| 想改数字实参,在函数里赋值 | 函数外看不到变化 | 数字用 return 交回;要就地改就传列表 |
return 后还写代码 | 那些代码永远不会执行 | 提前结束的逻辑放 return 前 |
| 在函数外用局部变量 | NameError 名字未定义 | 需要的结果用 return 交还 |
| 默认参数放左边 | 语法错误 | 默认参数一律靠右 |
动手实验
- 写函数
is_pass(score),分数不低于 60 返回1,否则返回0。用循环检查 45、60、90 三个分数并打印结果。
💡 查看答案
python
def is_pass(score):
if score >= 60:
return 1 # 及格,立刻结束函数
return 0
for s in [45, 60, 90]:
print(s, "分:", is_pass(s))text
45 分: 0
60 分: 1
90 分: 1- 写函数
swap_two(pair),接收一个两元素列表,交换这两个元素的位置(在列表内修改)。调用后打印列表。
💡 查看答案
python
def swap_two(pair):
pair[0], pair[1] = pair[1], pair[0] # 列表是可变对象,修改带得出来
nums = [3, 7]
swap_two(nums)
print(nums)text
[7, 3]如果传入的是两个普通整数变量,交换只发生在函数内部,函数外不会变。
- 写函数
power(base, n=2),计算base的n次方,n默认是 2。调用power(5)和power(2, 3)并打印。
💡 查看答案
python
def power(base, n=2): # n 默认 2
result = 1
for i in range(n):
result *= base
return result
print(power(5)) # 5 的 2 次方
print(power(2, 3)) # 2 的 3 次方text
25
8本章小结
| 概念 | 一句话 |
|---|---|
| 形参 / 实参 | 定义时的占位符 / 调用时填的值 |
return | 交还结果,函数立刻结束 |
| 局部变量 | 只在函数内部有效 |
| 全局变量 | 所有函数之外定义,处处可读 |
| 可变 / 不可变传参 | 数字改不动本体,列表改得动 |
| 默认参数 | 调用时可省略的参数,靠右放 |
下一章处理文字数据:字符串。
