python基础（*args,**kwargs、聚合与打散、函数注释与嵌套、名称空间与global,nonlocal使用）

一、参数的高级方法：

　　1.1 参数的定义：

　　　　1.1.1 用途：

　　　　　　在不明确接收参数数量时使用*args和**kwargs

　　　　1.1.2 特点：

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

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

　　　　　　实参: 位置 > 关键字参数

　　　　1.1.3 动态参数：

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

　　

# 动态参数示例：


# 位置参数 > 动态的位置参数
def func(a,b,c,*args):  # 在形参位置*叫做聚合
    print(a,b,c)
    print(args)   # 元组形式

func(1,2,3,4,5,9,6,7,8)

　　　　1.1.4 动态默认参数：

　　　　　　默认参数 > 动态默认参数

　　

# 动态默认参数：


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

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

　　　　1.1.5 综合示例：

　　

# 综合示例

# 示例1：
# 动态参数与动态默认参数
def func(*args, **kwargs):
    print(args, kwargs)  # args = () kwargs = {}

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

# 示例2：
def func(a, b, c, *args, x=1, y=1, z=1, **kwargs):
    print(a, b, c)  # 位置参数
    print(args, kwargs)  # 动态位置参数(元组)和动态默认参数(字典)
    print(x, y, z)  # 默认参数
    # 1 2 3
    # (1,2,3,4,5)
    # 1 1 1
    # {'a': 1, 'b': 1, 'c': 1}

func(1, 2, 3, 4, 5, e=1, f=2, g=3)

二、聚合与打散：

　　2.1 聚合的定义：

　　　　2.1.1 形参：

　　　　　　在形参处出现*就是在聚合成一个元组

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

　　　　2.1.2 实参：

　　　　　　在实参调用的时候 *将可迭代的对象(字符串，列表，元组，字典，结合)打散
　　　　　　在实参调用的时候 **将可迭代的对象(字典)打散,字典是将键取出 关键字参数(键=值)

　　　　2.1.3 聚合与打散的方法：

　　

# 聚合：
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


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


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

　　　　2.1.4 综合示例：

　　

# 字典的聚合与打散：
dic = {'a': 1, 'b': 2}
def func(*args, **kwargs):  # 聚合 {'a': 1, 'b': 2}
    print(args, *kwargs)  # print('a','b')


func(**dic)  # 字典打散后：a=1,b=2以关键字参数传入



# 列表的聚合与打散：
def func(*args, **kwargs):  # 聚合 (1,2,3,5,4)
    print(*args, *kwargs)  # print(1 2 3 4)

func(*[1, 2, 3, 4])

三、 函数的注释：

　　3.1 定义：　　　

　　　　""" """ 官方推荐
　　　　查看注释: func名.__doc__
　　　　查看函数名: func名.__name__

　　3.2 应用：

　　　　对程序注释作用，方便程序的查阅理解

　　3.3 注释示例：

　　

# 示例


def func(user, pwd):
    """
    登录函数
    :param user: 用户名
    :param pwd: 密码
    :return: 校验后的账号和密码
    """
    print(666)
print(func.__doc__)  # 查看注释
print(func.__name__)   # 查看函数名

四、 名称空间：

　　4.1 定义：

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

　　4.2 加载顺序：

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

　　4.3 取值顺序：　　

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

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

　　4.5 关键字(global,nonlocal)用法：

　　　　4.5.1 定义：
　　　　　　global :

　　　　　　 　　在局部修改全部变量,如果没有就创建一个新的
　　　　　　nonlocal :

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

　　　　4.5.2 global关键字的用法：

　　

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



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

　　　　4.5.3 nonlocal关键字的用法：

　　

# nonlocal关键字的用法：

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

# 类型示例1
def func1():
    def func2():
        a = 1
        def func3():
            nonlocal a
            a = 8
            print(a)
        func3()
    print(func2())
func1()

# 打印：8 None



# 类型示例2
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

五、函数的嵌套：

　　5.1 定义：

　　　　函数嵌套 多个函数嵌套调用

　　5.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)
    fun()

func2()

# 1 3 6 7