第十章

day 10

第十章

1、函数进阶：

def eat(a,b,c,d,e,f)
	print(a,b,c,e,f)
eat("麻辣烫","大烧饼","大煎饼","大腰子","韭菜","羊蝎子")

如何解决参数数量太多？

（1）动态位置参数：

• def eat(*args):    # 函数的定义阶段 *聚合(打包)    
      print(args)    # tuple    
      print(*args)   # 函数体中的 *    打散(解包)
  eat("麻辣烫","大烧饼","大煎饼","大腰子","韭菜","羊蝎子")
  

• def eat(a,b,*c):       #位置参数 > 动态位置参数
      print(a)    
      print(b)    
      print(c)     # tuple
  eat("面条","米饭","馒头","大饼")
  

• def eat(a,b,*args,d=2,**c):  # 位置参数 > 动态位置参数 > 默认参数 > 动态默认参数   
      print(a)    
      print(b)   
      print(d)    
      print(args)     # tuple  
      print(c)        # dict
  eat("面条","米饭","大烧饼","大煎饼",a1=1,b1=2)        # 位置 > 关键字
  

• def eat(*args,**kwargs):  # (万能传参)   
      print(args) # tulpe    
      print(kwargs) #
      lst = [1,23,4,6,7]
      dic = {"key1":1,"key2":3}应用场景
   eat(lst,dic)
   eat(*lst,**dic) # eat(1,23,4,6,7,"key1"=1,"key2"=2)
  

• 总结：

  1. *args（聚合位置参数）大家伙都用的名字，可以进行修改但是不建议修改
  2. **kwargs（聚合关键字参数）大家伙都用的名字，可以进行修改但是不建议修改
     • 函数的定义阶段 和* 都是聚合
     • 函数体中*就是打散 * args 将元组进行打散，** kwargs将字典的键获取

（2）形参：

1. 位置参数

   动态位置参数：先执行位置参数，位置参数接受后额外的参数由动态位置参数进行接受，获取的是一个元组

2. 默认参数

   动态关键字参数（默认）：先执行默认参数，默认参数额外后的由默认进行接受，获取的是一个字典

   实参和函数体：

   • *打散
   • **实参时能够使用

2、函数的注释：

def a(a:int,b:int):  
    """求和    
    :param a: int 
    :param b: int  
    :return:  int 
    """    
    return a + b
def b(a:int,b:int):  
    """求差   
    :param a: int  
    :param b: int  
    :return:  int   
    """   
    return a - b

1. 函数名. __ doc __ 查看函数的注释
2. 函数名. __ name __ 查看函数的名字

3、命名空间

1. 内置空间：python解释器自带的空间

2. 全局空间：py文件中顶个写的就是全局空间

3. 局部空间：函数体中就是局部空间

   1. 加载顺序：

      • 内置空间

      • 全局空间

      • 局部空间

        def func():
            a = 1
            print(a)
        func()
        

   2. 取值顺序：

      • 局部空间

      • 全局空间

      • 内置空间

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

4. 作用域：

   • 全局作用域：全局+内置
   • 局部作用域：局部

4、函数嵌套：

不管在什么位置，只要是函数名()就是在调用一个函数

• 混合嵌套：

  def f1():
      print(11)
  def f2():
      print(22)
      f1()
  def f3():
      print(33)
      f1()
  def run():
      f3()
      f2()
      f1()
  run()
  

  def foo():
      a = 10
      def f1(b):
          c = b
          def foo(c):
              print(c)
              print(foo.__doc__)
          foo()
          print(b)
      f1()
      print(a)
  foo(25)
          
  

5、global 只修改全局

6、nonlocal: 只修改局部，修改离nonlocal最近的一层，上一层没有继续向上上层查找，只限在局部

a = 10
def func():
    global a
    a = a - 6
    print(a)
print(a)
func()
print(a)

a = 100
def func():
    b = 10
    def foo():
        b = a
        def f1():
            nonlocal b
            b = b + 5
            print(b)
    	f1()
    	print(b)
    foo()
    print(b)
func()
print(a)
 
     

enumerate() 默认从0开始数，第一个参数是可迭代对象，第二个对象是起始值