class class_name(base_class): base_class是它继承的父类
class_var
def methods(self,args):
statements
经典类、新式类
版本2和版本3的区别，3都是新式类
首先，写法不一样：
class A: #旧式类 pass class B(object): #新式类 pass经典类和新式类的区别：
1）__slots__,
新式类里有这个，‘槽’的意思，对属性的一个限制，只能访问槽里边的属性。
2）继承顺序，super
3）__new__,
4)__getattribute__
可以看到：
1.A的属性比较少，B的属性比较多。
2.A可以对__slots__以外的属性赋值，B不可以。因为Python是动态的，所以可以随便往里边添加属性，但是如果有了槽之后，即有了__slots__之后，只能添加槽里边有的
东西。三个引号包括的内容在help帮助里边会显示。我们写程序的时候尽量用新式类。
实例属性一般定义再__init__里边，比如上边的self.owner,self.length,self.width,self.height。类属性一般定义在方法外边，比如上边的country属性。
#!/usr/bin/env python # -*- coding: utf-8 -*- #copyRight by heibanke class Car(object): country = u'中国' def __init__(self, length, width, height, owner=None): self.owner = owner self.length = length self.width = width self.height = height self.country = "china" if __name__ == '__main__': a = Car(1.2,1.4,1.5,u'黑板客') b = Car(2.2,2.4,2.5,u'小张') print a.owner, b.owner print a.country, b.country #country访问的是实例属性 b.country = u'美国' #改变的是实例属性 print a.country, b.country #输出实例属性 print Car.country #输出类属性 print "--------------------------" del a.country #删除a的实例属性 print a.country#因为a的实例属性别删除了，所以会找类属性，所以输出的是类属性 #del a.country #del Car.country #print a.country
输出为：
>>> 黑板客 小张 china china china 美国 中国 -------------------------- 中国 >>>当我们调用a.country时，先去实例属性中找，如果有，就用实例属性的，如果没有就找类属性的。当我们用Car.country的时候，我们调用的类属性。
当我们把a的country删除之后，a的在实例属性中找不到，就会到类属性中找。而b的country没有删除，所以直接就用实例属性中的country。
不能直接访问。对类自己可见，对外不可见的。
目的：保证赋值的合理性。
两种做法：
1.__xxx 两个下划线，不能直接访问到，但可以间接访问到
2._xxx 一个下划线，可以直接访问到，但是有一个下划线提示我们直接访问是不合理的，实际上是自己提醒自己的方式
__xxx__ 两边都有两个下划线，这是系统自带的属性。
_xxx 不能用于’from module import *’ 以单下划线开头的表示的是protected类型的变量。即保护类型只能允许其本身与子类进行访问。
__xxx 双下划线的表示的是私有类型的变量。只能是允许这个类本身进行访问了。连子类也不可以
__xxx__定义的是特列方法。像__init__之类的，是系统定义的名字，我们应该避免这样命名变量
#!/usr/bin/env python # -*- coding: utf-8 -*- #copyRight by heibanke class Car(object): country = u'中国' def __init__(self, length, width, height, owner=None): self.__owner = owner#双下划綫，不可以直接访问 assert length>0,"length must larger than 0" #单下划线，可以直接访问，但是此时已经提醒作者，不应该直接访问的，作者自己监督 self._length = length self._width = width self._height = height def getOwner(self): return self.__owner def setOwner(self, value): self.__owner = value def getLength(self): return self._length def setLength(self,value): assert value>0,"length must larger than 0" self._length = value if __name__ == '__main__': a = Car(1.2,1.4,1.5,u'黑板客') print a.getOwner() #a.setLength(-1)描述符——定义了get和set的一个对象。
编程描述符有什么好处：像取属性一样操作方法，把方法当做属性去访问。
a.setlength(-1) 这是直接用get和set方法定义的方法
a.length=-1 这是用描述符实现的
用法：
#!/usr/bin/env python # -*- coding: utf-8 -*- #copyRight by heibanke class Car(object): country = u'中国' def __init__(self, length, width, height, owner=None): self._owner = owner self._length = length self._width = width self._height = height @property #相当于get方法 def owner(self): return self._owner @owner.setter #相当于set方法 def owner(self, value): self._owner = value @owner.deleter #相当于delete方法 def owner(self): self._owner = None @property def length(self): return self._length @length.setter def length(self, value): assert value>0,"length must larger than 0" self._length = value if __name__ == '__main__': a = Car(1.2,1.4,1.5,u'黑板客') print a.owner del a.owner print a.owner a.length=-1
输出：
>>> 黑板客 None Traceback (most recent call last): File "C:\Users\shiye\AppData\Local\Temp\property03.py", line 36, in <module> a.length=-1 File "C:\Users\shiye\AppData\Local\Temp\property03.py", line 28, in length assert value>0,"length must larger than 0" AssertionError: length must larger than 0 >>> a.length=-1@property 是get方法
@owner.setter 是set方法
@owner.deleter 是delete方法
但是出现了一个新的问题，造成了代码的冗余,因为我们每一个属性，都要定义三个这样的方法，非常的麻烦
__getattr__ ——特殊方法
自动调用
当访问一个属性，访问不到时，它会自动调用。
__setattr__
给属性赋值的时候自动调用
__delattr__
删除属性的时候自动调用
#!/usr/bin/env python # -*- coding: utf-8 -*- #copyRight by heibanke class Car(object): country = u'中国' __slots__=('length','width','height','owner','__dict__') def __init__(self, length, width, height, owner=None): self.owner = owner self.length = length self.width = width self.height = height def __getattr__(self,name): print "__getattr__",name return self.__dict__.get(name,None) def __setattr__(self,name,value): print "__setattr__",name if name!='owner': assert value>0, name+" must larger than 0" self.__dict__[name]=value def __delattr__(self,name): print "__delattr__",name if name=='owner': self.__dict__[name]=None if __name__ == '__main__': a = Car(1.2,1.4,1.5,u'黑板客') """ print a.owner del a.owner print a.owner a.length=1 print a.country a.country = 'china' print a.country """ #a.name = u"一汽"
输出：
>>> __setattr__ owner __setattr__ length __setattr__ width __setattr__ height >>> a.name __getattr__ name >>> a.lenth=a __setattr__ lenth >>> a.length=-4 __setattr__ length Traceback (most recent call last): File "<pyshell#2>", line 1, in <module> a.length=-4 File "C:/Users/shiye/Documents/set.py", line 22, in __setattr__ assert value>0, name+" must larger than 0" AssertionError: length must larger than 0 >>> __getattr__ __members__ __getattr__ __methods__ del a.length __delattr__ length >>> del owner Traceback (most recent call last): File "<pyshell#4>", line 1, in <module> del owner NameError: name 'owner' is not defined >>> del a.owner __delattr__ owner >>>发现没有name属性，会调用__getattr__ 函数，其他的都一样。
我们可以看到，我们只是产生了一个a，然后赋值的时候全部都调用了__setattr__,
而且我们可以在这个地方对我们要赋的值就行判断，这样就免除了在每一次赋值的时候 都要判断的麻烦。
如果我们用__slot__之后，就不会有__dict__这个东西了，就意味着无法再往里边添加__slot__以外的属性了，但是当我们把__dict__这个东西加进__slot__之后，我们，我们依然可以添加__slot__以外的属性。比如上边的例子a.name这个属性。
当我们调用a.mm的时候，因为不存在这个属性，所以会自动调用__getattr__。
这样我们就通过这些解决了，我们在设置属性时要对属性进行判断的一个过程。
但是我们为什么要用__slots__和__dict__一起来配合使用呢？
在__slots__里边加上__dict__之后，无法限制对属性的访问。如果没有slots的话，只有没有的属性才会调用__getattr__，有的属性就不会调用。而如果加上__slots__的
话，slots里边有的也会调用__getattr__。
但是这样也会有新的问题出现，如何控制对属性的赋值呢，可以用下边的方法：
我们先用assert判断一下访问的属性是否在slots里边，然后再判断，__setattr__和__delete__也要这么做
#!/usr/bin/env python # -*- coding: utf-8 -*- #copyRight by heibanke class Car(object): country = u'中国' __slots__=('length','width','height','owner','__dict__') def __init__(self, length, width, height, owner=None): self.owner = owner self.length = length self.width = width self.height = height def __getattr__(self,name): print "__getattr__",name assert name in self.__slots__, "Not have this attribute "+name return self.__dict__.get(name,None) def __setattr__(self,name,value): print "__setattr__",name assert name in self.__slots__, "Not have this attribute "+name if name!='owner': assert value>0, name+" must larger than 0" self.__dict__[name]=value def __delattr__(self,name): print "__delattr__",name assert name in self.__slots__, "Not have this attribute "+name if name=='owner': self.__dict__[name]=None if __name__ == '__main__': a = Car(1.2,1.4,1.5,u'黑板客') """ print a.owner del a.owner print a.owner a.length=1 print a.country a.country = 'china' print a.country a.name = u"一汽" """大多数的时候，我们是这么用__getattr__的，，比如getattr(a,’length’)是在我们运行程序的时候才决定我们要访问哪一个属性。
非数据描述符定义了一个函数：__get__
数据描述符定义两个函数：__get__ __set__
描述符可以用作描述类的属性的这样的一个东西。当你定义了__get__ __set__，之后，这个类就可以作为另一个类的属性。
举例：
#!/usr/bin/env python # -*- coding: utf-8 -*- #copyRight by heibanke class PositiveNum(object): def __init__(self,value): self.val = value def __get__(self, instance, owner): # instance = a,b # owner = Car print "__get__",instance,owner return self.val def __set__(self, instance, value): # instance = a,b print "__set__",instance,value try: assert int(value)>0 self.val = value except AssertionError: print "ERROR: "+str(value)+" is not positive number." except: print "ERROR: "+str(value)+" is not number value." def __delete__(self,instance): print "__delete__",instance self.val = None #def __getattribute__(self,name): #print self, name class Car(object): country = u'中国' length = PositiveNum(0) width = PositiveNum(0) height = PositiveNum(0) #__slots__=('owner','length','width','height') def __init__(self, length, width, height, owner=None): self.owner = owner self.length = length self.width = width self.height = height if __name__ == '__main__': a = Car(1.2,1.4,1.5,u'黑板客') b = Car(2.2,2.4,2.5,u'小明')
这样有一个好处，就是我们在对他进行初始化的时候，也把也进入了__init__里边对值进行了判断，免除了前边讲的冗余的问题。但是从运行结果上看，我们知道a.length和
b.length是一样的，为什么呢？因为length是个类属性。我们上边定义的那个类PositiveNum，里边有__set__和__get__函数，所以它不再是一个实例变量而是一个类变量。
怎么解决这个问题呢？
针对类修改PositiveNum
class PositiveNum(object): def __init__(self): self.default = 1 self.data = {} def __get__(self, instance, owner): # instance = x # owner = type(x) print "__get__",instance,owner return self.data.get(instance, self.default) def __set__(self, instance, value): # instance = x print "__set__",instance,value try: assert int(value)>0 self.data[instance] = value ###针对instance进行赋值，不同的instance有不同的值，这样就保证了是实例变量而不是类变量 except AssertionError: print "ERROR: "+str(value)+" is not positive number." except: print "ERROR: "+str(value)+" is not number value." def __delete__(self,instance): print "__delete__",instance del self.data[instance]实际上data是一个字典，我们针对不同的instance进行输出。但是也有一个问题，这个时候我们可以对a.x这样的属性进行赋值，实际上我们不想这样的，怎么办呢？我们可
以在Car类里边加上__slots__进行限制。
另外新式类里边多了一个__attribute__的描述符。在访问属性的时候就会被调用，所以调用的时机比较多。一般来说我们很少用的，如果改变了它，会考虑很多情况，因为
许多情况它都会被调用的。
分类
类方法 @classmethod
实例方法
静态方法 @staticmethod
特殊方法（魔法方法） __init__等
形式上的区别：
1、调用是通过类和实例进行的，不能直接调用
2、有自己的特殊参数 self cls
3、有自己的声明语法@classmethod @staticmethod __xx__()
实质的区别：——绑定
类方法——绑定类
实例方法——绑定实例
静态方法——和函数没有区别，无绑定
特殊方法——在某些场合自动调用
方法和函数的区别：
函数(function)就相当于一个数学公式，它理论上不与其它东西关系，它只需要相关的参数就可以。所以普通的在module中定义的称谓函数是很有道理的。
方法是与某个对象相互关联的，也就是说它的实现与某个对象有关联关系。这就是方法。虽然它的定义方式和函数是一样的。也就是说，在Class定义的函数
就是方法。
静态方法和实例方法的区别主要体现在两个方面：
1. 在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以
无需创建对象。
2. 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。
3. 类方法可以被对象调用，也可以被实例调用；传入的都是类对象，主要用于工厂方法，具体的实现就交给子类处理
4. 静态方法参数没有实例参数 self, 也就不能调用实例参数
静态方法和类方法的区别：
逻辑上类方法应当只被类调用，实例方法实例调用，静态方法两者都能调用。主要区别在于参数传递上的区别，实例方法悄悄传递的是self引用作为参数，而
类方法悄悄传递的是cls引用作为参数。静态方法无隐含参数，主要为了类实例也可以直接调用静态方法。
#!/usr/bin/env python # coding: utf-8 # http://stackoverflow.com/questions/12179271/python-classmethod-and-staticmethod-for-beginner class Date(object): #self 作为实例参数 def __init__(self, day=0, month=0, year=0): self.day = day self.month = month self.year = year def __str__(self):#用于输出的时候显示内容 return "{0}-{1}-{2}".format(self.year, self.month, self.day) # cls作为类方法的参数 @classmethod def from_string(cls, date_as_string): year, month, day = map(int, date_as_string.split('-')) date1 = cls(day, month, year) return date1 #静态方法，用类还是用实例都可以访问，这里没有self或者cls作为参数 @staticmethod def is_date_valid(date_as_string): year, month, day = map(int, date_as_string.split('-')) return day <= 31 and month <= 12 and year <= 3999 @staticmethod def millenium(month, day): return Date(month, day, 2000) #返回的是Date对象 class DateTime(Date): #特殊方法，当我们print一个类的时候，按照__str__的方式显示出来 def __str__(self): return "{0}-{1}-{2} - 00:00:00PM".format(self.year, self.month, self.day) if __name__=="__main__": s='2012-09-11' if Date.is_date_valid(s): date1 = Date.from_string('2012-09-11') print date1 date2 = DateTime.from_string('2012-09-11') print date2 millenium_new_year1 = Date.millenium(1, 1) print millenium_new_year1 millenium_new_year2 = DateTime.millenium(10, 10) print millenium_new_year2
输出：
>>> 2012-9-11 2012-9-11 - 00:00:00PM 2000-1-1 2000-10-10 >>>
属性访问：__getattr__,__setattr__,__getattribute__
实例生成/类生成：__init__,__new__
数字计算：__add__,__sub__,__mul__,__div__,__pow__,__round__
调用方法：__str__,__repr__,__lent__,__bool__ 可以通过函数调用的方式，比如str()的方式调用，不需要用类或者实例的方式
比较大小：__cmp__,__lt__,__le__,__eq__,__ne__,__gt__,__ge__
集合访问：__setslice__,__getslice__,__getitem__,__setitem__,__contains__
迭代器： __iter__,__next__
#!/usr/bin/python # -*- coding: utf-8 -*- #copyRight by heibanke class Employee(object): def __init__(self, name, job=None, pay=0): # class = data + logic self._name = name self._job = job self._pay = pay def giveRaise(self, percent): self._pay = int(self._pay * (1 + percent)) def __str__(self): return '[Employee: %s, %s, %s]' % (self._name, self._job, self._pay) class Manager(Employee): def __init__(self, name, pay): # Redefine constructor Employee.__init__(self, name, 'mgr', pay) def giveRaise(self, percent, bonus=.10): Employee.giveRaise(self, percent + bonus) if __name__ == '__main__': a=Employee("xiaoli",'sw_engineer',10000) b=Employee("xiaowang",'hw_engineer',12000) c=Manager("xiaozhang",8000) members=[a,b,c] for member in members: member.giveRaise(0.1) print member
输出：
>>> [Employee: xiaoli, sw_engineer, 11000] [Employee: xiaowang, hw_engineer, 13200] [Employee: xiaozhang, mgr, 9600] >>> c.__class__ <class '__main__.Manager'> >>> c.__class__.__base__ <class '__main__.Employee'> >>> c.__class__.__base__.__base__ <type 'object'> >>> c.__class__.__base__.__base__.__base__ >>>
为什么会是这样呢？
我们导入inspect来查看一下D优先继承哪些类。可以看到BAC的顺序
mro:method resolution order
经典类（classic）是深度优先
新式类（new）是广度优先
由于我们定义的是经典类，所以D先继承了B，然后继承A，然后继承C。（深度优先）
经典类和新式类的区别：
经典类定义A的时候
新式类定义A的时候
当我们有多重继承的时候，会导致父类别多次调用了。
为了解决这个问题，在新式类中我们引进了super关键字(super只在新式类中有)，避免父类的多次调用。
super是一个类，不是一个函数，调用规则：
super(D,self).test()。
不使用super的情况：
#!/usr/bin/python # -*- coding: utf-8 -*- #copyRight by heibanke class A: def test(self): print "A's test" class B(A): def test(self): print "B's test" A.test(self) #super(B,self).test() class C(A): def test(self): print "C's test" A.test(self) class D(B,C): def test(self): print "D's test" B.test(self) C.test(self) if __name__=="__main__": a=D() a.test()输出：
>>> ================================ RESTART ================================ >>> D's test B's test A's test C's test A's test >>>
使用super的情况：
#!/usr/bin/python # -*- coding: utf-8 -*- #copyRight by heibanke class A(object): def test(self): print "A's test" class B(A): def test(self): print "B's test" super(B,self).test() class C(A): def test(self): print "C's test" super(C,self).test() class D(B,C): def test(self): print "D's test" super(D,self).test() if __name__=="__main__": a=D() a.test()输出：
>>> ================================ RESTART ================================ >>> D's test B's test C's test A's test >>>
把已有的类变成新的类属性。
通过已有的类生成新类。
#!/usr/bin/python # -*- coding: utf-8 -*- #copyRight by heibanke class Employee(object): def __init__(self, name, job=None, pay=0): # class = data + logic self._name = name self._job = job self._pay = pay def giveRaise(self, percent): self._pay = int(self._pay * (1 + percent)) def __str__(self): return '[Employee: %s, %s, %s]' % (self._name, self._job, self._pay) class Manager(Employee): def __init__(self, name, pay): # Redefine constructor super(Manager,self).__init__(name, 'mgr', pay) def giveRaise(self, percent, bonus=.10): super(Manager,self).giveRaise(percent + bonus) class Department(object): def __init__(self, *args): self.members = list(args) def addMember(self, person): self.members.append(person) def showAll(self): for person in self.members: print person def giveRaise(self,percent): for person in self.members: person.giveRaise(percent) if __name__ == '__main__': a=Employee("xiaoli",'sw_engineer',10000) b=Employee("xiaowang",'hw_engineer',12000) c=Manager("xiaozhang",8000) d=Department(a,b,c) d.showAll() d.giveRaise(0.1) d.showAll()
输出：
>>> [Employee: xiaoli, sw_engineer, 10000] [Employee: xiaowang, hw_engineer, 12000] [Employee: xiaozhang, mgr, 8000] [Employee: xiaoli, sw_engineer, 11000] [Employee: xiaowang, hw_engineer, 13200] [Employee: xiaozhang, mgr, 9600] >>>
多态是不同的类的相同的方法，相同的参数，不同功能。调用时便于将一组对象放在集合里，无需判断对象的具体类型，统一调用。
里氏代换原则：
父类出现的地方，子类一定可以出现，反之不一定。
重载：相同的方法的不同的参数。对应Python是args，kwargs。
最典型的是运算符重载。
——比较难，但是大部分不会用到它。
元（meta）
语法——》语句
类——》对象
元类——》类
元类就是生成类的类。通过元类来编程就是元编程。
元编程——type
type(name,bases,attrs)
name:类名字符串
bases:父类元组
attrs:属性字典
A=type(‘A’,(object,),{‘b’:1})
a=A()
print A, a.b
c++和python的类的概念是不一样的。c++的类就是语法，编译的时候类并没有生成，只是在语法上限制了一些东西。而Python是一个对象，是可以生成出来的，比如上边的A，是
通过编程序生成出来的。在Python里边可以通过元类生成类。
但是这样的方式让人看起来不舒服，于是Python提供另外一种方法：
class simplemeta(type): def __init__(cls,name,bases,nmspc): super(simplemeta,cls).__init__(name,bases,nmspc) cls.uses_metaclass=lambda self:’yes’
写法1：
A=simplemeta(‘A’,(),{})
type也是一个类，类似于object类，type类里边的东西比object多一些。
写法2：
class A(object):
__metaclass__==simplemeta
方法2中提供了__metaclass__的关键字，让我们很清楚的知道这就是一个元类。以后尽量用方法2来写。
但是通过元类生成类和通过继承父类生成类有什么区别呢？
元类和父类的区别：
1、通过元类的初始化函数，或用metaclass关键字来生成新类
2、通过继承父类来生成新类
元类主要是定义类的行为，父类主要定义的是实例的行为。
不可继承的类——最终类
class final(type): def __init__(cls,name,bases,namespace): super(final,cls).__init__(name,bases,namespace) for klass in bases: if isinstance(klass,final): raise TypeError(str(klass.__name__)+’is final’)当你想定义一个最终类的时候，加上这个元类就可以了。
为什么？
因为在finla类里边，有一些属性，因为B是final生成的，所以会在klaas里边，所以当我们运行的时候，isinstance会显示B是一个final,所以就raise TypeError(……)。
new的用途——新式类里边才会有的东西。
__new__和__init__的区别：__new__是分配空间，__init__是配置参数，执行属性是先分配空间再配置参数。
我们可以看到，第一个生成正整数没有成功，第二个成功了，为什么呢？
因为__init__都已经配置好参数了，而对于int这种不可变的类型，你在对他改变是没有用的，而__new__只是分配好空间，没有产生什么值，所以就可以改变。
单例模式中用__new__可以提前判断。
class singleton(object): def __new__(cls): if now hasattr(cls): cls.instance=super(singleton,cls).__new__(cls) return cls.instance
元类的用法
抽象函数——虚函数，在子类里实现。
class MyAbstractClass(object):
def method1(self):
raise NotImplementedError(‘please Implement this method’)
但是这样用有一个问题：如果我们没有实现里边方法，当我们不用这个方法的时候，不会报错，只有当子类使用这个方法的时候才会报错，所以我们一般用下
边的方法，导进来一个abs的类。
接口，由一组抽象函数组成的类
from abs import ABCMeta,abstractmethod
from MyAbstractClass2(object):
__metaclass__=ABCMeta
@bastractmethod
def method1(self):
pass
按照这么实现，即使子类没有调用这个方法，如果他没有实现这个方法，也会报错。
注意看注释信息，报错的时机不一样的。
元编程——ORM
ORM:Object Relational Mapping对象关系映射
将数据库的操作用面向对象的程序方法实现。
匹配由ORM来产生，我们只要生成类进行操作就行了。
好处：
1、易改：便于更新数据库，sql语句是由底层根据数据库类型生成的上层数据模型无需变化。
2、易用：便于对数据模型进行操作，创建，更新，查询，删除。用户编写简单，无需写sql语句即可操作数据。
3、易看：使数据模型的程序文档化。便于维护。
缺点：
不灵活，没有sql语句强大等。
class user(model);
id=integerField(’uid’)
name=stringField(‘username’)
email=stringField(‘email’)
password=stringField(‘password’)
u=user(id=12345,name=’Michael’,email=’test@orm.org’,password=’my_pwd)
u.save()
具体内容可参考廖雪峰老师的博客学习相关的知识。
#!/usr/bin/env python # -*- coding: utf-8 -*- # http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001386820064557c69858840b4c48d2b8411bc2ea9099ba000 ' Simple ORM using metaclass ' __author__ = 'Michael Liao' class Field(object): def __init__(self, name, column_type): self.name = name self.column_type = column_type def __str__(self): return '<%s:%s>' % (self.__class__.__name__, self.name) class StringField(Field): def __init__(self, name): super(StringField, self).__init__(name, 'varchar(100)') class IntegerField(Field): def __init__(self, name): super(IntegerField, self).__init__(name, 'bigint') class ModelMetaclass(type): def __new__(cls, name, bases, attrs): print "name is ",name print "bases is ",bases print "attrs is ",attrs if name=='Model': return type.__new__(cls, name, bases, attrs) print('Found model: %s' % name) mappings = dict() for k, v in attrs.iteritems(): if isinstance(v, Field): print('Found mapping: %s ==> %s' % (k, v)) mappings[k] = v for k in mappings.iterkeys(): attrs.pop(k) attrs['__mappings__'] = mappings # 保存属性和列的映射关系 attrs['__table__'] = name # 假设表名和类名一致 return type.__new__(cls, name, bases, attrs) class Model(dict): __metaclass__ = ModelMetaclass def __init__(self, **kw): print "Model instance __init__" super(Model, self).__init__(**kw) def save(self): fields = [] params = [] args = [] for k, v in self.__mappings__.iteritems(): fields.append(v.name) params.append('%s') args.append(self[k]) sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params)) print('SQL: %s' % sql) print('ARGS: %s' % str(args)) @classmethod def find_all(cls, *args): sql = 'select * from %s' % cls.__table__ print('SQL: %s' % sql) # testing code: class User(Model): id = IntegerField('uid') name = StringField('username') email = StringField('email') password = StringField('password') u1 = User(id=12345, name='Michael', email='test1@orm.org', password='my-pwd') u2 = User(id=22345, name='Richael', email='test2@orm.org', password='my-pwd') u3 = User(id=32345, name='Hichael', email='test3@orm.org', password='my-pwd') u1.save() u2.save() u3.save()
转载于:https://www.cnblogs.com/shixisheng/p/5926353.html
相关资源：JAVA上百实例源码以及开源项目