全局变量#

在函数之外定义的变量，称之为全局变量，在整个文件中（包括函数内）都可以使用（通常定义在文件的顶部）。

局部变量#

在函数内部定义的变量，称之为局部变量，只能在该函数内部使用，外部无法访问（函数执行完毕后，会自动销毁其内部局部变量）。

示例#

1
# 定义函数
2
num = 100  # 全局变量
3
def circle_area(r):
4
    pi = 3.14
5
    area = pi * r * r  # 局部变量
6
    return area
7

8
count = 0  # 全局变量
9
# 调用函数
10
c_area = circle_area(10)
11
print(c_area)

示例1：不使用global（无法修改全局变量）#

1
num1 = 1  # 全局变量
2

3
def fun1():
4
    num1 = 100  # 局部变量，只是新建了一个同名的局部变量
5
    print(num1)
6

7
fun1()  # 100
8
print(num1)  # 1（全局变量未被修改）

示例2：使用global（可以修改全局变量）#

1
num1 = 1  # 全局变量
2

3
def fun1():
4
    global num1  # 告诉python解释器，函数中使用全局变量num1
5
    num1 = 100  # 修改全局变量num1
6
    print(num1)
7

8
fun1()  # 100
9
print(num1)  # 100（全局变量被修改）

注意事项#

• 在基于 global 声明全局变量时，要先声明，再使用

1. 位置参数#

调用函数时根据函数定义时的位置来传递参数。

1
# 定义函数
2
def reg_stu(name, age, gender, city):
3
    print(f"注册成功,姓名:{name}，年龄:{age}，性别:{gender}，城市:{city}")
4
    return {"name": name, "age": age, "gender": gender, "city": city}
5

6
# 调用函数（顺序必须与定义一致）
7
stu = reg_stu("张三", 18, "男", "北京")
8
print(stu)

要求：调用函数时参数顺序与定义函数时参数顺序完全一致

2. 关键字参数#

调用函数时以函数定义时形参名称作为关键字，以 "键=值" 的形式来传递参数（不要求顺序）。

1
# 定义函数
2
def reg_stu(name, age, gender, city):
3
    print(f"注册成功,姓名:{name}，年龄:{age}，性别:{gender}，城市:{city}")
4
    return {"name": name, "age": age, "gender": gender, "city": city}
5

6
# 调用函数（顺序可以不一致）
7
stu = reg_stu(name="张三", age=18, gender="男", city="北京")
8
print(stu)
9

10
stu2 = reg_stu(gender="男", name="王武", city="上海", age=22)
11
print(stu2)

3. 位置参数与关键字参数混用#

1
# 位置参数在前，关键字参数在后
2
stu = reg_stu("赵四", 28, gender="男", city="上海")
3
print(stu)

要求：如果位置参数与关键字参数混用，关键字参数必须在位置参数之后（关键字参数之间，没有顺序要求）

注意事项#

• 默认参数必须放在没有默认值的参数列表的后面，一个函数在定义时是可以设置多个默认参数的
• 函数调用时，如果为默认参数传递了值，则会修改默认的参数值；如果没有传递该参数，则直接使用默认值

1. 位置传递（*args）#

传递的所有匹配的位置参数都会被 args 变量收集，这些参数会合并封装为一个元组（注意并不会封装关键字参数）。

1
# 定义函数
2
def calc_data(*args):
3
    min_data = min(args)
4
    max_data = max(args)
5
    avg_data = sum(args) / len(args)
6
    return min_data, max_data, round(avg_data, 1)
7

8
# 调用函数
9
data = calc_data(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
10
print(data)  # (10, 100, 55.0)
11

12
data = calc_data(100, 200, 300, 400, 500)
13
print(data)  # (100, 500, 300.0)

注意事项#

• args 只是约定俗成的变量名，并不是关键字，这里可以使用任何合法的变量名（如 *data）

2. 关键字传递（**kwargs）#

参数是以 "键=值" 形式传递的关键字参数，这些 "键=值" 参数都会被 kwargs 接受，并合并封装为一个字典类型。

1
# 定义函数
2
def calc_data(*args, **kwargs):
3
    min_data = min(args)
4
    max_data = max(args)
5
    avg_data = sum(args) / len(args)
6

7
    if kwargs.get('round'):
8
        avg_data = round(avg_data, kwargs.get('round'))
9

10
    return min_data, max_data, avg_data
11

12
# 调用函数（带配置参数）
13
data = calc_data(100, 200, 300, 400, round=2, count=0)
14
print(data)  # (100, 400, 250.0)
15

16
# 调用函数（不带配置参数）
17
data = calc_data(33, 11, 28, 91, 32, 75, 49)
18
print(data)  # (11, 91, 45.6)

注意事项#

• kwargs 只是约定俗成的变量名，并不是关键字，这里可以使用任何合法的变量名（如 **options）

不定长参数小结#

1. 什么是不定长参数？

   • 参数个数不确定，此时就可以使用不定长参数解决这类问题

2. 不定长参数的分类？

   • *args：不定长位置参数，函数调用时，通过位置参数传递多个参数封装到一个元组(tuple)中
   • **kwargs：不定长关键字参数，函数调用时，通过关键字参数传递多个参数封装到一个字典(dict)中

3. args与kwargs的应用场景？*

   • *args 适用于处理数量不确定的数据（核心数据）
   • **kwargs 适用于处理数量不确定的选项（函数的配置参数，用来定制函数的行为）

1
# 核心数据：你要什么
2
点奶茶("珍珠奶茶")
3

4
# 选项：你要什么样的
5
点奶茶("珍珠奶茶", 甜度="少糖", 冰度="去冰", 加料=["布丁", "珍珠"], 大小="大杯")

定义语法#

1
lambda 参数列表 : 函数体

示例对比#

1
# 命名函数
2
def out_line():
3
    print('-------------------------')
4

5
def add(x, y):
6
    return x + y
7

8
out_line()
9
print(add(10, 20))
10

11

12
# 匿名函数
13
out_line = lambda : print('-------------------------')
14
add = lambda x, y: x + y
15

16
out_line()
17
print(add(100, 200))

注意事项#

• 函数逻辑比较简单（单行表达式）且只在一个地方使用时，可以考虑使用匿名函数，简化书写（通常作为高阶函数的参数使用）
• 匿名函数中可以返回结果，也可以不返回结果。返回结果时，不需要写 return，表达式的运行结果就是要返回的结果

匿名函数小结#

1. 匿名函数的定义方式

   1
   lambda 参数列表 : 函数体

2. 命名函数与匿名函数的选择？

   • 建议使用匿名函数的情况：函数逻辑简单，只在一个地方调用（常作为高阶函数的参数）
   • 建议使用命名函数的情况：函数逻辑复杂，需要多步操作，需要多个地方重复使用或需要加文档说明的场景

代码的可读性和可维护性比简洁性更重要

一、知识回顾（读完直接做下面的实践题）#

1. 作用域：函数外定义的是全局变量（整个文件都能用），函数内定义的是局部变量（只在该函数里能用，函数执行完就销毁）
2. 想在函数里修改全局变量，要在函数内先声明 global 变量名（先声明，再使用）
3. 位置参数：调用时实参顺序必须与形参顺序完全一致（参数少、顺序自然时用）
4. 关键字参数：调用时写成 形参名=值，顺序随意、可读性好
5. 两种混用时，位置参数必须在前、关键字参数在后（关键字参数之间没有顺序要求）
6. 默认参数（缺省参数）：定义时给参数一个默认值，如 def reg_stu(name, age, gender, city='北京'):；不传就用默认值，传了就覆盖；默认参数要放在没有默认值的参数后面
7. 不定长位置参数 *args：把多传的位置参数收集成一个元组（args 只是约定名，可以叫别的）
8. 不定长关键字参数 **kwargs：把多传的关键字参数收集成一个字典（常用来收配置项，如 round=2）
9. 函数也是”值”：函数可以当参数传给另一个函数，传进去的是它封装的逻辑，如 calc(10, 20, add)
10. 匿名函数 lambda 参数列表 : 函数体：没有名字、一行写完，适合逻辑简单且只在一处使用的场景；返回结果不用写 return，表达式的值就是结果

二、裸写题#

• 2-1 三角形类型判断 定义一个函数 triangle_type(a, b, c)，根据传入的三个边长判定三角形类型：

  • 等边三角形：三边相等
  • 等腰三角形：两边相等
  • 普通三角形：三边都不相等
  • 不能构成三角形：任意两边之和小于等于第三边

  批改（2026-09-28）：⚠️ 判断逻辑正确，但只测了 triangle_type(3, 3, 999)（不能构成三角形）一种情况，等边/等腰/普通三种分支都没验证；建议按参考答案把 4 种情况各跑一遍。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：先过一遍”能不能围成三角形”的关（任意两边之和都要大于第三边），能围成的再按”三边相等 / 有两边相等 / 都不等”往下分 二级 · 方法：外层 if a + b > c and a + c > b and b + c > a:，内层用 if a == b == c: / elif a == b or a == c or b == c: / else:，各分支 return 对应的字符串 三级 · 骨架：if a + b > ____ and a + c > b and b + c > a: / if a == b == ____: / elif a == b ____ a == c ____ b == c: / else: return "不能构成三角形"

  参考答案（做完再点开）

  1
  # 2-1
  2
  def triangle_type(a, b, c):
  3
      if a + b > c and a + c > b and b + c > a:
  4
          if a == b == c:
  5
              return "等边三角形"
  6
          elif a == b or a == c or b == c:
  7
              return "等腰三角形"
  8
          else:
  9
              return "普通三角形"
  10
      else:
  11
          return "不能构成三角形"
  12
  
  13
  print(triangle_type(3, 4, 5))    # 普通三角形
  14
  print(triangle_type(3, 3, 5))    # 等腰三角形
  15
  print(triangle_type(8, 8, 8))    # 等边三角形
  16
  print(triangle_type(3, 4, 7))    # 不能构成三角形

  显示更多显示更少

• 2-2 成绩统计函数 定义一个函数 calc_stats(*scores)，接收任意数量的成绩，返回最高分、最低分、平均分。

  批改（2026-09-28）：✅ 正确（最高分 96、最低分 78、平均分 87.8，输出与预期一致）。代码与文件末尾注释答案高度相似（连那组测试数据都一样），建议重做一遍确认掌握。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：参数个数不定，就把它收成一包整体处理：最高、最低、平均值各用现成函数算出来，一起返回 二级 · 方法：定义时用不定长位置参数 *scores（收集成元组）；最高 max(scores)、最低 min(scores)、平均 sum(scores) / len(scores)（要保留一位小数可以再套 round(值, 1)）；return 最高, 最低, 平均 一次返回三个值 三级 · 骨架：def calc_stats(____scores): / return ____(scores), min(scores), round(sum(scores) / ____(scores), 1)

  参考答案（做完再点开）

  1
  # 2-2
  2
  def calc_stats(*scores):
  3
      return max(scores), min(scores), round(sum(scores) / len(scores), 1)
  4
  
  5
  highest, lowest, avg = calc_stats(85, 92, 78, 96, 88)
  6
  print(f"最高分: {highest}, 最低分: {lowest}, 平均分: {avg}")

• 2-3 学生信息注册 定义一个函数 register(name, age, gender, city='北京')，使用默认参数，返回学生信息字典。

  批改（2026-09-28）：✅ 正确（默认值 城市=北京、传参覆盖成 城市=上海 两组输出都对）。与文件末尾注释答案高度相似（注释和测试数据都一致），建议重做一遍确认掌握。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：其中一个参数在定义时就给好默认值——调用时不传就是默认的，传了就按传的来 二级 · 方法：默认参数写在参数列表最后，如 city='北京'；函数里把参数装进字典 return {"name": name, "age": age, "gender": gender, "city": city} 三级 · 骨架：def register(name, age, gender, ____='北京'): / return {"name": ____, "age": age, "gender": gender, "city": city}

  参考答案（做完再点开）

  1
  # 2-3
  2
  def register(name, age, gender, city='北京'):
  3
      return {"name": name, "age": age, "gender": gender, "city": city}
  4
  
  5
  # 使用默认值
  6
  stu1 = register("张三", 18, "男")
  7
  print(stu1)  # {'name': '张三', 'age': 18, 'gender': '男', 'city': '北京'}
  8
  
  9
  # 覆盖默认值
  10
  stu2 = register("李四", 20, "女", "上海")
  11
  print(stu2)  # {'name': '李四', 'age': 20, 'gender': '女', 'city': '上海'}