精华内容
下载资源
问答
  • python 抽象类

    千次阅读 2018-04-09 23:36:53
    从网上找了好多资料,对python抽象类的总结都比较乱,所以自己整理了一篇供大家学习交流 在我们了解抽象类的时候先了解一下什么是接口 1.在python中并没有interface这个关键字来声明这是个接口,如果非要模仿接口...

    python 抽象类

          从网上找了好多资料,对python抽象类的总结都比较乱,所以自己整理了一篇供大家学习交流

    在我们了解抽象类的时候先了解一下什么是接口

    1.在python中并没有interface这个关键字来声明这是个接口,如果非要模仿接口的概念就用到了第三方模块,比如:abs模块。
    2、接口就是只定义了一些方法,而没有实现。【(这些方法被称为抽象方法),大家自行脑补,在一个方法中直接写了一个pass就是没有实现任何功能的方法,就叫做抽象方法】
    3.这些功能需要被另一个类(B)继承,由B类实现某个功能,或者全部功能。
    比如:我们常说的一些外部API的接口,只是调用,功能由调用的接口实现。

    实例程序:

    class Human:    #定义一个接口
       def eat(self): #抽象方法,下同
          pass
       def sleep(self):
          pass
       def play(self):
          pass
    #调用接口
    class People(Human):   #我们继承Human接口,通过这个类来实现功能
       def eat(self):
          print("吃饭")
       def    sleep(self):
          print("睡觉")
       def play(self):
          print("打豆豆")
    #实例对象
    ren = People()
    ren.eat()
    #此处仅代表个人观点,这个接口,有点像继承,然后方法重写,但是父类就是没有功能。

    进入重点  抽象方法

         1.抽象类给我们的第一感觉就是,八九年代的抽象派的感觉,生涩难懂,其实不然,我们也就会发现这就是一个概念。

         2.抽象类,就像是类和接口的混合体,具有接口的特性,在python中利用第三方abc模块,实现抽象类。
         3抽象方法不存在重写的问题,却有实现的问题
         4含有抽象方法的类一定是抽象类,但是抽象类不一定含有抽象方法,此时也没有任何意义了。     5.在python中接口(抽象类)常用于协同工作。
    注意:在python中,我们不以有无执行体来区分是否是抽象类,而是根据是否有@abc.abstractmethod装饰器作为标准。

    抽象描述

    注意:不能直接实例化抽象类!!!

    示例程序:
    import abc  #导入abc模块
    class InMa(metaclass=abc.ABCMeta):  #定义抽象方法
       @abc.abstractmethod       #定义抽象方法
       def login(self):
          pass
       @abc.abstractmethod
       def zhuce(self):
         pass
    class Login(InMa):  #继承抽象类
       def __inti__(self,name,pwd):
          self.name = name
          self.password = pwd
       def login(self):           #实现抽象方法功能
    
          if self.name == "qq" and self.password == "111":
             print("恭喜登录成功")
          else:
             print("登录失败")
    
    class Zc(Login):
       def __init__(self,name,pwd):
          self.name = name
          self.password = pwd
       def zhuce(self):
          print("恭喜注册成功")
          print("username:",self.name)
          print("password:",self.password)
     #实例对象
    ren = Zc("Jaue","qqq")
    ren.zhuce()

    梦想还是要有的,万一实现了呢~~~

    梦想

    展开全文
  • python抽象类

    2019-08-19 16:53:49
    与java一样,python也有抽象类的概念但是同样需要借助模块实现,抽象类是一个特殊的类,它的特殊之处在于只能被继承,不能被实例化 2 为什么要有抽象类 如果说类是从一堆对象中抽取相同的内容而来的,那么抽象类...

    1 什么是抽象类

        与java一样,python也有抽象类的概念但是同样需要借助模块实现,抽象类是一个特殊的类,它的特殊之处在于只能被继承不能被实例化

    2 为什么要有抽象类

    如果说类是从一堆对象中抽取相同的内容而来的,那么抽象类是从一堆中抽取相同的内容而来的,内容包括数据属性和函数属性。

      比如我们有香蕉的类,有苹果的类,有桃子的类,从这些类抽取相同的内容就是水果这个抽象的类,你吃水果时,要么是吃一个具体的香蕉,要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。

        从设计角度去看,如果类是从现实对象抽象而来的,那么抽象类就是基于类抽象而来的。

      从实现角度来看,抽象类与普通类的不同之处在于:抽象类中只能有抽象方法(没有实现功能),该类不能被实例化,只能被继承,且子类必须实现抽象方法。这一点与接口有点类似,但其实是不同的,即将揭晓答案 

    3. 在python中实现抽象类

    import abc # 利用abc模块实现抽象类
    # 一切皆文件
    class All_file(metaclass=abc.ABCMeta):
        all_type = 'file'
    
        @abc.abstractmethod #定义抽象方法,无需实现功能
        def read(self):
            '子类必须定义读功能'
            pass
    
        @abc.abstractmethod  # 定义抽象方法,无需实现功能
        def write(self):
            '''子类必须定义写功能'''
            pass
    
    class Txt(All_file): #子类继承抽象类,但是必须定义read和write方法
        def read(self):
            print('文本数据的读取方法')
    
        def write(self):
            print('文本数据的写入方法')
    
    class Sata(All_file): #子类继承抽象类,但是必须定义read和write方法
        def read(self):
            print('硬盘数据的读取方法')
    
        def write(self):
            print('硬盘数据的写入方法')
    
    class Process(All_file): #子类继承抽象类,但是必须定义read和write方法
        def read(self):
            print('进程数据的读取方法')
    
        def write(self):
            print('进程数据的写入方法')
    
    wenbenwenjian=Txt()
    yingpanwenjian=Sata()
    jinchengwenjian=Process()
    
    #这样大家都是被归一化了,也就是一切皆文件的思想
    wenbenwenjian.read()
    yingpanwenjian.write()
    jinchengwenjian.read()
    
    #这样大家都是被归一化了,也就是一切皆文件的思想
    print(wenbenwenjian.all_type)
    print(yingpanwenjian.all_type)
    print(jinchengwenjian.all_type)

    4. 抽象类与接口

    抽象类的本质还是类,指的是一组类的相似性,包括数据属性(如all_type)和函数属性(如read、write),而接口只强调函数属性的相似性。

    抽象类是一个介于类和接口直接的一个概念,同时具备类和接口的部分特性,可以用来实现归一化设计 

    展开全文
  • Python抽象类的新写法

    2020-09-21 23:17:56
    主要介绍了Python抽象类的新写法,本文讲解了老版本中的hack方式实现抽象类,以及2.7以后使用abstractmethod模块写抽象类的方法,需要的朋友可以参考下
  • Python抽象类

    千次阅读 2018-06-24 12:06:36
    抽象类抽象类描述了相关的一组类的通用的特征和行为。在客户的应用程序中,抽象类是不能正常实例化的,它的子类叫做具体类,这表明它们才是真正用来在客户应用程序中创建对象的类。设计一个AbstractBag类前面我们在...

    抽象类

    抽象类描述了相关的一组类的通用的特征和行为。在客户的应用程序中,抽象类是不能正常实例化的,它的子类叫做具体类,这表明它们才是真正用来在客户应用程序中创建对象的类。

    下面是本文的集合框架图


    设计一个AbstractBag类

    前面我们在Python 基于数组、链表实现的包接口中以不同方法实现了包接口。然后又在Python继承中实现了一个继承ArrayBag类的子类ArraySortedBag类。现在我们需要在ArrayBag类和LinkedBag类之上实现一个抽象类来去除冗余代码。

    包类中最显而易见的冗余方法是直接调用其它方法而没有直接访问实例变量的那些方法,这包括isEmpty、__str__、__add__和__eq__等方法。冗余的实例变量有点难以识别。包类使用了两个实例变量,分别是self._items和self._size。每个类中,self._items引用的是数据结构的一个不同的数据类型,相反,self._size在每一个包类中都引用了一个整数值。因此只有self._size是一个冗余的实例变量。

    由于__len__方法访问了self._size而不是self._items,因此它也被视为冗余方法。

    我们可以将包类中冗余的方法删除,并且将它们放置到一个叫做AbstractBag的新类中,然后,包类会通过继承变为AbstractBag的子类,从而访问这些方法。

    注意:通常一个类的方法和变量对其所有的子孙类都是适用的。

    AbstractBag类中的__init__方法

    (1)引入变量self._size并将其初始化为0

    (2)如果需要的话,将源集合中的项添加到self中

    因此,我们需要删除初始化变量self._items的行,这是子类的职责。

    class AbstractBag(object):
        """An abstract bag implementation."""
    
        # Constructor
        def __init__(self, sourceCollection = None):
            """Sets the initial state of self, which includes the contents of sourceCollection, if it's present."""
            self._size = 0
            if sourceCollection:
                for item in sourceCollection:
                    self.add(item)
    AbstractBag子类的__init__方法修改

    ArrayBag的__init__方法修改(LinkedBag的__init__方法修改类似,这里忽略)

    这个方法仍然负责将self._items设置为一个新的数组,然后在通过AbstractBag中的__init__方法来初始化包的大小并且在需要的是时候添加源集合的项。

    from arrays import Array
    from abstractbag import AbstractBag
    
    class ArrayBag(AbstractBag):
        """An array-based bag implementation."""
    
        # Class variable
        DEFAULT_CAPACITY = 10
    
        # Constructor
        def __init__(self, sourceCollection = None):
            """Sets the initial state of self, which includes the contents of sourceCollection, if it's present."""
            self._items = Array(ArrayBag.DEFAULT_CAPACITY)
            AbstractBag.__init__(self, sourceCollection)

    这里需要注意__init__中编写的两条语句的顺序,在运行超类中的构造方法之前,将self._items初始化为新的数组,以便有地方存储添加到新包中的任何项。

    AbstractBag中的__add__方法泛化

    ArrayBag类中的__add__方法

        def __add__(self,other):
            """Returns a new bag containing the contents of self and other."""
            result = ArrayBag(self)
            for item in other:
                result.add(item)
            return result

    如果直接将这个__add__方法复制到AbstractBag类中,然后使用测试函数来测试的话,+运算符使用了AbstractBag中的__add__方法,这会引发一个异常。因为这里__add__方法试图创建一个ArrayBag的一个实例来保存其结果,但是你真正想要的并不是一个特定的实例,而是一个self类型的一个实例,而不用管这个类型是什么。要解决这个问题,我们使用Python中的type函数来获取self的类型。

        def __add__(self, other):
            """Returns a new bag containing the contents of self and other."""
            result = type(self)(self)
            for item in other:
                result.add(item)
            return result

    完整的抽象类AbstractBag代码如下
    class AbstractBag(object):
        """An abstract bag implementation."""
    
        # Constructor
        def __init__(self, sourceCollection = None):
            """Sets the initial state of self, which includes the
            contents of sourceCollection, if it's present."""
            self._size = 0
            if sourceCollection:
                for item in sourceCollection:
                    self.add(item)
    
        # Accessor methods
        def isEmpty(self):
            """Returns True if len(self) == 0, or False otherwise."""
            return len(self) == 0
        
        def __len__(self):
            """Returns the number of items in self."""
            return self._size
    
        def __str__(self):
            """Returns the string representation of self."""
            return "{" + ", ".join(map(str, self)) + "}"
    
        def __add__(self, other):
            """Returns a new bag containing the contents
            of self and other."""
            result = type(self)(self)
            for item in other:
                result.add(item)
            return result
    
        def __eq__(self, other):
            """Returns True if self equals other,
            or False otherwise."""
            if self is other: return True
            if type(self) != type(other) or \
               len(self) != len(other):
                return False
            for item in self:
                if not item in other:
                    return False
            return True
    完整的继承抽象类AbstractBag的ArrayBag类的代码如下
    from arrays import Array
    from abstractbag import AbstractBag
    
    class ArrayBag(AbstractBag):
        """An array-based bag implementation."""
    
        # Class variable
        DEFAULT_CAPACITY = 10
    
        # Constructor
        def __init__(self, sourceCollection = None):
            """Sets the initial state of self, which includes the
            contents of sourceCollection, if it's present."""
            self._items = Array(ArrayBag.DEFAULT_CAPACITY)
            AbstractBag.__init__(self, sourceCollection)
    
        # Accessor methods
        def __iter__(self):
            """Supports iteration over a view of self."""
            cursor = 0
            while cursor < len(self):
                yield self._items[cursor]
                cursor += 1
    
        # Mutator methods
        def clear(self):
            """Makes self become empty."""
            self._size = 0
            self._items = Array(ArrayBag.DEFAULT_CAPACITY)
    
        def add(self, item):
            """Adds item to self."""
            # Check array memory here and increase it if necessary
            self._items[len(self)] = item
            self._size += 1
    
        def remove(self, item):
            """Precondition: item is in self.
            Raises: KeyError if item in not in self.
            Postcondition: item is removed from self."""
            # Check precondition and raise if necessary
            if not item in self:
                raise KeyError(str(item) + " not in bag")
            # Search for the index of the target item
            targetIndex = 0
            for targetItem in self:
                if targetItem == item:
                    break
                targetIndex += 1
            # Shift items to the left of target up by one position
            for i in range(targetIndex, len(self) - 1):
                self._items[i] = self._items[i + 1]
            # Decrement logical size
            self._size -= 1
            # Check array memory here and decrease it if necessary        

    所有集合的一个抽象类

    如果你查看AbstractBag类的代码,你会发现,几乎所有的方法(包括__init__方法)都运行其他的方法或函数,或者直接访问变量self._size,它们都不会提及包类。除了__str__方法(它使用花括号创建了一个字符串)和__eq__方法(它并不比较给定位置的成对的项)。更好的建议是:将这些方法和数据放到一个更加通用的类中,这样的类叫做AbstractCollection。


    AbstractCollection类负责引入和初始化self._size变量,所有集合类都使用这个变量。AbstractCollection的__init__方法也可以将源集合中的项加入到self。这个类还包含了所有集合可用的最通用的方法:isEmpty、__len__和__add__,这里的“最通用”是指它们的实现不需要由子类来修改。

    最后AbstractCollection还包含了__str__和__eq__方法的默认实现,它们在AbstractBag中的当前形式适合于无序的集合,但是大多数集合类很可能是线性的而不是无序的。因此,这两个方法在AbstractBag中保持不变,但是在AbstractCollection中提供了新的实现。新的__str__方法用方括号来分割字符串,新的__eq__方法比较给定位置成对的项,AbstractCollection的子类仍然能够自由定制__str__和__eq__以满足自己的需要。

    创建AbstractCollection类和AbstractBag类的步骤:

    (1)从之前实现的AbstractBag类中复制代码,然后将该类命名为AbstractCollection类

    (2)通过删除父类中对__init__的调用,修改__init__方法

    (3)修改__str__和__eq__方法以提供合理的默认行为

    (4)从AbstractBag类中删除isEmpty、__len__和__add__方法


    AbstractCollection类
    class AbstractCollection(object):
        """An abstract collection implementation."""
    
        # Constructor
        def __init__(self, sourceCollection = None):
            """Sets the initial state of self, which includes the
            contents of sourceCollection, if it's present."""
            self._size = 0
            if sourceCollection:
                for item in sourceCollection:
                    self.add(item)
    
        # Accessor methods
        def isEmpty(self):
            """Returns True if len(self) == 0, or False otherwise."""
            return len(self) == 0
        
        def __len__(self):
            """Returns the number of items in self."""
            return self._size
    
        def __str__(self):
            """Returns the string representation of self."""
            return "[" + ", ".join(map(str, self)) + "]"
    
        def __add__(self, other):
            """Returns a new bag containing the contents
            of self and other."""
            result = type(self)(self)
            for item in other:
                result.add(item)
            return result
    
        def __eq__(self, other):
            """Returns True if self equals other,
            or False otherwise."""
            if self is other: return True
            if type(self) != type(other) or \
               len(self) != len(other):
                return False
            otherIter = iter(other)
            for item in self:
                if item != next(otherIter):
                    return False
            return True
    

    AbstractBag类
    from abstractcollection import AbstractCollection
    
    class AbstractBag(AbstractCollection):
        """An abstract bag implementation."""
    
        # Constructor
        def __init__(self, sourceCollection = None):
            """Sets the initial state of self, which includes the
            contents of sourceCollection, if it's present."""
            self._size = 0
            AbstractCollection.__init__(self,sourceCollection)
        
    
        def __str__(self):
            """Returns the string representation of self."""
            return "{" + ", ".join(map(str, self)) + "}"
    
    
        def __eq__(self, other):
            """Returns True if self equals other,
            or False otherwise."""
            if self is other: return True
            if type(self) != type(other) or len(self) != len(other):
                return False
            for item in self:
                if not item in other:
                    return False
            return True



    总结

    抽象类充当其它一组类所共有的数据和方法的一个库。如果这些其它的类不是抽象类,它们就叫做具体类。

    抽象类是不能实例化的。

    展开全文
  • Python抽象类与抽象方法

    千次阅读 2017-12-22 13:19:55
    抽象方法 抽象方法表示基类的一个方法... Python的abc提供了@abstractmethod装饰器实现抽象方法,下面以Python3的abc模块举例。 实现In [19]: from abc import ABC, abstractmethodIn [20]: class A(object): ...: '

    抽象方法

    抽象方法表示基类的一个方法,没有实现,所以基类不能实例化,子类实现了该抽象方法才能被实例化。
    Python的abc提供了@abstractmethod装饰器实现抽象方法,下面以Python3的abc模块举例。

    实现

    In [19]: from abc import ABC, abstractmethod
    
    In [20]: class A(object):
        ...:     '''
        ...:     抽象类
        ...:     '''
        ...:     @abstractmethod
        ...:     def fun1(self):
        ...:         pass
        ...:     @abstractmethod
        ...:     def fun2(self):
        ...:         pass
        ...:     
    
    In [21]: a = A()
    
    In [22]: a
    Out[22]: <__main__.A at 0x105cb8198>
    
    In [23]: class B(A):
        ...:     '''
        ...:     继承抽象类
        ...:     '''
        ...:     
        ...:     pass
    
    In [24]: b = B()
    
    In [25]: b
    Out[25]: <__main__.B at 0x105cd1a58>
    • 注意此处抽象方法没有起到作用,因为抽象类没有继承ABC
    In [28]: class A(ABC):
        ...:     '''
        ...:     抽象类
        ...:     '''
        ...:     @abstractmethod
        ...:     def fun1(self):
        ...:         pass
        ...:     @abstractmethod
        ...:     def fun2(self):
        ...:         pass
        ...:     
    
    In [29]: class B(A):
        ...:     pass
        ...: 
    
    In [30]: b = B()
    ---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
    <ipython-input-30-bb7a6e918aa7> in <module>()
    ----> 1 b = B()
    
    TypeError: Can't instantiate abstract class B with abstract methods fun1, fun2
    
    In [31]: class B(A):
        ...:     def fun1(self):
        ...:         print('fun1')
    
    In [32]: b = B()
    ---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
    <ipython-input-32-bb7a6e918aa7> in <module>()
    ----> 1 b = B()
    
    TypeError: Can't instantiate abstract class B with abstract methods fun2
    展开全文
  • Python 抽象类的实现

    2019-08-16 09:56:08
    import abc class AbstractClass(abc.ABC): @abc.abstractmethod def show(self): pass class ChildClass(Abstract... """ AbstractClass是一个抽象类 继承它的子类必须要重写抽象方法 """ def show(se...
  • python抽象类、抽象方法的实现

    千次阅读 2017-12-07 23:58:13
    由于python没有抽象类、接口的概念,所以要实现这种功能得abc.py这个类库,具体方式如下:# coding: utf-8 import abc#抽象类 class StudentBase(object): __metaclass__ = abc.ABCMeta @abc.abstractmethod def ...
  • python 抽象类 定义

    2020-05-11 19:16:32
    python 的abc模块中,提供了ABC,ABCMeta,及abstractmethod,abstractproperty等装饰器 from abc import ABCMeta,abstractmethod,abstractproperty, ABC class People(ABC): @abstractmethod def get(self)...
  • python 抽象类、抽象方法的实现

    千次阅读 2020-10-11 09:51:06
    python 抽象类、抽象方法的实现 抽象基类提供了一种要求子类实现指定协议的方式,如果一个抽象基类要求实现指定的方法,而子类没有实现的话,当试图创建子类或者执行子类代码时会抛出异常。 python 没有抽象类、...
  • Python 抽象类抽象方法

    千次阅读 2017-07-12 10:07:28
    Python3中创建方法from abc import ABCMeta,abstractmethod class Abstract(metaclass=ABCMeta): @abstractmethod def func(self): passclass A(Abstract): def func(self): print("A")class
  • python抽象类(ABC)

    2019-07-15 17:22:26
    抽象类python中的库是abc,它包含的方法有: ABC ABCMeta abstractmethod abstractclassmethod abstractstaticmethod abstractproperty 具体解释可以查看python手册(例子中的code都是基于python3.7...
  • 第7.21节 Python抽象类—register注册虚拟子类

    千次阅读 多人点赞 2019-06-20 18:42:58
    上两节介绍了Python抽象类的真实子类的定义和使用,本节介绍另一种抽象类的实现方法:虚拟子类方法。 一、 相关概念 虚拟子类是将其他的不是从抽象基类派生的类”注册“到抽象基类,让Python解释器将该类作为抽象...
  • 总结python抽象类和抽象方法的写法

    千次阅读 2015-07-11 11:24:09
    本文章主要总结利用abc模块实现的python抽象类和抽象方法的编写。 步骤: 1 导入abc模块 import abc 2 编写抽象类 class class1(object):__metaclass__ = abc.ABCMeta #抽象方法编写@abc.abstractmethoddef method...
  • 今天在看apscheduler源代码中,看到abc.py这个文件,出于好奇,...可以看出这个是是2007年,由Python创始人Guido van Rossum和Talin一起引入的。 引入目的: 重载isinstance()和issubclass()。 增加新模块abc...
  • python 抽象类和接口

    2020-07-07 21:41:45
    可以通过普通实现接口,但是并没有起到规范作用,继承者可以选择实现或不实现 # 普通定义接口 # class Animal(object): # def say(self): # pass # def eat(self): # pass 通过abc模块来创建,类似于java中的...
  • python抽象类与接口类的区别

    千次阅读 2019-08-05 10:16:17
    # 接口类只规定子类要实现哪些方法 ...Python 原生仅支持抽象类,不支持接口类 # 接口类 class Api(metaclass=ABCMeta): @abstractmethod def get(self): print("33333") @abstractmethod def post(self): ...
  • 第7.20节 案例详解:Python抽象类之真实子类.pdf
  • 第7.20节 案例详解:Python抽象类之真实子类

    千次阅读 多人点赞 2019-06-19 18:45:38
    第7.20节 案例详解:Python抽象类之真实子类 上节介绍了Python抽象基类相关概念,并介绍了抽象基类实现真实子类的步骤和语法,本节结合一个案例进一步详细介绍。 一、 案例说明 本节定义了图形的抽象基类Shape,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 111,031
精华内容 44,412
关键字:

python抽象类的作用

python 订阅