Skip to content

第 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))  # 0
text
1
0

score = 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 声明与定义分离

PythonC++
预告机制无: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 值/引用传递

PythonC++
默认行为传入的是对象本身,能否改动取决于对象类型值传递:形参是实参的复制
改原数据的方式传入可变对象(如列表),在函数内修改其内容引用传递:参数类型写成 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++ 的 &),修改就带出来了。

问题三:默认参数

调用时经常给同一个值,可以给参数设默认值,调用时省略它。

PythonC++
写法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()   # 还是 1
text
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))   # 0
text
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))    # 6
text
3
6

return 的值就是数学里的函数值 ​

数学里写 f(2)=3,3 叫"函数值"。编程里 add_one(2) 算出的 3 也是函数值,只是交还的方式叫 return。

数学Python
f(x)=x+1def add_one(x): return x + 1
f(2)add_one(2)
f(2)=3 中的 3add_one(2) 交还的 3

函数值和普通值一样用:能打印、能赋值、能继续运算。这正是"函数可以像积木一样拼接"的原因——一个函数的输出,可以直接当另一个函数的输入。

常见错误 ​

错误写法后果正确做法
想改数字实参,在函数里赋值函数外看不到变化数字用 return 交回;要就地改就传列表
return 后还写代码那些代码永远不会执行提前结束的逻辑放 return 前
在函数外用局部变量NameError 名字未定义需要的结果用 return 交还
默认参数放左边语法错误默认参数一律靠右

动手实验 ​

  1. 写函数 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
  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]

如果传入的是两个普通整数变量,交换只发生在函数内部,函数外不会变。

  1. 写函数 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交还结果,函数立刻结束
局部变量只在函数内部有效
全局变量所有函数之外定义,处处可读
可变 / 不可变传参数字改不动本体,列表改得动
默认参数调用时可省略的参数,靠右放

下一章处理文字数据:字符串。