【一】前言引入
-
千万不要被所谓“元类是99%的python程序员不会用到的特性”这类的说辞吓住。
- 因为每个中国人,都是天生的元类使用者
-
我们引用太极的思想
- 道生一,一生二,二生三,三生万物
- 即我是谁?我从哪里来?我到哪里去?
-
我们拿到Python中
-
type就相当于我们的道,由 type 产生了其他一系列的产物
【二】道生一,一生二,二生三,三生万物
- 道
- 相当于我们的 type
- 一
- 相当于我们学到的
metaclass
- 元类 --- 也叫类生成器
- 相当于我们学到的
- 二
- 相当于
class
类- 类 --- 实例生成器
- 相当于
- 三
- 相当于
instance
- 实例
- 相当于
- 万物
- 相当于各种属性和方法
- 我们日常调用的方法和属性
- 相当于各种属性和方法
【二】道和一
- 我们已经学会了实例化类和调用类的属性和方法
- 因此我们现在研究的是道(也就是
type
) - 一(元类也就是
metaclass
)
【1】精简版二生三、三生万物
-
由上面我们将这些思想用我们的代码演示一下
-
首先我们定义一个类
# 这个类就相当于我们的 **二(类的实例容器)**
class Person():
- 这个类就相当于我们的 二(类的实例容器)
- 我们再向这个类里面添加一些属性
# 这个类就相当于我们的 **二(类的实例容器)**
class Person():
# 这些属性就相当于我们的**万物**
def say_hello(self, name='world'):
print('Hello, %s.' % name)
- 这些属性就相当于我们的万物
- 接下来我们再实例一个对象出来
# 这个类就相当于我们的 **二(类的实例容器)**
class Person():
# 这些属性就相当于我们的**万物**
def say_hello(self, name='world'):
print('Hello, %s.' % name)
# 这个对象就相当于我们的 **三 (实例)**
person = Person()
- 这个对象就相当于我们的 三 (实例)
- 我们再调用其中的类方法或类属性
# 这个类就相当于我们的 **二(类的实例容器)**
class Person():
# 这些属性就相当于我们的**万物**
def say_hello(self, name='world'):
print('Hello, %s.' % name)
# 这个对象就相当于我们的 **三 (实例)**
person = Person()
# 这就相当于我们的利用万物
person.say_hello()
- 完整的如下
# 创建一个Person类,拥有属性say_hello ----二的起源
class Person():
# 万物的容器内的方法和属性
def say_hello(self, name='world'):
print('Hello, %s.' % name)
# 从Person类创建一个实例person ----二生三
person = Person()
# 使用person调用方法say_hello() ----三生万物
person.say_hello()
-
由以上一步步,我们演示了二生三,三生万物的大致过程
-
从构建一个类,再到实例化一个对象,再到调用类中的属性或方法
-
那我们会发出疑问:
- 类从何来?
- 既然都有二生三,三生万物了,那这个二从何来?
- 一生二又是怎么来的?
-
于是我们开始研究一生二的过程
-
class Hello()
这句话只是将一生二的部分缩减到了简简单单的一步,只是为了我们日常使用过程中更方便一些 -
那完整版的又是长什么样呢?
【三】完整版一生二,二生三,三生万物
- 我们假定我们已经定义好了一个方法
# 假如我们有一个函数叫run
def run(self, name='world'):
print('Hello, %s.' % name)
-
也就是我们已经是万物的一部分了
-
接下来我们要探究如何一生二,二生三,三生出来他
-
于是我们就用到了 一个 我们最开始说到的 道(type)
- 由这个 道(起源) 负责将这个给我造出来
-
于是就有了
# 假如我们有一个函数叫run
def run(self, name='world'):
print('Hello, %s.' % name)
# 通过type创建Hello class ---- 神秘的“道”,可以点化一切
# 这次我们直接从“道”生出了“二”
Person = type('Person', (object,), dict(say_hello=run))
- 我们运行结果如下
# 假如我们有一个函数叫run
def run(self, name='world'):
print('Hello, %s.' % name)
# 通过type创建Hello class ---- 神秘的“道”,可以点化一切
# 这次我们直接从“道”生出了“二”
Person = type('Person', (object,), dict(say_hello=run))
# 从Person类创建一个实例person ----二生三,完全一样
person = Person()
# 使用person调用方法say_hello ----三生万物,完全一样
person.say_hello()
# Hello, world.
-
我们可以发现,运行效果和我们上面的用class造万物是一样的效果
-
我么可以发现其实,最重要的就是这一句
Person = type('Person', (object,), dict(say_hello=run))
- 这句话给我们的感觉就是我们直接 就是 道生出了二 而没有一的参与
【四】道的分析
-
Person = type('Person', (object,), dict(say_hello=run))
-
在上面我们已经发现了这句话和我们的class 关键字具有一样的效果,那我们就来分析一下这句话,里面的三个参数 指的 都是什么含义?
-
这三个参数 和 我们上面所说的 我是谁?我从哪里来?我到哪里去? 契合到了一起
第一个参数:
我是谁。
在这里,我需要一个区分于其它一切的命名,以上的实例将我命名为“Person”
第二个参数:
我从哪里来
在这里,我需要知道从哪里来,也就是我的“父类”,以上实例中我的父类是“object”——python中一种非常初级的类。
第三个参数:
我要到哪里去
在这里,我们将需要调用的方法和属性包含到一个字典里,再作为参数传入。以上实例中,我们有一个say_hello方法包装进了字典中。
- 值得注意的是,三大永恒命题,是一切类,一切实例,甚至一切实例属性与方法都具有的。
- 理所应当,它们的“创造者”,道和一,即type和元类,也具有这三个参数。
- 但平常,类的三大永恒命题并不作为参数传入,而是以如下方式传入
class Hello(object){
# class 后声明“我是谁”
# 小括号内声明“我来自哪里”
# 中括号内声明“我要到哪里去”
def say_hello(){
}
}
- 造物主,可以直接创造单个的人,但这是一件苦役。
- 造物主会先创造“人”这一物种,再批量创造具体的个人。
- 并将三大永恒命题,一直传递下去。
“道”可以直接生出“二”,但它会先生出“一”,再批量地制造“二”。
type可以直接生成类(class),但也可以先生成元类(metaclass),再使用元类批量定制类(class)。
【五】元类 ----> 道生一,一生二
【1】Metalass
原理
- 一般来说,元类均被命名后缀为
Metalass
- 想象一下,我们需要一个可以自动打招呼的元类,它里面的类方法呢,有时需要
say_Hello
,有时需要say_Hi
,有时又需要say_Sayolala
,有时需要say_Nihao
。
- 想象一下,我们需要一个可以自动打招呼的元类,它里面的类方法呢,有时需要
- 如果每个内置的say_xxx都需要在类里面声明一次,那将是多么可怕的苦役!
- 不如使用元类来解决问题。
- 以下是创建一个专门“打招呼”用的元类代码:
class SayMetaClass(type):
def __new__(cls, name, bases, attrs):
attrs['say_' + name] = lambda self, value, saying=name: print(saying + ',' + value + '!')
return type.__new__(cls, name, bases, attrs)
-
记住两点:
-
1、元类是由“type”衍生而出,所以父类需要传入type。
- 【道生一,所以一必须包含道】
-
2、元类的操作都在
__new__
中完成,它的第一个参数是将创建的类,之后的参数即是三大永恒命题:-
我是谁,我从哪里来,我将到哪里去。
-
它返回的对象也是三大永恒命题,
接下来,这三个参数将一直陪伴我们。
-
-
-
在__new__中,我只进行了一个操作,就是
attrs['say_'+name] = lambda self,value,saying=name: print(saying+','+value+'!')
-
它跟据类的名字,创建了一个类方法。
- 比如我们由元类创建的类叫“Person”,那创建时就自动有了一个叫“say_Hello”的类方法,然后又将类的名字“Person”作为默认参数saying,传到了方法里面。
- 然后把hello方法调用时的传参作为value传进去,最终打印出来。
-
那么,一个元类是怎么从创建到调用的呢?
- 来!一起根据道生一、一生二、二生三、三生万物的准则,走进元类的生命周期吧!
# 道生一:传入type
class SayMetaClass(type):
# 传入三大永恒命题:类名称、父类、属性
def __new__(cls, name, bases, attrs):
# print(cls) # <class '__main__.SayMetaClass'>
# print(name) # Hello
# print(bases) # (<class 'object'>,)
# print(attrs) # {'__module__': '__main__', '__qualname__': 'Hello'}
# 创造“天赋”
attrs['say_' + name] = lambda self, value, saying=name: print(saying + ',' + value + '!')
# print(attrs) # {'__module__': '__main__', '__qualname__': 'Hello', 'say_Hello': <function SayMetaClass.__new__.<locals>.<lambda> at 0x000002490A581B40>}
# 传承三大永恒命题:类名称、父类、属性
return type.__new__(cls, name, bases, attrs)
# 一生二:创建类
class Hello(object, metaclass=SayMetaClass):
pass
# 二生三:创建实列
person = Hello()
# 三生万物:调用实例方法
person.say_Hello('world!')
# 道生一:传入type
# 构建一个类(传承于始祖),这个类具有部分始祖的功能
# 利用希腊的例子 上帝(type) ----> 造了亚当(SayMetaClass) ----> 造了其他的人类
class SayMetaClass(type):
# 传入三大永恒命题:类名称、父类、属性
# 这里实例化了 这个类的三个属性 这个类的名称、传入的这个类的父类、这个类的名称空间
def __new__(cls, name, bases, attrs):
# 创造“天赋”
# 向传入的这个类的名称空间里面塞 属性和方法
attrs['say_' + name] = lambda self, value, saying=name: print(saying + ',' + value + '!')
# 传承三大永恒命题:类名称、父类、属性
# 基于以上的三个组成部分,调用始祖(造物主)的 方法 造出来一个类
# 亚当可以自己造人,但是他不干活,他就让上帝来干活
return type.__new__(cls, name, bases, attrs)
# 一生二:创建类
# 上帝造完了这个人了,交给亚当来保管,因为是亚当负责 捏的人 ,所以应该具有亚当捏的特征
class Hello(object, metaclass=SayMetaClass):
pass
# 二生三:创建实列
# 亚当和上帝造出来的那个人
person = Hello()
# 三生万物:调用实例方法
# 那个人学会的技能和特有的特征
# ----> 这个人牛逼了,自学了某个东西。激活了血统
person.say_Hello('world!')
注意:通过元类创建的类,第一个参数是父类,第二个参数是metaclass
- 普通人出生都不会说话,但有的人出生就会打招呼说“Hello”,“你好”,“sayolala”,这就是天赋的力量。
- 它会给我们面向对象的编程省下无数的麻烦。
- 现在,保持元类不变,我们还可以继续创建
Sayolala
,Nihao
类,如下:
# 道生一:传入type
# 构建一个类(传承于始祖),这个类具有部分始祖的功能
# 利用希腊的例子 上帝(type) ----> 造了亚当(SayMetaClass) ----> 造了其他的人类
class SayMetaClass(type):
# 传入三大永恒命题:类名称、父类、属性
# 这里实例化了 这个类的三个属性 这个类的名称、传入的这个类的父类、这个类的名称空间
def __new__(cls, name, bases, attrs):
# 创造“天赋”
# 向传入的这个类的名称空间里面塞 属性和方法
attrs['say_' + name] = lambda self, value, saying=name: print(saying + ',' + value + '!')
# 传承三大永恒命题:类名称、父类、属性
# 基于以上的三个组成部分,调用始祖(造物主)的 方法 造出来一个类
# 亚当可以自己造人,但是他不干活,他就让上帝来干活
return type.__new__(cls, name, bases, attrs)
#######################################开始造第一个人了#######################################
# 一生二:创建类
# 上帝造完了这个人了,交给亚当来保管,因为是亚当负责 捏的人 ,所以应该具有亚当捏的特征
class Hello(object, metaclass=SayMetaClass):
pass
# 二生三:创建实列
# 亚当和上帝造出来的那个人
hello = Hello()
# 三生万物:调用实例方法
# 那个人学会的技能和特有的特征
# ----> 这个人牛逼了,自学了某个东西。激活了血统
hello.say_Hello('world!')
# Hello,world!!
#######################################开始造第二个人了#######################################
# 一生二:创建类
# 亚当又闲得蛋疼捏出来一个人
class Sayolala(object, metaclass=SayMetaClass):
pass
# 二生三:创建实列
# 这个人出生了
s = Sayolala()
# 三生万物:调用实例方法
# 这个人又学会了新东西
s.say_Sayolala('japan!')
# Sayolala,japan!!
#######################################开始造第三个人了#######################################
# 一生二:创建类
class Nihao(object, metaclass=SayMetaClass):
pass
# 二生三:创建实列
n = Nihao()
# 三生万物:调用实例方法
n.say_Nihao('中华!')
# Nihao, 中华!
【2】 list
方法
-
普通的 list方法是没有
add
的功能的 -
普通的list方法
L2 = list() L2.add(1) # AttributeError: 'list' object has no attribute 'add'
-
而我们用上面的方法造了一个新的list方法,不让他按照原来的走
# 道生一 class ListMetaclass(type): def __new__(cls, name, bases, attrs): # 天赋:通过add方法将值绑定 attrs['add'] = lambda self, value: self.append(value) return type.__new__(cls, name, bases, attrs) # 一生二 class MyList(list, metaclass=ListMetaclass): pass # 二生三 L = MyList() # 三生万物 L.add(1) print(L) # [1]
【六】总结
【1】年轻的造物主,请随我一起开创新世界。
- 我们选择两个领域,一个是Django的核心思想,“Object Relational Mapping”
- 即对象-关系映射,简称ORM。
- 这是Django的一大难点,但学完了元类,一切变得清晰。
- 你对Django的理解将更上一层楼!
- 另一个领域是爬虫领域(黑客领域)
- 一个自动搜索网络上的可用代理,然后换着IP去突破别的人反爬虫限制。
【2】挑战一:通过元类创建ORM
(1)准备工作,创建一个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类实例化时将得到两个参数,name和column_type,
-
它们将被绑定为Field的私有属性
-
如果要将Field转化为字符串时,将返回“Field:XXX”
-
XXX是传入的name名称。
-
(2)准备工作:创建StringField和IntergerField
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')
- 它的作用是
- 在StringField,IntegerField实例初始化时,
- 自动调用父类的初始化方式。
【3】道生一
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):
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)
-
它做了以下几件事
-
创建一个新的字典
mapping
-
将每一个类的属性,通过
.items()
遍历其键值对。如果值是Field
类,则打印键值,并将这一对键值绑定到mapping
字典上。 -
将刚刚传入值为
Field
类的属性删除。 -
创建一个专门的
__mappings__
属性,保存字典mapping
。 -
创建一个专门的
__table__
属性,保存传入的类的名称。
-
【4】一生二
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):
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)
class Model(dict, metaclass=ModelMetaclass):
def __init__(self, **kwarg):
super(Model, self).__init__(**kwarg)
def __getattr__(self, key):
try:
return self[key]
except KeyError:
raise AttributeError("'Model' object has no attribute '%s'" % key)
def __setattr__(self, key, value):
self[key] = value
# 模拟建表操作
def save(self):
fields = []
args = []
for k, v in self.__mappings__.items():
fields.append(v.name)
args.append(getattr(self, k, None))
sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join([str(i) for i in args]))
print('SQL: %s' % sql)
print('ARGS: %s' % str(args))
- 如果从Model创建一个子类User:
class User(Model):
# 定义类的属性到列的映射:
id = IntegerField('id')
name = StringField('username')
email = StringField('email')
password = StringField('password')
-
这时
id= IntegerField('id')
就会自动解析为: -
Model.__setattr__(self, 'id', IntegerField('id'))
-
因为
IntergerField('id')
是Field的子类的实例- 自动触发元类的
__new__
- 所以将
IntergerField('id')
存入__mappings__
并删除这个键值对。
- 自动触发元类的
【4】二生三、三生万物
- 当你初始化一个实例的时候并调用save()方法时候
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):
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)
class Model(dict, metaclass=ModelMetaclass):
def __init__(self, **kwarg):
super(Model, self).__init__(**kwarg)
def __getattr__(self, key):
try:
return self[key]
except KeyError:
raise AttributeError("'Model' object has no attribute '%s'" % key)
def __setattr__(self, key, value):
self[key] = value
# 模拟建表操作
def save(self):
fields = []
args = []
for k, v in self.__mappings__.items():
fields.append(v.name)
args.append(getattr(self, k, None))
sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join([str(i) for i in args]))
print('SQL: %s' % sql)
print('ARGS: %s' % str(args))
class User(Model):
# 定义类的属性到列的映射:
id = IntegerField('id')
name = StringField('username')
email = StringField('email')
password = StringField('password')
u = User(id=12345, name='Batman', email='batman@nasa.org', password='iamback')
u.save()
-
这时先完成了二生三的过程:
-
先调用
Model.__setattr
__,将键值载入私有对象 -
然后调用元类的“天赋”,
ModelMetaclass.__new__
,将Model中的私有对象,只要是Field的实例,都自动存入u.__mappings
__。
-
-
接下来完成了三生万物的过程:
- 通过
u.save()
模拟数据库存入操作。 - 这里我们仅仅做了一下遍历
__mappings__
操作,虚拟了sql
并打印,在现实情况下是通过输入sql
语句与数据库来运行。
- 通过
-
输出结果为
Found model: User
Found mapping: name ==> <StringField:username>
Found mapping: password ==> <StringField:password>
Found mapping: id ==> <IntegerField:id>
Found mapping: email ==> <StringField:email>
SQL: insert into User (username,password,id,email) values (Batman,iamback,12345,batman@nasa.org)
ARGS: ['Batman', 'iamback', 12345, 'batman@nasa.org']