心得：遇到难以理解的东西，我愿意花费更多的时间去达到我想要的目的，那怕会很累很辛苦。
装饰器

先说说装饰器，装饰器今天看了好多篇的资料才彻底理解它的含义，但它真正的作用是用来装饰函数或者类，在其基本的方法下增加新的方法，不改变原方法。
一般而言，我们要想拓展原来函数代码，最直接的办法就是侵入代码里面修改，例如：
import time
def f():
    print("hello")
    time.sleep(1)
    print("world")　　

这是我们最原始的的一个函数，然后我们试图记录下这个函数执行的总时间，那最简单的做法就是改动原来的代码：
import time
def f():
    start_time = time.time()
    print("hello")
    time.sleep(1)
    print("world")
    end_time = time.time()

    execution_time = (end_time - start_time)*1000
    print("time is %d ms" %execution_time)

但是实际工作中，有些时候核心代码并不可以直接去改，所以在不改动原代码的情况下，我们可以再定义一个函数。（但是生效需要再次执行函数）
import time

def deco(func):
    start_time = time.time()
    f()
    end_time = time.time()
    execution_time = (end_time - start_time)*1000
    print("time is %d ms" %execution_time)

def f():
    print("hello")
    time.sleep(1)
    print("world")

if __name__ == '__main__':

    deco(f)
    print("f.__name__ is",f.__name__)
    print() 

这里我们定义了一个函数deco，它的参数是一个函数，然后给这个函数嵌入了计时功能。但是想要拓展这一千万个函数功能，
就是要执行一千万次deco()函数，所以这样并不理想！接下来，我们可以试着用装饰器来实现，先看看装饰器最原始的面貌。
import time

def deco(f):
    def wrapper():
        start_time = time.time()
        f()
        end_time = time.time()
        execution_time = (end_time - start_time)*1000
        print("time is %d ms" %execution_time )
    return wrapper

@deco
def f():
    print("hello")
    time.sleep(1)
    print("world")

if __name__ == '__main__':
    f()

这里的deco函数就是最原始的装饰器，它的参数是一个函数，然后返回值也是一个函数。
其中作为参数的这个函数f()就在返回函数wrapper()的内部执行。然后在函数f()前面加上@deco，
f()函数就相当于被注入了计时功能，现在只要调用f()，它就已经变身为“新的功能更多”的函数了,
（不需要重复执行原函数）。
扩展1：带有固定参数的装饰器
import time

def deco(f):
    def wrapper(a,b):
        start_time = time.time()
        f(a,b)
        end_time = time.time()
        execution_time = (end_time - start_time)*1000
        print("time is %d ms" % execution_time)
    return wrapper

@deco
def f(a,b):
    print("be on")
    time.sleep(1)
    print("result is %d" %(a+b))

if __name__ == '__main__':
    f(3,4)

扩展2：无固定参数的装饰器
import time

def deco(f):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        res = f(*args, **kwargs)
        end_time = time.time()
        execution_time_ = (end_time - start_time)*1000
        print("time is %d ms" %execution_time)
        return res #函数的返回值（函数内return后才可以接收）
    return wrapper


@deco
def f(a,b):
    print("be on")
    time.sleep(1)
    print("result is %d" %(a+b))
    return 1  #函数的返回值（这里的值）

@deco
def f2(a,b,c):
    print("be on")
    time.sleep(1)
    print("result is %d" %(a+b+c))


if __name__ == '__main__':
    f2(3,4,5)
    f(3,4)

多个装饰器存在时，自下而上一个一个的去装饰
def dec1(func):
    print("1111")
    def one():
        print("2222")
        func()
        print("3333")
    return one
 
def dec2(func):
    print("aaaa")
    def two():
        print("bbbb")
        func()
        print("cccc")
    return two
 
@dec1
@dec2
def test():
    print("test test")
 
test()
结果：
aaaa
1111
2222
bbbb
test test
cccc
3333

带参数的装饰器：
# -*- coding: UTF-8 -*-
""""=================================================
@Project -> File   ：Django -> 二叉树之有序列表
@IDE    ：PyCharm
@Author ：爱跳水的温文尔雅的laughing
@Date   ：2020/4/2 21:56
@Desc   ：
=================================================="""
import time


def out_args(out_args):
    def wrapper(f):
        def wrapper(*args, **kwargs):
            start_time = time.time()
            print(out_args)
            res = f(*args, **kwargs)
            end_time = time.time()
            execution_time_ = (end_time - start_time) * 1000
            print("time is %d ms" % execution_time_)
            return res  # 函数的返回值（函数内return后才可以接收）
        return wrapper
    return wrapper


@out_args("外部参数")
def f(a, b):
    print("be on")
    time.sleep(1)
    print("result is %d" % (a + b))
    return 1  # 函数的返回值（这里的值）

if __name__ == '__main__':
    c=f(1,2)
    print("c",c)

#输出
外部参数
be on
result is 3
time is 1000 ms
c 1

类

Python内置装饰器
在Python中有三个内置的装饰器，和类有关：
类属性：

属于类的公有属性;用类名调用,用类名修改可以永久性修改类属性;和用实例调用结果一样，用实例修改，只能修改当前实例的类属性。
实例属性：

实例属性可以被实例方法用，使用方法为self.x
实例方法：

定义的方法，可以调用类属性和实例属性
类方法：

classmethod 使用装饰器进行装饰，接收的第一个参数为类的本身，主要用于对参数的预处理,可以访问类的属性。
类中的静态方法：

staticmethod 是类静态方法，其跟成员方法的区别是没有 self 参数，并且可以在类不进行实例化的情况下调用
property：

property 是属性的意思，表示可以通过通过类实例直接访问的信息
当我们传入的参数，为一串字符串，并不符合对象属性接收的参数，我们的类属性就派上了用场，进行参数的预处理和访问类属性。
import re
class People():
	nation="china" #类属性

	def __init__(self,name,age):
		self.name=name  #实例属性
		self.__age=age #设置私有变量

	def get_info(self):  #实例方法
		print(self.name,self.__age)

	@classmethod  #类方法
	def pre_args(cls,obj,nation): #传递参数
		name=re.findall(r'\w+',obj)[0]
		age=re.findall(r'\d+',obj)[0]  
		person=cls(name,age)  #实例化
		print(cls.nation)
		return person

	@staticmethod  #静态方法
	def cal(a,b):
		print("两数之和为：",a+b)

	@property  #可以访问私有变量
	def change_age(self):
		return self.__age

p1=People.pre_args("@tianjian#27","nation")  #直接用类调用类方法
print(p1)
p1.get_info()

People.cal(3,5)  #调用静态方法

p2=People("tian",26)
print(p2.change_age)
print(p2.__age) #不能访问私有变量

结果：

私有变量不能直接被访问
china
<__main__.People object at 0x7f2d8beaacc0>
tianjian 27
两数之和为： 8
26
Traceback (most recent call last):
  File "cls_usage.py", line 67, in <module>
    print(p2.__age)
AttributeError: 'People' object has no attribute '__age'