zoukankan      html  css  js  c++  java

  • 在Python中定义和使用抽象类的方法

    https://www.jb51.net/article/87710.htm

    像java一样python也可以定义一个抽象类。

    在讲抽象类之前，先说下抽象方法的实现。

    抽象方法是基类中定义的方法，但却没有任何实现。在java中，可以把方法申明成一个接口。而在python中实现一个抽象方法的简单的方法是：

    ?
    1
    2
    3
    class Sheep（object）：
      def get_size(self):
        raise NotImplementedError

    任何从Sheep继承下来的子类必须实现get_size方法。否则就会产生一个错误。但这种实现方法有个缺点。定义的子类只有调用那个方法时才会抛错。这里有个简单方法可以在类被实例化后触发它。使用python提供的abc模块。

    ?
    1
    2
    3
    4
    5
    6
    7
    import abc
    class Sheep(object):
      __metaclass__ = abc.ABCMeta
       
      @abc.absractmethod
      def get_size(self):
        return


    这里实例化Sheep类或任意从其继承的子类（未实现get_size）时候都会抛出异常。

    因此，通过定义抽象类，可以定义子类的共同method（强制其实现）。

    如何使用抽象类

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    import abc
     
    class A(object):
      __metaclass__ = abc.ABCMeta
     
      @abc.abstractmethod
      def load(self, input):
        return
     
      @abc.abstractmethod
      def save(self, output, data):
        return

    通过ABCMeta元类来创建一个抽象类, 使用abstractmethod装饰器来表明抽象方法

    注册具体类

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    class B(object):
       
      def load(self, input):
        return input.read()
     
      def save(self, output, data):
        return output.write(data)
     
    A.register(B)
     
    if __name__ == '__main__':
      print issubclass(B, A)   # print True
      print isinstance(B(), A)  # print True

    从抽象类注册一个具体的类

    子类化实现

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    class C(A):
     
      def load(self, input):
        return input.read()
     
      def save(self, output, data):
        return output.write(data)
         
    if __name__ == '__main__':
      print issubclass(C, A)   # print True
      print isinstance(C(), A)  # print True

    可以使用继承抽象类的方法来实现具体类这样可以避免使用register. 但是副作用是可以通过基类找出所有的具体类

    ?
    1
    2
    3
    4
    for sc in A.__subclasses__():
      print sc.__name__
     
    # print C

    如果使用继承的方式会找出所有的具体类，如果使用register的方式则不会被找出

    使用__subclasshook__

    使用__subclasshook__后只要具体类定义了与抽象类相同的方法就认为是他的子类

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    import abc
     
    class A(object):
      __metaclass__ = abc.ABCMeta
     
      @abc.abstractmethod
      def say(self):
        return 'say yeah'
     
      @classmethod
      def __subclasshook__(cls, C):
        if cls is A:
          if any("say" in B.__dict__ for B in C.__mro__):
            return True
        return NotTmplementd
     
    class B(object):
      def say(self):
        return 'hello'
     
    print issubclass(B, A)   # True
    print isinstance(B(), A)  # True
    print B.__dict__      # {'say': <function say at 0x7f...>, ...}
    print A.__subclasshook__(B) # True

    不完整的实现

    ?
    1
    2
    3
    4
    5
    6
    7
    class D(A):
      def save(self, output, data):
        return output.write(data)
     
    if __name__ == '__main__':
      print issubclass(D, A)   # print True
      print isinstance(D(), A)  # raise TypeError

    如果构建不完整的具体类会抛出D不能实例化抽象类和抽象方法

    具体类中使用抽象基类

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    import abc
    from cStringIO import StringIO
     
    class A(object):
      __metaclass__ = abc.ABCMeta
     
      @abc.abstractmethod
      def retrieve_values(self, input):
        pirnt 'base class reading data'
        return input.read()
     
     
    class B(A):
     
      def retrieve_values(self, input):
        base_data = super(B, self).retrieve_values(input)
        print 'subclass sorting data'
        response = sorted(base_data.splitlines())
        return response
     
    input = StringIO("""line one
    line two
    line three
    """)
     
    reader = B()
    print reader.retrieve_values(input)

    打印结果

    ?
    1
    2
    3
    base class reading data
    subclass sorting data
    ['line one', 'line two', 'line three']

    可以使用super来重用抽象基类中的罗辑, 但会迫使子类提供覆盖方法.

    抽象属性

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    import abc
     
    class A(object):
      __metaclass__ = abc.ABCMeta
     
      @abc.abstractproperty
      def value(self):
        return 'should never get here.'
     
    class B(A):
       
      @property
      def value(self):
        return 'concrete property.'
     
    try:
      a = A()
      print 'A.value', a.value
    except Exception, err:
      print 'Error: ', str(err)
     
    b = B()
    print 'B.value', b.value

    打印结果,A不能被实例化，因为只有一个抽象的property getter method.

    ?
    1
    2
    Error: ...
    print concrete property

    定义抽象的读写属性

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    import abc
     
    class A(object):
      __metaclass__ = abc.ABCMeta
     
      def value_getter(self):
        return 'Should never see this.'
     
      def value_setter(self, value):
        return
     
      value = abc.abstractproperty(value_getter, value_setter)
     
    class B(A):
       
      @abc.abstractproperty
      def value(self):
        return 'read-only'
     
    class C(A):
      _value = 'default value'
     
      def value_getter(self):
        return self._value
     
      def value_setter(self, value):
        self._value = value
     
      value = property(value_getter, value_setter)
     
    try:
      a = A()
      print a.value
    except Exception, err:
      print str(err)
     
    try:
      b = B()
      print b.value
    except Exception, err:
      print str(err)
     
    c = C()
    print c.value
     
    c.value = 'hello'
    print c.value

    打印结果, 定义具体类的property时必须与抽象的abstract property相同。如果只覆盖其中一个将不会工作.

    ?
    1
    2
    3
    4
    error: ...
    error: ...
    print 'default value'
    print 'hello'

    使用装饰器语法来实现读写的抽象属性, 读和写的方法应该相同.

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    import abc
     
    class A(object):
      __metaclass__ = abc.ABCMeta
     
      @abc.abstractproperty
      def value(self):
        return 'should never see this.'
     
      @value.setter
      def value(self, _value):
        return
     
    class B(A):
      _value = 'default'
     
      @property
      def value(self):
        return self._value
     
      @value.setter
      def value(self, _value):
        self._value = _value
     
    b = B()
    print b.value    # print 'default'
     
    b.value = 'hello'
    print b.value    # print 'hello'
  • 相关阅读:
    【HTML】html站标设置、网页小图标
    【idea】2020完整安装过程
    pptp，l2tp获取登录用户信息用pppd参数即可
    Postfix+Dovecot+MySQL搭建邮件服务器（续）
    Postfix+Dovecot+MySQL搭建邮件服务器
    zimage 和bzimage 有什么区别
    Linux编译内核
    8种nosql数据库对比
    core dump
    ulimit -c unlimited
  • 原文地址：https://www.cnblogs.com/Alight/p/9607708.html
Copyright © 2011-2022 走看看