修饰器

例子1：

def display_time(func):
       def wrapper(n):
               t1 = time.time()
               result = func(n)
               t2 = time.time()
               print(t2-t1)
               return result
       return wrapper
def is_Prime(num):
       if num < 2:
               return True
       elif num ==  2:  
               return False
       else:
               for i in (2,num):
                       if num % i == 0:
                               return False
               return True
@display_time
def find_Prime(n):
       count = 0 
       for i in range(2,n):
               if is_Prime(i):
                       count += 1
       return count
find_Prime(10000)

解释：
修饰器把find_Prime修饰成了一个变量
当在find_Prime上添加@display_time后
调用find_Prime(10000)时,find_Prime(10000)作为参数传入display_time
实际上调用的是:display_time(find_Prime10000))
再看display_time中，
由于return wrapper语句，调用了wrapper
而在wrapper中，才真正调用了find_Prime(10000)
优点：
当我们想要为一个程序计时，第一想到的就是在程序中增加计时代码，但那样会使程序看起来很乱很杂。
所以利用修饰器，给原本的程序附上其他功能。
也就是说，本程序归本程序，计时归计时。
而且，这样做的话，计时修饰器可以用于任何想要增加计时代码的程序来计时。

例子2（进一步改进）：

def display_time(func):
       def wrapper(arg,*arg,**kwang):
               t1 = time.time()
               result = func(arg,*arg,**kwang)
               t2 = time.time()
               print(t2-t1)
               return result
       return wrapper
def is_Prime(num):
       if num < 2:
               return True
       elif num ==  2:  
               return False
       else:
               for i in (2,num):
                       if num % i == 0:
                               return False
               return True
@display_time
def find_Prime(n):
       count = 0 
       for i in range(2,n):
               if is_Prime(i):
                       count += 1
       return count
find_Prime(10000)

解释：
将wrapper中的参数，从固定不变的n改为了*arg 和 ** Kwang，以接受不同的参数。

例子3（不同参数展示）:
我这次新写了个程序，作用是将列表中的整形，转化为字符型，我也想计算他的时间，那我只需要这样：

import time
def display_time(func):
    def wrapper(arg,  **kwang):
        t1 = time.time()
        result = func(arg, **kwang)
        t2 = time.time()
        print(t2 - t1)
        return result

    return wrapper

@display_time
def int2str(lst):
    lenth = len(lst)
    for i in range(lenth):
        lst[i] = str(lst[i])
    return lst

print(int2str([1,2,3,4,5]*100))

例子4（结合多进程知识）（for fun）：

import time
from multiprocessing import Pool
import os


def display_time(func):
    def wrapper(*arg, **kwang):
        t1 = time.time()
        res = func(*arg, **kwang)
        t2 = time.time()
        print(t2 - t1)
        return res
    return wrapper


def int2str(ele):
    ele = str(ele)
    return ele


@display_time
def mutiprocess(fuc):
    lst = [1, 2, 3, 4, 5, 6]
    num = os.cpu_count()
    pool = Pool(num)
    res = pool.map(fuc, lst)
    pool.close()
    pool.join()
    return res


if __name__ == "__main__":
    print(mutiprocess(int2str))

0.31006860733032227
['1', '2', '3', '4', '5', '6']

to be continued