【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'