函数嵌套,名称空间,闭包函数.

函数嵌套
    嵌套指的是,一个物体包含另一个物体
    函数嵌套指的就是一个函数包含另一个函数
按照函数的两个阶段 分为
    嵌套调用
        指的是,在函数的执行过程中调用了另一个函数
        其好处是,可以简化外层大函数的代码,使得结构更清晰,
        可以将一个大的复杂的功能拆分为多个简单的小功能

    嵌套定义
        指的是,在函数的函数体中定义了另一个函数
        需要注意的是:内部定义的函数,只能在内部使用,外界无法直接访问
        唯一的使用场景就是闭包函数,除此之外不要这么写

事例:

def max(a,b):
     if a > b:
         return a
     return b

 print(max(100,200))

 def max_3(a,b,c):
     temp = max(a,b)
     m = max(temp,c)
     return m

 def max_4(a,b,c,d):
     temp = max(a,b)
     m1 = max(temp,c)
     m2 = max(m1, d)
     return m2

 print(max_4(1,2,3,4)

名称空间
    namespace
    就是存储名字的内存区域
名称空间的分类
    内置名称空间,存的是解释器自带的名称,例如print,len,其特点是在程序运行过程中一直有效
        特点:其特点是在程序运行过程中一直有效
        生命周期:随着解释器的启动而生效,随着解释器运行结束而失效

    全局名称空间
        只要是顶着最左边写的,没有任何缩进的,就在全局名称空间中
        特点:其特点是在程序运行过程中一直有效
        生命周期:随着py文件的执行而生效,随着py文件的执行结束而失效
        需要注意的是:在if 中 如果if 是顶着最左边的没有缩进的那么if里面的名字也属于全局
        同样的,while for with都是如此

    局部名称空间
        存的是函数内定义的名字,
        特点:仅在函数调用时临时有效
        生命周期:随着函数的调用而生效,随着函数的调用结束而失效

    名称空间的加载顺序
        内置 -- >  全局  -- > 局部
    名字的查找顺序
        局部 -- >  全局  -- > 内置

print(len)
name = "bgon"
print(name)
if 1 == 1:
    age = 1 # 也是全局的

print(age)

作用域
    域指的是区域,范围,作用域指的就是作用区域,作用范围,有效范围
    简单的说就是名字的有效范围
存储名词的有三个地方
    内置名称空间
    全局名称空间
    局部名称空间
全局作用域
    由于,内置名称空间的名字与全局名称空间的名字,可以在任何位置来访问,
    所以它们俩可以划到同一个范围,称之为全局范围即全局作用域
局部作用域
    局部名称空间的名字只能在当前的函数中访问,所以它单独划到一个范围中,
    这个范围称之为局部作用范围即局部作用域

global(全局) 与 nonlocal(不使用本地) 关键字
global
    当需要在函数内部修改全局中名字的值时需要使用global
    注意,必须在使用这个名字之前声明(写)global
nonlocal(不使用本地)
    当需要在内层函数中修改外层函数中的名字是就需要使用nonlocal
    会一层一层往外找,直到找到了为止,但是只能找函数中的不能找到全局的名字

 

a = 100
def func():
    global a  # 声明一下 我要使用全局的a
    #改写法 既有修改a的值的意思 也有定义变量的意思,默认在函数中都是在定义新变量
    a = 1
    a = 100

func()
print(a)

 

 

a = 0
def f1():
    a = 1
    def f2():
        def f3():
            nonlocal a
            a = 3
        f3()
        print("f2 中的a", a)
    f2()
    print("f1 中的a",a)
f1()
print("全局的a",a)

 

函数对象
    没有新技术点
    目的是为了让你知道 函数都可以怎么来使用

面向对象中一句经典语录:万物皆对象,也就是说函数也是对象
函数是第一类对象:
    1.能够被调用
    2.可以当做容器类型的元素
    3.可以当做函数的参数
    4.可以当做函数的返回值
函数名除了可以调用之外与一个变量名,没有本质区别,变量能怎么用函数名就,能怎么用

def func():
    print("func run")

def func2():
    print("func2 run")

li = [func,func2]
print(li)
li[0]()

def func3(f):
    print(f)
    f()

func3(func)

 

函数对象的应用场景的事例:

def register():
    print("注册....")

def login():
    print("登录....")

def transfer():
    print("转账....")

def withdraw():
    print("提现....")

dic = {"1": register, "2": login, "3": transfer, "4": withdraw} # 建议采用字典
def main():
    while True:
        print("""
        1.注册
        2.登录
        3.转账
        4.提现""")
        res = input("请选择功能:").strip()
        if res in dic:
            dic[res]()
        else:
            print("输入有误!")

闭包函数
    闭包:一个函数将另一个函数关闭在内部,反过来说一个函数被另一个函数包裹
    闭包函数也是一种函数
    其特点是:
        1.该函数是定义在另一个函数的中的
        2.该函数包含了对外层函数中名字的引用,无论在任何位置使用这个函数,其都包含了外部名字引用
    满足以上两条 就称之为闭包函数

    需要注意的是:名字所在的作用域 在函数定义阶段就已经固定了,与调用位置无关

    现阶段 可以将闭包理解为 另一种为函数体传值的方式
    之前只能通过参数给函数传值
    现在可以通过闭包的方式

 def func1():
     def func2():
         print("func2 run")
     func2()
 func1()

 由于名称空间与作用域的特点,内层定义的函数 只能在内层函数
 而函数对象可以将一个函数作为返回值,使得内部函数也可以被外界使用
def outer():
    name = "扎尔伯克"
    def inner():
        a = 100
        print("inner a",a)
        print("name :",name)
    return inner

inner = outer()
inner()