python 第十章 动态参数+名称空间+嵌套+修改值

动态参数

# *args(args 可以更换，建议使用args)
# 万能参数，可以接受任意多个位置参数
# *在函数定义的时候叫聚合
# 万能参数
# 一个位置参数
# 一般位置函数
def func(a,b=1):
    print(a,b)
func(1)
# 输出
# 1 1

def func(*args):
    print(args)
func(1,2,3,4,5,6,7)
# 输出一个元组
# (1, 2, 3, 4, 5, 6, 7)

# 任意多个位置参数
def func(a,b,*args):
    print(a,b,args)
func(1,2,3,4,5,6,7)
# 输出
# 1 2 (3, 4, 5, 6, 7)

# 去掉*，打散
def func(*args):
    print(*args)
func(1,2,3,4,5,6,7)
# 输出元素
# 1 2 3 4 5 6 7


# 动态位置参数：
# 先传参*args,再传默认参数
# 元组（接受的是位置参数）
# 可以打散

# 位置参数，放在后面
def func(*args,a=1,b=2):
    print(args,a,b)
func(1,2,3,4,5,6,7)
# 输出
# (1, 2, 3, 4, 5, 6, 7) 1 2

# 位置参数，放在前面，先执行默认参数
def func(a=1,b=2,*args):
    print(a,b,args)
func(1,2,3,4,5,6,7)
# 输出
# 1 2 (3, 4, 5, 6, 7)

# 去掉*，可以打散
def func(*args,a=1,b=2):
    print(args,a,b)
func(1,2,3,4,5,6,7)
# 输出
# 1 2 3 4 5 6 7 1 2

# 优先级
# 位置参数>动态位置参数>默认参数
def func(a,b,*args,c=1,d=3):
    print(a,b,args,c,d)
func(1,2,3,4)
# 输出 1 2 (3, 4) 1 3

# 打散后是源数据类型
def func(a,b,*args,c=1,d=3):
    print(a,b,*args,c,d)
func(1,2,3,4)
# 输出 1 2 3 4 1 2

# **kwargs
# 字典（接受的是关键字参数）
# 不能打散，打散后只有键

# 关键字参数
def func(a,b,**kwargs):
    print(a,b,kwargs)

def func(a,b,**kwargs):
    print(a,b,kwargs)
func(1,2,c=1,d=4)
# 输出 1 2 {'c': 1, 'd': 4}

# 不能打散，打散后只有键
def func(a,b,**kwargs):
    print(a,b,*kwargs)
func(1,2,c=1,d=4)
# 输出1 2 c d

# *args **kwargs
# 万能传参
def func(*args,**kwargs):
    print(args,kwargs)
func(1,2,3,a=1,b=3,c="78")
# 输出
# (1, 2, 3) {'a': 1, 'b': 3, 'c': '78'}

# 参数的优先级：位置参数 > 动态位置参数 > 默认参数（关键字参数） > 动态关键字参数
# 1、万能参数：动态位置参数，动态关键字参数（常用*args，**kwargs）
# 2、位置参数，动态位置参数
# 3、动态位置参数，关键字参数，动态关键字参数



# 列表用*打散成元组
lst = [12,3,45,]
def func(*args):
    print(*args)
# func(lst[0],lst[1]) 之前的方法
func(*lst)
# 输出 12  3  45


# 字典用*打散成
dic = {"key":1,"key1":34}
def func(**kwargs):
    print(kwargs)
func(**dic)
# 输出 {'key': 1, 'key1': 34}

名称空间

# 内置空间：python自带的方法
# eg:print input len range
# 每一次运行加载内置空间
#
#
# 全局空间：当前py文件中需要开辟的空间存放在全局空间
# 每一次运行加载全局空间
#
#
# 局部空间：函数中开辟的空间就是局部空间
#
# 加载顺序：
# 内置>全局>局部
#
# 取值顺序：
# 局部>全局>内置（找不到会报错）
#
# 作用域：
# 全局作用域：
# 泛指内容：内置空间+全局空间
#
# 局部作用域
# 只指局部空间

嵌套

# 不管在什么位置，只要是函数名+()就是调用此函数
# 函数调用执行后,函数体在开辟的空间就自动销毁了
# 如何传参就如何退参



def func():
    a = 1
    def foo():
        b = 2
        print(b)
        print(a)
        def f1():
            print(b)
        return f1()
    return foo
print(func())
# 没有调用函数foo
#输出   没有值

def func():
    a = 1

    def foo():
        b = 2
        print(b)
        print(a)
        def f1():
            print(b)
        return f1()
    return foo()
print(func())
# 输出
# print(b) 2
# print(a) 1
# print(b) 2
# print(func()) 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 0x10d2f81e0>
# <function c at 0x10d3bb268>


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())
# 输出
# 地址
# 1
# None



def func(a):
    foo(a)
def foo(e):
    b(e)
def b(c):
    print(c)
    return 10
print(func(5))

修改值

# global 声明强制修改全局变量
# 局部不能修改全局，是出于安全考虑
a = 10
def func():
    global a # 声明改变全局变量的值
    a += 1
    print(a) # 11
func()
print(a) # 11
# 输出11

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



# nonlocal 在最外层的函数中修改局部空间的变量值，只修改离他最近的一层
# 找的上一层没有，继续向上找，直到找到最外层函数
a = 10
def func():
    def f1():
        a = 30
        def foo():
            nonlocal a
            a += 1
            print(a)   # 31
        foo()
        print(a) # 31
    f1()
func()
print(a)   # 10

a = 10
def func():
    def f1():
        a = 30
        def foo():
            nonlocal a
            a += 1
            print(a)# 31 第1步
        foo()
        print(a)# 31 第2步
    f1()
func()
print(a) #10 第3步

今日总结

# 1、函数的动态参数
# *args,**kwargs 万能传参  参数名字可以换
# 能够接受动态的位置参数和动态的关键字参数
# *args - tuple
# 打散的是源数据类型
# **kwargs - dict
# 打散的是字典的键
# 定义阶段(*,**是聚合作用)
# 使用阶段(*是打散作用)
# 优先级：位置>动态位置>默认>动态关键字
#
#
# 2、函数的注释
# 每次写函数的时候都需要写注释
# """
# 函数名.__doc__
# """
#
# 3、名称空间
# 内置空间：python解释器自带的
# 全局空间：当前文件(.py文件)
# 局部空间：函数体开辟的空间
#
# 加载顺序：内置>全局>局部
# 取值顺序：局部>全局>内置
#
# 作用域：
# 全局作用域：内置+全局
# 局部作用域：局部
#
#
# 4、函数嵌套
# 函数中套函数
# 函数嵌套调用
# 函数嵌套参数的传递
# 函数嵌套返回值的传递
#
# 5、global nonlocal
# global：修改全局空间变量对应的值
# nonlocal：在外层的函数中，修改局部空间的变量值，完全步涉及全局变量
# 只修改离他近的上一层，最近的没有变量再向上找，直到找到最外层函数
#
# global于nonlocal不共用
#
# 6、三元运算符
# a = 10
# b = 20
# c = a if a >b else b
# 变量名 = 条件成立的结果 条件 不成立的结果