动态参数

三元运算

变量 = 条件成立的结果 条件判断 条件不成立的结果(只能两种结果)

lst = [1,2,2,4,5,6]
def func(a):
    return "大了" if len(a) > 5 else "不大"
func(lst)

a = 10 
b = 20
c = a if a > b else b
#变量名 = 条件成立的结果  条件判断   条件不成立的结果

enumerate:枚举

enumerate(枚举对象,计数起始数字(默认0))

函数的动态参数

参数

位置参数

默认参数

动态传参(万能传参)

def func(*arges)#*args 万能(接收任意多个)的位置参数  *在函数定义的时候叫做聚合
	print(*args)#*打散
	print(args)#以元组形式展示
func(1,2,3,4,5,6,74,8,8,9,)

位置参数>动态位置参数>默认参数>动态关键字参数

def func(*args,a=1,b=2,):
    print(a,b,args)
func(1,2,1,132,13,21,22,3)

*args 动态接受位置参数 **kwargs动态接受关键字参数

def func(a,b,**kwargs):
    print(a, b,* kwargs)#拿到的时键
    print(a,b,kwargs)#字典(接受的关键字参数)
func(1,2,c=1,d=2)
结果:
1 2 {'c': 1, 'd': 2}

def func(a,b,*args,c=1,d=2,**kwargs):
    print(a,b,args,c,d,kwargs)
func(1,2,3,4,c=8,d=10,e="dsadsa",f="dsafa")
结果:
1 2 (3, 4) 8 10 {'e': 'dsadsa', 'f': 'dsafa'}

def func(*args,**kwargs):#万能传参
    print(args,kwargs)

def func(*args):#打包    
    print(*args)#打散
lst = [ 1, 2,2,2]
func(*lst)#打散

结果:
1 2 2 2

def func1(**kwargs):
    print(kwargs)
dic ={"1":2,"2":3,"2":4}
func1(**dic
结果:
{'1': 2, '2': 4}

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

1.万能传参 : 动态位置参数,动态关键字参数(最常用的)

2.位置参数: 动态位置参数

3.动态位置参数,关键字参数,动态关键字参数

函数的注释

def func(a,b,c,d):
    """
    逻辑判断...
    :param a:str
    :param b:int
    :param c:bool
    :return:
    """
    print(a,b,c,d)

def func1(user,password):
    """
    密码加密
    :param user:用户名 str
    :param password: 密码 str
    :return: 加密的密码 MD5
    """
    print(user,password)
func(1,2,2,1)
print(func.__doc__)
print(func1.__doc__)#查看注释

名称空间

内置空间:print input len 解释器定义好的

全局空间:当前的py文件中需要开辟的空间存放在全局空间

局部空间:函数体内的开辟的空间就是局部的空间

加载顺序:

内置空间>全局空间>局部空间

执行顺序:

局部空间>全局空间>内置空间(找不到就报错)

作用域:

全局作用域:内置空间加全局空间

局部作用域:局部空间

函数的嵌套

不管在什么位置,只要是函数名加括号就在在调用此函数

函数调用执行后,函数体中开辟的空间就自动销毁

def func():
    print(1)
    def f1():
        print(2)
    return f1()
func()
结果
1
2

def func():
    a = 1
    def foo():
       b = 2
       print(b) #b = 2
       print(a) #a = 1
       def f1():
            print(b)
       return f1()
    return foo
print(func())
结果:
<function func.<locals>.foo at 0x00000295C9D9CB70>

def func():
    a = 1
    def foo():
       b = 2
       print(b) #b = 2
       print(a) #a = 1
       def f1():
            print(b)
       return f1()
    return foo()
print(func())
结果:
2
1
2
None

函数互相引用

def func():
    a = 1
    foo()
    print(a)
def foo():
    b = 2
    print(b)
func()
结果:
2
1

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 0x000001AD3E8ECAE8>
<function c at 0x000001AD3E8ECBF8>


def func():
    a = 1
    def b():
        print(a)
def foo():
    b = 1
    def z():
        print(func)
        print(b)
    ret = z()
    func()
    return ret
def run():
    foo()
print(run())
结果:
<function func at 0x000002294FC9CAE8>
1
None

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(5))
结果
5
None

def func(a):

    return foo(a)

def foo(e):
    return b(e)

def b(c):
    print(c)
    return 10
print(func(5))
结果
5
10

global nonlocal

global #声明 修改全局空间变量对应的值

a = 1
def f1():
    a = 10
    print(a)#10
    def f2():
        a = 15
        print(a) #15
        def f3():
            global a
            a += 1
            print(a)#2
        print(a)#15
        f3()
    print(a)#10
    f2()
    print(a)#10
f1()
结果:
10
10
15
15
2
10

nonlocal --在外层的函数中,修改局部空间的变量值,完全不涉及全局空间,只修改离他最近的一层的变量名,最近的一层没有变量,继续向上找,直到找到最外层函数

a = 1
def func():
    a = 10
    print(a)#10
    def foo():
        a = 15
        def f1():
            nonlocal a
            a += 5
            print(a)#25
        print(a)#20
        f1()
        print(a)#25
    print(a)#10
    foo()
    print(a)#15
print(a) #1
func()
结果:
1
10
10
15
20
20
10