跳转到主要内容

Python

08 函数

把一段代码打包复用,管好变量的作用范围

  • Python
  • 入门

目标:把一段代码打包成「技能」,随叫随到——写出不重复、好维护的程序。

1. 为什么需要函数

算 BMI 的代码写过了,换个程序还要再写一遍?把打包它:

def calc_bmi(weight, height):
    bmi = weight / (height * height)
    print(f"BMI 是 {bmi:.1f}")

calc_bmi(65, 1.72)      # BMI 是 22.0
calc_bmi(50, 1.60)      # BMI 是 19.5

函数 = 把一段逻辑起个名字存起来,用的时候喊名字 + 给材料。

  • def 定义函数,后面跟函数名。
  • 圆括号里是参数(要加工的原材料)。
  • 缩进块里是干活的具体代码。
  • 用 函数名(值) 调用它——定义了不调用,一行都不会执行。

2. return:把结果交回来

print 只是「给人看」,return 才是「交给程序继续用」:

def calc_bmi(weight, height):
    bmi = weight / (height * height)
    return bmi                    # 把结果交出去

my_bmi = calc_bmi(65, 1.72)       # 接住返回值
if my_bmi > 24:
    print("偏重了")
else:
    print("正常范围")

区别记住这句:print 给人看,return 给程序用。

return 后面可以跟任何东西,也可以返回多个值:

def min_max(nums):
    return min(nums), max(nums)     # 打包返回

low, high = min_max([3, 1, 4, 1, 5])    # 拆开接住
print(low, high)                         # 1 5

没有 return 的函数返回 None(表示「什么都没有」)。

3. 参数的几种玩法

参数决定函数「怎么收材料」。从最熟悉的传法开始,一层层加本事。

3.1 位置参数:按顺序对号入座

最普通的传法——第一个值给第一个参数,依此类推,前几章一直在用:

def calc_bmi(weight, height):
    return weight / (height * height)

print(calc_bmi(65, 1.72))    # 65 → weight,1.72 → height

缺点有二:参数一多,f(65, 1.72, 22, True) 这种调用没人看得懂每个数是什么;顺序传反不报错但结果全错——calc_bmi(1.72, 65) 照样出数。

3.2 关键字参数:按名字点名

调用时写 参数名=值,顺序随便、含义自明:

def print_info(name, age, city):
    print(f"{name},{age} 岁,来自 {city}")

print_info(city="上海", name="小红", age=20)   # 小红,20 岁,来自 上海

和位置参数混用时只有一条规则:位置在前,关键字在后:

print_info("小红", age=20, city="上海")    # ✅
# print_info(name="小红", 20, city="上海")  # ❌ SyntaxError:
#                                          #    位置参数不能跟在关键字后面

关键字的真正杀手锏是跳过中间的默认参数(默认值下一小节讲):函数有四个参数、三个有默认值,你只想改最后一个时——

def report(title, width=80, indent=0, uppercase=False):
    print(title, width, indent, uppercase)

report("月报", uppercase=True)    # 不用把 width、indent 挨个写一遍

3.3 默认值:参数的保底设置

调用时不传就用默认值。两条规则,每条都常撞:

规则一:有默认值的参数必须排在没默认值的后面:

def greet(name, greeting="你好"):    # ✅
    print(f"{greeting},{name}!")

greet("小明")                    # 你好,小明!
greet("小明", greeting="早安")    # 早安,小明!

# def bad(name="你好", greeting):   # ❌ SyntaxError:没默认值的参数
#     pass                         #    不能跟在有默认值的后面

原因:若允许 def f(a=1, b),f(5) 说不清 5 给 a 还是 b。

规则二:默认值在 def 执行时创建一次,之后所有调用共享同一个。数字、字符串无所谓;列表、字典会出事——Python 最著名的坑之一:

def add_item(item, box=[]):      # ❌ box 只在定义时创建一次
    box.append(item)
    return box

print(add_item("苹果"))          # ['苹果']
print(add_item("香蕉"))          # ['苹果', '香蕉']!上次加的东西还在

def add_item_safe(item, box=None):    # ✅ None 只是「没传」的暗号
    if box is None:
        box = []                 # 每次调用现建新列表
    box.append(item)
    return box

print(add_item_safe("苹果"))     # ['苹果']
print(add_item_safe("香蕉"))     # ['香蕉']

3.4 传列表/字典:函数里改的是「同一个」

传参传的是名字,不是复印件。变量是贴在列表上的标签,传参等于把标签抄给函数一份——两个标签指着同一个列表:

def add_item(box, item):
    box.append(item)             # 原地修改:动的是列表本体

cart = ["苹果"]
add_item(cart, "香蕉")
print(cart)                      # ['苹果', '香蕉']:外面的 cart 跟着变

但重新赋值只影响函数自己(就是 4.1 的「赋值即局部」):

def reset(box):
    box = []                     # 本地名字改指一个新列表
    print("里面:", box)

cart = ["苹果"]
reset(cart)                      # 里面: []
print(cart)                      # ['苹果']:外面纹丝不动

口诀:原地修改(append / remove / sort)内外都看得见;重新赋值只换自己手里的标签。不想让函数动你的列表,就传一份拷贝:add_item(cart.copy(), "香蕉")。

3.5 见识一下:参数个数不定的函数

print("a", "b", "c")、max(1, 2, 3) 能吃任意多个参数,靠的是定义里的星号:

def total(*args):                # 多余的位置参数全收进 args 这个元组
    return sum(args)

print(total(1, 2, 3, 4))         # 10

入门阶段会认即可;*args / **kwargs 的完整机制(打包、解包、万能转发签名)在第 14 章第 3 节讲透。

4. 变量的作用范围

函数内创建的变量,函数外看不见(局部变量);函数外的变量函数内能读(全局变量),但别在函数里改它:

def calc():
    inner = 10          # 局部变量:只在函数里活着
    print(total)        # 100,能看外面的

total = 100             # 全局变量
calc()
# print(inner)          # ❌ NameError:外面看不见 inner

4.1 为什么「能读不能改」:赋值即局部

规则只有一条:函数里只要对一个名字赋值,Python 就认定它是函数自己的局部变量——哪怕外面真有同名全局变量。于是每个初学者都会撞上一次的报错来了:

count = 0

def add():
    count += 1      # ❌ UnboundLocalError:count 被当成函数自己的
                    #    局部变量,还没赋值就读了

add()

count += 1 是赋值 → count 被判定为局部变量 → 右边又要先读它 → 读到一个「还没出生」的变量,Python 拒绝执行。记住报错名 UnboundLocalError,它就是这条规则的化身。

4.2 global:真要改时的开关(认识即可)

真想改,Python 留了开关——函数开头声明 global:

count = 0

def add():
    global count    # 声明:本函数里的 count 指外面的那个
    count += 1      # ✅ 真的改到外面了

add()
add()
print(count)        # 2

但能不用就不用:函数隔着好几行偷偷改外面的变量,读代码的人完全看不出来,程序一大就变成排查灾难。更体面的写法还是「参数进、return 出」:

def add(count):
    return count + 1    # 要什么从参数进,产出什么用 return 出

count = 0
count = add(count)      # 想更新外面,就显式接住再赋值
print(count)            # 1

顺带埋个伏笔:内层函数想改外层函数的变量(不是全局的),用的是另一个关键字 nonlocal——第 14 章闭包那一节讲它。

最佳实践还是这句:函数要什么数据,就从参数传进去;算出什么结果,就用 return 传出来。函数像个自动售货机——投币(参数)、出饮料(返回值),别让它伸手到外面抓东西。

5. 把函数当积木用

函数可以互相调用、组合,这就是「搭程序」:

def read_number(prompt):
    return float(input(prompt))

def calc_bmi(weight, height):
    return weight / (height * height)

def main():
    w = read_number("体重(公斤):")
    h = read_number("身高(米):")
    bmi = calc_bmi(w, h)
    print(f"你的 BMI:{bmi:.1f}")

main()

main() 作为程序总入口,把流程串起来——中型以上程序的标准骨架。

6. 列表推导式:一行筛出、改造出新列表

「遍历 + 筛选 + 收集」是程序里最高频的套路。用循环写要四步:

scores = [90, 58, 76, 43, 88]
passed = []
for s in scores:
    if s >= 60:
        passed.append(s)

把这三步压成一行,就是列表推导式:

passed = [s for s in scores if s >= 60]   # 读法:对每个 s,满足条件就收进来
doubled = [s * 2 for s in scores]         # 不要 if 就是纯改造
labels = [f"{i}号:{s}分" for i, s in enumerate(scores)]   # 也能配 enumerate

结构是 [表达式 for 变量 in 列表 if 条件],从左往右读,收集进新列表的是表达式的结果、原列表不动。字典也有同款写法:{word: len(word) for word in words}。

什么时候用:一眼能读懂的筛选/改造。什么时候不用:逻辑超过一行(嵌套条件、多步计算)——老老实实写 for 循环,别硬凑。16 章 会讲它的「懒兄弟」生成器表达式——不一次性生成整个列表,边用边算。

常见坑

  • 定义了忘记调用:def hello(): ... 后面要写 hello() 才执行。
  • return 写在循环里会直接结束函数——想收集多个结果就先存列表最后 return。
  • 函数内 print(x) 了但外面接不到任何东西——要接就用 return。
  • 函数里 count += 1 想改全局变量 → UnboundLocalError(赋值即局部,见 4.1)。优先「参数进、return 出」,global 只在简单脚本里偶尔用。
  • 有默认值的参数排在没默认值的前面 → SyntaxError(3.3 规则一)。
  • 函数里 box.append(...) 把外面的列表也改了(3.4)——原地修改内外可见;想隔离就传 box.copy()。
  • 函数名和变量一样不能以数字开头,习惯用动词开头:calc_bmi、print_menu、save_data。

小练习

  1. 写 is_even(n),偶数返回 True,奇数返回 False,用循环测试 1~10。
  2. 写 max_of_three(a, b, c) 返回三个数中最大的(不用 max())。
  3. 写 count_words(text) 返回字数统计字典(第 7 章练习 3 的函数版),调用两次测试。
  4. 亲手撞一次 4.1 的坑:定义全局 count = 0 和 def add(): count += 1,运行看报错;再用「参数进、return 出」的方式改对它。
  5. 写两个版本的 remove_negative(nums):remove_negative_inplace 原地删掉负数(外面的列表看得见变化);remove_negative_copy 返回去掉负数的新列表、原列表不动。各用 [3, -1, 4, -1, 5] 调用并打印验证。
练习答案
# 练习 1
def is_even(n):
    return n % 2 == 0

for i in range(1, 11):
    print(i, is_even(i))

# 练习 2
def max_of_three(a, b, c):
    biggest = a
    if b > biggest:
        biggest = b
    if c > biggest:
        biggest = c
    return biggest

print(max_of_three(3, 9, 5))        # 9

# 练习 3
def count_words(text):
    counts = {}
    for word in text.split():
        counts[word] = counts.get(word, 0) + 1
    return counts

print(count_words("a b a c b a"))
# {'a': 3, 'b': 2, 'c': 1}

# 练习 4
count = 0

def add():
    count += 1          # ❌ 先亲手看到 UnboundLocalError

def add_safe(count):    # 参数进
    return count + 1    # return 出

count = add_safe(count)
print(count)            # 1

# 练习 5
def remove_negative_inplace(nums):
    for n in nums[:]:              # 复制一份遍历,边删边遍历才不出错
        if n < 0:
            nums.remove(n)         # 原地修改:外面看得见

def remove_negative_copy(nums):
    return [n for n in nums if n >= 0]   # 返回新列表:原列表不动

nums = [3, -1, 4, -1, 5]
remove_negative_inplace(nums)
print(nums)                          # [3, 4, 5]

nums2 = [3, -1, 4, -1, 5]
print(remove_negative_copy(nums2))   # [3, 4, 5]
print(nums2)                         # [3, -1, 4, -1, 5]