对于传入的参数做类型检测，（类型注解）

# 在init之前做判断，但是耦合度太高
class Person:
    def __init__(self, name:str, age:int):
        params = ((name, str), (age, int))
        if not self.typecheck(params):
            raise TypeError
        self.name = name
        self.age = age

    def typecheck(self, params):
        for p, t in params:
            if not isinstance(p, t):
                return False
        return True

使用装饰器，使用inspect模块完成

import inspect

def typecheck(fn):
    def wrapper(*args, **kwargs):
        sig  = inspect.signature(fn)
        params = sig.parameters # OrderedDict([('self', <Parameter "self">), ('name', <Parameter "name: str">), ('age', <Parameter "age: int">)])

        keys = list(params.keys())
        print(keys)
        values = list(params.values())
        print(values)
        # 位置参数
        for i, v in enumerate(args[1:]):
            if type(v) is not (values[1:])[i].annotation:
                raise Exception('-------Different Tyeps')
        # 关键字参数
        for i, v in kwargs.items(): # i=age, v=12
            for key in keys:
                if key == i and params[key].annotation != inspect._empty and type(v) is not params[key].annotation:
                    raise Exception('+++++++Different Types')
    return wrapper

class Person:

    @typecheck  # __init__ = typecheck(__init__)
    def __init__(self, name:str, age:int=12):
        self.name = name
        self.age = age

p = Person('jack', age=12) # 没有键值对的方式

使用描述器 将属性放到自己的属性字典中
class TypeCheck:
    def __init__(self, flag, type):
        self.flag = flag
        self.type = type

    def __get__(self, instance, owner):
        return instance.__dict__[self.flag]

    def __set__(self, instance, value):
        if isinstance(value, self.type):
            instance.__dict__[self.flag] = value
        else:
            raise TypeError


class Person:
    name = TypeCheck('name', str)
    age = TypeCheck('age', int)

    def __init__(self, name:str, age:int):
        self.name = name
        self.age = age

p = Person('tom', 18)
print(p.name)
print(p.age)
print(p.__dict__)

使用描述器 将属性放到描述器实例的属性字典中
class TypeCheck:
    def __init__(self, flag, type):
        self.flag = flag
        self.type = type
        self.data = {}

    def __get__(self, instance, owner):
        # return instance.__dict__[self.flag]
        print(self.__dict__)
        return self.data[self.flag]

    def __set__(self, instance, value):
        if isinstance(value, self.type):
            # instance.__dict__[self.flag] = value
            self.data[self.flag] = value
        else:
            raise TypeError

class Person:
    name = TypeCheck('name', str)
    age = TypeCheck('age', int)

    def __init__(self, name:str, age:int):
        self.name = name
        self.age = age

p = Person('tom', 12)
print(p.name)
print(p.age)
print(p.__dict__)

上面属于硬编码，将描述器写到 逻辑代码中。
现在将其提取出来，作为装饰器
函数装饰器
class TypeCheck:
    def __init__(self, flag, type):
        self.flag = flag
        self.type = type

    def __get__(self, instance, owner):
        return instance.__dict__[self.flag]

    def __set__(self, instance, value):
        if isinstance(value, self.type):
            instance.__dict__[self.flag] = value
        else:
            raise TypeError

import inspect
def typeassert(cls):
    sig = inspect.signature(cls)
    params = sig.parameters
    for flag, value  in params.items():
        # cls.__dict__[flag] = TypeCheck(flag, value.annotation) # 只有实例能添加属性到字典中，通过操作字典
        if value.annotation != inspect._empty: # 或者，value.empty
            setattr(cls, flag, TypeCheck(flag, value.annotation))
    return cls

@typeassert # Person=typeassert(Person）
class Person:
    # name = TypeCheck('name', str)
    # age = TypeCheck('age', int)
    def __init__(self, name:str, age:int):
        self.name = name
        self.age = age

p = Person('tom', 18)
print(p.name)
print(p.age)
print(p.__dict__)

上面属于硬编码，将描述器写到 逻辑代码中。
现在将其提取出来，作为装饰器
类装饰器

class TypeCheck:
    def __init__(self, flag, type):
        self.flag = flag
        self.type = type

    def __get__(self, instance, owner):
        return instance.__dict__[self.flag]

    def __set__(self, instance, value):
        if isinstance(value, self.type):
            instance.__dict__[self.flag] = value
        else:
            raise TypeError

import inspect
class TypeAssert:
    def __init__(self, cls):
        sig = inspect.signature(cls)
        params = sig.parameters
        for flag, value  in params.items():
            if value.annotation != inspect._empty: # 或者，value.empty
                setattr(cls, flag, TypeCheck(flag, value.annotation))
        self.cls = cls

    def __call__(self, *args, **kwargs):
        return self.cls(*args, **kwargs)

@TypeAssert # Person=TypeAssert(Person）
class Person:
    def __init__(self, name:str, age:int):
        self.name = name
        self.age = age

p = Person('tom', 18)
print(p.__dict__)
print(p.name)
print(p.age)
print(p.__dict__)