day12 函数对象，名称空间与作用域

"""
今日内容：
    1、函数参数传值细节
    2、三元表达式
    3、列表及字典推导式
    4、函数对象
    5、名称空间与作用域
    6、函数的嵌套定义初识
"""

"""
一、函数参数的传值细节
    举例：
        num = 10
        def fn(n=num):
            print(n)
        num = 20
        fn()
    在上例中函数的参数列表是一个带有默认值的位置形参，由于初识传值为 n = num = 10
    在调用之前num又重新赋值了，此时在函数内打印n 值为10
    原因为：在执行时，函数的参数已经由于值拷贝赋值上了10，此时num被重新赋值不会影响n与10的绑定关系
"""

"""
二、三元表达式
    三元表达式是if...else...的语法糖（简写形式），与原来的判断语句没有任何区别
    三元表达式的格式为：
        a if a < b else b
    三元表达式肯定会返回一个值，这个值可以被变量接收页可以进行打印
    例如：
        a = input("a:")
        b = input("b:")
        print(a if a > b else b)  # 只会返回大值
    三元表达式只能返回一个值，如果想要返回两个值，可以用元组将两个值进行接收，实际上还是一个值
"""

"""
三、列表及字典推导式
    列表及字典的推导式就是列表及字典的语法糖，并且可以在生成列表及字典时可以添加简单的逻辑
    我们平时创建列表及字典时经常会使用list() 及 dict() 进行创建，但是这样不能添加逻辑
    列表及字典的推导式的格式为：
        ls = [v for i in range(10)]
    其与下方表达式一样：
        ls = []
        for i in range(10):
            ls.append(i)
    在进行列表推导式中还可以对列表中的值添加简单的逻辑，【可以在添加时使用三元表达式】
        ls = ["偶数" if i % 2 == 0 else "奇数" for i in range(10)]  #使用此方法定义函数时，必须使用else

　　另一种使用方法：
　　　　ls = [i for i in range(10) if i%2==0] # 此方法可以不使用else

        
    能被字典推到式推导的数据在循环取值时都必须可以被解压赋值为两个值
    ls = [("a":1),("b",2)]
    dic = {k:v for k,v in ls}  # {"a":1,"b":2}
"""

"""
四、函数对象
    在python中万物皆对象，所有能够保存的内存地址的变量统称为对象
        -- 由于在函数中所有的变量都是用来保存内存地址的，所以所有的变量都是对象
        --存放整数地址的是整型对象，存放函数内存地址的就是函数对象，实际上函数与普通的变量完全相同
    举例：
        def fn():
            pass
    在上例中，函数名fn中存放着函数的内存地址，如果要执行函数中的代码，只需要在函数的后面加（）就可以执行
    如果不执行函数，得到的是函数的内存地址，如果加括号执行函数，得到的就是函数的返回值
    
    函数对象的使用场景：
        1、作为调用函数 ---> 加()
        2、作为函数的返回值
        3、作为函数的参数
        4、作为变量传递给其它函数
        5、作为容器类型的元素
    
    实例： 进行数学运算
        def add(a, b):
            return a + b


        def low(a, b):
            return a - b
        
        
        def mul(a, b):
            return a * b
        
        
        def div(a, b):
            return a / b
        
        
        math_map = {
            "add": add,
            "low": low,
            "mul": mul,
            "div": div,
        }
        
        
        # 完成映射关系
        def get_math(math):
            if math not in math_map:
                print("该运算暂不支持")
            else:
                return math_map[math]
        
        
        def math(a, b, sym="add"):
            sym = get_math(sym)
            return sym(a, b)
        
        
        a = int(input("a: "))
        b = int(input("b: "))
        print(math(a,b,"mul"))
            
"""

"""
五、函数的名称空间及作用域
    -- 名称空间：函数名字与内存地址的对应关系，存储在堆区中，python解释器会遍历访问名称空间，采用的是堆栈存储结构
        -- 堆栈存储结构：采用的是先进后出，后进先出的取值原则
        -- 队列存储结构：采用先进先出、后进后出的取值原则
        
        -- 三种名称空间：
            -- Built-in：内置名称空间；系统级，一个；随解释器执行而产生，解释器停止而销毁
            -- Global：全局名称空间；文件级，多个；随所属文件加载而产生，文件运行完毕而销毁
            -- Local：局部名称空间；函数级，多个；随所属函数执行而产生，函数执行完毕而销毁
        
        -- 名称空间的加载顺序： 内置名称空间（系统级） --> 全局名称空间（文件级） --> 局部名称空间（函数级）
        -- 名称空间的遍历顺序：名称所在函数的局部名称空间 --> 函数所在函数的局部名称了空间 --> 全局名称空间 --> 内置名称空间 
        
    -- 作用域：名字起作用的范围 
        -- 四种作用域：
            -- Built-in：内置作用域：作用所有文件的所有地方
            -- Global：全局作用域：作用当前文件的所有地方
            -- Enclosing：嵌套作用域：作用当前函数已内部被嵌套函数
            -- Local：局部作用域：作用当前函数内部
        
        -- 不同的作用域之间的名字可以重复，以达到重复使用名字的目的
        -- 函数会优先查找自己作用域中的名字，如果未发现会查找上一级名称空间，再到全局名称空间，再到内置名称空间
    
"""

"""
六、函数的嵌套定义
    -- 在函数中定义另一个函数叫做函数的嵌套定义
        def outer():
            print('outer run')
            a = 10
            def inner():
                print('inner run')
            inner()
        outer()
    
    -- 函数对象(变量)与普通对象(变量)一样，在函数内部定义，随函数调用而产生，调用结束而销毁，所以只能在函数内部调用
    
"""