zoukankan      html  css  js  c++  java
  • python核心高级学习总结6面向对象进阶之元类

    元类引入

    在多数语言中,类就是一组用来描述如何生成对象的代码段,在python中同样如此,但是在python中把类也称为类对象,是的,你没听错,在这里你只要使用class关键字定义了类,其解释器在执行时就会创建一个对象,但是这个对象比较特殊,它可以创建自己的实例对象(像其他语言一样)。你可以对它进行下面的操作:

    1. 你可以将它赋值给⼀个变量
    2. 你可以拷⻉它
    3. 你可以为它增加属性
    4. 你可以将它作为函数参数进⾏传递

    动态创建类

    听起来python在这方面跟一些语言的差别了吧,没错它还可以在运行时动态地创建它们,你可以在函数中创建类,用class关键字即可。

    def choose_class(name):
      if name == 'foo':
      class Foo(object):
      pass
      return Foo # 返回的是类, 不是类的实例
      else:
      class Bar(object):
      pass
      return Bar

    如果你想知道python中的变量或者数值的类型,你可以用万能而强大的type,如下(注意它们的返回值)

    >>> print type(1) #数值的类型
    <type 'int'>
    >>> print type("1") #字符串的类型
    <type 'str'>
    >>> print type(ObjectCreator()) #实例对象的类型
    <class '__main__.ObjectCreator'>
    >>> print type(ObjectCreator) #类的类型
    <type 'type'>

    使用type创建类

    创建格式:type(类名, 由⽗类名称组成的元组( 针对继承的情况, 可以为空) ,包含属性的字典( 名称和值) )
    可以⼿动像这样创建:
    Test2 = type("Test2",(),{}) #定了⼀个Test2类
    In [5]: Test2() #创建了⼀个Test2类的实例对象
    Out[5]: <__main__.Test2 at 0x10d406b38>

    上面等价于

    class Test2:
        pass

    使⽤type创建带有属性的类

    Foo = type('Foo', (), {'bar':True})

    可以翻译为

    >>> class Foo(object):
    … bar = True

    这个类跟普通创建的类一样使用,如继承这个类,你可以用下面的方法

    >>> FooChild = type('FooChild', (Foo,),{})
    >>> print FooChild
    <class '__main__.FooChild'>
    >>> print FooChild.bar # bar属性是由Foo继承⽽来
    True

    同样等价于

    >>> class FooChild(Foo):
    … pass

    注意:添加的属性都是类属性,第二个参数是继承自哪儿,采用元组的形式,也要知道在python中元组中只有一个参数表示方法只能是(xx,),而不能是(xx)

     使⽤type创建带有⽅法的类

    如果你想为你的类增加方法,那么你创建一个签名函数,然后添加其为属性赋值即可。

    添加实例方法

    In [46]: def echo_bar(self): #定义了⼀个普通的函数
    ...: print(self.bar)
    ...:
    In [47]: FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})
    In [48]: hasattr(Foo, 'echo_bar') #判断Foo类中, 是否有echo_bar这个属性
    Out[48]: False
    In [49]:
    In [49]: hasattr(FooChild, 'echo_bar') #判断FooChild类中, 是否有echo_bar这个
    Out[49]: True
    In [50]: my_foo = FooChild()
    In [51]: my_foo.echo_bar()
    True

    添加类方法

    In [42]: @classmethod
    ...: def testClass(cls):
    ...: print(cls.bar)
    ...:
    In [43]:
    In [43]: Foochild = type('Foochild', (Foo,), {"echo_bar":echo_bar,"testClass":testClass})
    In [44]:
    In [44]: fooclid = Foochild()
    In [45]: fooclid.testClass()
    True

    添加静态方法

    In [36]: @staticmethod
    ...: def testStatic():
    ...: print("static method ....")
    ...:
    In [37]: Foochild = type('Foochild', (Foo,), {"echo_bar":echo_bar,“testStatic”:testStatic})
    In [38]: fooclid = Foochild()
    In [39]: fooclid.testStatic
    Out[39]: <function __main__.testStatic>
    In [40]: fooclid.testStatic()
    static method ....
    In [41]: fooclid.echo_bar()
    True
    看到这么多实现动态类的方法,你该明白python是怎么做到的,在这里就涉及到元类,元类就是用来创建类的东西,而创建类就是为了创建类的实例对象,所以可以这样理解,元类就是为了创建类对象的,而type实际上就是一个元类,传统类的元类就是types.classType,在python中元类的介绍中也介绍了元类,有兴趣的读者可以去看看。

    SO,结论就是Python中所有的东⻄, 注意, 我是指所有的东⻄——都是对象。 这包括整数、 字符串、 函数以及类。 它们全部都是对象,⽽且它们都是从⼀个类创建⽽来, 这个类就是type。

    __metaclass__属性

    你也可以定义自己的元类,用到的就是上面的属性,首先,你可以在定义⼀个类的时候为其添加__metaclass__属性。
    class Foo(object):
        __metaclass__ = something…
        #...省略...
    那么当python解释器看到下面代码时
    class Foo(Bar):
        pass
    python做了如下的操作:
    1. Foo中有__metaclass__这个属性吗? 如果是, Python会通过__metaclass__创建⼀个名字为Foo的类(对象)
    2. 如果Python没有找到__metaclass__, 它会继续在Bar( ⽗类) 中寻找__metaclass__属性, 并尝试做和前⾯同样的操作。
    3. 如果Python在任何⽗类中都找不到__metaclass__, 它就会在模块层次中去寻找__metaclass__, 并尝试做同样的操作。
    4. 如果还是找不到__metaclass__,Python就会⽤内置的type来创建这个类对象。
    在这个__metaclass__中可以放一些什么代码呢?------可以做任何涉及到类操作的事情,用type或者其子类来完成。
    下面是用自定义类来当做元类
    #coding=utf-8
    class UpperAttrMetaClass(type):
        # __new__ 是在__init__之前被调⽤的特殊⽅法
        # __new__是⽤来创建对象并返回之的⽅法
        # ⽽__init__只是⽤来将传⼊的参数初始化给对象
        # 你很少⽤到__new__, 除⾮你希望能够控制对象的创建
        # 这⾥, 创建的对象是类, 我们希望能够⾃定义它, 所以我们这⾥改写__new__
        # 如果你希望的话, 你也可以在__init__中做些事情
        # 还有⼀些⾼级的⽤法会涉及到改写__call__特殊⽅法, 但是我们这⾥不⽤
        def __new__(cls, future_class_name, future_class_parents, future_clas
            #遍历属性字典, 把不是__开头的属性名字变为⼤写
            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_parent
            # ⽅法3: 使⽤super⽅法
            return super(UpperAttrMetaClass, cls).__new__(cls, future_class_n
    #python2的⽤法
    class Foo(object):
        __metaclass__ = UpperAttrMetaClass
        bar = 'bip'
    # python3的⽤法
    # class Foo(object, metaclass = UpperAttrMetaClass):
        # bar = 'bip'
    print(hasattr(Foo, 'bar'))
    # 输出: False
    print(hasattr(Foo, 'BAR'))
    # 输出:True
    f = Foo()
    print(f.BAR)
    # 输出:'bip'
    
    其实简单地来讲,python中的元类用处一般就是下面三个
    1. 拦截类的创建
    2. 修改类
    3. 返回修改之后的类
    哈哈,我想说的是对于元类咱们99%的人不会用到。


  • 相关阅读:
    双缓冲绘图模式
    java异常
    15-11-24 system同步与异步
    15-11-23:system指令
    使用Swing组件编写一个支持中文文本编辑程序ChineseTextEdit.java
    JTextArea 加入滚动条
    键盘事件
    monitoring_db
    del_archivelog
    Redis 4.0.14 单实例安装
  • 原文地址:https://www.cnblogs.com/hulichao/p/python_object.html
Copyright © 2011-2022 走看看