函数的进阶

一、动态参数

def func(): # 形参

　　pass

func() # 实参

args和 kwargs 是可以更换的,但是程序员约定都用它

用途:在不明确接受参数,数量时使用*args和**kwargs

def func(*args):
    print(args)
func(1,2,3,)
#结果   （1，2，3）是一个元祖

def func(a,b,c,*args):  # 在形参位置*叫做聚合
    print(a,b,c)
    print(args)   # 元组形式
func(1,2,3,4,5,9,6,7,8)

#结果：
1 2 3
(4, 5, 9, 6, 7, 8)

位置参数 > 动态的位置参数

def func(**kwargs): # 动态默认参数  #形参的时候**聚合
    print(kwargs)  # 字典

func(a=1,b=2,c=3) # 关键字的形式传参

#结果： {'a': 1, 'b': 2, 'c': 3} 

def func(*args,**kwargs):    #动态参数 > 动态默认参数
    print(args,kwargs)
func(1,2,3,a=1,b=2,c=3)

#结果：
(1, 2, 3) {'a': 1, 'b': 2, 'c': 3}

动态参数 > 动态默认参数

def func(a,b,*args,**kwargs):     #位置参数 > 动态参数  > 动态默认参数
    print(a,b)
    print(args,kwargs)
func(1,2,3,4,5,d = 2,e = 3,f = 4)
#结果：
1 2
(3, 4, 5) {'d': 2, 'e': 3, 'f': 4}

位置参数 > 动态参数  > 动态默认参数

def func(a,b,*args,x = 66 ,y = 666 ,z = 6,**kwargs):
    print(a,b)
    print(x,y,z)
    print(args,kwargs)
func(1,2,3,4,5,6,d = 2,e = 3,f = 4)
 
#结果：
1 2
66 666 6
(3, 4, 5, 6) {'d': 2, 'e': 3, 'f': 4}

 

形参: 位置 > 动态位置 > 默认参数 > 动态默认参数

实参: 位置 > 关键字参数

在实参调用的时候 *将可迭代的对象打散,字典是将键取出

在形参处出现*就是在聚合

在实参调用的时候 **将字典打散成  关键字参数(键=值)

在形参处出现**就是将关键字参数聚合成一个字典

def func(*args,**kwargs): # * 聚合
    print(*args) # args = ()  *args = 1 2 3  *打散
    print(*kwargs) # args = ()  **kwargs = a,b  *打散 字典的键
func(1,2,3,a=4,b=5)

#结果：1 2 3
      #a b

li = [1,2,3,5,4]

def func(*args):  # 聚合 (1,2,3,5,4)
    print(args)
    print(*args)  # 打散 1,2,3,5,4
func(*li)         # 1,2,3,5,4

 

dic = {'a':1,'b':2}
def func(*args,**kwargs):  
    print(args,*kwargs)    #() a b
func(**dic)                # 将键打散

二、函数的注释

def log(user,pwd):

    """

    登录函数

    :param user: 用户名

    :param pwd: 密码

    :return: 校验后的账号和密码

    """

    print(111)

# print(log.__doc__)

#简单了解

# print(log.__name__) # 反射

三、名称空间

1.内置空间中所有代码  -- 内置空间

2.自己写的py文件      -- 全局空间

3.函数中的代码        -- 局部空间

a = 10

def func():
    a = 1
    print(a)
func()
print(a)   
#      1       10

# 加载顺序:

1.内置空间       2.全局空间      3.局部空间

# 取值顺序:

1.局部空间      2.全局空间    3.内置空间      4.找不到就报错

# 作用域:

1.全局作用域  内置+全局 = 全局作用域

2.局部作用域  函数内的就是局部作用域

四、函数的嵌套

函数嵌套内,从最里层返回一个任意字符串,在外部接受打印

# 第一种函数嵌套 在函数func内

def func():
    print(3)
    def f():
        print(1)
    print(2)
    f()
func()

#   3
#   2
#   1

 

# 第二种函数嵌套 多个函数嵌套调用

def func2():
    print(1)
    log()

def func1():
    print(3)

def log():
    func1()
    print(6)
    def fun():
        print(7)

#函数没有调用，没有输出结果

def func2():
    print(1)
    log()

def func1():
    print(3)

def log():
    func1()
    print(6)
func2()

#   1
#   3
#   6

 

def func():
    a = 1
    def log():
        a = 5
        def info():
            a = 10
            print(a)
        info()
        print(a)
    log()
    print(a)
func()

 

五、gloabal、nonlocal

gloabal

a = 10
def func():
    global a  # (声明)我要修改a 找到要a
    a+=1      # 修改
func()
print(a)
#11

 

def func():
    global a  #(声明我要修改a,找不到a的时候在全局创建一个 a=0)
    a = 1  # a = 1
func()
print(a)

nonlocal

def func():
    a = 1
    def log():
        a = 5  # a = 15
        def info():
            nonlocal a # 声明修改log函数下边的变量a
            a += 10   # a = a + 10  a = 15
            print(a)  # 15
        info()
        print(a)  # 15
    log()
    print(a)  # 1
func()
#   15
#   15
#   1

def f():
    a = 1
    print(a)
    def a1():
        a = 5
        print(a)
        def l():
            nonlocal a
            a = 8
            print(a)
        l()
        print(a)
    print(a1())
f()