10函数的进阶

动态函数

# def func(a,b,c,*args):  # 在形参位置*叫做聚合
#     print(a,b,c)
#     print(args)   # 元组形式
#
# func(1,2,3,4,5,9,6,7,8)
结果
1 2 3
(4, 5, 9, 6, 7, 8)

*args  是动态关键字参数,在形参位置*叫做聚合,*args会把位置参数没有对应上的元素都'吃'掉,组成一个元组.

#位置参数大于动态参数.

# func(a=1,b=2,c=3) # 关键字的形式传参

# def func(**kwargs): # 动态默认参数  #形参的时候**聚合 #    
 print(kwargs)  # 字典

# def func(a,b,c,*args,x=1,y=1,z=1,**kwargs):
#     print(a,b,c)
#     print(args,kwargs)
#     print(x, y, z)
#     # 1 2 3
#     # (1,2,3,4,5)
#     # 1 1 1
#     # {'a': 1, 'b': 1, 'c': 1}
# func(1,2,3,4,e=1,f=2,g=3)

**kwargs      动态关键字参数

# args 和 kwargs 是可以更换的，但是程序员约定都用它

# 用途：在不明确接收参数、数量时使用*args和**kwargs

# 位置参数>动态的位置参数

# 形参：位置>动态位置>默认参数>动态默认参数

# 实参：位置>关键字参数

*和**的用法:

# 在实参调用的时候 *将可迭代的对象打散，字典是将键取出

# 在形参出现*就是在聚合

# 在实参调用的时候，**将字典打散成  关键字参数（键=值）

# 在形参处出现**就是将关键字参数聚合成一个字典。

# def func(a,b,c,*args,x=1,y=1,z=1,**kwargs):
#     print(a,b,c)
#     print(args,kwargs)
#     print(x, y, z)
#     # 1 2 3
#     # (1,2,3,4,5)
#     # 1 1 1
#     # {'a': 1, 'b': 1, 'c': 1}
# func(1,2,3,4,e=1,f=2,g=3)

 

注意：参数arg、*args、**kwargs三个参数的位置必须是一定的。必须是(arg,*args,**kwargs)这个顺序，否则程序会报错。

 

1. 函数的注释

print(aaa._doc_) 查看注释

#     2.1 函数的注释:
#         """ """ 官方推荐
#        查看注释: func名.__doc__
#        查看注释: func名.__name__

名称空间

1. 内置空间中所有代码——内置空间
2. 自己写的py文件——全局空间
3. 函数中的代码——局部空间

*注：

       加载顺序：
                     内置空间——>全局空间——>局部空间

       查找值的顺序：

                     局部空间——>全局空间——>内置空间——>报错

              作用域：

                            全局作用域 内置+全局=全局作用域

                            局部作用域 函数内的就是局部作用域

a = 10

def func():
    global a        global：声明a为全局变量。//找到要修改的值，修改后放回
    a += 1

func()
print(a)

global 和 nonloca   

global声明全局找全量,

nonloca   

nonloca  是在函数嵌套里面找上一级变量,但是只能在函数里面找,不能找到全局

 

 

# 加载顺序: ''' 1.内置空间 2.全局空间 3.局部空间 '''

 

# 取值顺序: ''' 1.局部空间 2.全局空间 3.内置空间 4.找不到就报错 '''

 

# 作用域: ''' 1.全局作用域  内置+全局 = 全局作用域 2.局部作用域  函数内的就是局部作用域 '''

 

# a = 10
# def func():
#     global a  # (声明)我要修改a 找到要a
#     a+=1      # 修改
# func()
# print(a)

# def func():
#     global a  #(声明我要修改a,找不到a的时候在全局创建一个 a=0)
#     a = 1  # a = 1
# func()
# print(a)

函数的嵌套:

 

# 第一种函数嵌套 在函数func内
# def func():
#     print(3)
#     def f():
#         print(1)
#     print(2)
#     f()
# func()
# 第一种函数嵌套 在函数func内
# def func():
#     print(3)
#     def f():
#         print(1)
#     print(2)
#     f()
# func()

# 在一个局部空间内,nonlocal会修改离他最近的那个变量,如果上一层
# 没有就继续向上找,直到走到局部空间头部

# global : 在局部修改全部变量,如果没有就创建一个新的
# nonlocal : 在局部空间内,修改离自己最近的变量,如果上一层没有就继续向上找,
# 直到找到局部变量的顶层,局部空间内没有可以修改的变量,就报错

坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!11