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

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: Python 中的全局变量是在函数外部定义的变量,可以在程序的任何位置进行访问和修改。在函数内部可以使用 `global` 关键字来声明一个变量全局变量,这样就可以在函数内部修改这个全局变量的值。 例如,下面的代码定义了一个全局变量 `count`,并在函数 `increment()` 中使用了 `global` 关键字来声明 `count` 为全局变量: ```python count = 0 def increment(): global count count += 1 print(count) increment() # 输出 1 increment() # 输出 2 ``` 注意,如果在函数内部没有使用 `global` 关键字来声明变量全局变量,那么 Python 会将它视为局部变量,而不是全局变量。如果在函数内部对这个变量进行修改,那么只会影响到函数内部的这个局部变量,而不会影响到全局变量。 ### 回答2: Python中,全局变量是在程序的所有函数之外声明的变量,可以在整个程序中的任何地方使用。 声明全局变量的方法是在函数外部直接使用变量名进行赋值,不需要使用任何关键字。 在函数内部,如果要访问全局变量,需要使用关键字`global`来标识该变量全局变量,否则会被当作局部变量处理。 如果在函数内部对全局变量进行修改,在函数调用结束后,全局变量的值也会被修改。 全局变量的作用范围是整个程序,可以在不同的函数中进行访问和修改。 全局变量的好处是可以在不同的函数中共享数据,简化了函数之间传递参数的过程。 然而,滥用全局变量可能导致程序的可读性和可维护性降低,容易造成变量之间的混淆和不必要的依赖关系。 因此,在编程中应该尽量避免过多地使用全局变量,可以使用函数的参数来传递数据,或者使用局部变量来处理函数内部的计算。 ### 回答3: 在Python中,全局变量是在函数外部定义的变量,其作用域在整个程序中都是可见的。全局变量可以在程序的任何地方使用,包括函数内部。如果在函数内部对全局变量进行修改,需要使用`global`关键字来声明该变量全局变量全局变量的好处是可以在整个程序中共享数据,方便在不同函数之间传递信息。另外,全局变量可以在函数内部被修改,然后在其他地方使用该变量的新值。 然而,滥用全局变量也具有一些问题。首先,全局变量容易导致命名冲突,如果多个函数中出现同名的全局变量,可能会引起代码中的混乱。其次,全局变量破坏了封装性,使得函数之间的依赖性增加,降低了代码的可维护性和可测试性。 因此,在使用全局变量时需要明智地选择使用场景,并尽量减少全局变量的使用。可以考虑使用函数参数和返回值来传递信息,或者使用对象的属性来保存状态。此外,模块间的变量也可以通过导入模块的方式进行共享。 总结起来,全局变量Python中是一种便捷的共享数据的方式,但需要注意命名冲突和代码混乱的问题,并尽量避免滥用。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值