day10：

一、今日内容大纲：

1. 形参角度：
   • 万能参数
   • *的魔性用法
   • 仅限关键字参数（了解）
   • 形参的最终顺序
2. 名称空间：
   1. 全局名称空间，局部........
   2. 加载顺序，取值顺序
   3. 作用域
3. 函数的嵌套（高阶函数）
4. 内置函数 globals locals
5. 关键字：nonlocal global

二、昨日内容回顾：

• 函数是以功能为导向，减少重复代码，提高代码的可读性。

  def func()
  	函数体
  

• 函数的调用：func()

• 函数的返回值：return

  • 结束函数

    def func()
    	count = 1
    	while 1:
    		count += 1
    		print(count)
    		return  # 结束函数，循环也随之结束
    func()  # 2
    

  • return单个值：类型跟值相同

  • return多个值：元组类型

• 函数的参数：

  • 实参角度：位置、关键字、混合。
  • 形参角度：位置、默认。

三、具体内容：

1. 形参角度：

   • 万能参数

     def eat(a,b,c,d):
         print('我请你吃：%s,%s,%s,%s' %(a,b,c,d))
     
     eat('蒸羊羔', '蒸熊掌', '蒸鹿邑','烧花鸭')
     
     def eat(a,b,c,d,e,f):
         print('我请你吃：%s,%s,%s,%s,%s,%s' %(a,b,c,d,e,f))
     
     eat('蒸羊羔', '蒸熊掌', '蒸鹿邑','烧花鸭','烧雏鸡','烧子鹅')
     
     # 急需要一种形参，可以接受所有的实参,即万能参数。
     # *args, 约定俗称：args.
     # 函数定义时，*代表聚合。他将所有的位置参数聚合成一个元组，赋值给args。
     
     def eat(*args):
         print(args)  # 元组
         print('我请你吃：%s,%s,%s,%s,%s,%s' % args)
     
     eat('蒸羊羔', '蒸熊掌', '蒸鹿邑','烧花鸭','烧雏鸡','烧子鹅')
     
     # 写一个函数：计算你传入函数的所有的数字的和。
     def func(*args):
         count = 0
         for i in args:
             count += i
         return count
     print(func(1,2,30,1))
     
     # **kwargs
     # 函数的定义时： ** 将所有的关键字参数聚合到一个字典中，将这个字典赋值给了kwargs.
     def func(**kwargs):
         print(kwargs)
     func(name='alex',age=73,sex='laddyboy')
     
     # 万能参数：*args, **kwargs，
     def func(*args,**kwargs):
         print(args)
         print(kwargs)
     func()
     print()
     

   • *的魔性用法

     # * **在函数的调用时，*代表打散。
     def func(*args,**kwargs):
         print(args) # (1,2,3,22,33)
         print(kwargs)
     
     func(*[1,2,3],[22,33])  # (1, 2, 3, [22, 33])
     func(*'fjs',*'fkj')  # ('f', 'j', 's', 'f', 'k', 'j')
     func(**{'name': '太白'},**{'age': 18})  # {'name': '太白', 'age': 18}
     

   • 仅限关键字参数（了解）

     # 位于*，**之间（c）
     def func(a,b,*args,sex= '男',c,**kwargs,):
         print(a,b)
         print(sex)
         print(args)
         print(c)
         print(kwargs)
     func(1,2,3,4,5,6,7,sex='女',c='666',name='Alex',age=80)
     

   • 形参的最终顺序

     # 形参角度的参数的顺序
     # *args 的位置？
     def func(*args,a,b,sex= '男'):
         print(a,b)
     func(1,2,3,4)
     
     # args得到实参的前提，sex必须被覆盖了。
     def func(a,b,sex= '男',*args,):
         print(a,b)
         print(sex)
         print(args)
     func(1,2,3,4,5,6,7,)
     # 正确顺序:
     def func(a,b,*args,sex= '男'):
         print(a,b)
         print(sex)
         print(args)
     func(1,2,3,4,5,6,7,sex='女')
     
     # **kwargs 位置？
     def func(a,b,*args,sex= '男',**kwargs,):
         print(a,b)
         print(sex)
         print(args)
         print(kwargs)
     func(1,2,3,4,5,6,7,sex='女',name='Alex',age=80)
     
     # 形参角度最终的顺序：位置参数，*args，默认参数，仅限关键字参数，**kwargs
     

2. 名称空间：

   1. • 全局名称空间：

        整个文件里，变量与值，函数名与函数体的对应关系。

      • 局部（临时）名称空间：

        函数体里，变量与值的对应关系，随着函数的结束而消失。

      • 内置名称空间：

        python源码给你提供的一些内置的函数，print，input..

   2. • 加载顺序：

        内置名称空间 ---> 全局名称空间 ----> 局部名称空间（函数执行时）

      • 取值顺序：

        • 就近原则（LEGB原则），且单向不可逆。

        • （从局部找时）局部名称空间 ---> 全局名称空间 ---> 内置名称名称空间

          # 从局部找
          input = '太白金星'
          def func():
              # input = 'alex'
              print(input)
          func()
          
          #从全局找（全局-->内置）
          input = '太白金星'
          def func():
              input = 'alex'
          func()
          print(input)
          

   3. 作用域：

      • 全局作用域：内置名称空间，全局名称空间

      • 局部作用域：局部名称空间

        #  局部作用域可以引用全局作用域的变量
        date = '周五'
        def func():
            a = 666
            print(date)
        print(a)  # 报错,局部使用完既释放。
        func()
        print(a)  # 报错
        
        # 局部作用域不能改变全局变量。
        count = 1
        def func():
            count += 2
            print(count)
        func()  # 报错:local variable 'count' referenced before assignment
        
        # 原因：当python解释器读取到局部作用域时，发现了你对一个变量进行修改的操作，解释器会认为你在局部已经定义过这个局部变量了，他就从局部找这个局部变量，找不到,报错了。
        
        # 使用可以，不能改变
        def func():
            count = 1
            def inner():
                print(count)
            inner()
        func()  # 1
        
        def func():
            count = 1
            def inner():
                count += 1
                print(count)
            inner()
        func()  # local variable 'count' referenced before assignment
        

3. 函数的嵌套（高阶函数）

   # 例1：
   def func1():
       print('in func1')
       print(3)
   
   def func2():
       print('in func2')
       print(4)
   
   func1()
   print(1)
   func2()
   print(2)
   # in func1 3 1 in func2 4 2
   
   # 例2：
   def func1():
       print('in func1')
       print(3)
   
   def func2():
       print('in func2')
       func1()
       print(4)
   
   print(1)
   func2()
   print(2)
   # 1 in func2 in func1 3 4 2
   
   # 例3：
   def fun2():
       print(2)
   
       def fun3():
           print(6)
   
       print(4)
       fun3()
       print(8)
   
   print(3)
   fun2()
   print(5)
   # 3 2 4 6 8 5
   

4. 内置函数 globals locals

   """
   本文件：研究内置函数：globals locals
   """
   a = 1
   b = 2
   def func():
       name = 'alex'
       age = 73
       print(globals())  # 返回的是字典：字典里面的键值对：全局作用域的所有内容。
       print(locals())  # 返回的是字典：字典里面的键值对：当前作用域的所有的内容。
   # print(globals())  # 返回的是字典：字典里面的键值对：全局作用域的所有内容。
   # print(locals())  # # 返回的是字典：字典里面的键值对：当前作用域的所有的内容。
   func()
   

5. 关键字：nonlocal global