Python学习Day12

1.函数对象复习
    一、函数对象：把函数的内存地址当作一种变量值去使用
        1.引用
        x = 10
        y = x
        
        def func1():
            print('from func')
        
        func1 = 函数的内址
        
        func2 = func1 
        func2()
        
        2.可以当作参数传给另外的函数
        def func1():
            print('from func')
            
        def bar(xxx):
            print(xxx)
            xxx()
            
        bar(func1)
        
        3.可以当作一个函数的返回值
        def func1():
            print('from func')
        
        def bar():
            return func1
        f = bar()
        f()
        
        4.可以当作容器类型的元素
        def func1():
            print('from func')
            
        l=[func1]
        print(l)
        l[0]()
        
        def register():
            print('注册')
        def login():
            print('登录')
        def shopping():
            print('购物')
        def pay():
            print('支付')
        
        func_dic={
            '1':register,
            '2':login,
            '3':shopping,
            '4':pay
        }
        
        while True:
            print('''
            0 退出
            1 注册
            2 登录
            3 购物
            4 支付
            ''')
            choice=input('>>>: ').strip()
            if choice == '0':break
            if choice in func_dic:
                func_dic[choice]()
            else:
                print('输入错误的指令')
                
2.函数嵌套复习
    函数嵌套定义
    def outter():
        def inner():
            pass
            
        x = 10
        y = 20
        
    from math import pi
    def circle(radius,mode=0):
        def perimiter(radius):
            return 2 * pi *radius
        
        def area(radius):
            return pi *(radius **2)
            
        if mode == 0:
            return perimiter(radius)
        elif mode == 1:
            return area(radius)
            
    circle(10,0)
    
    函数嵌套调用
    def max2(x,y):
        if x > y:
            return x
        else:
            return y
            
    
    def max4(a,b,c,d):
        res1 = max2(a,b)
        res2 = max2(res1,c)
        res3 = max2(res2,d)
        return res3
        
3.名称空间与作用域
    1）什么是名称空间namespaces
        存放名字与值内存地址绑定关系的地方
    2）为何要有名称空间
    3）如何用名称空间
        内置名称空间
        全局名称空间
        局部名称空间
        
    4）总结结论：
        1.查找名字的顺序是从当前位置往外查找
        2.名称空间的嵌套关系是在函数定义阶段就固定死的与调用位置无关
        
    def outter():
        x = 11111
        def inner():
            print(x)
        return inner
    
    f = outter()
    
    
    def foo():
        x = 222222222
        f()
        
    foo()
    
    
    1 = []
    def func():
        l.append(111)
        l.append(2222)
    func()
    print(1)
    
    
    def f1():
        y = 1111
        def f2():
            x = 3333
            def f3():
                nonlocal y
                y = 2222

4.闭包函数
    1.什么是闭包函数
        闭函数：该函数一定是定义在函数内的函数
        包函数：该内部函数包含对外层函数作用域名字的引用
        def outter():
            x = 111
            def inner():
                print(x)
            return inner
        f = outter()
        x = 2222
        f()
        
    2.为何要用闭包函数
    3.如何用
        为函数体传值的方案一：直接以参数的形式传入
        def f(x):
            print(x)
        f(10)
        f(11)
        为函数体传值的方案二：直接以参数的形式传入
        def outter(x):
            def f():
                print(x)
            return f
        
        fff=outter(10)
        fff()
        
        fff1=outter(11)
        fff1()
        
        
        def outter(x):
            #x=10
            def f():
                print(x)
            return f
            
        xxx=outter(10)
        yyy=outter(11)
        print(xxx)
        
5.装饰器
    1.什么是装饰器
        装饰器指的是为被装饰对象添加新功能的工具
        装饰器本身可以是任意可调用对象
        被装饰对象本身也可以是任意可调用对象
    2.为何要用装饰器
        开放封闭原则：对修改封闭，对扩展开发
        
        装饰器的实现原则：
            1.不能修改被装饰对象的源代码
            2.不能修改被装饰对象的调用方式
        
        装饰器的目的：
            就是在遵循原则1和2的前提为被装饰对象添加新功能
            
    3.如何用
        part1
        import time
        
        def index():
            time.sleep(l)
            print('welcome to index page')
            
        def wrapper():
            start=time.time()
            func()
            stop=time.time()
            print('run time is %s' %(stop-start))
        wrapper()
        
        part2
        import time
        def outter(func):
            #func=最原始那个index的内存地址
            def wrapper(*args,**kwargs):
                start=time.time()
                res=func(*args,**kwargs)#最原始那个index的内存地址
                stop=time.time()
                print('run time is %s' %(stop-start))
                return res 
            return wrapper
        
        @outter#index=outter(index)#index=outter(最原始那个index的内存地址）
        def index():
            time.sleep(1)
            print('welcome to index page')
            return 1234
            
        @outter #home=outter(home)
        def home(name):
            time.sleep(1)
            print('welcome %s to home page' %name)
            
            
        res=index() #wrapper的内存地址（）
        print('返回值',res)
        
        home('egon')
        
        
        小练习
        import time
        
        def auth(func):
            #func=index
            def wrapper(*args,**kwargs):
                name=input('name>>>:').strip()
                pwd=input('pwd>>>:').strip()
                if name == 'egon' and pwd == '123':
                    print('login successfull')
                    res=func(*args,**kwargs)
                    return res
                else:
                    print('user or pwd error')
            return wrapper
            
            
        def outter(func):
            def wrapper(*args,**kwargs):
                res=func(*args,**kwargs)
                return wrapper
            return wrapper
        @outter
        def index():
            time.sleep(1)
            print('welcome to index page')
            return 1234
            
        index()