动态参数(函数),函数嵌套,命名空间

   一.态参数即动态接受位置参数或是关键字参数

1.动态接受位置参数

def func(*args):
    print(args)
func("food","drink")     #得到的是("food","drink")   元组

def func(name,*args):  #需要注意  位置参数必须在位置动态参数前面
    print(name,args)
func("food","drink","ice")  #结果是 food ("drink","ice")

 

 

如果动态位置参数一定要写在位置参数前面,则实参需要用关键字传参

def func(*args,name,):  
    print(name,args)
func("food","drink",name="ice")  #结果是 ice ,("food","drink")

 

 

如果形参中you默认值参数,则默认值参数要写在位置动态参数后面.

def chi(a, b, *food, c="娃哈哈"):
print(a, b, food, c)
chi("⾹香蕉", "菠萝") # ⾹香蕉 菠萝 () 娃哈哈 默认值生效
chi("⾹香蕉", "菠萝", "葫芦娃") # ⾹香蕉 菠萝 ('葫芦娃',) 娃哈哈 默认值⽣生效
chi("⾹香蕉", "菠萝", "葫芦娃", "⼝口罩") # ⾹香蕉 菠萝 ('葫芦娃', '⼝口罩') 娃哈哈 默
认值生效     可以利用关键字参数进行修改默认值参数

如果默认值参数在位置动态参数之前,则只有一种情况生效. 
就是实参只传两个实参,也可以利用关键字和未知参数进行更改默认值参数.

2,动态接受关键字参数

def func(**kwargs):
    print(kwargs)
func(a = "wahaha")        #{'a': 'wahaha'}

需要注意的是   函数调用的时候位置参数一定要放在关键字参数前面,否则会报错

最终程序
形参   位置参数   *args    默认值参数    **kwargs   
可以随意组合调用,单位之不能变

3,无敌传参

def func(*args, **kwargs):    顺序不能变
print(args, kwargs)
func("麻花藤","⻢马晕",wtf="胡辣汤")

4,动态传参的另外一种方式   打散

 

def func (*args):
    print(args)
lst = [1,2,3,4]
func(*lst)    #(1, 2, 3, 4)   调用的时候用 * 对列表进行了打散
只要是可迭代对象都可以被打散


============================================================

def func (**kwargs):
    print(kwargs)
dic = {"x":"a","y":"b"}  # x,y不能用纯数字和数字开头
func(**dic)          #{'x': 'a', 'y': 'b'}

调用的时候用 ** 对字典进行了打散  注意

5,函数的注释

 

def func (**kwargs):
    '''
    
    :param kwargs: 
    :return:                   #引号里面的即函数的注释,也叫文档注释
    '''
    print(kwargs)
dic = {"x":"a","y":"b"}
func(**dic)    #{'x': 'a', 'y': 'b'}

 

 

二.命名空间

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

def fun():
    a = 10
    print(a)
fun()
print(a) # a在pytharm 中 已经飘红了  不存在了已经..

 

我们给存放名字和值对应关系的空间叫  命名空间

命名空间分类

全局命名空间   我们直接在py⽂文件中, 函数外声明的变量量都属于全局命名空间

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

内置命名空间   存放python解释器为我们提供的名字, list, tuple, str, int这些都是内

置命名空间

 加载顺序:

内置命名空间    全局命名空间   局部命名空间(函数b被执行的时候)

取值顺序:

局部命名空间   全局命名空间   内置命名空间

1.  作用域   分为全局作用域和全局作用域

全局作用域包含   内置命名空间和全局命名空间  

局部作用域   局部命名空间

我们可以使用globals()  查看全局作用域的内容

b = "nihao"
def fun():
    a = 10
    print(a)
    def a():
        c = 90
fun()
print(globals())

结果是

C:\Users\Administrator\AppData\Local\Programs\Python\Python37-32\python.exe F:/15期/8月份/练习.py
10
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0045DCB0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'F:/15期/8月份/练习.py', '__cached__': None, 'b': 'nihao', 'fun': <function fun at 0x00548540>}

 

绿色的是内部命名空间  红色的是全局命名空间

 

我们可以使用locals()  查看当前作用域的内容

def fun():
    a = 10
    print(a)
    def a():
        c = 90
fun()
print(locals())
===========================================================
结果是

C:\Users\Administrator\AppData\Local\Programs\Python\Python37-32\python.exe F:/15期/8月份/练习.py
10
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0045DCB0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'F:/15期/8月份/练习.py', '__cached__': None, 'b': 'nihao', 'fun': <function fun at 0x005C8540>} 

注意的是和上面的是一样的,因为locals()  放在全局的位置

如果locals()换个位置 就是不一样的答案了

 

如果locals()换个位置 就是不一样的答案了

a = 10
def func():
    a = 40
    b = 20
    def abc():
        print("哈哈")
    print(a, b) # 这⾥里里使⽤用的是局部作⽤用域
    print(globals()) # 打印全局作用域中的内容
    print(locals()) # 打印当前作用域中的内容
func()

结果是

40 20
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0044DCB0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'F:/15期/8月份/练习.py', '__cached__': None, 'a': 10, 'func': <function func at 0x004F8540>}
{'a': 40, 'b': 20, 'abc': <function func.<locals>.abc at 0x004F85D0>}

红色的表示全局空间的内容   绿色表示的当前即局部作用域内容

 三  函数的嵌套

a = 80   #90  99
def c():
    global a
    a = 90
    print(a)
    b = 78
    global a
    a = 29
    def d():
        nonlocal b
        a = 32
        b = 60
        # nonlocal b
        # b = 79
        print(b)
        print(a)
        def e():
            global a
            a = 99
            a = 59  #19
            print(b)
            print(a)
            def f():

                a = 19
                print(a)
            f()
        print(a)
        e()
        print(a)
    print(b)
    b = 39  #60  79
    print(b)
    d()
    print(b)
print(a)
c()

 

 四 关键字   global   nonlocal

 首先我们现在在全局声明一个全局变量,然后在局部调用这个变量,并改变这个变量的值

 

 

a = 10
def func():
    global a
    a = 90
    print(a)
print(a)
func()
print(a)#  结果为10,90,90  

# lst = ["麻花藤", "刘嘉玲", "詹姆斯"]
# def func():
#     lst.append("马云云") # 对于可变数据类型可以直接进行访问. 但是不能改地址. 说白
                            址,说白了不能赋值
# print(lst)
# func()
# print(lst)
得到的结果是

['麻花藤', '刘嘉玲', '詹姆斯']
['麻花藤', '刘嘉玲', '詹姆斯', '⻢马云云']

nonlocal 表⽰示在局部作⽤用域中, 调用父级命名空间中的变量

a = 10
def func1():
　　a = 20
　　def func2():
　　　　nonlocal a
　　　　a = 30
　　　　print(a)
　　func2()
　　print(a)
func1()

 

 

 

 函数注释
# def func(a, b):
#     """
#     这个函数是用来计算a和b的和
#     :param a: 第一个数据
#     :param b: 第二个数据
#     :return: 返回的是两个数的和
#     """
#     return a + b
#
# print(func.__doc__) # document文档