6.函数的动态参数

*args，**kwargs:能接受动态的位置参数和动态的关键字参数

*args -- tuple

*kwargs -- dict

动态参数优先级：位置参数 > 动态位置参数 > 默认参数(关键字参数) > 动态关键字参数

1.*.args:

接收动态的位置参数，接受任意多个,定义阶段*为聚合，调用阶段*为打散

def func(a,b,*args):#*.args可以替换，*s

    print(a,b,args)

    print(a,b,*args) #*为打散

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

#优先级： 位置参数 > 动态参数

def func(a=1,b=2,*args):#不推荐使用,不会报错

    print(a,b,args)

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

#默认参数放在动态参数后面

def func(*args,a=11,b=12):

    print(a,b,args)

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

#*args:元组，接收位置参数

2.**kwargs:

接收动态的关键字参数

#**kwargs:字典，接收关键字参数。

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

    print(a,b,kwargs)

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

def func(a,b,*args,c=1,d=2,**kwargs):

    print(a,b,args,c,d,kwargs)#*kwargs:获取是字典的键

 print(*kwargs)

func(1,2,3,4,c=8,d=10,e='alex',f='wusir')

3.#*args，**kwargs结合：

def func(*args,**kwargs):

    print(args,kwargs)

func(1,2,3,4,a=5,b=2,c=7)

4.扩展：将列表和字典传进去的方法

#列表

list1 = [12,23,3,4,5,6]

def func(*args):

    print(*args)

func(list1[0],list1[1]...)#笨方法

func(*list1)#用*打散全部上传

#字典

dict1 = {'k1':1,'k2':2}

def func(**kwargs):

    print(kwargs)

func(**dict1)

7.函数的注释：

反射

def func(user,passwd):

    """

    密码加密

    :param user:  用户名  str

    :param passwd:  密码  str

    :return:  加密的密码

    """

    return user,passwd

print(func.__doc__)#查看函数注释

print(func.__name__)#查看函数名

8.名称空间：

全局空间：当前的py文件需要开辟的空间存放在全局空间，(无缩进)

局部空间：函数中开辟的的空间就是局部空间

内置空间：用于存放内置函数

#每一次运行，都一定会加载内置空间和全局空间

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

取值顺序：局部空间 > 全局空间 > 内置空间

作用域：

全局作用域：内置空间 + 全局空间

局部作用域：局部空间

10.函数的嵌套

1.简单嵌套

def func():

    print(1)

    def f1():

        print(2)

    return f1()#f1没有返回值，默认返回None

func()#结果： 1  \n 2

#不管在什么位置，只要是函数名+(),就是调用此函数

def func():

    a = 1

    def foo():

        b = 2

        print(b)

        print(a)

        def f1():

            print(b)

        return f1()

    return foo #返回的是foo的内存地址，没有(),表示没有调用foo函数

print(func())#结果：<function func.<locals>.foo at 0x000002C49CBADD90>

#**调用foo.

def func():

    def foo():

        a = 1

        print(a)

    return doo

#a = func(),得到foo的内存，然后a()调用foo

a = func()

a()

2.函数的互相引用：

def func():

    a = 1

    foo()

    print(a)

def foo():

    b = 2

    print(b)

func()#结果： 2 \n 1

foo()#结果：2

同级函数：同级局部空间的数据不共享

def a():

    a = 1

    c()

    print(c)

def b():

    b = 2

    print(b)

def c():

    c = 3

    print(a)

def run():

    a()

run()#结果

#<function a at 0x0000015464512F28>

#<function c at 0x00000154661DDC80>

#同级局部空间的数据不共享，输出的是函数名对应的内存地址

3.函数嵌套的参数传递：

def func(a):

    foo(a)

def foo(e):

    b(e)

def b(c):

    print(c)

func(15)#结果：15

def func(a):

    foo(a)

def foo(e):

    b(e)

def b(c):

    print(c)

    return 10

print(func(15))#结果：15  \n None

#每一个函数都需要返回上一层结果才能返回最深层结果

def func(a):

    return(foo(a))

def foo(e):

    return(b(e))

def b(c):

    print(c)

    return 10

print(func(15))#结果：15  \n 10

11.global,nonlocal

1.global:

声明全局变量,可以修改全局变量

a = 10

def func():

    #a += 1#局部不可修改全局数据

    global a#声明全局变量，可以修改

    a +=1

    print(a)

func()

print(a)

2.nonlocal：

nonlocal声明的变量不是局部变量,也不是全局变量,而是外部嵌套函数内的变量

在外层的函数中，修改局部空间内的变量值，完全不涉及全局空间的变量，只修改此函数最近的上层的变量，上一层没有，继续向上寻找，直到最外层函数，如果最外层也没有，就报错。

a = 10

def func():

    def f1():

        a = 12

        def fool():

            nonlocal a

            a += 1

            print(a) #13

        print(a)# 12

        fool()

        print(a)#13

    print(a)# 10

    f1()

    print(a)#10

func()

print(a) #10

巴特西

python函数知识二动态参数、函数的注释、名称空间、函数的嵌套、global,nonlocal

6.函数的动态参数

1.*.args:

2.**kwargs:

3.#*args，**kwargs结合：

4.扩展：将列表和字典传进去的方法

7.函数的注释：

反射

8.名称空间：

10.函数的嵌套

1.简单嵌套

2.函数的互相引用：

3.函数嵌套的参数传递：

11.global,nonlocal

1.global:

2.nonlocal：

最新文章

热门文章

巴特西

python函数知识二 动态参数、函数的注释、名称空间、函数的嵌套、global,nonlocal

6.函数的动态参数

1.*.args:

2.**kwargs:

3.#*args，**kwargs结合：

4.扩展：将列表和字典传进去的方法

7.函数的注释：

反射

8.名称空间：

10.函数的嵌套

1.简单嵌套

2.函数的互相引用：

3.函数嵌套的参数传递：

11.global,nonlocal

1.global:

2.nonlocal：

最新文章

热门文章

python函数知识二动态参数、函数的注释、名称空间、函数的嵌套、global,nonlocal