精华内容
下载资源
问答
  • python抽象基类abc模块

    2019-12-06 16:43:57
    什么有抽象类,This is a good question。 抽象类的作用可以在不同的模块相互调用时使用,可以最精简的方式展示出代码之间的逻辑关系,让模块之间的依赖关系更清晰。可以让开发者不用考虑过多的实现细节,只...

    为什么要有抽象类,This is a good question。

    抽象类的作用可以在不同的模块相互调用时使用,可以用最精简的方式展示出代码之间的逻辑关系,让模块之间的依赖关系更清晰。可以让开发者不用考虑过多的实现细节,只关注当前抽象类的放方法和描述。方便多人合作开发,让代码可读性更高。

    python中的抽象基类封装在abc模块中,使用six包可以兼容python2和python3,使用方法如下:

    # -*- coding: utf-8 -*-
    import abc
    import six
    
    
    @six.add_metaclass(abc.ABCMeta)
    class A(object):
        @abc.abstractmethod
        def func(self):
            pass
    
    
    class B(A):
        def func(self):
            pass
    
    
    class C(A):
        pass
    
    
    if __name__ == "__main__":
        b = B()
        c = C()

    运行结果:

    Traceback (most recent call last):
      File "/Users/m/data/script/aaa.py", line 24, in <module>
        c = C()
    TypeError: Can't instantiate abstract class C with abstract methods greet

    对A中的func方法加了@abc.abstractmethod装饰器后,其子类中必须重写这个方法,否则会异常。

    实例化B的时候不会报错,因为B重写了所继承的A中的func方法,而C中没有重写func方法,所以会异常

    展开全文
  • Python面向对象之接口类(抽象类

    千次阅读 2018-08-09 08:31:27
    Python面向对象之接口类(抽象类):就是制定一个规范。 比如定义了一个接口类(抽象类)(他们是不可以进行实例化的,这就是他为什么是制定一个规范的原因)。 他的定义是需要abc模块,要变的就是他的方法,比如...

    Python面向对象之接口类(抽象类):就是制定一个规范。

    比如定义了一个接口类(抽象类)(他们是不可以进行实例化的,这就是他为什么是制定一个规范的原因)。
    他的定义是需要abc模块,要变的就是他的方法,比如下面的pay方法,
    定义好一个抽象类(接口类)Payment,他用装饰器@abstractmethod将pay方法装饰
    这样,其他类如果都继承了Payment方法,其他类中就都需要有一个pay方法,如果没有就会报错。

    就好比,起初我没有微信支付类,但是如果后续项目需要加微信支付此功能,支付的方法我可以起各种名字。
    但是为了统一支付接口,我们继承抽象类Payment后,我们的支付接口名就必须用pay.

    这就是接口类(抽象类的用途)

    from abc import ABCMeta, abstractmethod

    class Payment(metaclass=ABCMeta): # 抽象类(接口类)
    @abstractmethod
    def pay(self): # 制定一个规范
    pass

    class Alipay(Payment):
    def init(self, money):
    self.money = money

    def pay(self):
        print('使用支付宝花了%s钱' % (self.money,))
    

    class Jdpay(Payment):
    def init(self, money):
    self.money = money

    def pay(self):
        print('使用京东支付了%s钱' % (self.money,))
    

    class Wechatpay(Payment):
    def init(self, money):
    self.money = money

    def pay(self):
        print('使用微信支付了%s钱' % (self.money,))
    

    w1 = Wechatpay(200)
    a1 = Alipay(150)
    j1 = Jdpay(100)
    w1.pay()
    a1.pay()
    j1.pay()
    这里写图片描述

    展开全文
  • 的好处主要 方便复用(如果你函数写,就要复制整块代码,增加了代码量,增加了出错率)方便扩展(函数写段代码,若要升级、扩展,都十分复杂,容易出错,用类来扩展,则方便清晰)方便维护(因为是把抽象的...

    1. 类、对象在实际编程中有啥好处,为啥要用它们
    2. 再给你解释怎么去理解它们

    1.类的好处主要有

    • 方便复用(如果你用函数写,就要复制整块代码,增加了代码量,增加了出错率)
    • 方便扩展(函数写段代码,若要升级、扩展,都十分复杂,容易出错,用类来扩展,则方便清晰)
    • 方便维护(因为类是把抽象的东西映射成我们常见的,摸得到的东西,容易理解,维护也方便)

    举几个例子:

    比如你是玩具厂的工程师,你要制作一个机器,可以批量制作鸭子形状的玩具,也许你的思路如下:

    def makeDuckMoth():
        #这里可以放其他制作细节
        print('鸭子嘴巴制作完毕')
    
    def makeDuckEar():
        #这里可以放其他制作细节
        print('鸭耳朵制作完毕')
    
    def makeDuckEye():
        #这里可以放其他制作细节
        print('鸭眼睛制作完毕')
    
    def makeDuckHead():
        #这里可以放其他制作细节
        print('鸭头制作完毕')
    
    def makeDuckWing():
        #这里可以放其他制作细节
        print('鸭翅膀制作完毕')
    
    def makeDuckBody():
        #这里可以放其他制作细节
        print('鸭身体制作完毕')
    
    def makeDuckFoot():
        #这里可以放其他制作细节
        print('鸭脚制作完毕')
    
    def makeDuckMerge():
        #这里可以放其他制作细节
        print('鸭子组装完毕')
    
    makeDuckMoth() #制作鸭嘴巴
    makeDuckEar() #制作鸭耳朵
    makeDuckEye() #制作鸭眼睛
    makeDuckHead() #制作鸭头
    makeDuckWing()  #制作鸭翅膀,注意,猪是没有翅膀的
    makeDuckBody() #制作鸭身体
    makeDuckFoot() #制作鸭脚
    makeDuckMerge() #合并鸭子的各个部位,组装成最终鸭子
    

    第二天,老板让你,制作猪形状的玩具,难道你的代码如下:

    def makePigMoth():
        #这里可以放其他制作细节
        print('猪嘴巴制作完毕')
    
    def makePigEar():
    #这里可以放其他制作细节
    print(‘猪耳朵制作完毕’)
    
    def makePigEye():
    #这里可以放其他制作细节
    print(‘猪眼睛制作完毕’)
    
    def makePigHead():
    #这里可以放其他制作细节
    print(‘猪头制作完毕’)
    
    def makePigBody():
    #这里可以放其他制作细节
    print(‘猪身体制作完毕’)
    
    def makePigHand():
    #这里可以放其他制作细节
    print(‘猪手制作完毕’)
    
    def makePigFoot():
    #这里可以放其他制作细节
    print(‘4只猪脚制作完毕’)
    
    def makePigMerge():
    #这里可以放其他制作细节
    print(‘猪组装完毕’)
    
    makePigMoth() #制作猪嘴巴
    makePigEar() #制作猪耳朵
    makePigEye() #制作猪眼睛
    makePigHead() #制作猪头
    makePigBody() #制作猪身体
    makePigFoot() #制作4只猪脚
    makePigMerge() #合并猪的各个部位,组装成最终猪
    

    这样来,你确实完成了工作,但有没有觉得 有点累?

    是不是觉得,猪和鸭子有很多相似之处?

    如果你学会了,类的用法,可以非常轻松,下面是类的用法


    类就像是基因的制造图纸,我们人类,生的小孩,也是两只手,两只脚,一个嘴巴,除非变异,否则不会多出一只脚的,之所以这样有序的发展,是因为我们身体里,有基因这张图纸控制着我们的繁衍


    现在我们给上面例子中的制作鸭子、猪建立一个通用的制作基因表,利用他们相似制作流程 建立基因表

    class Animal(object):
        '''
        猪和鸭子的基类(基因图纸表)
        '''
        def __init__(self, name): # 实例化的时候传入要制作的东西名字,如猪、鸭子
            self.name = name 
        def makeMoth(self):
            #这里可以放其他制作细节  
            print(self.name+'的嘴巴 制作完毕') #这里的self.name就是获取我们传入的name
    
        def makeEar(self):
            #这里可以放其他制作细节  
            print(self.name+'的耳朵 制作完毕') 
    
        def makeEye(self):
            #这里可以放其他制作细节  
            print(self.name+'的眼睛 制作完毕') 
    
        def makeHead(self):
            #这里可以放其他制作细节  
            print(self.name+'的头 制作完毕') 
    
        def makeBody(self):
            #这里可以放其他制作细节  
            print(self.name+'的身体 制作完毕') 
    
        def makeFoot(self):
            #这里可以放其他制作细节  
            print(self.name+'的脚 制作完毕') 
    
        def makeMerge(self):
            #这里可以放其他制作细节  
            print(self.name+'合并完毕') 
    
        def makeAll(self): 
            # 一条龙。直接跑完整个流水线
            self.makeMoth()
            self.makeEar()
            self.makeEye()
            self.makeHead()
            self.makeBody()
            self.makeFoot()
            self.makeMerge()
    
    

    可以看到,上面的图纸里,我们没有放 makeWing() #制作翅膀,那是因为猪不会飞,我们只放猪和鸭子共有的、相同的东西

    接下来,用这个类,继承给Pig,代码如下

    class Pig(Animal):  # 括号里写Animal,意思是Pig继承Animal的所有特性,类似你继承你老爸的基因
        def makeMoth(self):
            #这里加详细的猪嘴巴制作流程,如长嘴巴,有两个孔  
            print(self.name+'的嘴巴 制作完毕') 
    
        def makeEar(self):
            #耳朵大大的
            print(self.name+'的耳朵 制作完毕') 
    
        def makeEye(self):
            #眼睛小小的 
            print(self.name+'的眼睛 制作完毕') 
    
        def makeHead(self):
            #很大的头 
            print(self.name+'的头 制作完毕') 
    
        def makeBody(self):
            #略 
            print(self.name+'的身体 制作完毕') 
    
        def makeFoot(self):
            #略  
            print(self.name+'的脚 制作完毕') 
    
        def makeMerge(self):
            #略  
            print(self.name+'合并完毕')
    

    在class Pig中,如 makeMoth里面,只加入详细制作猪嘴巴的代码,不要把制作猪头的代码放这里哦

    你发现,class Pig中 没有了这2段代码,这是因为,如果你继承别的对象,如Animal后,若完全不修改某些方法属性,就可以不写出来(实际还是存在Pig中的)

    def __init__(self, name):
            self.name = name 
    
        def makeAll(self): 
            # 一条龙。直接跑完整个流水线
            self.makeMoth()
            self.makeEar()
            self.makeEye()
            self.makeHead()
            self.makeBody()
            self.makeFoot()
            self.makeMerge()
    

    写出来意味着,你要覆盖以前代码块里的行为,如 我们写出了makeMoth,makeEar ...

    意味着我们要把makeMoth里的制作细节改成我们想要的,

    猪和鸭子的嘴巴长得不一样,制作细节肯定不同,对吧?


    最后我们用以下代码,让机器开始造猪

    pig1 = Pig('猪')  #实例化,相当于怀孕
    pig1.makeAll()  # 开始造猪,相当于在子宫里形成整体
    

    现在开始造鸭子的图纸,继承Animal,覆盖某些代码

    class Duck(Animal):  # 
        def makeMoth(self):
            #这里加详细的鸭子嘴巴制作流程,如长嘴巴,嘴巴硬 
            print(self.name+'的嘴巴 制作完毕') 
    
        def makeEar(self):
            #耳朵很小
            print(self.name+'的耳朵 制作完毕') 
    
        def makeEye(self):
            #眼睛小小的 
            print(self.name+'的眼睛 制作完毕') 
    
        def makeHead(self):
            #头很小 
            print(self.name+'的头 制作完毕') 
    
        def makeBody(self):
            #略 
            print(self.name+'的身体 制作完毕') 
    
        def makeFoot(self):
            #略  
            print(self.name+'的脚 制作完毕')     
    
        def makeMerge(self):
            #略  
            print(self.name+'合并完毕') 
    
        def makeWing(self): #增加翅膀的制作流程
            #略  
            print(self.name+'的翅膀 制作完毕') 
    
        def makeAll(self): #因为增加了翅膀,所以要覆写这个函数      
            self.makeMoth()
            self.makeEar()
            self.makeEye()
            self.makeHead()
            self.makeBody()
            self.makeFoot()
            self.makeWing()  #插入翅膀制作流程
            self.makeMerge()
    

    然后用以下代码实例化,开始做鸭子

    duck1 = Duck('鸭子')
    duck1.makeAll()
    

    以后我们要狗、牛、企鹅,都可以从Animal继承, Animal给我们提供了一个框架,我们只需要在这个框架上,扩展,延伸 就可以很方便的做出任何东西,这就是类的魅力


    如果你要做个别的咋办?

    可以建立一个 足够通用基类,慢慢扩展, 类似人类的老祖宗,最开始是微生物,后来是猴子

    class Weishengwu(object):
        '''假设一开始的老祖宗只会吃东西'''
        def __init__(self, name): 
            self.name = name 
        def eat(self):
            print('吃东西')
    
    #开始进化成鱼类
    
    class Fish(Weishengwu):
        '''在老祖宗只会吃的基础上,学会了移动'''
        def move(self):
            print('移动')
    
    
    #开始进化成猴子
    
    class Houzi(Fish):
        '''在鱼的基础上学会了爬树'''
        def __init__(self, name, love):  # 以前只有名字,现在有了爱好,或许是吃桃子、或许是荡秋千
            self.name = name 
            self.love = love 
        def eat(self):
            #覆写,因为吃东西的方式可能和鱼类不一样了
            print('牙齿吃东西')
    
        def move(self):
            #覆写,不是在水里移动了,是陆地上移动
            print('脚移动')
    
        def Pashu(self):
            print('爬树')
    
    #你可以继续进化,继续给他增加任何功能
    

    希望可以帮到你

    展开全文
  • 1,内容回顾 # 继承 : 什么什么的关系 ... # 如果子类自己,一定是先自己的 # 在中使用self的时候,一定要看清楚self指向谁 # 多继承 *** # 新式和经典: # 多继承寻找名字的...

    1,内容回顾

    # 继承 : 什么是什么的关系
    # 单继承 *****
        # 先抽象再继承,几个类之间的相同代码抽象出来,成为父类
        # 子类自己没有的名字,就可以使用父类的方法和属性
        # 如果子类自己有,一定是先用自己的
        # 在类中使用self的时候,一定要看清楚self指向谁
    # 多继承 ***
        # 新式类和经典类:
            # 多继承寻找名字的顺序 : 新式类广度优先,经典类深度优先
            # 新式类中 有一个类名.mro方法,查看广度优先的继承顺序
            # python3中 有一个super方法,根据广度优先的继承顺序查找上一个类
    
    
    

    2,接口类

    # java : 面向对象编程
    # 设计模式   —— 接口
    # 接口类 : python原生不支持
    # 抽象类 : python原生支持的
    from abc import abstractmethod,ABCMeta
    class Payment(metaclass=ABCMeta):  # 元类 默认的元类 type
        @abstractmethod
        def pay(self,money):pass   # 没有实现这个方法
    # 规范 :接口类或者抽象类都可以
    # 接口类 支持多继承,接口类中的所有的方法都必须不能实现 —— java
    # 抽象类 不支持多继承,抽象类中方法可以有一些代码的实现 —— java
    class Wechat(Payment):
        def pay(self,money):
            print('已经用微信支付了%s元'%money)
    
    class Alipay(Payment):
        def pay(self,money):
            print('已经用支付宝支付了%s元' % money)
    
    class Applepay(Payment):
        def pay(self,money):
            print('已经用applepay支付了%s元' % money)
    
    def pay(pay_obj,money):  # 统一支付入口
        pay_obj.pay(money)
    
    # wechat = Wechat()
    # ali = Alipay()
    app = Applepay()
    # wechat.pay(100)
    # ali.pay(200)
    p = Payment()

    3,接口类多继承

    
    
    
    # tiger 走路 游泳
    # swan 走路 游泳 飞
    # oldying 走路 飞
    from abc import abstractmethod,ABCMeta
    class Swim_Animal(metaclass=ABCMeta):
        @abstractmethod
        def swim(self):pass
    
    class Walk_Animal(metaclass=ABCMeta):
        @abstractmethod
        def walk(self):pass
    
    class Fly_Animal(metaclass=ABCMeta):
        @abstractmethod
        def fly(self):pass
    
    class Tiger(Walk_Animal,Swim_Animal):
        def walk(self):
            pass
        def swim(self):
            pass
    class OldYing(Fly_Animal,Walk_Animal):pass
    class Swan(Swim_Animal,Walk_Animal,Fly_Animal):pass
    
    # 接口类  刚好满足接口隔离原则 面向对象开发的思想 规范
    
    

    4,抽象类

    # 抽象类 : 规范
    # 一般情况下 单继承 能实现的功能都是一样的,所以在父类中可以有一些简单的基础实现
    # 多继承的情况 由于功能比较复杂,所以不容易抽象出相同的功能的具体实现写在父类中
    
    
    # 抽象类还是接口类 : 面向对象的开发规范 所有的接口类和抽象类都不能实例化
    # java :
    # java里的所有类的继承都是单继承,所以抽象类完美的解决了单继承需求中的规范问题
    # 但对于多继承的需求,由于java本身语法的不支持,所以创建了接口Interface这个概念来解决多继承的规范问题
    
    # python
    # python中没有接口类  :
      #  python中自带多继承 所以我们直接用class来实现了接口类
    # python中支持抽象类  : 一般情况下 单继承  不能实例化
      #  且可以实现python代码
    #一切皆文件
    import abc #利用abc模块实现抽象类
    
    class All_file(metaclass=abc.ABCMeta):
        all_type='file'
        @abc.abstractmethod #定义抽象方法,无需实现功能
        def read(self):
            '子类必须定义读功能'
            with open('filaname') as f:
                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)

    5,多态

    # 多态 python 天生支持多态
    # def func(int num,str name):
    #     pass
    #
    # func('alex',2)
    # class Payment:pass
    
    # class Alipay():
    #     def pay(self,money):
    #         print('已经用支付宝支付了%s元' % money)
    #
    # class Applepay():
    #     def pay(self,money):
    #         print('已经用applepay支付了%s元' % money)
    #
    # def pay(pay_obj,money):  # 统一支付入口  归一化设计
    #     pay_obj.pay(money)
    #
    # pay()
    
    # 什么是多态
    # python 动态强类型的语言
    # 鸭子类型
    # list tuple
    # 不崇尚根据继承所得来的相似
    # 我只是自己实现我自己的代码就可以了。
    # 如果两个类刚好相似,并不产生父类的子类的兄弟关系,而是鸭子类型
    # list tuple 这种相似,是自己写代码的时候约束的,而不是通过父类约束的
    # 优点 : 松耦合 每个相似的类之间都没有影响
    # 缺点 : 太随意了,只能靠自觉
    
    # class List():
    #     def __len__(self):pass
    # class Tuple():
    #     def __len__(self):pass
    #
    # def len(obj):
    #     return obj.__len__()
    #
    # l = Tuple()
    # len(l)
    #
    # # 强类型语言     多态
    # # python 语言    鸭子类型
    
    
    # 接口类和抽象类 在python当中的应用点并不是非常必要
    
    

    6,封装

    # 广义上面向对象的封装 :代码的保护,面向对象的思想本身就是一种
    # 只让自己的对象能调用自己类中的方法
    
    # 狭义上的封装 —— 面向对象的三大特性之一
    # 属性 和 方法都藏起来 不让你看见
    class Person:
        __key = 123  # 私有静态属性
        def __init__(self,name,passwd):
            self.name = name
            self.__passwd = passwd   # 私有属性
    
        def __get_pwd(self):         # 私有方法
            return self.__passwd   #只要在类的内部使用私有属性,就会自动的带上_类名
    
        def login(self):          # 正常的方法调用私有的方法
            self.__get_pwd()
    
    alex = Person('alex','alex3714')
    print(alex._Person__passwd)   # _类名__属性名
    print(alex.get_pwd())
    
    # 所有的私有 都是在变量的左边加上双下划綫
        # 对象的私有属性
        # 类中的私有方法
        # 类中的静态私有属性
    # 所有的私有的 都不能在类的外部使用
    
    # 昨天的复习和博客
    # 今天的作业、复习
    # 预习封装的内容
    
    
    
    展开全文
  • Python中的(Class)是一个抽象的概念,比函数还要抽象,这也就是Python的核心概念,面对对象的编程方法(OOP),其它如:Java、C++等都是面对对象的编程语言。面对对象(oop)中的对象,是一个非常重要的知识点,我们...
  • Python学习之

    2018-11-14 17:38:24
    什么有类:在面向对象编程中,你要通过来创建对象。通过你可以对对象进行定义抽象的属性和行为。比如对象是狗狗,你就可以通过来定义狗狗的名字,颜色,动作等等,将狗狗具体化。用类创建对象叫做实例化,...
  • python3:抽象基类(abc模块)

    千次阅读 2018-10-18 22:57:22
    疑问: 已经了鸭子类型 和多态 ,为什么还要这个呢? 答: 为了 解决两个事情 1. 调用抽象类,检查子类对象类型, 实现返回true* ** 请看以下代码: from collections.abc import Sized class P...
  • 对象 = 属性(变量)+ 方法(函数) 和对象是什么关系呢? solution:和对象的关系就...函数和方法有什么区别呢? solution: 方法和函数其实几乎完全一样,但有一点区别是方法默认有一个 self 参数,这个参数的作
  • 06-Python类与对象

    2020-06-03 16:52:20
    什么 百度百科: 是对象的抽象,对象是对客观事物的抽象通俗的话来说: 是类别的意思,是数据类型。 对象是类别下的具体事物。 也就是说: 是数据类型,对象是变量。 比如: 自定义一种数据...
  • **python 面向对象的三大特征之一:...Python没有多态,因为它处处是多态,它有什么?它有鸭子类型。 鸭子类型:看着像鸭子,他就是鸭子 解释:多个之间有相似的方法,使用类似,他们互称为鸭子 广义的封装...
  • oblong’是一个str对象,异常也是一个对象,抽象一点是,人,猫,够也是一个对象那对于一个对象,它就包括两方面的特征:属性:去描述它的特征方法: 它所具有的行为所以,对象=属性+方法 (其实方法也是一种属性...
  • 目录封装为什么要封装封装方法封装例子封装特性面向对象的封装三种形式:继承什么是继承为什么要继承如何继承单继承多继承新式、经典继承与抽象派生组合属性查找顺序重写子类中访问父类的内容子类初始化...
  • 什么mixin 面向对象编程特点中的一个就是继承性,mixin是多重继承,难道是继承的时候多写了两个就是mixin了么? 先说结论,mixin指在继承原始的功能下,把附加的不好抽象到父类的功能,写个新出来继承,...
  • 那么什么类型? 所有的的类型都是type type 是所有类型的鼻祖 type( 类名 ) = type 也是被创造出来的 可以由python解释器创造 也可以由特殊的方法创造 常规创造的 总是几个特性 能够实例化 能...
  • 首先,是一个集合,包含了数据,操作描述的一个抽象集合 你可以首先只把当做一个容器来使用 class Cycle: def __init__(self,r): self.pi=3.14 self.r=r a=Cycle(4) b=Cycle(7) 你看,我们定义了一个 Cycle ...
  • 面向对象最重要的概念就是(class)和实例(instance),抽象的模板,比如学生这个抽象的事物,可以一个Student来表示。而实例是根据创建出来的一个个具体的“对象”,每一个对象都从中继承相同的...
  • Python中Class与def函数的区别

    万次阅读 2019-07-17 18:16:34
    自己在编程过程中习惯函数def来封装模块,但是换了环境后发现同事大多采用class实现封装,两者之间有什么区别与优劣呢? Class与Instance Class是一个抽象概念,Instance是一个个具体的实现。 Class与Instance是...
  • —总体来说面向对象的底层还是面向过程,面向过程抽象,然后封装,方便使用就是面向对象,(万物皆对象) 2、什么: —是有着相同或者相近特征的事物的统称 —比如狗这一什么是狗,不知道,很难描述,...
  • 首先我是辣鸡,然后这个问题的确有点意思首先,是一个集合,包含了数据,操作描述的一个抽象集合你可以首先只把当做一个容器来使用class Cycle:def __init__(self,r):self.pi=3.14self.r=ra=Cycle(4)b=Cycle(7)...
  • :同一的事物,是个抽象的概念(属性、方法) 对象:符合描述的具体存在的 例如把电脑当做是一个,然后你现在所使用的具体存在的电脑就是对象。 为什么要封装?举个例子,ATM机是一个取钱、存钱,...
  • python中的接口

    2019-10-03 15:34:56
    接口只是定义了一些方法,而没有去实现,多用于程序设计时,只是设计需要有什么样的功能,但是并没有实现任何功能,这些功能需要被另一个(B)继承后,由 B去实现其中的某个功能或全部功能。 在python中接口由...
  • 什么时候接口类和抽象类 当几个子类的父类,相同的功能需要被实现时,就用抽象类 当几个子类相同的功能,但是实现各不相同的时候,使用接口类 什么是接口类 (在python里默认是没有的) 约束...
  • python中怎么表示空值

    2021-01-19 23:55:30
    首先了解python对象的概念 python中,万物皆对象,所有的操作都是针对对象的。 那什么是对象?5是一个int对象,‘oblong’...是对象的抽象化,对象是的实例化。不代表具体的事物,而对象表示具体的事物 也是
  • Python面向对象基础

    千次阅读 2021-02-23 11:44:04
    和对象的关系:用类去创建一个对象。 2.1 理解和对象 2.1.1 是对一系列具有相同特征和行为的事物的统称,是一个抽象的概念,不是真实存在的事物。 特征即是属性 行为即是方法 比如是制造洗衣
  • http://hi.baidu.com/python811022/blog/item/613a7b8d4369b116b31bba39.html<br />  ,多态可以分为变量的多态,方法的多态,的...按照OO的思想,我们会抽象出来一个,表示捷达汽车,其中个run()方法<br
  • 抽象一点是,人,猫,够也是一个对象那对于一个对象,它就包括两方面的特征:属性:去描述它的特征方法: 它所具有的行为所以,对象=属性+方法 (其实方法也是一种属性,一种区别于数据属性的可调属性):...
  • 前文导读 Python面向对象之继承(02) ...多态是指一种事物的多种形态,一个抽象类有多个子类,因而多态的概念依赖于继承。 1#多态:同一种事物的多种形态,动物分为人类,猪类(在定义角度) 2class A...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 140
精华内容 56
关键字:

python抽象类有什么用

python 订阅