Python学习Day11

1.函数对象
    def func1():
        print('run')
        
    #a=func1()
    #a=func1
    
    
    def func2(func):
        func()
        
    func2(func1)
    
    def func3():
        return func1
        
    f=func3()
    print(f)
    print(func1)
    
    a = 10
    b = 1
    c = 2
    
    li = [a,b,c]
    
    def func5():
        print('func5 run')
        
    li2=[func5]
    
    li2[0]()
    
    
    def login():
        print('登录')
    def register():
        print('注册')
    def shopping():
        print('购物')
        
    res=input('请选择功能名称：')
    #if res == 'login':
    #    login()
    #elif res == 'register':
    #    register()
    #elif res == 'shopping':
    #    shopping()
    #else:
    #    print('输入有误')
    
    funcdic = {'login':login,'register':register,'shopping':shopping}
    
    if res in funcdic:
        funcdic[res]()
    else:
        print('输入有误！')
        

2.函数的嵌套
    def func1():
        print('func1')
    func1()
    
    def func2():
        print('func2')
    func2()
    
    def login():
        print('登录')
        
    def show_money():
        print('余额充足')
    
    def get_money:
        login()
        show_money()
        
        
    嵌套定义
    
    def func1():
        print('func1')
        def func2():
            print('func2')
        fun2()
    func1()
    
    a=100
    print(a)
    b=200
    
    def func():
        c=1
        
    if a >100:
        p=1
    while True:
        s=10
        
    age = 18
    def func():
        age=19
        print(age)
        
    func()
    
    print(len)
    len = 100
    
    def func2():
        len =1
    
    func2()
    print(len)
    
4.作用域
    a = 'aasasasasaas'
    print()
    查看全局作用域中的内容
    print(dir(globals()['__builtins__']))
    查看局部作用域中的内容。注意，你在全局中使用locals看到的就是全局的内容，与globals没有区别
    print(locals())
    print(globals())
    
    def func():
        a = 100
        print(locals())
    func()
    
    age=18
    def func2():
        明确声明，要使用全局中的age
        global age
        age =19
        print(age)
    func2()
    print(age)
    a =1
    def func3():
        a = 10
        def inner():
            明确声明，要使用上一中的a如果上一层没有，则找上上层，但是注意不能找到全局中的
            nonlocal a 
            a = 100
            print(a)
        inner()
        print('这是func3中a',a)
    func3()
    print(a)
    
5.闭包函数
    age = 20
    如下就是一个闭包函数
    def fun1():
        age = 18
        def inner():
            print('hello')
            print(age)
        在返回这个内部的函数时，不是单纯的返回函数，还把函数中访问到的局部名称一起打包了
        相当于将内部函数与访问的数据打包在一起了，闭包这个名字就是这么得来的
        return inner
    f = fun1() f 就是inner
    f()
        函数的作用域在定义时就固定了，与调用的位置没有关系
        
    c = 1000
    
    闭包函数的模板
    def func2():
        a = 1
        b = 10
        def inner():
            print(a)
            print(b)
            print(c)
        return inner
    f = func2()
    __closure__用于访问闭包时打包的数据
    print(f.__closure__[0].cell_contents)
    print(f.__closure__[1].cell_contents)
    
    什么时候闭包函数
    1.定义在另一个函数内的函数
    2.内部的函数访问了外部的名称（数据，注意不包含全局的）
    
6.装饰器
    import time
    请你统计下载耗时
    start_time = time.time()
    download()
    end_time = time.time()
    print('下载耗时',(end_time-start_time))
    
    
    def download2():
        start_time = time.time()
        print('开始下载xxx.mp4')
        time.sleep(2)
        print('xxx.mp4下载完成!')
        end_time = time.time()
        print('下载耗时',(end_time-start_time))
    download2()
    
    def upload():
        print('开始上传xxx.mp4')
        time.sleep(2)
        print('xxx.mp4 上传完成！')
        
    def func(func):
        start_time = time.time()
        func()
        end_time = time.time()
        print(end_time-start_time)
        
    def download():
        print('开始下载xxx.mp4')
        time.sleep(2)
        print('xxx.mp4下载完成!')
        
    def outter(func):
        a = 1
        print(locals(),'xxxxx')
        def inner():
            在调用原始函数前 增加新功能
            func()
        
        print(inner)
        return inner
    
    download = outter(download)
    download()
    既遵守了开闭原则，又添加了新功能
    
    如此方式，违反了一个设计原则 开闭原则
    指的是，对扩展开放，对修改封闭（可以添加新功能，但不能修改原代码和调用方式）
    
    装饰器和闭包函数的关系：装饰器是一种设计代码的套路（在不修改原代码和调用方式的情况下，增加新功能）
    要完成装饰器，就需要使用闭包函数
    
    装饰模式
    
    print(time.time()) 返回一个时间戳，它是指从1970年1月1日0点0分（unix元年）到现在一共经历过的秒数
    time.sleep(1)
    print(time.time())
    
    start_time = time.time()
    time.sleep(3)
    end_time = time.time()
    
    print(end_time-start_time)