【python进阶】详解元类及其应用2

In [14]: def echo_bar(self):#定义了一个普通的函数
    ...:     print(self.bar)
    ...:

In [15]: FooChild = type(‘FooChild‘,(Foo,),{‘echo_bar‘:echo_bar})

In [16]: hasattr(Foo,‘echo_bar‘)#判断Foo类中，是否有echo_bar这个属性
Out[16]: False

In [17]: hasattr(FooChild,‘echo_bar‘)#判断FooChild类中，是否有echo_bar这个属性
Out[17]: True

In [18]: my_foo=FooChild()
    ...:

In [19]: my_foo.echo_bar()
True

In [20]: @staticmethod
    ...: def testStatic():
    ...:     print("static method ....")
    ...:

In [21]: Foochild=type(‘Foochild‘,(Foo,),{"echo_bar":echo_bar,"testStatic":testStatic})

In [22]: fooclid=Foochild()

In [23]: fooclid.testStatic
Out[23]: <function __main__.testStatic>

In [24]: fooclid.testStatic()
static method ....

In [25]: fooclid.echo_bar()
True

In [26]: @classmethod
    ...: def testClass(cls):
    ...:     print(cls.bar)
    ...:

In [27]: Foochild=type(‘Foochild‘,(Foo,),{"echo_bar":echo_bar,"testStatic":testStatic,"testClass":testClass})

In [28]: fooclid = Foochild()

In [29]: fooclid.testClass()
True

MyClass = MetaClass()#使?元类创建出?个对象，这个对象称为“类” 
MyObject = MyClass()#使?“类”来创建出实例对象

MyClass=type(‘MyClass‘,(),{})

In [30]: age = 35

In [31]: age.__class__
Out[31]: int

In [32]: name = ‘bob‘

In [33]: name.__class__
Out[33]: str

In [34]: def foo():
    ...:     pass
    ...:

In [35]: foo.__class__
Out[35]: function

In [36]: class Bar(object):
    ...:     pass
    ...:

In [37]: b = Bar()

In [38]: b.__class__
Out[38]: __main__.Bar

In [40]: name.__class__.__class__
Out[40]: type

In [41]: age.__class__.__class__
Out[41]: type

In [42]: foo.__class__.__class__
Out[42]: type

In [43]: b.__class__.__class__
Out[43]: type

class Foo(object):
      __metaclass__ = something...
      ...省略...

In [44]: class Foo(Bar):
    ...:     pass
    ...:

#-*-coding:utf-8-*-
def upper_attr(future_class_name,future_class_parents,future_class_attr):

    #遍历属性字典，把不是__开头的属性名字变为?写
    newAttr = {}
    for name,value in future_class_attr.items():
        if not name.startswith("__"):
            newAttr[name.upper()] = value

    #调?type来创建?个类
    return type(future_class_name,future_class_parents,newAttr)

class Foo(object,metaclass=upper_attr):
    bar = ‘bip‘

print(hasattr(Foo,‘bar‘))
print(hasattr(Foo,‘BAR‘))
f = Foo()
print(f.BAR)

#-*-coding:utf-8-*-
class UpperAttrMetaClass(type):

    #__new__是在__init__之前被调?的特殊?法
    #__new__是?来创建对象并返回之的?法
    #?__init__只是?来将传?的参数初始化给对象
    #你很少?到__new__，除?你希望能够控制对象的创建
    #这?，创建的对象是类，我们希望能够?定义它，所以我们这?改写__new__
    #如果你希望的话，你也可以在__init__中做些事情
    #还有?些?级的?法会涉及到改写__call__特殊?法，但是我们这?不?
    def __new__(cls,future_class_name,future_class_parents,future_class_attr):
        #遍历属性字典，把不是__开头的属性名字变为?写
        newAttr = {}
        for name,value in future_class_attr.items():
            if not name.startswith("__"):
                newAttr[name.upper()] = value

        #?法1：通过‘type‘来做类对象的创建
        #return type(future_class_name,future_class_parents,newAttr)
        
        #?法2：复?type.__new__?法
        #这就是基本的OOP编程，没什么魔法
        #return    type.__new__(cls,future_class_name,future_class_parents,future_class_attr)

        #?法3：使?super?法
        return super(UpperAttrMetaClass,cls).__new__(cls,future_class_name,future_class_parents,future_class_attr)

#python2的?法 
#class Foo(object):
#    __metaclass__ = upper_attr#设置Foo类的元类为upper_attr
#    bar = ‘bip‘

#python3的?法
class Foo(object,metaclass=upper_attr):
    bar = ‘bip‘

print(hasattr(Foo,‘bar‘)) 
#输出:False 
print(hasattr(Foo,‘BAR‘)) 
#输出:True
f = Foo()
print(f.BAR)
#输出:‘bip‘