原文地址:http://www.cnblogs.com/tkqasn/p/6524879.html
一:类也是对象
类就是一组用来描述如何生成一个对象的代码。
类也是一个对象,只要你使用关键字class,python解释器在执行的时候就会创建一个对象。
下面这段代码:
class ObjectCreator(object): pass
会在内存中创建一个对象,名字就是ObjectCreator,这个对象(类)自身拥有创建对象(类实例)的能力。
类的本质是一个对象,你可以拷贝它,可以将它赋给一个变量,将它作为参数传递给函数,可以为它增加属性。
以下为实例:
class ObjectCreator(object): pass print(ObjectCreator) #打印一个类 def echo(data): print(data) echo(ObjectCreator) #将类作为参数传递给函数 ObjectCreator.newAttribute = 'new attr' #为类添加新属性 print(hasattr(ObjectCreator,'newAttribute')) print(ObjectCreator.newAttribute) ObjectCreatorCopy = ObjectCreator #将类复制给一个变量 print(ObjectCreatorCopy) print(ObjectCreatorCopy()) ''' 输出: <class '__main__.ObjectCreator'> <class '__main__.ObjectCreator'> True new attr <class '__main__.ObjectCreator'> <__main__.ObjectCreator object at 0x0000000001EA9860> '''
二:动态的创建类
1 通过return class 动态的构建需要的类
类也是对象,所以我们再运行的时候动态的创建它们。在函数体中创建类:
def create_class(name): if name == 'foo': class Foo(object): pass return Foo else: class Berry(object): pass return Berry my_class = create_class('foo') print(my_class)#返回类 print(my_class())#返回类的实例 '''输出: <class '__main__.create_class.<locals>.Foo'> <__main__.create_class.<locals>
2 通过type函数构造类
上述方法需要你自己编写整个类的代码。由于类也是对象,所以也必须是通过什么东西来生成才对。
内置函数type可以让知道一个对象的类型是什么,like:
class Demo(object): pass print(type(100)) print(type('str')) print(type(Demo)) print(type(Demo())) ''' 输出: <class 'int'> <class 'str'> <class 'type'> <class '__main__.Demo'> '''
另外,type还可以动态的创建类。type可以接收一个类的描述作为参数,然后返回一个类。
type的语法:
type(类名,父类的元组(针对继承的情况,可以为空), 包含属性的字典(名称和值))
比如下面的代码:
class MyclassDemo(object): pass #可以手动通过type创建 MyclassDemo = type('MyclassDemo',(),{}) #返回一个类对象 print(MyclassDemo) print(MyclassDemo()) ''' 输出: <class '__main__.MyclassDemo'> <__main__.MyclassDemo object at 0x000000000213A3C8> '''
下面通过一个例子看看type是如何创建类的:
#1 构建Foo类 class Foo(object): bar = True # 使用type构建Foo Foo = type('Foo', (), {'bar': True}) print(Foo) # 2继承Foo类 class FooChild(Foo): pass # 使用type构建FooChild FooChild = type('Foochild',(Foo,), {}) print(FooChild) print(FooChild.bar) # 3为FooChild类增加方法 def echo_bar(self): print(self.bar) FooChild = type('FooChild',(Foo,),{'echo_bar': echo_bar}) print(hasattr(Foo,'echo_bar')) print(hasattr(FooChild, 'echo_bar')) my_foo = FooChild() my_foo.echo_bar() ''' 输出: <class '__main__.Foo'> <class '__main__.Foochild'> True False True True '''
可以看到,在python中,类也是对象,你可以动态的创建类。这就是当我们使用关键字class时python在幕后做的事,而这就是通过元类来实现的。
三:元类
1 什么是元类?
python中类也是对象,元类就是用来创建这些类(对象)的,元类是类的类,你可以这样理解:
MyClass = MetaClass() #元类创建类 MyObject = MyClass() #类创建对象 #MyClass通过type()来创建出MyClass类,它就是type()类的一个实例
函数type实际上是一个元类,type就是python在背后创建所有类的元类。现在想知道type为什么会全部采用小写形式而不是Type呢?好吧,我猜这是为了和str保持一致性,str是用来创建字符串对象的类,int是用来创建整数对象的类。type就是创建类对象的类。
你可以通过检查__class__属性来看到这一点。python中所有的东西 都是对象。这包括整数,字符串,函数以及类。它们全都是对象,而且是从一个类创建而来。
age = 33 print(age.__class__) name = 'alice' print(name.__class__) def foo(): pass print(foo.__class__) class Bar(object): pass b = Bar() print(b.__class__) # 那么任何一个__class__的__class__属性又是什么呢?? print(age.__class__.__class__) print(foo.__class__.__class__) print(b.__class__.__class__) ''' 输出: <class 'int'> <class 'str'> <class 'function'> <class '__main__.Bar'> <class 'type'> <class 'type'> <class 'type'> '''
因此,元类就是创建类这种对象的东西,type就是python的内建元类,当然了,你也可以创建自己的元类。
2 __metaclass__属性
你可以在写一个类的时候为其添加__metaclass__属性,定义了__metaclass__就定义了这个类的元类。
class Foo(object): #py2 __metaclass__ = something class Foo(metaclass=something): #py3 __metaclass__ = something
例如:当我们在编写如下代码时:
class Foo(Bar): pass
在该类定义的时候,它在内存中还没有生成,直到它被调用,python做了如下的操作:
1) Foo中有__metaclass__这个属性吗?如果有,python会在内存中通过__metaclass__创建一个名字为Foo的类对象。
2) 如果没有__metaclass__这个属性,它会继续在父类中寻找__metaclass__属性,并尝试做和前面同样的操作。
3)如果python在任何父类中都找不到__metaclass__,它就会在模块层次中去寻找__metaclass__,并尝试做同样的事情
4)如果还是找不到__metaclass__,python就会用内置的type来创建这个类对象。
现在的问题就是,你可以在__metaclass__中放置些什么代码呢?
答案就是:可以创建一个类的东西。那么什么可以用来创建一个类呢?type,或者任何使用到type或者子类化type的东西都可以。
三 自定义元类
元类的主要目的就是为了在创建类时能够自动的改变类。通常,你会为API做这样的事,你希望可以通过创建符合当前上下文的类。
假想一个很傻的例子,你决定在你的模块里所有类的属性都应该是大写形式。有好几种方法可以办到,但其中一种就是通过设定__metaclass__。采用这种方法,这个模块里所有类都会通过这个元类来创建,我们只需要告诉元类把所有的属性都改成大写形式就万事大吉了。
__metaclass__实际上可以被任意调用,它并不需要是一个正式的类。所以,我们这里就先以一个简单的函数作为例子开始。
1 使用函数当做元类
#元类会自动将你通常传给type的参数作为自己的参数传入 def upper_attr(future_class_name,future_class_parents,future_class_attr): '''返回一个类对象,将属性都转为大写形式''' attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__')) uppercase_attr = dict((name.upper(),value) for name,value in attrs) return type(future_class_name,future_class_parents,uppercase_attr) class Foo(metaclass=upper_attr): __metaclass__ = upper_attr bar = 'bip' print(hasattr(Foo,'bar')) print(hasattr(Foo,'BAR')) print(Foo.BAR) ''' 输出: False True bip '''
2 使用class来当做元类
__metaclass__必须返回一个类
''' 请记住,type实际上是一个类,就像str和int一样,所以,你可以从type继承 __new__ 是在__init__之前被调用的特殊方法。 __new__是用来创建对象并返回之的方法,__new__()是一个类方法 而__init__只是用来将传入的参数初始化给对象,它是在类创建之后执行的方法。 你很少用到__new__,除非你希望能够控制对象的创建。这里创建的对象是类,我们希望能够自定义它,所以我们这里改写__new__ 如果你希望的话,你也可以在__init__中做些事情。还有一些高级的用法会涉及到改写__call__特殊方法。但是我们这里不用,下面我们可以单独讨论这个使用 ''' class UpperAttrMetaClass(type): def __new__(uppersttr_metaclass, future_class_name, future_class_parents, future_class_attr): attrs = ((name,value) for name,value in future_class_attr.items()if not name.startswith('__')) uppercase_attr = dict((name.upper(),value) for name, value in attrs) return type(future_class_name,future_class_parents,uppercase_attr)
但是,这种方式其实不是OOP。我们直接调用了type,而且我们没有改写父类的__new__方法。现在让我们这样去处理:
class UpperAttrMetaclass(type): def __new__(upperattr_metaclass, future_class_name, future_class_parents, future_class_attr): attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__')) uppercase_attr = dict((name.upper(), value) for name, value in attrs) # 复用type.__new__方法 # 这就是基本的OOP编程,没什么魔法。由于type是元类也就是类,因此它本身也是通过__new__方法生成其实例,只不过这个实例是一个类. return type.__new__(upperattr_metaclass,future_class_name,future_class_parents,uppercase_attr)
你可能已经注意到了有个额外的参数upperattr_metaclass,这并没有什么特别的。类方法的第一个参数总是表示当前的实例,就像在普通的类方法中的self参数一样。当然了,为了清晰起见,这里的名字我起的比较长。但是就像self一样,所有的参数都有它们的传统名称。因此,在真实的产品代码中一个元类应该是像这样的:
class UpperAttrMetaClass(type): def __new__(cls, name,bases,dct): attrs = ((name,value) for name,value in dct.items() if not name.startswith('__')) uppercase_attr = dict((name.upper(),value)for name, value in attrs) return type.__new__(cls,name,bases,uppercase_attr)
如果使用super方法的话,我们还可以使它变得更清晰一些。
class UpperAttrMetaClass(type): def __new__(cls, name,bases,dct): attrs = ((name,value) for name,value in dct.items() if not name.startswith('__')) uppercase_attr = dict((name.upper(),value)for name, value in attrs) return super(UpperAttrMetaClass,cls).__new__(cls,name,bases,uppercase_attr)
四:使用原来创建ORM的实例
我们通过创建一个类似Django中的ORM来熟悉一下元类的使用,通常元类用来创建API是非常好得选择,使用元类编写很复杂,但是使用者可以非常简洁的调用API
class User(Model): #定义类的属性到列的映射: id = IntegerField('id') name = StringField('name') email = StringField('email') password = StringField('password')
例如:
#创建一个实例: u = User(id=12345, name='Alice', email='test@orm.org', password='my-pwd') #保存到数据库 u.save()
接下来我们来实现这么个功能:
#coding:utf-8 # 一:首先来定义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) 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') # 二 定义元类,控制Model对象的创建 class ModelMetaClass(type): #定义元类 def __new__(cls, name, bases, attrs): if name == 'Model': return super(ModelMetaClass, cls).__new__(cls,name,bases,attrs) mappings = dict() for k,v in attrs.items(): if isinstance(v,Field): #保存类属性和列的映射关系到mappings字典 print('found mappings:%s==>%s' %(k, v)) mappings[k] = v '''# 保存类属性和列的映射关系到mappings字典 print('found mappings:%s==>%s' % (k, v)) mappings[k] = v''' for k in mappings.keys(): #将类属性移除,使定义的类字段不污染User类属性,只在实例中可以访问这些key attrs.pop(k) attrs['__table__'] = name.lower()#假设表名和类名的小写一样,创建类时添加一个__table__类属性 attrs['__mappings__'] = mappings #保存属性和列的映射关系,创建类时添加一个__mappings__属性 return super(ModelMetaClass, cls).__new__(cls,name,bases,attrs) # 三 编写Model类 class Model(dict,metaclass=ModelMetaClass): __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('SRGS: %s' % str(args)) # 最后,我们使用定义好的ORM接口,使用起来非常的简单。 class User(Model): # 定义类的属性到列的映射: id = IntegerField('id') name = StringField('username') email = StringField('email') password = StringField('password') # 创建一个实例: u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd') # 保存到数据库: u.save() ''' 输出: found mappings:id==><IntegerField:id> found mappings:name==><StringField:username> found mappings:email==><StringField:email> found mappings:password==><StringField:password> SQL: insert into user (id,username,email,password) values (?,?,?,?) SRGS: [12345, 'Michael', 'test@orm.org', 'my-pwd'] '''
五:使用__new__ 方法和元类方式分别实现单例模式
1、__new__、__init__、__call__的介绍
__new__方法负责创建一个实例对象,在对象被创建的时候调用该方法它是一个类方法。__new__方法返回一个实例之后,会自动的调用__init__方法,对实例进行初始化。如果__new__方法不返回值,或者返回的不是实例,那么它就不会自动的去调用__init__方法。
__init__方法负责将该实例对象进行初始化,在对象被创建之后调用该方法,在__new__方法创建出一个实例之后对实例属性进行初始化。__init__方法可以没有返回值。
__call__方法其实和类的创建过程和实例化没有多大关系了,定义了__call__方法才能以函数的方式被执行。例如:
class A(object): def __call__(self): print('__call__ be called') a = A() a() #输出为:__call__ be called
#coding:utf-8 class Foo(object): def __new__(cls, *args, **kwargs): #__new__是一个类方法,在对象创建的时候调用 print("excute __new__") return super(Foo,cls).__new__(cls,*args,**kwargs) def __init__(self): #__init__是一个实例方法,在对象创建后调用,对实例属性做初始化 print("excute __init") f1 = Foo() ''' 输出: excute __new__ excute __init ''' #可以看出new方法在init方法之前执行
子类如果重写__new__方法,一般依然要调用父类的__new__方法
class Child(Foo): def __new__(cls, *args, **kwargs): return super(Child, cls).__new__(cls, *args, **kwargs)
必须注意的是,类的__new__方法之后,必须生成本类的实例才能自动调用本类的__init__方法进行初始化,否则不会自动调用__init__.
class Foo(object): def __init__(self, *args, **kwargs): print('Foo __init__') def __new__(cls, *args, **kwargs): return object.__new__(Stranger, *args, **kwargs) class Stranger(object): def __init__(self,name): print("class Stranger's __init__ be called" ) self.name = name foo = Foo('test') print(type(foo)) print(foo.name) ''' 输出: <class '__main__.Stranger'> Traceback (most recent call last): File "E:/py/awesome-python3-webapp/test/singleClass_demo.py", line 38, in <module> print(foo.name) AttributeError: 'Stranger' object has no attribute 'name' ''' # 说明:如果new方法返回的不是本类的实例,那么本类(Foo)的init和 # 生成的类(Stranger)的init都不会被调用
2 实现单例模式:
依照python官方文档的说法,__new__方法主要是当你继承一些不可变的class时(比如int,str,tuple)时,提供给你一个自定义这些类的实例化过程的途径。还有就是实现自定义的metaclass。接下来我们分别通过这两种方式来实现单例模式。
简单来说,单例模式的原理就是通过在类属性中添加一个判定为ins_flag,通过这个flag判断是否已经被实例化过了,如果被实例化过了就返回该实例。
1)__new__方法实现单例实例
class Singleton(object): def __new__(cls, *args, **kwargs): if not hasattr(cls,"_instance"): cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs) return cls._instance s1 = Singleton() s2 = Singleton() print(s1 is s2) # True
因为重写__new__方法,所以继承至Singleton的类,在不重写__new__的情况下都将是单例模式。
2)元类实现单例
class Singleton(type): def __init__(self, *args, **kwargs): print('__init__') self.__instance = None super(Singleton,self).__init__(*args, **kwargs) def __call__(self, *args, **kwargs): print('__call__') if self.__instance is None: self.__instance = super(Singleton,self).__call__(*args, **kwargs) return self.__instance class Foo(metaclass=Singleton): __metaclass__ = Singleton #在代码执行到这里的时候,元类中的__new__方法和__init__方法其实已经被执行了,而不是在Foo实例化的时候执行。且仅会执行一次。 foo1 = Foo() foo2 = Foo() print(Foo.__dict__)#'_Singleton__instance': <__main__.Foo object at 0x0000000002238B00>
#存在一个私有属性来保存属性,而不会污染Foo类(其实还是会污染,只是无法直接通过__instance属性访问)
print(foo1 is foo2) ''' 输出: __init__ __call__ __call__ {'__module__': '__main__', '__metaclass__': <class '__main__.Singleton'>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None, '_Singleton__instance': <__main__.Foo object at 0x0000000002238B00>} True '''
基于这个例子:
- 我们知道元类(Singleton)生成的实例是一个类(Foo),而这里我们仅仅需要对这个实例(Foo)增加一个属性(__instance)来判断和保存生成的单例。想想也知道为一个类添加一个属性当然是在__init__中实现了。
- 关于__call__方法的调用,因为Foo是Singleton的一个实例。所以Foo()这样的方式就调用了Singleton的__call__方法。不明白就回头看看上一节中的__call__方法介绍。
假如我们通过元类的__new__方法来也可以实现,但显然没有通过__init__来实现优雅,因为我们不会为了为实例增加一个属性而重写__new__方法。所以这个形式不推荐。
class Singleton(type): def __new__(cls, name, bases, attrs): print('__new__') attrs["_instance"] = None return super(Singleton, cls).__new__(cls, name, bases, attrs) def __call__(self, *args, **kwargs): print('__call__') if self._instance is None: self._instance = super(Singleton, self).__call__(*args, **kwargs) return self._instance class Foo(metaclass=Singleton): __metaclass__ = Singleton foo1 = Foo() foo2 = Foo() print(Foo.__dict__) print(foo1 is foo2) ''' 输出: __new__ __call__ __call__ {'__module__': '__main__', '__metaclass__': <class '__main__.Singleton'>, '_instance': <__main__.Foo object at 0x00000000021F8C88>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None} True '''
python 类和元类(metaclass)的理解和简单运用
深刻理解Python中的元类(metaclass)