Python基础09-闭包与装饰器

装饰器

        装饰器，字面意思就是装饰

        编程里面的装饰：比如有个函数，是登录的函数 ，在登录函数中增加其他功能

装饰器定义：

        是给已有的函数增加额外的功能，本质是一个闭包函数

闭包函数：

        变量函数销毁之后，有时候需要这个函数的变量 闭包解决这个问题

闭包的定义：

        在函数嵌套的前提下，内部函数使用外部函数的变量，并且外部函数返回内部函数

我们把这个使用外部函数变量的内部函数称为闭包

闭包形成条件：

        1.实现函数嵌套

        2.内部函数使用外部函数的变量

        3.外部函数返回内部函数名字

简单的闭包

# 外部函数
def test1():
    b=10
# 内部函数
def test2():
    print(b)
    return test2

a=test1()
a()

函数怎么去执行

        从上到下开始走，走到调用函数的时候才运行，调用test1()，开始运行test1()函数

test1函数，不会运行test2，原因是test2没有被调用，返回test2，给到test1，a接受变成test2        

拿到函数的变量，在另外一个函数计算

def test1(num1):
    def test2(num2):
        result=num1+num2
        print(result)
    return test2

# a相当于test2
a=test1(2)
a(3)

        函数调用 函数名()

        装饰器 @方法名

给已有的函数增加额外的功能

例如：发表文章，需要先登录才可以进行发表

闭包流程

检查有没有登录 comment

def check(fc):
    print('检查登录')
    def inner():
        print('登录')
        fc()
    return inner
    
# 发表评论
def comment():
    print('发表评论')

c=check(comment)
c()

从上到下开始走，走到check(comment)开始执行函数 ，fc是comment

print 检查 走到inner 不会被执行，走到return这里 返回一个inner

inner被谁接受？check接受 check(comment)赋值给 c 所以c就是 inner

inner()就变成了一个调用函数 走到inner函数中 打印 登录 fc()

fc是comment 相当于 comment（）

总结：给已有的函数增加额外的功能 不修改已有的函数的源代码

@方法名

def check(fc):
    print('检查登录')
    def inner():
        print('登录')
        fc()
        return inner

# @check 相当于 check(comment)  代理的意思
@check
def comment():
    print('发表评论')

comment()

@check 相当于 check(comment) check(fc)相当于 check(comment)

inner不执行 返回inner 返回inner给到谁 给到comment()函数 comment相当于是inner

inner() 走到登录 fc是什么 comment 发表评论

练习题目：现在有个函数，想要知道这个函数执行了多久 用装饰

import time
def decorate(fc):
    def inner():
        # 获得了当前的时间
        print(time.strftime('%Y-%m-%d %H:%M:%S'))
        t_start=time.time()
        a=fc()
        print(a)
        # 获得了当前的时间
        t_end=time.time()
        print(time.strftime('%Y-%m-%d %H:%M:%S'))
        print('总共花了多久的时间%.2f'%(t_end-t_start))
        # inner函数没有return  没有return  就是NOne
        return 2
    return inner

# 小弟相当于  decorate(test_un)
@decorate
def test_un():
    time.sleep(1)
    print('test_un在执行中')
    return 8

# test_un()相当于 inner
print(test_un())

另一种写法

import time
def decorate(fc):
    def inner(a,b,c):
        # 获得了当前的时间
        print(time.strftime('%Y-%m-%d %H:%M:%S'))
        t_start=time.time()
        a=fc(a,b,c)
        print(a)
        # 获得了当前的时间
        t_end=time.time()
        print(time.strftime('%Y-%m-%d %H:%M:%S'))
        print('总共花了多久的时间%.2f'%(t_end-t_start))
        # inner函数没有return  没有return  就是NOne
        return 2
    return inner
# 小弟相当于  decorate(test_un)
@decorate
def test_run(a,b,c):
    time.sleep(1)
    print('test_un在执行中')
    return a+b+c
    
# test_un()相当于 inner
print(test_run(1,2,3))

类方法和静态方法这个实例方法 object在python3 object上个顶级的父类

class Foo(object):
    def instance_method(self):
        print('实例方法')

    @staticmethod
    def static_method():
        print('静态方法')

    @classmethod
    def class_method(cls):
        print('类方法')

调用方式，实例方法就是对象方法 对象 类()

foo=Foo()
foo.instance_method()
foo.class_method()
foo.static_method()

静态方法和类方法还有实例方法都是可以通过对象去调用的

类进行调用

Foo.static_method()
Foo.class_method()
Foo.instance_method('aa')

静态方法和类方法都是可以通过类去调用

静态方法 静态方法中没有和类相关的东西 没有self class

独立的空间 公共的区域 都可以用 大家都可以去使用

class TimeTest(object):
    def __init__(self,hour,minute,second):
        self.hour=hour
        self.minute=minute
        self.second=second

    @staticmethod
    def showTime():
        return time.strftime('%H:%M:%S',time.localtime())

print(TimeTest.showTime())

类方法

class Tool:
    count=0

    def __init__(self,name):
        self.name=name
        Tool.count+=1

    @classmethod
    def show_tool_count(cls):
        print('工具对象的总数%d'%cls.count)

tool1=Tool('锄头')
tool2=Tool('斧头')
tool3=Tool('棒槌')
Tool.show_tool_count()