10_python_函数进阶

一、函数参数-动态参数

　　形参：位置参数、默认值参数、动态参数

　　动态参数分为两种：动态接收位置参数 *args  、动态接收关键字参数 *kwargs

   

　　1、 *args

 def chi(*food):
  print("我要吃", food)
 chi("大米饭", "小米饭")
 结果:
 我要吃 ('大米饭', '小米饭') # 多个参数传递进去. 收到的内容是元组tuple

　　注意：动态接收参数的时候要注意: 动态参数必须在位置参数后⾯

 def chi(*food, a, b):
  print("我要吃", food, a, b)
 chi("大米饭", "小米饭", "土豆", "茄子") # 这时程序运行会报错. 因为前面传递进去的所有位置参数都被*food接收了. a和b永远接收不到参数

 TypeError: chi() missing 2 required keyword-only arguments: 'a' and 'b'

 def chi(a, b, *food):
  print("我要吃", a, b, food)
 chi("大米饭", "小米饭", "馒头", "面条") # 前两个参数用位置参数来接收, 后面的参数用动态参数接收

 def chi(a, b, c='馒头', *food):
  print(a, b, c, food)
 chi("香蕉", "菠萝") # 香蕉 菠萝 馒头 (). 默认值生效
 chi("香蕉", "菠萝", "葫芦娃") # 香蕉 菠萝 葫芦娃 () 默认值不生效
 chi("香蕉", "菠萝", "葫芦娃", "口罩") # 香蕉 菠萝 葫芦娃 ('口罩',) 默认值不生效

 def chi(a, b, *food, c="娃哈哈"):
  print(a, b, food, c)
 chi("香蕉", "菠萝") # 香蕉 菠萝 () 娃哈哈 默认值生效
 chi("香蕉", "菠萝", "葫芦娃") # 香蕉 菠萝 ('葫芦娃',) 娃哈哈 默认值生效
 chi("香蕉", "菠萝", "葫芦娃", "口罩") # 香蕉 菠萝 ('葫芦娃', '口罩') 娃哈哈 默认值生效

　　2、动态接收关键字参数

 def func(**kwargs):
  print(kwargs)
 func(a=1, b=2, c=3)
 func(a=1, b=2)
 结果:
 {'a': 1, 'b': 2, 'c': 3}
 {'a': 1, 'b': 2}

　

　　最终顺序(*): 位置参数 > *args > 默认值参数 > **kwargs

 

　　3、如果想接收所有的参数:

 def func(*args, **kwargs):
  print(args, kwargs)
 func("麻花藤","晕",wtf="胡辣汤")

　　4、动态传参的另一种形式:

 def fun(*args):
  print(args)
 lst = [1, 4, 7]
 fun(lst[0], lst[1], lst[2])
 fun(*lst) # 可以使用*把一个列表按顺序打散
 s = "臣妾做不到"
 fun(*s) # 字符串也可以打散, (可迭代对象)

　　5、在实参位置上给⼀个序列,列表,可迭代对象前⾯加个*表⽰把这个序列按顺序打散， 在形参的位置上的* 表⽰把接收到的参数组合成⼀个元组 如果是⼀个字典, 那么也可以打散. 不过需要⽤两个*

 def fun(**kwargs):
  print(kwargs)
 dic = {'a':1, 'b':2}
 fun(**dic)

　　6、函数注释

 def chi(food, drink):
  """
  这⾥是函数的注释, 先写⼀下当前这个函数是⼲什么的, ⽐如我这个函数就是⼀个吃
  :param :param food: 参数food是什么意思
  :param :param drink: 参数drink是什么意思
  :return :return: 返回的是什么东东
  """
  print(food, drink)
  return "very good"

二、命名空间

　　在python解释器开始执行之后, 就会在内存中开辟一个空间, 每当遇到一个变量的时候, 就把变量名和值之间的关系记录下来, 但是当遇到函数定义的时候, 解释器只是把函数名读入内存, 表示这个函数存在了, 由于函数内部的变量和逻辑, 解释器是不关心的. 也就是说一开始的时候函数只是加载进来, 仅此而已, 只有当函数被调用和访问的时候, 解释器才会根据函数内部声明的变量来进行开辟变量的内部空间. 随着函数执行完毕, 这些函数内部变量占用的空间也会随着函数执行完毕后被清空

　　我们给存放名字和值的关系的空间起⼀个名字叫: 命名空间. 我们的变量在存储的时候就 是存储在这片空间中的.

　　命名空间分类: 

　　1、全局命名空间--> 我们直接在py⽂件中, 函数外声明的变量都属于全局命名空间

　　2、局部命名空间--> 在函数中声明的变量会放在局部命名空间 

　　3、内置命名空间--> 存放python解释器为我们提供的名字, list, tuple, str, int这些都是内 置命名空间

　　加载顺序: 1. 内置命名空间     2. 全局命名空间    3. 局部命名空间(函数被执⾏的时候)

　　取值顺序: 1. 局部命名空间     2. 全局命名空间    3. 内置命名空间

 a = 10
 def func():
  a = 20
  print(a)
 func() #

　　

　　作⽤域: 作⽤域就是作⽤范围, 按照⽣效范围来看分为 全局作⽤域和局部作⽤域 

　　　　<1>全局作⽤域: 包含内置命名空间和全局命名空间. 在整个⽂件的任何位置都可以使⽤(遵循 从上到下逐⾏执⾏)局部作⽤域: 在函数内部可以使⽤. 

　　　　<2> 作⽤域命名空间:

　　　　　　(1). 全局作⽤域: 全局命名空间 + 内置命名空间

　　　　　　(2). 局部作⽤域: 局部命名空间 我们可以通过globals()函数来查看全局作⽤域中的内容, 也可以通过locals()来查看局部作 ⽤域中的变量和函数信息

　　　　<3>关键字global和nonlocal

 

　　global表⽰. 不再使⽤局部作⽤域中的内容了. ⽽改⽤全局作⽤域中的变量

 a = 100
 def func():
  global a # 加了个global表示不再局部创建这个变量了. 而是直接使用全局的a
  a = 28
  print(a)
 func()
 print(a)

　　nonlocal 表⽰在局部作⽤域中, 调⽤⽗级命名空间中的变量.

 a = 10
 def func1():
  a = 20
  def func2():
      nonlocal a
      a = 30
      print(a)
  func2()
  print(a)
 func1()
 结果:
 加了nonlocal
 30
 30
 不加nonlocal
 30
 20