python中的命名空间以及函数的嵌套

一.动态传参

函数的形参中除了默认值参数和位置参数外,还有动态传参.当不确定形参有几个或者有很多的时候,就可以使用动态传参.

1.1 动态接收位置参数

在python中使用*来接收动态位置参数

 def chi(*food):    #只有动态参数
     print('我要吃',*food)
 chi('饭','肉','鱼')   #我要吃 饭 肉 鱼

 def chi(a,b,*food):    #动态参数和位置参数
     print('我要吃',*food)
 chi('饭','肉','鱼','桃子','苹果')   #我要吃 鱼 桃子 苹果

 def chi(*food,a,b):
     print('我要吃',*food)
 chi('饭','肉','鱼','桃子','苹果')   #chi() missing 2 required keyword-only arguments: 'a' and 'b'
 #★动态参数必须在位置参数的后面,否则就全被动态参数给收了

 def chi(a,b,*food,c='哈哈'):    #动态参数和位置参数和默认值参数
     print('我要吃',*food,c)
 chi('饭','肉','鱼','桃子','苹果')   #我要吃 鱼 桃子 苹果 哈哈
 #★顺序位置参数,动态参数,默认值参数

1.2动态接收关键字参数

在python中使用**来接收动态关键字参数

 def chi(**food):     #只有动态关键字参数
     print(food)
 chi(a='收到',b=1,c=6)   #{'a': '收到', 'b': 1, 'c': 6}

 def chi(a,b,**food):     #动态关键字参数和位置参数
     print(a,b,food)
 chi('sd','zc',n='收到',z=1,x=2)  # 3sd zc {'n': '收到', 'z': 1, 'x': 2}

 def chi(a,b,c='哈哈',**food):     #动态关键字参数和位置参数和默认值参数
     print(a,b,c,food)
 chi('sd','zc',n='收到',z=1,x=2)   #sd zc 哈哈 {'n': '收到', 'z': 1, 'x': 2}

★★★最终顺序:位置参数>*args>默认值参数>**kwargs★★★

这四种参数可以任意的进行使用

如果想接受所有的参数:

 def func(*args,**kwargs):   #无敌
     print(args,kwargs)
 func(0,1,2,'及',a=1,b=2,c='积极')    #(0, 1, 2, '及') {'a': 1, 'b': 2, 'c': '积极'}
 ##############接收到的动态位置参数保存在元组中,接收到的动态关键字参数保存在字典中############

1.3 打散和聚合

 def func(*args):
     print(args)
 lis=[1,2,3,4,5]
 func(lis)    #([1, 2, 3, 4, 5],)

 ##################将一个可迭代对象打碎需要在这个可迭代对象前加*#######################
 def func(*args):
     print(args)
 lis=[1,2,3,4,5]
 func(*lis)   #(1, 2, 3, 4, 5)

 #如果是字典

 def func(**kwargs):
     print(kwargs)
 dic={1:'a',2:'b',3:'c',4:'d',5:'e'}
 func(**dic)     #TypeError: func() keywords must be strings打散之后变成了1='a'不符合逻辑

 ##################这里字典的键只能是字符串类型####################

 def func(**kwargs):
     print(kwargs)
 dic={'A':'a','B':'b','C':'c','D':'d','E':'e'}
 func(**dic)    #{'A': 'a', 'B': 'b', 'C': 'c', 'D': 'd', 'E': 'e'}

 #########################形参的位置*,**: 聚合;实参的位置*,**: 打散#############################

1.4 函数的注释

 #在函数名下且只能在函数名下,输入多行注释即可产生
 def func(**kwargs):
     '''
     这个位置写当前函数是干什么的
     :param kwargs: kwargs参数是什么意思
     :return: 返回值是什么玩意
     '''
     print(kwargs)
 dic={'A':'a','B':'b','C':'c','D':'d','E':'e'}
 func(**dic)

二.命名空间

2.1

在python解释器开始运行之后,就会在内存中开辟一个空间,每当遇到一个变量的时候,就会把变量名和值之间的关系记录下来,当遇到函数定义的时候,解释器只是把函数的名读入内存,表示这个函数存在了,至于函数内部的变量和逻辑,解释器是不关心的,也就是说,一开始函数只是加载进来,只有当函数被调用或访问的时候,解释器才会根据函数内部声明的变量开辟内存空间,但是,随着函数的执行完毕,这些函数内部变量占用的空间也会随着函数的执行完毕而被清空.

 def func():
     a=10
     print(a)
 func()
 print(a)   #此时的a不存在

命名空间 :存放名字和值之间的空间

命名空间的分类:

1.全局命名空间:函数外声明的变量都属于全局命名空间

2.局部命名空间:在函数中声明的变量会放在局部命名空间

3.内置命名空间:python解释器为我们提供的名字,list,tuple......

加载顺序:

1.内置命名空间

2.全局命名空间

3.局部命名空间

2.2作用域就是作用范围.

1.全局作用域

2.局部作用域

 a=10
 def func():
     a=40
     b=20
     def abc():
         print('哈哈')
     print(a,b)
     print(globals())    # 'a': 10, 'func': <function func at 0x0000025C198F2EA0>
     print(locals())     # 'b': 20, 'a': 40
 func()
 #####通过globals()函数来查看全局作用域中的内容,通过locals()函数来查看局部作用域中的内容

2.3 关键字global和nonlocal

global: 在局部访问全局中的内容
nonlocal: 在局部寻找外层函数中离他最近的那个变量

以上是有nonlocal的情况:
一下是没有nonlocal的情况: