一、property
先看下面例子：
依赖于birthday设置User对象的属性
class User: def __init__(self,name,birthday): self.name = name self.birthday = birthday #age依赖于当前时间，需要做一番计算 self.age = datetime.today().year - self.birthday.year user = User("ming",date(year=1992,month=8,day=12)) print(user.age)
但是这样好吗？如果是更加复杂的计算就必须以函数的方式返回。
from datetime import date,datetime class User: def __init__(self,name,birthday): self.name = name self.birthday = birthday def get_age(self): return datetime.today().year - self.birthday.year user = User("ming",date(year=1992,month=8,day=12)) print(user.get_age())
虽然可以实现功能，但是明明是属性值却还要调用方法？有没有解决方案了？
通过property关键字就可以实现。
from datetime import date,datetime class User: def __init__(self,name,birthday): self.name = name self.birthday = birthday @property def age(self): return datetime.today().year - self.birthday.year user = User("ming",date(year=1992,month=8,day=12)) print(user.age)
@property可以把一个函数当作一个属性来供用户操作
既然是属性操作，还可以进行set和del操作。
from datetime import date,datetime class User: def __init__(self,name,birthday): self.name = name self.birthday = birthday self._age = None @property def age(self): return datetime.today().year - self.birthday.year @age.setter def age(self,value): self._age = value @age.deleter def age(self): del self._age user = User("ming",date(year=1992,month=8,day=12)) print(user.age) #27 print(user._age) #None #需要注意的是属性名不能和@property的方法名相同 user._age = 28 print(user.age) #27 print(user._age) #28
二、__getattr__和__getattribute__
__getattr__:当找不到相应的属性的时候所作的逻辑操作。
如果没有定义__getattr__方法，对于找不到的属性会直接报错。
from datetime import date,datetime class User: def __init__(self,name,birthday): self.name = name self.birthday = birthday user = User("ming",date(year=1992,month=8,day=12)) print(user.age) #AttributeError: 'User' object has no attribute 'age'
如果设置了相应的方法找不到相应的属性会执行相应的逻辑。
from datetime import date,datetime class User: def __init__(self,name,birthday): self.name = name self.birthday = birthday def __getattr__(self, item): return "no find attr" user = User("ming",date(year=1992,month=8,day=12)) print(user.age) #no find attr
当然不单单只是返回报错。
from datetime import date,datetime class User: def __init__(self,name,birthday,info): self.name = name self.birthday = birthday self.info = info def __getattr__(self, item): return self.info.get(item) info = {"company_name":"正名", "position":"Director", "family_information":{"father":"farmer","monther":'farmer'}, "Working company":["百度","阿里","苹果"]} user = User("ming",date(year=1992,month=8,day=12),info) print(user.position) #Director
__getattribute__:会比__getattr__更加霸道，所有的属性访问都会走下面的逻辑，不论是否存在。
from datetime import date,datetime class User: def __init__(self,name,birthday): self.name = name self.birthday = birthday def __getattr__(self, item): return self.info.get(item) def __getattribute__(self, item): return "test" user = User("ming",date(year=1992,month=8,day=12)) print(user.position) #test #不存在的也可以
__getattribute__在某些时候想要控制属性访问还是特别有用的。
三、属性描述符和属性的查找范围
user.age看似简单，但是内部实现的原理并不简单，通过下面内容应该可以清楚user.age的整个生命周期。
1.数据属性描述符
我们在自定义一个属性的时候该如何对属性本身做一些限制了？
我们要知道，类里面的所有方法都是针对于对象本身的，而不是针对这个属性的。
因此，我们需要将属性也变成一个自定义的对象，这样我们就能对属性进行操作
在ORM中，我们使用的是如下方式创建以及定义表：
class BusinessUnitType(models.Model): """ 业务单元分类 """ name = models.CharField(max_length=64)
下面我们可以模拟上述操作。
class CharField: def __init__(self,max_length=32): self.max_length = max_length class User: name= CharField(max_length=6) user = User() user.name = "str" print(user.name)
但是现在还没有添加限制，比如必须是字符串，比如最大长度为6.
class CharField: def __init__(self,max_length): self.max_length = max_length def __get__(self, instance, owner): return self.value def __set__(self, instance, value): if not isinstance(value,str): raise ValueError("name必须是字符串") if len(value) > self.max_length: raise ValueError("超过规定长度") if not isinstance(self.max_length,int): raise ValueError("max_length 必须是整数") self.value = value def __delete__(self, instance): del self.value class User: name= CharField(max_length=6)
打印测试：
user = User() user.name = 1 #ValueError: name必须是字符串 user.name = "uuuuuuuu" #ValueError: 超过规定长度 user.name = "yannc" #ValueError: max_length 必须是整数 print(user.name)
现在我们回过头来看看instance和value是什么
instance是一个user对象，竟然将外层内当参数传进来了，现在还没用过。
value就是name对象，或者说是值。当我们不知道怎么操作这些方法的时候，可以使用debug打印下到底做了什么。
现在回过头来想，我们就必须这样吗？
我们写一个使用常用的方式：
class NewPerson: def __init__(self,name=None): self.name = name def __set__(self, instance, value): print("123") newperson = NewPerson() newperson.name = "kebi" #这个操作根本就不会经过__set__魔法方法，__set__属于对象操作。
我们可以定义一个set_name方法，对name的赋值进行限制，估且不说name.set_name("kebi")这种形式好不好，
但是每一个属性的设置方法我都要进行定义，你觉得麻烦不？就不能newperson.name=""这种形式吗？
对于属性的操作难道我们就毫无办法吗？
其实可以使用@property，这个可以实现。
class Person: @property def name(self): return self._name @name.setter def name(self,value): self._name = value person = Person() person.name = "kibi" print(person.name)
虽然可以实现，但是如果一个类的属性非常多，那么这个类就会显得非常臃肿。
对于属性的操作我们在类里面随便定义一个方法都可以操作，但是你把属性的值改变了之后，还是当前属性吗？
现在再来看看：
class CharField: def __init__(self,max_length): self.max_length = max_length def __get__(self, instance, owner): return self.value def __set__(self, instance, value): if not isinstance(value,str): raise ValueError("name必须是字符串") if len(value) > self.max_length: raise ValueError("超过规定长度") if not isinstance(self.max_length,int): raise ValueError("max_length 必须是整数") self.value = value def __delete__(self, instance): del self.value class User: name= CharField(max_length=6)
name对于User来说是一个属性，但是同时也是一个对象，给一个对象赋值name="kebi"，name还是CharField对象吗？
这就要说到属性操作符，CharField既是一个类，也是一个属性描述符，这个一个有点特别的类。
为什么这样说了？name可以说是CharField的对象，但是又str的对象，CharField更像是一个辅助类。
什么是属性描述符？只要是__get__、__set__、__delete__三个方法中的任意一个就是一个属性描述符。、
2.非数据属性描述符
当你只使用__get__方法来构造描述符的时候，你所构造的描述符就是一个非数据描述符。
class CharField: def __init__(self,max_length): self.max_length = max_length def __get__(self, instance, owner): return self.value class User: name = CharField()
3.属性查找过程
class CharField: pass class User: name = CharField()
对于数据属性描述符、非数据属性描述符、类属性和对象属性的优先级说明：
如果user = User()，那么user.age的调用顺序如下：
（1）如果age在User类或者基类中，并且是数据属性描述符，那么调用其__get__方法。
关于属性描述符的定义：
class CharField: def __get__(self, instance, owner): return self.value def __set__(self, instance, value): pass def __delete__(self, instance): pass class User: name= CharField() user = User() user.name = “kebi”
（2）如果age在user的__dict__中，那么以return self.age的方式调用。
出现在user的__dict__中，可能有三种情况：
class User: def __init__(self,name): #方法1 self.name = name user = User('ming') #方法2 user.age = 28 # 方法3：回溯机制 user.__dict__['addr'] = "罗田"
（3）如果age出现在User类或者基类__dict__中，并且是非数据属性描述符，那么调用其__get__方法。
class CharField: def __get__(self, instance, owner): return self.value
（4）如果age出现在User类或者基类__dict__中，不是描述符，以return self.age调用。
（5）如果User有__getattr__方法，调用__getattr__
（6）抛出AttributeError异常
class User: pass user = User() print(user.name) #AttributeError: 'User' object has no attribute 'name'
优先级：
数据属性描述符 > 对象属性 > 非数据属性描述符 > 常规类属性 > __getattr__
下面是一个示例应该可以更好的阐述。
from datetime import date,datetime class Name1(): """数据属性描述符""" def __get__(self, instance, owner): pass def __set__(self, instance, value): pass def __delete__(self, instance): pass class Name3(): """非数据属性描述符""" def __get__(self, instance, owner): pass class User: name1 = Name1() name3 = Name3() """普通类对象""" name4 = "kebi" def __init__(self,name,birthday): self.name2 = name self.birthday = birthday def __getattr__(self, item): return "56789" def __getattribute__(self, item): #第一步：调用数据属性描述符name1 #第二步：调用self.name2 #第三步：调用非数据属性描述符name3 #第四步：调用类属性name4 #第五步：调用__getattr__方法 #第六步：抛出AttributeError return "123" user = User("ming",date(year=1992,month=8,day=12))
从上述示例中，关于user.age获取操作都是在__getattribute__方法中实现。
下面示例会证明上述过程：
示例1:
class User: def __getattr__(self, item): return "__getattr__" user = User() print(user.name)
示例2：类属性 > __getattr__
class User: name = "class_attr" def __getattr__(self, item): return "__getattr__" user = User() print(user.name)
示例3：非数据描述符 > 类属性
class Name: def __get__(self, instance, owner): return "Non-data attribute descriptor" class User: name = Name() def __getattr__(self, item): return "__getattr__" user = User() print(user.name)
示例4：对象属性 > 非数据属性描述符
class Name: def __get__(self, instance, owner): return "Non-data attribute descriptor" class User: def __init__(self): self.name = "object_attr" user = User() print(user.name)
示例5：数据属性描述符 > 对象属性
class Name: def __get__(self, instance, owner): return "data attribute descriptor" def __set__(self, instance, value): pass class User: name = Name() def __init__(self): self.name = "object_attr" user = User() print(user.name)
最后来看一个示例：
class Name: def __get__(self, instance, owner): return "Non-data attribute descriptor" def __set__(self, instance, value): pass class User: name = Name() def __init__(self): self.name = "object_attr" def __getattr__(self, item): return "__getattr__" def __getattribute__(self, item): return "123" user = User() print(user.name) #"123"
你可能会纳闷，为啥是这个？因为__getattribute__屏蔽了所有，
整个属性调用本身就在__getattribute__中进行，你现在重写，不就是覆盖了原有操作了吗。
还有一点需要注意的是，当你使用属性描述符设置值的时候，属性并不会出现在__dict__中。
class Name: def __get__(self, instance, owner): return self.name def __set__(self, instance, value): self.name = value class User: name = Name() user = User() user.name = "maoxian" print(user.name) #maoxian print(user.__dict__) #{}
当你使用__dict__来添加属性的时候，尤其是混合数据操作符的时候，可能会有以下异常：
class Name: def __get__(self, instance, owner): return self.name def __set__(self, instance, value): self.name = value class User: name = Name() user = User() user.__dict__["name"] = "maoxian" print(user.__dict__) #{'name': 'maoxian'} #当你在调用的user.nage的时候，优先还是先找数据属性描述符 print(user.name) #AttributeError: 'Name' object has no attribute 'name' #当然下面方法还是可用： user.__dict__['name']
四、__init__和__new__的区别
__init__：构造器，用来初始化对象的信息
__new__：在对象创建之前被创建。如果__new__没有返回值，那么也不会执行__init__函数。
class User: def __new__(cls, *args, **kwargs): #这个cls代表当前类User print("new") def __init__(self): #self代表当前对象 print("init") user = User() #new 这里根本不会执行__init__函数
给__new__一个返回值就可以。
class User: def __new__(cls, *args, **kwargs): return super().__new__(cls) def __init__(self): print("init") user = User()
__new__只有在新式类中实现
五、自定义元类
1.动态创建类的方式
（1）通过函数创建
def create_class(name): if name == "User": class User: def __str__(self): return "User" return User else: class Person: def __str__(self): return "User" return Person User = create_class("User") print(User) user = User() print(user)
（2）通过type来动态创建类
type中提供了三种创建方法：
type(object_or_name, bases, dict) type(object) -> the object's type type(name, bases, dict) -> a new type
下面是实现示例：
创建一个类：
User = type("User",(),{}) print(User)
定义一个属性：
User = type("User",(),{"name":"mao"}) user = User() print(user.name)
定义一个方法：
def see(self): #这里必须要传递一个self参数 print("I see a dog") User = type("User",(),{"name":"mao","see":see}) user = User() user.see()
定义一个父类：
class Anlu: def go_to_anlu(self): print("go to anlu") User = type("User",(Anlu,),{"name":"mao","see":see}) user = User() user.go_to_anlu()
2.元类
元类就是创建类的类。比如type就是一个元类
a = 1 print(type(a)) #<class 'int'> print(type(int)) #<class 'type'> b = [1,2,3] print(type(b)) #<class 'list'> print(type(list)) #<class 'type'>
python中的int、str、list、dict、class都是type创建。
六、通过元类实现一个简单的ORM
在使用元类编程的时候，必须继承type类，一般在元类里面都是重写__new__方法，
用于在对象初始化之前做一些操作，比如数据的整理。
class IntegerField(): def __init__(self,db_column,max_length=0): self._value = None self.max_length = max_length self.db_column = db_column if max_length: #0 == Flase if not isinstance(max_length,numbers.Integral): raise ValueError("max_length must be int") elif max_length < 0: raise ValueError("max_length > 0") else: raise ValueError("max_length must bi have") def __get__(self, instance, owner): return self._value def __set__(self, instance, value): #这个value = name if not isinstance(value,numbers.Integral): raise ValueError("value must be int") if value < 0: raise ValueError("value must greater than 0") elif value < pow(10,self.max_length) -1: raise ValueError("value should not be greater than max") def __delete__(self, instance): del self._value class CharField(): def __init__(self,db_column,min_length=0,max_length=0): self._value = None #_value是name的值，这个一般都会预留 self.db_column = db_column self.min_length = min_length self.max_length = max_length if max_length: if not isinstance(max_length,numbers.Integral): raise ValueError("max_length must be int") elif max_length < 0: raise ValueError("max_length > 0") else: raise ValueError("max_length must bi have") if min_length: if not isinstance(min_length,numbers.Integral): raise ValueError("min_length must be int") elif min_length < 0: raise ValueError("min_length > 0") elif min_length > max_length: raise ValueError("min_length less than max_length") def __get__(self, instance, owner): return self._value def __set__(self, instance, value): if not isinstance(value,str): raise ValueError("value must be str") if len(value) > self.max_length or len(value) < self.min_length: raise ValueError("Value length is error") self._value = value def __delete__(self, instance): del self._value class Student(): name = CharField(db_column="",min_length=1,max_length=32) age = IntegerField(db_column="",max_length=32) class Meta: db_table = "student"
上方代码通过属性描述符实现了对数据的检测功能。
虽然上面有了ORM的雏形，但是还需要对一些初始信息进行封装。比如字段信息
创建元类：ModelMetaClass
class ModelMetaClass(type): def __new__(cls, name,bases,attrs, **kwargs): if name == "BaseModel": return super().__new__(cls, name, bases, attrs, **kwargs) #重新整理字段，这样方便表结构的初始化 fields = {} for key,value in attrs.items(): if isinstance(value,Field): fields[key] = value attrs_meta = attrs.get("Meta",None) _meta = {} db_table = name.lower() #如果student中有Meta配置 if attrs_meta: #取出db_table这个属性 table = getattr(attrs_meta,"db_table",None) if table: db_table = table #存在就会重新赋值 _meta["db_table"] = db_table #重新整理attrs中的属性 attrs["_meta"] = _meta attrs["fields"] = fields del attrs["Meta"] return super().__new__(cls, name, bases, attrs, **kwargs)
这就玩了吗？还需要一些初始化的改动，将初始化信息单独封装起来成BaseModel
class BaseModel(metaclass=ModelMetaClass): def __init__(self,*args,**kwargs): #下面这部分主要是怕用户不使用属性描述符来初始化信息。 for key,value in kwargs.items(): setattr(self,key,value) return super().__init__() #下面就可以定义数据库操作了。 def save(self): fields = [] values = [] for key,value in self.fields.items(): db_column = value.db_column if not db_column: db_column = key.lower() fields.append(db_column) value = getattr(self,key) values.append(str(value)) sql = "insert into {db_table} ({fields}) value({values})".format(db_table=self._meta["db_table"], fields=",".join(fields), values=",".join(values)) pass
下面是完整代码：
import numbers class Field: pass class IntegerField(Field): # 属性描述符做字段验证 def __init__(self,db_column,max_length=0): self._value = None self.max_length = max_length self.db_column = db_column if max_length: #0 == Flase if not isinstance(max_length,numbers.Integral): raise ValueError("max_length must be int") elif max_length < 0: raise ValueError("max_length > 0") else: raise ValueError("max_length must bi have") def __get__(self, instance, owner): return self._value def __set__(self, instance, value): #这个value = name if not isinstance(value,numbers.Integral): raise ValueError("value must be int") if value < 0: raise ValueError("value must greater than 0") elif value < pow(10,self.max_length) -1: raise ValueError("value should not be greater than max") def __delete__(self, instance): del self._value class CharField(Field): #属性描述符做字段验证 def __init__(self,db_column,min_length=0,max_length=0): self._value = None #_value是name的值，这个一般都会预留 self.db_column = db_column self.min_length = min_length self.max_length = max_length if max_length: if not isinstance(max_length,numbers.Integral): raise ValueError("max_length must be int") elif max_length < 0: raise ValueError("max_length > 0") else: raise ValueError("max_length must bi have") if min_length: if not isinstance(min_length,numbers.Integral): raise ValueError("min_length must be int") elif min_length < 0: raise ValueError("min_length > 0") elif min_length > max_length: raise ValueError("min_length less than max_length") def __get__(self, instance, owner): return self._value def __set__(self, instance, value): if not isinstance(value,str): raise ValueError("value must be str") if len(value) > self.max_length or len(value) < self.min_length: raise ValueError("Value length is error") self._value = value def __delete__(self, instance): del self._value class ModelMetaClass(type): # def __new__(cls, name,bases,attrs, **kwargs): if name == "BaseModel": return super().__new__(cls, name, bases, attrs, **kwargs) #重新整理字段，这样方便表结构的初始化 fields = {} for key,value in attrs.items(): if isinstance(value,Field): #找出字段，为了方便验证重新定义Field类 fields[key] = value attrs_meta = attrs.get("Meta",None) _meta = {} db_table = name.lower() #如果student中有Meta配置 if attrs_meta: #取出db_table这个属性 table = getattr(attrs_meta,"db_table",None) if table: db_table = table #存在就会重新赋值 _meta["db_table"] = db_table #重新整理attrs中的属性 attrs["_meta"] = _meta attrs["fields"] = fields del attrs["Meta"] return super().__new__(cls, name, bases, attrs, **kwargs) class BaseModel(metaclass=ModelMetaClass): def __init__(self,*args,**kwargs): #支持Student(name=xxx)这个赋值操作 for key,value in kwargs.items(): setattr(self,key,value) return super().__init__() #定义插入操作 def save(self): fields = [] values = [] for key,value in self.fields.items(): db_column = value.db_column if not db_column: db_column = key.lower() fields.append(db_column) value = getattr(self,key) values.append(str(value)) sql = "insert into {db_table} ({fields}) value({values})".format(db_table=self._meta["db_table"], fields=",".join(fields), values=",".join(values)) pass class Student(BaseModel): name = CharField(db_column="",min_length=1,max_length=32) age = IntegerField(db_column="",max_length=32) class Meta: db_table = "student" student = Student() student.name = "kebi" print(student.name) student.save()