函数的进阶

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

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

def func(**kwargs): # 动态默认参数 #形参的时候**聚合
print(kwargs) # 字典---->{'a':1,'b':2,'c':3}
func(a=1,b=2,c=3) # 关键字的形式传参

 

def func(a,b,c,*args,x=1,y=1,z=1,**kwargs):
    print(a,b,c)         1 2 3
    print(args,kwargs)  (4,) {'e': 1, 'f': 2, 'g': 3}
    print(x, y, z)       1 1 1
func(1,2,3,4,e=1,f=2,g=3)

# def func(*args,**kwargs): # * 聚合
# print(*args) # args = () *args = 1 2 3 *打散
# print(*kwargs) # args = ()  *打散 字典的键a ，b          **kwargs =(a=4,b=5)但是这种形式的print打印不出来 
# func(1,2,3,a=4,b=5)

# 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   



# func(**dic)    可以将字典打散成a=1,b=2的形式           
# dic = {'a':1,'b':2}


# def func(*args,**kwargs):  # 聚合 
#     print(args,*kwargs)  
# func(*[1,2,3])                

# args和 kwargs 是可以更换的,但是程序员约定都用它
# 用途:在不明确接受参数,数量时使用*args和**kwargs
# 动态位置参数 > 动态关键字参数
# 形参: 位置 > 动态位置 > 默认参数 > 动态默认参数
# 实参: 位置 > 关键字参数
# 在实参调用的时候 *将可迭代的对象打散,字典是将键取出
# 在形参处出现*就是在聚合
# 在实参调用的时候 **将字典打散成 关键字参数(键=值)
# 在形参处出现**就是将关键字参数聚合成一个字典

 

 

 函数的的注释

def aaa(user,pwd):
"""
登录函数
:param user: 用户名
:param pwd: 密码
:return: 校验后的账号和密码
"""
print(111)

# print(aaa.__doc__)

#简单了解
# print(aaa.__name__) # 反射？

名称空间

# 1.内置空间中所有代码 -- 内置空间
# 2.自己写的py文件 -- 全局空间
# 3.函数中的代码 -- 局部空间

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

# 加载顺序:
'''
1.内置空间
2.全局空间
3.局部空间
'''

# 取值顺序:
'''
1.局部空间
2.全局空间
3.内置空间
4.找不到就报错
'''

# 作用域:
'''
1.全局作用域 内置+全局 = 全局作用域
2.局部作用域 函数内的就是局部作用域
'''

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

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

 函数的嵌套

# 第一种函数嵌套 在函数func内
# def func():
#     print(3)
#     def f():
#         print(1)
#     print(2)
#     f()
# func()


# 第二种函数嵌套 多个函数嵌套调用
# def func2():
#     print(1)
#     log()
#
# def func1():
#     print(3)
#
# def log():
#     func1()
#     print(6)
#     def fun():
#         print(7)

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


# 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()


# 在一个局部空间内,nonlocal会修改离他最近的那个变量,如果上一层
# 没有就继续向上找,直到走到局部空间头部

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

# global : 在局部修改全部变量,如果没有就创建一个新的
# nonlocal : 在局部空间内,修改离自己最近的变量,如果上一层没有就继续向上找,
# 直到找到局部变量的顶层,局部空间内没有可以修改的变量,就报错