python 收集参数&命名关键字参数、全局变量&局部变量

1.  函数参数

(1) 收集参数（普通收集参数、关键字收集参数）

'''
(1) 普通收集参数 (可变参数)
语法:
def func(*参数名):
    pass

参数前面加上一个 * 的就是普通收集参数;
普通收集参数专门用于收集多余的普通实参，形成一个元组

arg => argument 参数
'''

def func(a, b, c, *arg):
    print(a, b, c, end='\t\t')  # 1, 2, 3
    print('arg: ', arg)   # (4, 5, 6)

func(1, 2, 3, 4, 5, 6)


'''
(2) 关键字收集参数
# 语法
def func(**参数):
    pass
参数前面加上**的就是关键字收集参数
关键字收集参数:用于收集多余的关键字实参,形成一个字典

def func(a, b, c, **kwargs):
    pass

# kwargs => keyword arguments
'''

def func(a, b, c, **kwargs):
    print(a, b, c, end='\t\t')
    print('kwargs: ', kwargs)

func(1, 2, 3, f=11, d=13, zz=99)

  执行结果：

1 2 3        arg:  (4, 5, 6)
1 2 3        kwargs:  {'f': 11, 'd': 13, 'zz': 99}

 

 (2)  命名关键字参数

'''
# 命名关键字
# 语法:
def func(参数1, 参数2, *, 参数3, 参数4):
    pass
(1) 在函数的定义处, * 号后面的参数就是命名关键字参数
(2) 在函数的定义处, 在普通收集参数和关键字收集参数之间的是命名关键字参数
def func(*arg, 命名关键字参数, **kwargs)

命名关键字必须使用关键字实参的形式进行调用
'''

# 形式1
def func(a, b, *, c):
    print(a, b, c)

func(1, 2, c=4)  # 必须写上*号后面的参数名并赋值 c=4

# 形式2
'''
如果命名关键字指定了默认值,那么在调用时,
可以不指定实参.默认使用自己的值
'''
def func(a, b, *, c=5):
    print(a, b, c)

func(1, 2, c=6)  # c为命名关键字默认参数，可以不传，但传参时，必须写上 c=4

# 形式3
def func(*arg, d, **kwargs):
    print(arg)  # 1 2 23
    print(kwargs)  # {c:1,f:2}
    print(d)  # d = 3

func(1, 2, 23, c=1, f=2, d=3)  # d为命名关键字，必须写上 d=xxx

 

2.  变量相关（global / locals / globals / nonlocal）

# 作用域:作用范围
# 命名空间 : 划分一块区域保存所有数据,以字典的方式存储(变量与值形成映射关系).一共三种.
(1)内建命名空间:解释器启动时创建,直到解释器运行结束,生存周期最长
(2)全局命名空间:文件运行时创建,直到解释器运行结束,生存周期较长
(3)局部命名空间:函数调用时,里面的局部变量才创建,调用结束后即释放,生存周期较短
#命名空间的提出是为了划分和控制变量是否可见,以及生存周期的长短.

#命名空间 创建顺序:(了解)
    python解释器启动->创建内建命名空间->创建全局命名空间->创建局部命名空间
#命名空间 销毁顺序:(了解)
    函数调用结束后->销毁函数对应的局部命名空间数据->销毁全局命名空间数据->销毁内建命名空间数据

global    :关键字:声明全局变量获修改全局变量
locals()  :返回字典,当前作用域所有内容(locals调用之前的变量)
globals() :返回字典,存放着全局作用域所有内容
nonlocal  :关键字:修改局部变量(当前函数上一层的局部变量)

（1）global 全局变量的获取和定义

了解 global 之前，先了解一下局部变量和全局变量：
局部变量:在函数内部声明的变量就是局部变量.
全局变量:在函数外部声明的变量或用global关键字在函数内部声明的变量

作用域:作用的范围
局部变量:作用范围在函数的内部
全局变量:作用范围横跨整个文件
'''
python特有:
如果外部存在该全局变量,那么利用global关键字,可以允许在函数内部修改全局变量
如果外部不存在该全局变量,那么利用global关键字,可以允许在函数内部定义全局变量
在使用global 关键字的时候,一般写在函数内部的第一行.
'''

c = 78


def func1():
    a = 1  # 为局部变量
    # 如果不加 global c 只能获取 不能修改
    # 加了global c 告诉系统在函数内部允许修改全局变量c
    global c
    print(c)
    c = 90


def func2():
    global a  # 在函数内部通过global 定义全局变量
    a = 985

 （2）locals 

locals 获取当前作用域的所有变量

'''
locals 获取当前作用域的所有变量
'''
# 获取打印返回值之前的所有内容
a = 10
b = 20
res = locals()
c = res['__name__']
print('c: ', c)
print('res: ', res)
d = 30


# 获取调用 locals 之前的所有的内容
def func():
    f1 = 11
    f2 = 12
    res = locals()
    f3 = 13
    print('func var: ', res)


func()

 执行结果：

c:  __main__
res:  {'__name__': '__main__', '__doc__': '\nlocals 获取当前作用域的所有变量\n', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001B002DE4390>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:\\test.py', '__cached__': None, 'a': 10, 'b': 20, 'res': {...}, 'c': '__main__'}
func var:  {'f1': 11, 'f2': 12}

 

（3）globals

'''
globals 只获取全局变量(无论在函数内外都只获取全局变量)
globals 返回的是系统的 全局命名空间的字典 ,在空间里面放的全局变量
'''

# (1) 如果在函数的外面,获取globals()返回值打印之前, 所有的内容.
a = 5
res = globals()
b = 15
print('函数外部： ', res)  # 拿不到 c 以及之后的元素
c = 26

# (2) globals 如果在函数的里面,获取globals调用之前,所有的内容
# (3) globals 动态创建全局变量


def func():
    f1 = 1
    # globals 如果在函数的里面,获取globals调用之前,所有的内容
    res = globals()
    f2 = 2
    print('函数内部： ', res)
    # globals 可以批量创建全局变量
    for i in range(3):
        res["a%d" % (i)] = i


func()
print('a0: ', a0)
print('a1: ', a1)
print('a2: ', a2)
d = 10

执行结果：

函数外部：  {'__name__': '__main__', '__doc__': '\nglobals 只获取全局变量(无论在函数内外都只获取全局变量)\n', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000017D3B5C4390>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:\\test.py', '__cached__': None, 'a': 5, 'res': {...}, 'b': 15}
函数内部：  {'__name__': '__main__', '__doc__': '\nglobals 只获取全局变量(无论在函数内外都只获取全局变量)\n', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000017D3B5C4390>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:\\test.py', '__cached__': None, 'a': 5, 'res': {...}, 'b': 15, 'c': 26, 'func': <function func at 0x0000017D3B57C1E0>}
a0:  0
a1:  1
a2:  2

 （4）nonlocal (符合LEGB原则)

#找寻变量的调用顺序采用 LEGB 原则(即就近原则)
B —— Builtin(Python)；Python内置模块的命名空间　　(内建作用域)
G —— Global(module)； 函数外部所在的命名空间　　　 (全局作用域)
E —— Enclosing function locals；外部嵌套函数的作用域　　(嵌套作用域)
L —— Local(function)；当前函数内的作用域          (局部作用域)
依据就近原则，从下往上，从里向外，依次寻找

 演示代码：

# nonlocal 修改的是局部变量，不是全局变量.
a = 10


def outer():
    a = 100

    def inner():
        a = 1000

        def smaller():
            nonlocal a  # 修改外层第一个局部变量
            a += 1  # 不可修改，仅可修改容器类型参数
        smaller()
        print(a)

    inner()
    print(a)

outer()
print(a)

 执行结果：

1001
100
10

 

转载于:https://www.cnblogs.com/trent-fzq/p/10891603.html