第十节

一、函数进阶

1. 动态参数

   • *a r g s —— 聚合位置参数，动态位置参数

     默认返回的是tuple元组

     def eat(*args):  # 函数的定义阶段 *聚合(打包)
         print(args) # tuple
         print(*args) # 函数体中的 *    打散(解包)
     eat(*args) # 打散可得迭代的数据类型

     def eat(a,b,*c):
         print(a)
         print(b)
         print(c)     # tuple
     eat("面条","米饭","馒头","大饼")
     # 返回的是 面条，米饭，(馒头，大饼)

   • k w a r g s —— 聚合关键字参数，动态默认参数

     默认返回的是d i c t字典

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)# 位置 > 关键字

参数位置 > 动态参数位置 > 默认参数位置 > 动态默认参数位置

• 定义的时候 * ** 都是聚合

• 函数体和实际参时 * a r g s 将元组中的元组打散，** k w a r g s将字典中的键获取

• 形参：

  • 位置参数：

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

  • 默认参数：

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

• 实参和函数体：

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

 def eat(*args,**kwargs):  # (万能传参)
     print(args) # tulpe
     print(kwargs) #dict
 lst = [1,23,4,6,7]
 dic = {"key1":1,"key2":3}
 # 应用场景
 eat(lst,dic)
 # ([1, 23, 4, 6, 7], {'key1': 1, 'key2': 3})
 # {}
 eat(*lst,**dic)
 # (1, 23, 4, 6, 7)
 # {'key1': 1, 'key2': 3}
 
 # 数据库  ———— **
 def func(*args,**kwargs):
     print(kwargs)
 func("key"=1,"ke1"=1)# 数据库都是传入的键值对

2. 函数的注释

   def 函数名():
       """
       注释信息
       :return:
       """
       return
   # 函数名.__doc__查看注释内容
   # 函数名.__name__查看函数名称

3. 名称空间

   1，内置空间：Python解释器自带的空间

   2，全局空间：p y文件顶格写的就是全局空间

   3，局部空间：函数体就是局部空间

   • 加载：

     • 内置空间 > 全局空间 > 局部空间

   • 取值：

     • 局部空间 > 全局空间 > 内置空间

   • 作用域：作用域就是作用范围, 按照生效范围来看分为 全局作用域 和 局部作用域

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

     • 局部作用域：局部

4. 函数的嵌套

   • 不管在什么位置，只要出现函数名()就是在调用函数。

     # 混合嵌套:
     def f1():
         print(11)
     ​
     def f2():
         print(22)
         f1()
     ​
     def f3():
         print(33)
         f1()
     ​
     def run():
         f3()
         f2()
         f1()
     run()
     #33
     #11
     #22
     #11
     #11
     ​
     def func(a):
         print(a)
         return f1(foo(a))
     ​
     def foo(b):
         print(b)
         return b + 5
     ​
     def f1(args):
         return args + 10
     ​
     print(func(5))
     #5
     #5
     #20
     ​
     def foo(a):
         a = 10
         def f1(b):
             c = b
             def foo(c):
                 print(c)
                 print(foo.__doc__)
             foo(c)
             print(b)
         f1(a)
         print(a)
     foo(25)
     #10
     #None
     #10
     #10
     ​
     def foo():
         a = 10
         func(a)
     ​
     def func(a):
         print(a)
     ​
     foo()
     #10

5. global 和 nonlocal

   • global ：只修改全局变量，如果全局没有，则创建一个新的

   • nonlocal：只修改局部变量，修改声明nonlocal 最近的一层，上层没有继续向上上层查找；只限制在局部，找不到就报错。

   a = 10
   def func():
       global a
       a = a - 6
       print(a)
   print(a)#10    直接读取全局空间的值
   func()#4
   print(a)#4     global 已经改变了全局空间中a的值
   ​
   ​
   a = 100
   def func():
       b = 10
       def foo():
           b = a# b = a = 100
           def f1():
               nonlocal b
               b = b + 5 # b = 100 + 5
               print(b)  # 105
           f1()
           print(b)  # 105   b的值随着nonlocal改变了
       foo()
       print(b) # 10     读取的是相同空间的值
   func()
   print(a) # 100    全局空间的b 没发生改变

6.