day011

可变长参数

• 一、可变长形参之*

  * 形参

  形参中的* 会将溢出的位置实参全部接收 , 存储为元组的形式 , 然后把元组赋值给*后的参数 ,

  约定俗成形参名为 *args

  def sum_self(*args):
      res = 0
      for num in args:
          res += num
      return res
  
  
  res = sum_self(1, 2, 3, 4)
  print(res)   # 10
  

• 二、可变长实参之*

• 实参中的，会将后参数的值循环取出，打散成位置实参。以后但凡碰到实参中带的，它就是位置实参，应该马上打散成位置实参去看。

• def func(x, y, z, *args):
      print(x, y, z, args)
  
  
  func(1, *(1, 2), 3, 4)
  

• 1 1 2 (3, 4)

• 三、可变长形参之**

• 形参中的会将溢出的关键字实参全部接收，然后存储字典的形式，然后把字典赋值给后的参数。需要注意的是：**后的参数名约定俗成为kwargs。

• def func(**kwargw):
      print(kwargw)
  
  
  func(a=5)
  

• {'a': 5}

• 四、可变长实参之**

• 实参中的，会将后参数的值循环取出，打散成关键字实参。以后但凡碰到实参中带的，它就是关键字实参，应该马上打散成关键字实参去看。

• def func(x, y, z, **kwargs):
      print(x, y, z, kwargs)
  
  
  func(1, 3, 4, **{'a': 1, 'b': 2})
  

• 1 3 4 {'a': 1, 'b': 2}

• 五、可变长参数应用

• def index(name, age, sex):
      print(f"name: {name}, age: {age}, sex: {sex}")
  
  
  def wrapper(*args, **kwargs):
      print(f"args: {args}")
      print(f"kwargs: {kwargs}")
      index(*args, **kwargs)
  
  
  wrapper(name='tjx', sex='male', age=19)
  

• args: ()
  kwargs: {'name': 'tjx', 'sex': 'male', 'age': 19}
  name: nick, age: 19, sex: male

• 六、命名关键字形参

• 现在有一个需求：函数的使用者必须按照关键字实参传

• def register(x, y, **kwargs):
      if 'name' not in kwargs or 'age' not in kwargs:
          print('用户名和年龄必须使用关键字的形式传值')
          return
      print(kwargs['name'])
      print(kwargs['age'])
  
  
  register(1, 2, name='tjx', age=19)
  

• tjx
  19

• 命名关键字形参：在函数定义阶段，*后面的参数都是命名关键字参数。

  特点：在传值时，必须按照key=value的方式传值，并且key必须命名关键字参数的指定的参数名。

def register(x, y, *, name, gender='male', age):
    print(x)
    print(age)


register(1, 2, x='nick', age=19)  # TypeError: register() got multiple values for argument 'x'

• 一、函数对象的四大功能

• 1.引用

• x = 'hello tjx'
  y = x
  
  f = func
  print(f)
  

• <function func at 0x10af72f28>

• 2.当作参数传给一个函数

• len(x)
  
  
  def foo(m):
      m()
  
  
  foo(func
  

• from func

• 3.可以当作函数的返回值

• def foo(x):
      return x
  
  
  res = foo(func)
  print(res)
  res()
  

• <function func at 0x10af72f28>
  from func

• 4.可以当作容器类型的元素

• l = [x]
  
  function_list = [func]
  function_list[0]()
  

• from func

• 二、练习

• def pay():
      print('支付1e成功')
  
  
  def withdraw():
      print('提现2e成功')
  
  
  dic = {
      '1': pay,
      '2': withdraw,
  }
  while True:
      msg = """
      '1': 支付,
      '2': 提现,
      '3': 退出,
      """
      print(msg)
      choice = input('>>: ').strip()
      if choice == '3':
          break
      elif choice in dic:
          dic[choice]()
  

• '1': 支付,
  

  '2': 提现,
  '3': 退出,

  : 1
  支付1e成功
  '1': 支付,
  '2': 提现,
  '3': 退出,
  : 2
  提现2e成功
  '1': 支付,
  '2': 提现,
  '3': 退出,
  : 3

• 函数对象

  函数对象 == 函数名 , 变量对象可以做的函数对象也可以。函数对象的四大功能如下：

  1. 引用
  2. 当做容器类元素
  3. 当做参数传给一个函数
  4. 当做函数的返回值

  函数嵌套

  def 函数名():
      def 函数名():
          代码块
  

  名称空间

  内置名称空间

  内置名称空间：存放Pyhton解释器自带的名字，如int、float、len

  生命周期：在解释器启动时生效，在解释器关闭时失效

  全局名称空间

  全局名称空间：除了内置和局部的名字之外，其余都存放在全局名称空间

  生命周期：在文件执行时生效，在文件执行结束后失效

  局部名称空间

  局部名称空间：用于存放函数调用期间函数体产生的名

  生命周期：在文件执行时函数调用期间时生效，在函数执行结束后失效

  加载顺序

  内置--》全局--》局部

  查找顺序

  从当前的所在位置开始查找，如果当前所在的位置为局部名称空间，则查找顺序为：局部--》全局--》内置

  不会逆向查找

  作用域

  作用域关系在函数定义阶段就固定死了，与函数的调用无关

  全局作用域

  全局有效，全局存活，包含内置名称空间和全局名称空间。

  局部作用域

  局部有效，临时存储，只包含局部名称空间。

  global

  修改全局作用域中的变量 , 即局部的可以修改全局的

  nonlocal

  修改局部作用域中的变量 , 即局部的修改外层局部的