变量作用域#

变量的作用域指的是变量的作用范围（标识这个变量在哪里可以使用，在哪儿不可以使用）。

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)

global关键字#

global 关键字用于明确的告诉Python解释器，在函数中要使用全局变量，使得可以在函数内部修改全局变量的值。

1
num1 = 1  # 全局变量
2

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

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

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（全局变量被修改）

变量作用域小结#

1. 什么是局部变量，全局变量？

   • 在函数内部定义的变量就是局部变量，函数外声明的变量是全局变量

2. global关键字的作用？

   • 在函数内部使用，声明接下来要使用的是全局变量，语法：global xxx

3. 注意事项

   • 尽量避免在函数中使用全局变量，因为会使代码难以维护和调试
   • 考虑使用函数参数和返回值来传递数据，而不是依赖全局变量
   • global 主要用在程序的状态、配置和计数器等场景中

函数传参方式#

传参方式指的是，在调用函数时，传递实参的方式。

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)

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)

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

位置参数 vs 关键字参数#

1
# 位置参数（简洁但可读性差）
2
s = calc(87, 68, 92, 85)
3

4
# 关键字参数（可读性强）
5
s = calc(math=87, chinese=68, english=92, computer=85)

黄金法则：半年后回头看你今天写的代码，能否一眼看出每个参数的含义，如果不能，就应该使用关键字参数。

传参方式小结#

1. 位置参数

   • 调用函数时，传入的实参的顺序与定义函数时形参的顺序完全一致

2. 关键字参数

   • 调用函数时，通过 "形参名=值" 的形式传递参数，顺序没有要求
   • 如果同时存在位置参数与关键字参数，位置参数在前，关键字参数在后

3. 两种传参方式的适用场景

   • 一切以代码结构清晰明了（可读性）、便于维护（维护性）为目标
   • 如果参数比较少（不超过3个），可直接使用位置参数
   • 如果参数数量较多，建议使用关键字参数

默认参数#

默认参数也称为缺省参数，用于在定义函数时，为参数提供默认值，调用函数时，可以不传递有默认值的参数。

1
# 定义函数（city有默认值'北京'）
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
# 调用函数（不传city，使用默认值）
7
stu = reg_stu("张三", 18, "男")
8
print(stu)  # 城市:北京
9

10
# 调用函数（传city，覆盖默认值）
11
stu = reg_stu("赵四", 22, "男", "深圳")
12
print(stu)  # 城市:深圳

不定长参数#

当参数个数不确定时，可以使用不定长参数解决这类问题。

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)

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)

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

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

函数作为参数#

普通参数：数字、布尔、字符串、列表、元组、集合、字典等。

特殊参数：函数。

1
def add(x, y):
2
    return x + y
3

4
def subtract(x, y):
5
    return x - y
6

7
def calc(x, y, oper):
8
    return oper(x, y)
9

10
# 传递的是函数中封装的逻辑
11
result = calc(10, 20, add)
12
print(result)  # 30
13

14
result = calc(10, 20, subtract)
15
print(result)  # -10

匿名函数#

匿名函数指的是没有名称的函数，需要通过 lambda 表达式来声明函数，可以简化简单函数的编写（单行表达式）。

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))

总结口诀#

• 作用域：函数外定义全局用，函数内定义局部用
• global：想改全局先声明，global放在函数中
• 位置参数：按顺序传，简洁但要记清楚
• 关键字参数：键值对传，顺序随意可读性强
• 默认参数：给个默认值，不传就用它
• 不定长参数：*args收元组，**kwargs收字典
• 匿名函数：lambda一行写，简单场景用它

练习题#

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

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

  知识点： 多参数函数、if-elif-else 条件判断、return 返回字符串

  参考答案：

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

  显示更多显示更少

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

  知识点： 不定长参数 *args、内置函数 max/min/sum/len、return 多个返回值

  参考答案：

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

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

  知识点： 默认参数、return 返回字典

  参考答案：

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