实用指南：Python函数：从定义到调用的实用指南

在编程时，你会不会遇到这样的问题：一段代码需要反复使用，每次都复制粘贴不仅麻烦，改起来还要一个个改，稍不注意就出错？这时候，“函数”就能帮你解决——它就像一个“代码工具包”，把常用的代码打包起来，想用的时候喊一声它的名字就能执行，既省心又高效。今天我们就用最直白的方式，把Python函数的定义、调用和使用技巧讲透。

一、先搞懂：函数到底是什么？

一个“函数”——它有固定的功能（榨汁），需要输入“原料”（水果），最后输出“结果”（果汁）。就是先举个生活中的例子：你家里有一台榨汁机，每次想喝果汁，不用重新造一台机器，只要把水果放进去、按下开关，就能得到果汁。这里的“榨汁机”就

编程里的函数和榨汁机完全是一个逻辑：把一段实现特定功能的代码块封装起来，起一个名字（函数名）。以后得用这个功能时，直接调用这个名字就行，不用再写一遍代码。比如计算两个数的和，不管是计算1+2还是100+200，都能靠同一个“求和函数”完成。

容易说，函数的核心价值就是“封装复用、简化代码、便于维护”——写一次用多次，改一次全生效。

二、函数的基础：怎么定义一个函数？

定义函数就像“制作榨汁机”，要规定它的名字、需要的原料（参数）和具体的工作流程（代码逻辑）。Python里定义函数的语法非常固定，记住这个“模板”就行：

python
def 函数名(参数1, 参数2, ...):
"""函数说明文档（可选，用于解释函数功能）"""
函数体代码（实现作用的具体代码，注意缩进）
return 返回值（可选，用于把结果交给调用者）

我们逐个拆解这些部分，保证你一看就懂：

def：这是Python的“函数定义关键字”，必须放在最前面，告诉Python“接下来要定义一个函数了”，就像榨汁机的“出厂标识”。

函数名：给函数起的名字，方便调用时“喊它”。命名规则和变量一样：只能用字母、数字、下划线，不能以数字开头，最好见名知意（比如求和函数叫add，榨汁函数叫juice）。

参数函数应该的“原料”。比如求和函数需要两个数字，括号里就写两个参数；如果不需要原料，括号里能够空着。就是：放在括号里，

函数说明文档：用三个双引号括起来的文字，说明函数的功能、参数含义、返回值是什么——虽然可选，但强烈推荐写，不然过几天自己都忘了这个函数是干嘛的。

函数体函数里的代码。就是：函数的核心，是实现具体功能的代码。这里必须缩进（通常4个空格），不然Python会分不清哪部分

return返回值：函数执行完后，把结果“交出去”的关键字。如果没有return，函数执行完后会默认返回None（可以理解为“没有结果”）。

1. 入门实例：定义一个简单的求和函数

大家来定义一个计算两个数之和的函数，把上面的模板用起来：

python
def add_numbers(num1, num2):
"""计算两个数字的和并返回结果
参数：
num1: 第一个数字
num2: 第二个数字
返回值：
两个数字的和
"""
total = num1 + num2 # 函数体：计算和
return total # 返回结果

这样，一个求和函数就定义好了。注意：定义函数只是“制作了榨汁机”，它不会自己运行——要让它工作，还需要“调用”它。

2. 无参数、无返回值的函数

不是所有函数都需要参数和返回值。比如一个单纯打印“欢迎信息”的函数，既不需要原料，也不用返回结果：

python
def show_welcome():
"""打印欢迎信息，无参数无返回值"""
print("欢迎学习Python函数！")
# 没有return，默认返回None

三、函数的核心：怎么调用函数？

调用函数就是“使用榨汁机”——喊出函数名，给它喂上原料（参数），就能得到结果（返回值）。调用的语法比定义容易多了：

python
返回值变量 = 函数名(参数1, 参数2, ...)

如果函数有返回值，许可用变量接住；如果没有，直接写“函数名(参数)”就行。

1. 调用前面定义的函数

大家把刚才定义的add_numbers和show_welcome调用起来，看看效果：

python
# 1. 调用无参数函数
show_welcome() # 直接写函数名+空括号

# 2. 调用有参数函数，并用变量接住返回值
result1 = add_numbers(3, 5) # 给num1传3，num2传5
result2 = add_numbers(10.5, 20.3) # 也支持浮点数

# 打印结果
print("3+5的结果是：", result1)
print("10.5+20.3的结果是：", result2)

运行结果：

Plain Text
欢迎学习Python函数！
3+5的结果是： 8
： 30.8就是10.5+20.3的结果

很直观？调用函数时，参数的数量和类型要和函数定义时匹配——比如add_numbers需要两个数字，你不能只传一个，也不能传字符串（比如add_numbers("3",5)会报错）。就是是不

2. 两种参数传递方式：位置参数和关键字参数

给函数传参数有两种常见方式，根据场景选着用，能让代码更清晰。

位置参数：最常用的方式，参数的顺序和函数定义时一致。比如add_numbers(3,5)，3对应num1，5对应num2，靠“位置”来匹配。

python
# 位置参数：按定义顺序传参
result = add_numbers(2, 4) # 2→num1，4→num2，结果6

关键字参数：明确写出“参数名=值”，不用管顺序，适合参数比较多的场景。比如add_numbers(num2=5, num1=3)，虽然顺序反了，但Python能依据参数名匹配。

python
# 关键字参数：明确参数名，顺序可换
result = add_numbers(num2=5, num1=3) # 结果还是8
print(result)

两种方式还能混合用，但要注意：位置参数必须在关键字参数前面。比如add_numbers(3, num2=5)是对的，但add_numbers(num1=3, 5)会报错。

3. 函数调用的“嵌套”

函数调用还能嵌套——一个函数的返回值允许直接作为另一个函数的参数。比如计算3+5的和，再乘以2：

python
# 先调用add_numbers(3,5)得到8，再把8传给乘2的运算
final_result = add_numbers(3,5) * 2
print(final_result) # 结果16

# 更简洁的嵌套写法
final_result = add_numbers(3,5) * 2 # 和上面效果一样

甚至可以把函数调用放在另一个函数的参数里，比如：

python
# 计算(2+3)+(4+5)，嵌套调用add_numbers
total = add_numbers(add_numbers(2,3), add_numbers(4,5))
print(total) # 结果14

四、函数的进阶：灵活的参数设置

前面讲的参数都是“必须传的”，但实际开发中，我们可能需“可选参数”——比如买奶茶时，“糖度”默认是全糖，想换甜度再自己选。Python的函数参数支持这种灵活设置，主要有“默认参数”和“不定长参数”两种。

1. 默认参数：给参数设个“默认值”

定义函数时，可以给参数加一个“默认值”，调用时如果不传这个参数，就用默认值；如果传了，就用新值。语法是“参数名=默认值”。

实例：定义一个“买奶茶”的函数，糖度默认全糖，温度默认常温：

python
def buy_milk_tea(flavor, sugar="全糖", temperature="常温"):
"""买奶茶函数
参数：
flavor: 奶茶口味（必须传，无默认值）
sugar: 糖度（可选，默认全糖）
temperature: 温度（可选，默认常温）
"""
print(f"您点的奶茶：{flavor}，{sugar}，{temperature}")

调用这个函数时，有多种方式：

python
# 1. 只传必须参数（口味），用默认糖度和温度
buy_milk_tea("珍珠奶茶") # 输出：您点的奶茶：珍珠奶茶，全糖，常温

# 2. 传口味和糖度，温度用默认
buy_milk_tea("草莓奶绿", "七分糖") # 输出：您点的奶茶：草莓奶绿，七分糖，常温

# 3. 传所有参数，覆盖默认值
buy_milk_tea("杨枝甘露", "三分糖", "冰饮") # 输出：您点的奶茶：杨枝甘露，三分糖，冰饮

# 4. 用关键字参数，跳过中间的默认参数（比如只改温度）
buy_milk_tea("芋圆波波", temperature="热饮") # 输出：您点的奶茶：芋圆波波，全糖，热饮

设置默认参数有个重要规则：有默认值的参数必须放在无默认值参数的后面。比如def buy_milk_tea(sugar="全糖", flavor)是错的，Python会直接报错。

2. 不定长参数：参数数量不确定怎么办？

10个。这时候就需要“不定长参数”，用“*”和“**”来实现。就是有时候我们不知道要传多少个参数，比如计算“任意多个数字的和”——可能是2个，也可能

（1）*args：接收任意多个位置参数，存成元组

通过在参数名前加“*”，该参数就会接收所有传来的位置参数，存成一个元组（可以理解为“不可修改的列表”）。参数名通常叫args，也能够叫别的，但args是约定俗成的。

实例：定义一个“计算任意多个数字和”的函数：

python
def add_any(*args):
"""计算任意多个数字的和"""
total = 0
# 遍历args元组，把每个元素加起来
for num in args:
total += num
return total

调用时可能传任意多个参数：

python
print(add_any(1,2)) # 传2个参数，结果3
print(add_any(3,4,5,6)) # 传4个参数，结果18
print(add_any(10,20,30,40,50)) # 传5个参数，结果150
print(add_any()) # 不传参数也可以，结果0

（2）**kwargs：接收任意多个关键字参数，存成字典

在参数名前加“**”，这个参数会接收所有传来的关键字参数，存成一个字典（键是参数名，值是参数值）。参数名通常叫kwargs，是“keyword arguments”的缩写。

实例：定义一个“打印用户信息”的函数，用户可能提供姓名、年龄、性别等任意信息：

python
def show_user_info(**kwargs):
"""打印用户的任意信息"""
print("用户信息：")
# 遍历kwargs字典，打印键值对
for key, value in kwargs.items():
print(f"{key}：{value}")

调用时传任意多个关键字参数：

python
# 传2个关键字参数
show_user_info(name="张三", age=20)
# 传3个关键字参数
show_user_info(name="李四", gender="女", city="北京")

运行结果：

Plain Text
用户信息：
name：张三
age：20
用户信息：
name：李四
gender：女
city：北京

五、函数的“边界”：局部变量和全局变量

在函数里定义的变量，和在函数外定义的变量，作用范围是不一样的——这就像“办公室的物品”和“家里的物品”，适用范围不同。这就是“局部变量”和“全局变量”的区别。

1. 局部变量：函数内部的“私有变量”

在函数体内部定义的变量，只能在函数内部使用，函数外部无法访问——这就是局部变量。

python
def test_local():
# 局部变量：只能在test_local内部用
local_var = "我是局部变量"
通过print(local_var) # 函数内部能够访问，正常打印

# 调用函数
test_local()

# 函数外部尝试访问局部变量，会报错
print(local_var) # NameError: name 'local_var' is not defined

2. 全局变量：函数内外都能访问的变量

在函数外部定义的变量，默认是全局变量，函数内部可以访问（但要修改的话需要加关键字global）。

python
# 全局变量：函数内外都能访问
global_var = "我是全局变量"

def test_global():
# 函数内部访问全局变量，正常
print("函数内部访问全局变量：", global_var)

# 如果要修改全局变量，必须加global声明
global global_var
global_var = "全局变量被修改了"

# 调用函数
test_global()

# 函数外部访问修改后的全局变量
print("函数外部访问全局变量：", global_var)

运行结果：

Plain Text
函数内部访问全局变量：我是全局变量
函数外部访问全局变量：全局变量被修改了

建议：尽量少在函数内部修改全局变量，因为全局变量作用范围广，修改后容易影响其他地方的代码，不好排查问题。如果需要函数修改外部值，最好用return返回结果，在外部再赋值。

六、函数的“组合”：函数嵌套和递归（入门）

函数不是孤立的，它们行互相组合——一个函数里可以调用另一个函数，甚至自己调用自己。

1. 函数嵌套：函数内部调用另一个函数

比如大家定义一个“计算数字平方”的函数，再定义一个“计算两个数字平方和”的函数，后者可以调用前者：

python
# 定义计算平方的函数
def square(num):
return num * num

# 定义计算平方和的函数，嵌套调用square
def square_sum(num1, num2):
# 调用square函数计算每个数的平方，再求和
sum_sq = square(num1) + square(num2)
return sum_sq

# 调用函数
result = square_sum(3,4)
print("3的平方+4的平方=", result) # 结果25

2. 递归入门：函数自己调用自己

递归是一种特殊的嵌套——函数自己调用自己，但必须满足两个条件：有终止条件（不然会无限循环）和每次调用都让问题范围缩小。最经典的例子就是计算“阶乘”（n! = n × (n-1) × ... × 1，0! = 1）。

python
def factorial(n):
"""用递归计算n的阶乘"""
# 终止条件：n=0或1时，阶乘是1
if n == 0 or n == 1:
return 1
# 递归调用：n! = n × (n-1)!
return n * factorial(n-1)

# 测试
print(factorial(5)) # 5×4×3×2×1=120
print(factorial(3)) # 6

递归虽然简洁，但如果递归层数太多（比如n=1000），会导致程序出错，所以一般用在逻辑清晰且层数不深的场景。

七、常见错误避坑指南