Day10--Python--动态传参,作用域

python的三目运算
a = 10
b = 20
c = a if a > b else b  #先判断中间的条件a > b是否成立,成立返回if前面的值,不成立返回else后面的值,也可以 c = a if a.isalpha() else b  条件可以是各种各样的
print(c)

1.动态传参
    1.*args 动态接收位置参数. 接收所有的实参对应的剩余位置参数,返回的是元组
        *表示接收位置参数的动态传参

        def func(a, b, *args): #arguments参数
            print(a, b, args)

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

    2.**kwargs 动态接收关键字参数   关键字的动态传参,返回的是字典.  接收无意义的关键字参数(兜底)

        def func(**kwargs):
            print(kwargs)

        func(a=10, b=20)

        def func(*args, **kwargs):    #无敌模式,所有的参数都能接收
            print(args, kwargs)

        *,**在形参中表示聚合,在实参中表示打散

    顺序:
        位置参数,  *args, 默认值参数,  **kwargs

    聚合与打散:
        在函数调用时:
            *可迭代对象,代表打散(list,tuple,str,dic(t键))将元素一一添加到args.
            **字典,代表打散,将所有键值对放到一个kwargs字典里.
        在函数定义时, *args, **kwar 代表的是聚合

    def func(*args):  # *在这里,其实相当于把传进来的参数做了一次聚合,聚合成一个元组
        print(args)

        l1 = [1, 20, 30]
        l2 = [1, 2, 33, 49]
        tu = (1, 2, 3)
        func(*l1, *l2, *tu) # 在实参位置*表示打散,打散的是可迭代对象

    def func(**kwargs): # **把接收到的关键字参数打包(聚合)成字典
        print(kwargs) # 一定是字典

    dic1 = {'name1':'alex', 'age1': 40}
    dic2 = {'name2': 'sylar', 'age2': 50}

    func(**dic1, **dic2)   #在打散聚合后的字典中,key必须是str  'func() keywords must be strings'

----------------------------*args--------------------------------
    def eat(*food): #*表示的是不定参数,可以传递任意个信息 参数名是food, 接收到的是元组
        print(food)
    eat('大米饭','咸菜','可乐')
------------------------位置,*args,默认值------------------------
如果默认值参数在*args前面. 如果想让默认值生效. *args将永远接不到值
def func( a, b, *args,c = 5): # arguments参数
    print(a, b, c, args)

func(1,2,3,4,5,6,8,c = 10)
-----------------------------**kwargs----------------------------
def func(**kwargs): # ** 把接收到的关键字参数打包(聚合)成字典
    print(kwargs) # 一定是字典

dic = {"张无忌": "明教教主", "谢逊": "金毛狮王", "范瑶": "光明右使"}
func(张无忌=dic['张无忌'], 谢逊=dic['谢逊'], 范瑶=dic['范瑶'])
func(**dic) # 这里的** 是把字典打散. 字典的key作为参数的名字, 字典的值作为参数的值传递给形参

2.作用域
　　作用域:作用范围.按照生效范围来看分为全局作用域和局部作用域.
　　全局作用域:包含内置名称空间,全局名称空间.在整个文件的任意位置都能被引用,全局有效.
　　局部作用域:局部名称空间.在函数内部使用,只在局部范围内有效.

　　名称空间(命名空间):放置变量与对应的值的关系,即变量与这个变量对应的值的地址的关系的空间.
　　临时名称空间:当函数执行的时候,会在内存中开辟一个临时名称空间,存放函数体内的所有变量与值的关系,随着函数执行完毕,临时空间自动关闭.

   内置名称空间:所有内置函数存储的空间.   
   全局名称空间/名称空间/命名空间/全局命名空间:代码在运行伊始,创建的存储"变量名与值的关系"的空间.
   局部名称空间/局部命名空间/临时名称空间/临时命名空间:在函数的运行中开辟的临时空间. 

   加载顺序：内置名称空间 => 全局名称空间 => 局部名称空间
　　取值顺序：局部名称空间 =>全局名称空间 =>内置名称空间
    　　综上,在取值时,从小范围一层一层扩大范围寻找.

        globals() 查看全局空间作用域中的内容   #print(globals())
        locals()  查看当前空间作用域中的内容   #print(locals())

3.global nonlocal
    global: 在局部引入全局变量
    nonlocal: 在局部,引入离他最近的那一层的变量  从小范围到大范围一层层搜索

-------------------------------------------------------------
最开始会开辟一个自己的命名空间- 内置名称空间
a = 10   #全局
print(a)
# 直接在py文件一个层面上是全局名称空间
def func():
    hasakey = 10
# 在函数内部属于局部名称空间
func()
加载顺序: 内置 => 全局 => 局部
取值顺序: 局部 => 全局 => 内置

a = 10 # 全局
def func():
    lilei = "李雷"

---------------------------------------------------------------
函数的嵌套:
    def func1():
        print("我是func1")

    def func2():
        print("我是func2")
        func1()

    def func3():
        func2()
        print("我是func3")
    func3()
    这样的代码不是嵌套. 互相调用

    函数可以互相嵌套
    def outer():
        def inner():
            print("我是内部")
        print("我是外部")
        inner()

    outer()

    def outer():
        print("我是外面的")
        def inner_1():
            def inner_2():
                print("我是里面的2")
            inner_2()
            print("我是里面的1")
        inner_1()
        print("我是外面的收尾")

    outer()
---------------------------------------------------------------
    a = 10
    def func():
        global a #表示在当前作用域中的使用的a是全局中的变量
        a = 20 # 所有的a都是外面的了
        print(a) # 直接从全局调用的a不可修改,只可赋值,但用global后可以修改全局中a的值

    print(a) # 10
    func() # 20
    print(a) # 20

---------------------------------------------------------------
    def outer():
        a = 10
        def inner():
            nonlocal a # 找的是局部当中, 离他最近的上层的那个变量
            a = 20
            print(a)
        print(a) # 10
        inner() # 20
        print(a) # 20
    outer()

---------------------------------------------------------------

    a = 1
    def fun_1():
        a = 2
        def fun_2():
            nonlocal a
            a = 3
            def fun_3():
                a = 4
                print(a)
            print(a)
            fun_3()
            print(a)
        print(a)
        fun_2()
        print(a)
    print(a)
    fun_1()
    print(a)

    global 引入全局变量, 可以定义全局变量
    nonlocal 引入局部中离他最近的外层变量
---------------------------------------------------------------
    def func():
        global a # 没有也得有. 自动帮你创建
        a = 20

    func()
    print(a)