python——使用枚举类enum/type动态创造类/元类metaclass python

目录

枚举类enum
type()动态创造类
元类metaclass
枚举类enum
当我们需要定义常量时，一个办法是用大写变量通过整数来定义，例如月份：

JAN = 1 FEB = 2 MAR = 3 ... NOV = 11 DEC = 12

好处是简单，缺点是类型是int，并且仍然是变量。
更好的方法是为这样的枚举类型定义一个class类型，然后，每个常量都是class的一个唯一实例。Python提供了Enum类来实现这个功能：

from enum import Enum Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

for name, member in Month.__members__.items(): print(name, '=>', member, ',', member.value)

value属性则是自动赋给成员的int常量，默认从1开始计数。
如果需要更精确地控制枚举类型，可以从Enum派生出自定义类：

from enum import Enum, unique @unique class Weekday(Enum): Sun = 0 # Sun的value被设定为0 Mon = 1 Tue = 2 Wed = 3 Thu = 4 Fri = 5 Sat = 6 #调用枚举成员的 3 种方式 >>>print(print(Weekday.Tue)) Weekday.Tue >>>print(Weekday['Tue']) Weekday.Tue >>>print(Weekday(1)) Weekday.Mon#调取枚举成员中的 value 和 name >>>print(Weekday.Mon.value) 1 >>>print(Weekday.Mon.name) Mon#遍历枚举类中所有成员的2种方式 >>> for name, member in Weekday.__members__.items(): ...print(name, '=>', member) ... Sun => Weekday.Sun Mon => Weekday.Mon Tue => Weekday.Tue Wed => Weekday.Wed Thu => Weekday.Thu Fri => Weekday.Fri Sat => Weekday.Sat>>>for weekday in Weekday: ...print(weekday) Weekday.Sun Weekday.Mon Weekday.Tue Weekday.Wed Weekday.Thu Weekday.Fri Weekday.Sat

@unique装饰器可以帮助我们检查保证没有重复值。
【python——使用枚举类enum/type动态创造类/元类metaclass】枚举类成员之间不能比较打下，但可以用 == 或者 is 进行比较是否相等
type()动态创造类
type()函数既可以返回一个对象的类型，又可以创建出新的类型，比如，我们可以通过type()函数创建出Hello类，而无需通过class Hello(object)...的定义：

>>> def fn(self, name='world'): # 先定义函数 ...print('Hello, %s.' % name) ... >>> Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class >>> h = Hello() >>> h.hello() Hello, world. >>> print(type(Hello)) >>> print(type(h))

要创建一个class对象，type()函数依次传入3个参数：

class的名称；
继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法；
class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上。

元类metaclass
一般我们先先定义类，然后创建实例。但是我们可以根据metaclass创建出类，所以：先定义metaclass，就可以创建类，最后创建实例。metaclass允许你创建类或者修改类。换句话说，你可以把类看成是metaclass创建出来的“实例”。
eg,metaclass可以给我们自定义的MyList增加一个add方法：
1.定义ListMetaclass，按照默认习惯，metaclass的类名总是以Metaclass结尾，以便清楚地表示这是一个metaclass：

# metaclass是类的模板，所以必须从`type`类型派生： class ListMetaclass(type): def __new__(cls, name, bases, attrs): attrs['add'] = lambda self, value: self.append(value) return type.__new__(cls, name, bases, attrs)

2.我们在定义类的时候还要指示使用ListMetaclass来定制类，传入关键字参数metaclass：

class MyList(list, metaclass=ListMetaclass): pass

当我们传入关键字参数metaclass时，魔术就生效了，它指示Python解释器在创建MyList时，要通过ListMetaclass.__new__()来创建，在此，我们可以修改类的定义，比如，加上新的方法，然后，返回修改后的定义。
__new__()方法接收到的参数依次是：

当前准备创建的类的对象；
类的名字；
类继承的父类集合；
类的方法集合。

测试一下MyList是否可以调用add()方法：

>>> L = MyList() >>> L.add(1) >>> L [1]

元类的主要用途是创建API, ORM就是一个典型的例子。ORM全称“Object Relational Mapping”，即对象-关系映射，就是把关系数据库的一行映射为一个对象，也就是一个类对应一个表，这样，写代码更简单，不用直接操作SQL语句。要编写一个ORM框架，所有的类都只能动态定义，因为只有使用者才能根据表的结构定义出对应的类来。

首先来定义Field类，它负责保存数据库表的字段名和字段类型：

class Field(object):def __init__(self, name, column_type): self.name = name self.column_type = column_typedef __str__(self): return '<%s:%s>' % (self.__class__.__name__, self.name)

在Field的基础上，进一步定义各种类型的Field，比如StringField，IntegerField等等：

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')

下一步，就是编写最复杂的ModelMetaclass了：

class ModelMetaclass(type):def __new__(cls, name, bases, attrs): if name=='Model': return type.__new__(cls, name, bases, attrs) print('Found model: %s' % name) mappings = dict() for k, v in attrs.items(): if isinstance(v, Field): print('Found mapping: %s ==> %s' % (k, v)) mappings[k] = v for k in mappings.keys(): attrs.pop(k) attrs['__mappings__'] = mappings # 保存属性和列的映射关系 attrs['__table__'] = name # 假设表名和类名一致 return type.__new__(cls, name, bases, attrs)

以及基类Model：

class Model(dict, metaclass=ModelMetaclass):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] = valuedef 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))

当用户定义一个class User(Model)时，Python解释器首先在当前类User的定义中查找metaclass，如果没有找到，就继续在父类Model中查找metaclass，找到了，就使用Model中定义的metaclass的ModelMetaclass来创建User类，也就是说，metaclass可以隐式地继承到子类，但子类自己却感觉不到。
在ModelMetaclass中，一共做了几件事情：

排除掉对Model类的修改；
在当前类（比如User）中查找定义的类的所有属性，如果找到一个Field属性，就把它保存到一个__mappings__的dict中，同时从类属性中删除该Field属性，否则，容易造成运行时错误（实例的属性会遮盖类的同名属性）；
把表名保存到__table__中，这里简化为表名默认为类名。

在Model类中，就可以定义各种操作数据库的方法，比如save()，delete()，find()，update等等。
我们实现了save()方法，把一个实例保存到数据库中。因为有表名，属性到字段的映射和属性值的集合，就可以构造出INSERT语句。
编写代码试试：

u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd') u.save()

输出如下：

Found model: User Found mapping: email ==> Found mapping: password ==> Found mapping: id ==> Found mapping: name ==> SQL: insert into User (password,email,username,id) values (?,?,?,?) ARGS: ['my-pwd', 'test@orm.org', 'Michael', 12345]