变量作⽤域

变量作⽤域指的是变量⽣效的范围，主要分为两类：局部变量和全局变量。

局部变量

所谓局部变量是定义在函数体内部的变量，即只在函数体内部⽣效

  1.  a = 100
  2.  print(a)
  3. testA() # 100
  4. print(a) # 报错：name 'a' is not defined

变量a是定义在 testA 函数内部的变量，在函数外部访问则⽴即报错。

局部变量的作⽤：在函数体内部，临时保存数据，即当函数调⽤完成后，则销毁局部变量。

全局变量

所谓全局变量，指的是在函数体内、外都能⽣效的变量。

思考：如果有⼀个数据，在函数A和函数B中都要使⽤，该怎么办？

答：将这个数据存储在⼀个全局变量⾥⾯。

  1.  # 定义全局变量a a = 100
  2. def testA():
  3.   print(a) # 访问全局变量a，并打印变量a存储的数据
  4. def testB():
  5.  print(a) # 访问全局变量a，并打印变量a存储的数据
  6. testA() # 100
  7. testB() # 100

testB 函数需求修改变量a的值为200，如何修改程序？
  1. a = 100
  2. def testA():
  3.  print(a)
  4. def testB():
  5.  a = 200
  6.  print(a)
  7. testA() # 100
  8. testB() # 200
  9. print(f'全局变量a = {a}') # 全局变量a = 100

思考：在 testB 函数内部的 a = 200 中的变量a是在修改全局变量 a 吗？

答：不是。观察上述代码发现，15⾏得到a的数据是100，仍然是定义全局变量a时候的值，⽽没有返回

testB 函数内部的200。综上： testB 函数内部的 a = 200 是定义了⼀个局部变量。

思考：如何在函数体内部修改全局变量？
  1. a = 100
  2. def testA():
  3.  print(a)
  4. def testB():
  5.  # global 关键字声明a是全局变量
  6.  global a
  7.  a = 200
  8.  print(a)
  9.   testA() # 100
  10. testB() # 200
  11. print(f'全局变量a = {a}') # 全局变量a = 200

多函数程序执⾏流程

⼀般在实际开发过程中，⼀个程序往往由多个函数（后⾯知识中会讲解类）组成，并且多个函数共享某

些数据，如下所示

共⽤全局变量

  1. # 1. 定义全局变量
  2. glo_num = 0
  3. def test1():
  4.  global glo_num
  5.  # 修改全局变量
  6.  glo_num = 100
  7. def test2():
  8.  # 调⽤test1函数中修改后的全局变量
  9.  print(glo_num)
  11. # 2. 调⽤test1函数，执⾏函数内部代码：声明和修改全局变量
  12. test1()
  13. # 3. 调⽤test2函数，执⾏函数内部代码：打印
  14. test2() # 100

返回值作为参数传递

  1. def test1():
  2.  return 50
  3. def test2(num):
  4.  print(num)
  5. # 1. 保存函数test1的返回值
  6. result = test1()
  7. # 2.将函数返回值所在变量作为参数传递到test2函数
  8. test2(result) # 50

函数的返回值

如果⼀个函数如些两个return (如下所示)，程序如何执⾏？

  1. def return_num():
  2.  return 1
  3.  return 2
  4. result = return_num()
  5. print(result) # 1

只执⾏了第⼀个return，原因是因为return可以退出当前函数，导致return下⽅的代码不执⾏。

思考：如果⼀个函数要有多个返回值，该如何书写

  1. def return_num():
  2.  return 1, 2
  3. result = return_num()
  4. print(result) # (1, 2)
  5. 123456

注意：

  1. return a, b 写法，返回多个数据的时候，默认是元组类型。

  2. return后⾯可以连接列表、元组或字典，以返回多个值。

函数的参数

位置参数

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

  1. def user_info(name, age, gender):
  2.  print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
  3. user_info('TOM', 20, '男')

注意：传递和定义参数的顺序及个数必须⼀致。

关键字参数

函数调⽤，通过“键=值”形式加以指定。可以让函数更加清晰、容易使⽤，同时也清除了参数的顺序需

求。

  1. def user_info(name, age, gender):
  2.  print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
  3. user_info('Rose', age=20, gender='⼥')
  4. user_info('⼩明', gender='男', age=16)

注意：函数调⽤时，如果有位置参数时，位置参数必须在关键字参数的前⾯，但关键字参数之间不存在

先后顺序

缺省参数

缺省参数也叫默认参数，⽤于定义函数，为参数提供默认值，调⽤函数时可不传该默认参数的值（注

意：所有位置参数必须出现在默认参数前，包括函数定义和调⽤）。

  1. def user_info(name, age, gender='男'):
  2.  print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
  3. user_info('TOM', 20)
  4. user_info('Rose', 18, '⼥')

注意：函数调⽤时，如果为缺省参数传值则修改默认参数值；否则使⽤这个默认值。

不定⻓参数

不定⻓参数也叫可变参数。⽤于不确定调⽤的时候会传递多少个参数(不传参也可以)的场景。此时，可

⽤包裹(packing)位置参数，或者包裹关键字参数，来进⾏参数传递，会显得⾮常⽅便。

包裹位置传递

  1. def user_info(*args):
  2.  print(args)
  3. # ('TOM',)
  4. user_info('TOM')
  5. # ('TOM', 18)
  6. user_info('TOM', 18)

注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为⼀个元组(tuple)，

args是元组类型，这就是包裹位置传递

包裹关键字传递
  1. def user_info(**kwargs):
  2.  print(kwargs)
  3. # {'name': 'TOM', 'age': 18, 'id': 110}
  4. user_info(name='TOM', age=18, id=110)

综上：⽆论是包裹位置传递还是包裹关键字传递，都是⼀个组包的过程。

拆包和交换变量值

拆包：元组
  1. def return_num():
  2.  return 100, 200
  3. num1, num2 = return_num()
  4. print(num1) # 100
  5. print(num2) # 200

拆包：字典
  1. dict1 = {'name': 'TOM', 'age': 18} a, b = dict1
  2. # 对字典进⾏拆包，取出来的是字典的key
  3. print(a) # name
  4. print(b) # age
  5. print(dict1[a]) # TOM
  6. print(dict1[b]) # 18

交换变量值

需求：有变量 a = 10 和 b = 20 ，交换两个变量的值。

⽅法⼀

借助第三变量存储数据。
  1. # 1. 定义中间变量
  2. c = 0
  3. # 2. 将a的数据存储到c c = a
  4. # 3. 将b的数据20赋值到a，此时a = 20
  5. a = b
  6. # 4. 将之前c的数据10赋值到b，此时b = 10
  7. b = c
  8. print(a) # 20
  9. print(b) # 10

⽅法⼆
  1. a, b = 1, 2 a, b = b, a
  2. print(a) # 2
  3. print(b) # 1

引⽤

在python中，值是靠引⽤来传递来的。

我们可以⽤ id()

id() 来判断两个变量是否为同⼀个值的引⽤。 我们可以将id值理解为那块内存的地址标识。

  1. # 1. int类型
  2. a = 1 b = a
  3. print(b) # 1
  4. print(id(a)) # 140708464157520
  5. print(id(b)) # 140708464157520
  6. a = 2
  7. print(b) # 1,说明int类型为不可变类型
  8. print(id(a)) # 140708464157552，此时得到是的数据2的内存地址
  9. print(id(b)) # 140708464157520
  10. # 2. 列表
  11. aa = [10, 20]
  12. bb = aa
  13. print(id(aa)) # 2325297783432
  14. print(id(bb)) # 2325297783432
  15. aa.append(30)
  16. print(bb) # [10, 20, 30], 列表为可变类型
  17. print(id(aa)) # 2325297783432
  18. print(id(bb)) # 2325297783432

引⽤当做实参
  1. def test1(a):
  2.  print(a)
  3.  print(id(a))
  4.  a += a
  5.  print(a)
  6.  print(id(a))
  7. # int：计算前后id值不同
  8. b = 100
  9. test1(b)
  10. # 列表：计算前后id值相同
  11. c = [11, 22]
  12. test1(c)

可变和不可变类型

所谓可变类型与不可变类型是指：数据能够直接进⾏修改，如果能直接修改那么就是可变，否则是不可变.

可变类型
  1. 列表
  3. 字典
  5. 集合

不可变类型
  1. 整型
  3. 浮点型
  5. 字符串
  7. 元组