美文网首页
python面向对象和元类的理解

python面向对象和元类的理解

作者: lethe_zh | 来源:发表于2018-09-27 19:35 被阅读0次

    1 python类对象与实例对象

    python中一切皆对象(广义上的对象),类也不例外,我们可以称类为类对象。python中内建函数type()可以返回对象的类型,例如type(int)会得到返回值<class 'type'>,而int为类型工厂函数,是内置的类对象。如果对自定义的类使用type()也会返回相同的值<class 'type'>
    从上述我们可以总结出:python中type为一般类对象的类(除非子类化type,用type子类创建类对象),即type类可以实例化得到类对象,再由类对象实例化得到实例对象。创建类的类被称为元类

    1.1 类属性&实例属性

    1.1.1 类属性

    类属性是一个类对象的数据或函数元素,类属性包括数据属性和方法。
    数据属性 是仅属于类的变量,与任何实例无关,这与C++和Java中静态成员变量相似。
    方法 是定义在类中的函数,根据用法,可以分为绑定方法与非绑定方法。绑定方法必须实例化后才能调用,需要与实例绑定;非绑定方法则可以分为静态方法和类方法,可以使用装饰器@staticmethod@classmethod实现。虽然绑定方法需要实例化后才能调用,但其定义在类中,因此其也属于类的属性。

    class P():
        version = 1.0 #类的静态数据
    
        @classmethod
        def show(cls): #类方法
            print(cls.version)
     
        def __init__(self, name, address): #绑定方法,self代表实例
            self.name = name
            self.address = address
        
        def display(self):
            print(self.name)
            print(self.address)
    
        def __call__(self):
            print(self.name)
    
    def fn():
        print('hello,python')
    
    if __name__ == '__main__':
        p = P('jay','american')
        p1 = P('h','china')
        p1.fn = fn
        print(P.__dict__)
        print(p1.__dict__)
    

    以上是创建类对象的一个例子,__dict__为对象的特殊属性,其值为对象属性构成的字典(并非所有类或实例都有该属性,若定义了__slots__属性则会取代__dict__属性),
    运行结果如下:

    >>
    {'__module__': '__main__', 'version': '1.0',
    'show': <classmethod object at 0x000002A48351EB70>, '__init__': <function P.__init__ at 0x000002A4835137B8>, 'display': <function P.display at 0x000002A483513840>, '__call__': <function P.__call__ at 0x000002A4835138C8>, '__dict__': <attribute '__dict__' of 'P' objects>, '__weakref__': <attribute '__weakref__' of 'P' objects>, '__doc__': None}
    {'name': 'h', 'address': 'china', 'fn': <function fn at 0x000002A4816B1E18>}
    

    运行结果同时也验证了上述说法,类中定义的绑定方法:__init__, display, __call__,和非绑定方法:show,都是属于类的属性;而fn,name,address则属于实例属性。

    1.1.2 实例属性

    实例属性是只属于实例对象的方法和数据属性。不同于静态语言,python能动态地创建实例属性,上述代码中的fn即为动态创建的实例属性。
    但这样特性的缺陷是如果实例属性在条件语句中创建,若该条件语句并未执行,该属性也就不存在,而后面的代码试着访问这些属性,就会发生错误。
    解决办法是避免中途创建实例属性,尽量在__init__方法中初始化实例属性。

    1.1.3 类属性VS实例属性

    类属性也能通过实例访问,但前提是该实例中没有同名的属性。任何对实例属性的赋值都会新建一个实例属性并对其赋值,但如果类属性中存在同名的属性,则不会对类属性产生影响,若要改变类属性需要使用类名,而不是实例名。

    class P():
        version = 1
    >>p1 = P()
    >>p1.version
    1
    >>p1.version = 2
    >>p1.version
    2
    >>P.version
    1
    >>P.version = 2
    >>P.version
    2
    

    1.2 类的特殊方法(魔术方法)

    __init__:初始化方法,属于类的绑定方法,第一个参数必须为self(代表实例对象),且无返回值,在__new__返回实例对象后才能调用。
    __new__:真正的构造方法,用于创建实例对象,属于静态方法,第一个参数为cls(代表类对象),其返回值为实例对象。
    __call__:将对象设置为可调用对象(可以向函数一样用()调用),元类type中实现了该函数,因此类对象为可调用对象,实例化时就是通过调用类来创建实例对象的,覆盖时需要调用父类方法,即super().__call__()

    关键知识:覆盖上述特殊函数时,需要特别注意,元类中自定义__call__(self, *args, **kwargs),类对象中若自定义__init__(self, *args, **kwargs), 则自定义__new__(cls, *args, **kwargs),原因如下:

    p1 = P(*args, **kwargs) 
    '''执行顺序:'''
    P.__call__(*args, **kwargs):
        super().__call__(*args, **kwargs)
        goto↓
            p1 = object().__new__(P)
            p1.__init__(*args, **kwargs)
        return p1
    

    2 Metaclass元类

    2.1 自定义元类

    元类是用来创建其他的类,它的实例就是其他的类。
    执行类定义时,解释器会先寻找类属性__metaclass__,如果此属性中未定义,则向上查找其父类中的__metaclass__
    type__init__函数有三个位置参数,分别为:类名称,父类名称元祖,类属性字典;可直接使用type()快速创建类对象:
    People = type('People',(object,),dict(show = fn, setage = fn1, age = None))
    也可子类化type类后,创建元类,再创建类对象:

    from time import ctime
    
    class MetaC(type):
        def __init__(self, *args):
            super().__init__(*args)
            print('调用类的init')
        
        def __call__(self, *args, **kwargs):
            print('调用类的call')
            _instance = super().__call__(*args, **kwargs)
            print('call return %s' %_instance)
            return _instance
    
    class Foo(metaclass=MetaC):
        # __metaclass__ = MetaC
    
        def __init__(self, version=None):
            print('调用对象的init')
    
        def __new__(cls, *args, **kwargs):
            print('调用对象的new')
            _instance = super().__new__(cls)
            print('new return %s' %_instance)
            return _instance
        
    foo = Foo('hello')
    

    运行结果:

    >>
    调用类的init
    调用类的call
    调用对象的new
    new return <__main__.Foo object at 0x0000018D2F57EF98>
    调用对象的init
    call return <__main__.Foo object at 0x0000018D2F57EF98>
    

    2.2 单例模式的实现

    下面是几种单例模式的实现方法,有些会用到上述的元类知识。

    2.2.1 装饰器实现单例

    import weakref
    
    def single_obj(cls):
    #实例缓存为弱引用,实例不被使用时会释放该实例
        _spam_cache = weakref.WeakValueDictionary()
        @wraps(cls)
        def wrapper(*args, **kwargs):
            if cls not in _spam_cache :
                _instance = cls(*args, **kwargs)
                _spam_cache [cls] = _instance
                return _instance
            else:
                return _spam_cache [cls]
        return wrapper
    
    @single_obj
    class A():
        def __init__(self, version):
            self.version = version
            print(self.version)
    
    a1 = A(1.3)
    a2 = A(1.2)
    print('a1 id:',id(a1))
    print('a2 id:',id(a2))
    

    2.2.2 利用元类,类的__call__方法实现单例

    class Singleton(type):
        def __init__(self, *args, **kwargs):
            self._instance = None
            super().__init__(*args, **kwargs)
        
        def __call__(self, *args, **kwargs):
            if self._instance is None:
                self._instance = super().__call__(*args, **kwargs)
                return self._instance
            else:
                return self._instance
    
    class B(metaclass=Singleton):
        def __init__(self, name):
            self.name = name
            print(name)
    
    b1 = B('what')
    b2 = B('hell')
    print(b2.name)
    print('b1 id:',id(b1))
    print('b2 id:',id(b2))
    

    2.2.3 通过__new__实现单例(此方法不可行)

    class C(object):
        _instance = None
    
        def __init__(self, name):
            self.name = name
            print(name)
    
        def __new__(cls, *args, **kwargs):
            if cls._instance is None:
                cls._instance = super().__new__(cls)
            return cls._instance
    
    c1 = C('dsfsfd')
    c2 = C('java')
    
    print('c1 id:',id(c1))
    print('c2 id:',id(c2))
    
    • 若采用上述方法,无论类是否实例化,__init__都会被调用,实例对象会被修改;

    相关文章

      网友评论

          本文标题:python面向对象和元类的理解

          本文链接:https://www.haomeiwen.com/subject/zfyeoftx.html