Python学习札记(四十) 面向对象编程 Object Oriented Program 11

参考：使用元类

NOTE：

type()

1.type()函数可以用于检查一个类或者变量的类型。

#!/usr/bin/env python3

class Myclass(object):
	"""docstring for Myclass"""
	def __init__(self):
		super(Myclass, self).__init__()

	def func(self):
		pass

def main():
	h = Myclass()
	print(type(h))

if __name__ == '__main__':
	main()

sh-3.2# ./oop12.py 
<class '__main__.Myclass'>

class的定义是运行时动态创建的，而创建class的方法就是使用type()函数。

2.因此，我们可以通过type()函数在运行时动态创建一个类，这是动态语言的一个特点：

	NewClass = type('NewClass', (Myclass,), dict(func=run))
	h1 = NewClass()
	h1.func()

running

创建一个对象，需要给type()函数传入三个参数：

type(name, bases, dict) -> a new class

第一个是类名，第二个是继承的基类，第三个是绑定该类中的函数。

通过type()函数创建的类完全和用class关键字声明的类一样，因为Python解释器遇到class定义的时候，也是通过type()方法来定义一个类的。

type()方法支持动态创建一个类，也就是说，动态语言本身支持运行时动态创建类，这与静态语言有非常大的不同。

metaclass

元类本身而言，它们其实是很简单的：

1)拦截类的创建

2)修改类

3)返回修改之后的类

1.元(猿)类：是我们创建类的模板。

创建一个对象时，我们需要依据它的类进行创建；创建一个类的时候，我们需要依据它的元类来进行创建。

也就是说，可以把类看成是metaclass创建出来的“实例”。

#!/usr/bin/env python3

class Listmetaclass(type):
	"""docstring for Listmetaclass"""
	def __new__(cls, name, bases, attrs):
		attrs['add'] = lambda self, value: self.append(value)
		return type.__new__(cls, name, bases, attrs)

class NewClass(list, metaclass=Listmetaclass): # 指示解释器在创建类的时候通过元类的__new__()创建
	pass

def main():
	h = NewClass()
	h.add(1)
	print(h)

if __name__ == '__main__':
	main()

sh-3.2# ./oop13.py 
[1]

事实上，将函数add直接写在一个继承的子类中会好很多，这是一个十分难懂的点。

2.特殊情况：“Object Relational Mapping”，即对象-关系映射。

#!/usr/bin/env python3

class Field(object):
	"""docstring for Field"""
	def __init__(self, name, column_type):
		super(Field, self).__init__()
		self.name = name
		self.column_type = column_type
		
	def __str__(self):
		print('<%s:%s>' % (self.__class__.__name__, self.name))

class IntegerField(Field):
	"""docstring for IntegerField"""
	def __init__(self, name):
		super(IntegerField, self).__init__(name, 'int')
		
class StringField(Field):
	"""docstring for StringField"""
	def __init__(self, name):
		super(StringField, self).__init__(name, 'string')

class Modelmetaclass(type): # type
	"""docstring for Modelmetaclass"""
	def __new__(cls, name, bases, attrs):
		if name == 'Model':
			return type.__new__(cls, name, bases, attrs)
		print('Found name:%s' % name)
		mappings = dict() # save mappings of attributes
		for i, j in attrs.items():
			if isinstance(j, Field):
				print('mapping: %s ==> %s' % (i, j))
				mappings[i] = j # name i => 'Field'
		for i in mappings.keys():
			attrs.pop(i) # delete attrs that have been transfer to 'Field'
		attrs['__mappings__'] = mappings 
		attrs['__table__'] = name 
		return type.__new__(cls, name, bases, attrs)

class Model(dict, metaclass=Modelmetaclass):
	"""docstring for Model"""
	# reuse the old definitions of functions
	def __init__(self, **kw):
		super(Model, self).__init__(**kw)
		
	def __getattr__(self, key):
		try:
			return self[key]
		except KeyError:
			raise AttributeError(r"'Model' object has no attribute '%s'" % key)

	def __setattr__(self, key, value):
		self[key] = value

	def save(self):
		fields = []
		params = []
		args = []
		for k, v in self.__mappings__.items():
			fields.append(v.name)
			params.append('?')
			args.append(getattr(self, k, None))
		sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params))
		print('SQL: %s' % sql)
		print('ARGS: %s' % str(args))

# User provide the interfaces
class User(Model):
	id = IntegerField('id')
	name = StringField('username')
	email = StringField('email')
	password = StringField('password')

def main():
	# Create an object
	u = User(id=9, name='Wasdns', email='952693358@qq.com', password='1234567')
	# Save the object in the Database
	u.save()

if __name__ == '__main__':
	main()

具体解释请参考原文“美3333333”的回答。

2017.3.10