目錄
枚舉類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
裝飾器可以幫助我們檢查保證沒有重複值。
枚舉類成員之間不能比較打下,但可以用 == 或者 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))
<class 'type'>
>>> print(type(h))
<class '__main__.Hello'>
要創建一個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_type
def __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] = 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))
當用戶定義一個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='[email protected]', password='my-pwd')
u.save()
輸出如下:
Found model: User
Found mapping: email ==> <StringField:email>
Found mapping: password ==> <StringField:password>
Found mapping: id ==> <IntegerField:uid>
Found mapping: name ==> <StringField:username>
SQL: insert into User (password,email,username,id) values (?,?,?,?)
ARGS: ['my-pwd', '[email protected]', 'Michael', 12345]