Python之面向对象(四)类的约束与super()深入了解

6.6 类的约束

  1. 首先,你要清楚,约束是对类的约束,什么叫抽象类?从小到大的过程叫做抽象
  2. 接口类:(在抽象类的基础上)在python中,默认是没有接口类的,接口类不能被实例化(如果实例化会报错),接口类中的方法不能被实现
    • 例子:
    • #正常调用
      class Applepay:
          def pay(self,money):
             print('apple pay 支付了%s'%money)
      class Alipay:
          def pay(self,money):
              print('支付宝 支付了%s'%money)
      def payment(pay_obj,money):#实例化另外一种调用,这个方法让实例化的时候按照pyment调用就像下面的payment(apple1,200)
          pay_obj.pay(money)
      apple1=Applepay()
      Payment(apple1,200)
    • 有时候写的时候会把方法写错,自己定义一个主动报错;接口初成:手动报异常:NotImplementedError来解决开发中遇到的问题
    • 例子:
    • class Payment:
          def pay(self):
              raise NotImplementedError#主动让程序报错
      class Wechatpay(Payment):#微信支付
         def pay(self,money):
              print('微信支付了%s元'%money)
      class QQchatpay(Payment):#QQ支付
          def fuqian(self,money):
              print('QQ支付了%s元')
      p=Wechatpay()
      p.pay(200)#不报错
      q=QQchatpay()#不报错
      q.pay()#报错,查询子类没有该方法,则查找父类,执行父类的方法,然后报错
    • 借用abc模块来实现接口;接口类(就是为了提供标准,约束后面的子类)
    • 例子:
    • # 3.借用abc模块来实现接口
      #接口类(就是为了提供标准,约束后面的子类)
      from abc import ABCMeta,abstractmethod
      class Payment(metaclass=ABCMeta):
          @abstractmethod
          def pay(self,money):
              pass
      
      class Wechatpay(Payment):
          def fuqian(self,money):
              '''实现了pay的功能,但是方法名字不一样'''
              print('微信支付了%s元'%money)
      
      class Alipay:
          def pay(self,money):
              print('支付宝  支付了%s' %money)
      
      # p = Wechatpay() #报错了(因为上面定义了一个接口类,接口类里面
      # 定义了一个pay方法,而在下面的Wechatpay方法里没有pay方法,不能
      # 调用,在接口类里面约束一下,接口类里的pay方法里面不能写其他,直接pass)
      a = Alipay()
      a.pay(200)
      p = Payment() #接口类不能被实例化
      
      #借用abc模块来实现接口
    • 为何要使用接口:接口提取了一群类共同的函数,可以把接口当做一个函数的集合。

      然后让子类去实现接口中的函数。这么做的意义在于归一化,什么叫归一化,就是只要是基于同一个接口实现的类,那么所有的这些类产生的对象在使用时,从用法上来说都一样。

      归一化,让使用者无需关心对象的类是什么,只需要的知道这些对象都具备某些功能就可以了,这极大地降低了使用者的使用难度。比如:我们定义一个动物接口,接口里定义了有跑、吃、呼吸等接口函数,这样老鼠的类去实现了该接口,松鼠的类也去实现了该接口,由二者分别产生一只老鼠和一只松鼠送到你面前,即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑,都会吃,都能呼吸。再比如:我们有一个汽车接口,里面定义了汽车所有的功能,然后由本田汽车的类,奥迪汽车的类,大众汽车的类,他们都实现了汽车接口,这样就好办了,大家只需要学会了怎么开汽车,那么无论是本田,还是奥迪,还是大众我们都会开了,开的时候根本无需关心我开的是哪一类车,操作手法(函数调用)都一样

    • 继承的第二种含义非常重要,它又叫做接口继承
    • 接口继承实质上是要求“做出一个良好的抽象,这个抽象规定了一个兼容接口,使得外部调用者无需关心具体细节,可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上,叫做归一化。
    • 抽象类:在python中,默认是有的,父类的方法,子类必须实现,抽象类(父类)的方法可以被实现
    • 总结:约束. 其实就是?类对?类进?约束. ?类必须要写xxx?法. 在python中约束的?式和?法有两种:
      1. 使?抽象类和抽象?法, 由于该?案来源是java和c#. 所以使?频率还是很少的
      2. 使??为抛出异常的?案. 并且尽量抛出的是NotImplementError. 这样比较专业, ?且错误比较明确.(推荐)

6.6 super()深入了解

  1. class A:
        def f1(self):
            print('in A f1')
    
        def f2(self):
            print('in A f2')
    
    class Foo(A):
        def f1(self):
            super().f2()
            print('in A Foo')
    
    obj = Foo()#实例化对象obj 将obj对象地址赋值给object init方法中self中
    obj.f1()#调用子类中的f1方法 遇到super 执行父类中的f2方法 执行完之后继续执行子类f1方法
    #结果为:'in A f2' 'in A Foo'
  2. class A:
        def f1(self):
            print('in A')
    
    class Foo(A):
        def f1(self):
            super(Foo,self).f1()#2 按照mro算法 执行bar类
            print('in Foo')#4 输出
    
    class Bar(A):
        def f1(self):
            print('in Bar')#3输出
    
    class Info(Foo,Bar):
        def f1(self):
            super(Info,self).f1()#1 执行父类 Foo
            print('in Info f1')#5输出
    
    obj = Info()#实例化对象obj,基于Info创建一个对象内存地址赋值给obj
    obj.f1()#执行f1方法 针对多继承 继承顺序采用 mro(c3)算法,先执行Foo
    print(Info.mro)# [<class '__main__.Info'>, <class '__main__.Foo'>, <class '__main__.Bar'>, <class '__main__.A'>, <class 'object'>]
    #结果为:'in Bar''in Foo''in Info f1'
  3. class A:
        def f1(self):
            print('in A')
    
    class Foo(A):
        def f1(self):
            super().f1()
            print('in Foo')
    
    class Bar(A):
        def f1(self):#3
            print('in Bar')#4 输出
    
    class Info(Foo,Bar):
        def f1(self):#1
            super(Foo,self).f1()#2 多继承按照c3算法 Foo下一个是bar 执行bar类
            print('in Info f1')#5 输出
    
    obj = Info()#对象实例化,obj对象地址赋值给object类中init 方法中self参数
    obj.f1()#执行f1函数 现在子类查找(Info)
    #结果为 'in Bar' 'in Info f1'

原文地址:https://www.cnblogs.com/zhangdadayou/p/11415357.html

时间: 2024-11-05 11:42:35

Python之面向对象(四)类的约束与super()深入了解的相关文章

Python之面向对象与类

本节内容 面向对象的概念 类的封装 类的继承 类的多态 静态方法.类方法 和 属性方法 类的特殊成员方法 继承层级关系中子类的实例对象对属性的查找顺序问题 一.面向对象的概念 1. "面向对象(OOP)"是什么? 简单点说,"面向对象"是一种编程范式,而编程范式是按照不同的编程特点总结出来的编程方式.俗话说,条条大路通罗马,也就说我们使用不同的方法都可以达到最终的目的,但是有些办法比较快速.安全且效果好,有些方法则效率低下且效果不尽人意.同样,编程也是为了解决问题,

python开发面向对象思想--类关联

为了关联各个属性.使用了uuid 工号属性.每个对象都有唯一的属性.另外为了保证对象唯一.我给每个对象的属性都做了hash生成了唯一的属性.hash过程中发现不能hash对象.hash只能hash不可变对象.其次取出对象使用了类静态方法,这样可以一次取出所有的对象,然后用户选择的时候再把uuid存储到对应的关联属性中.如果要查询uuid对应的对象是谁可以通过uuid去打开对应的文件.然后既可以获取到对应的对象了.遮样所有的对象都可以关联起来了. #!/usr/bin/env python#-*-

Python之面向对象:类的内置方法

1.def __add__(self,other): c1+c2 两个实例的加法操作就是执行__add__()方法 2.__str__(self): print一个实例的时候,执行的是__str__()这个内置方法 eg: class Vector(object): def __init__(self,a,b): self.a = a self.b = b def __str__(self): return 'Vector(%d,%d)'%(self.a,self.b) def __add__(

【Python】[面向对象编程] 类和实例

1.注:必须牢记类是抽象的模板,而实例是根据类创建出来的一个个具体的“对象”2.定义类通过class 关键字:class 后面跟着类名,类名通常都是大写开头,接着是(object),表示类是从哪里继承俩的,所有类都继承 自object. class Student(object): pass 3.通过定义一个特殊的__init__方法,在创建实例的时候,就把name,score等属性绑上去: class Student(object): def __init__(self, name, scor

Python基础20_类的约束,异常处理,MD5加密,日志

一. 类的约束 约束程序的结构, 在分配任务之前就应该把功能定义好, 然后分别交给底下的程序员来完成相应的功能 在python中有两种办法来解决这样的问题 1. 提取父类, 然后在父类中定义好方法, 在方法中抛出一个异常, 这样所有继承父类的子类都必须重写这个方法, 否则访问的时候就会报错 class Base: def login(self): raise NotImplementedError   # 没有被实现错误, 要求子类必须重写login方法 , 不然抛出异常 class User(

面向对象之:封装,多态,以及类的约束

1.封装 把很多数据封装到?个对象中. 把固定功能的代码封装到?个代码块, 函数, 对象, 打包成模块. 这都属于封装的思想. 具体的情况具体分析. 比如. 你写了?个很?B的函数. 那这个也可以被称为封装. 在?向对象思想中. 是把?些看似?关紧要的内容组合到?起统?进?存储和使?. 这就是封装. 顾名思义就是将内容封装到某个地方,以后再去调用被封装的内容 封装的步骤 将内容封装到某处 class A: def __init__(self,name): self.name=name self.

22.python中的面向对象和类的基本语法

当我发现要写python的面向对象的时候,我是踌躇满面,坐立不安呀.我一直在想:这个坑应该怎么爬?因为python中关于面向对象的内容很多,如果要讲透,最好是用面向对象的思想重新学一遍前面的内容.这个坑是如此之大,犹豫再三,还是只捡一下重要的内容来讲吧,不足的内容只能靠大家自己去补充了. 惯例声明一下,我使用的版本是 python2.7,版本之间可能存在差异. 好,在开讲之前,我们先思考一个问题,看代码: 为什么我只创建是为 a 赋值,就可以使用一些我没写过的方法? 可能会有小伙伴说:因为 a

Python面向对象02/类的空间问题

Python面向对象02/类的空间问题 内容大纲 1.从空间角度研究类 2..类与类之间的关系 1.类的空间问题 1.1何处可以添加对象属性 在类的__init__可以添加,在类的方法也可以添加,在类的外部也可以添加 # class Human: # # mind = '有思想的' # # def __init__(self, name, age): # self.name = name # self.age = age # # def eat(self,argv): # # self.hobb

面向对象的三大特性 鸭子类型 类的约束 super的深度剖析

1.三大特性 封装 ? 把很多数据封装到?个对象中. 把固定功能的代码封装到?个代码块, 函数, 对象, 打包成模块. 这都属于封装的思想. 具体的情况具体分析. 比如. 你写了?个很?B的函数. 那这个也可以被称为封装. 在?向对象思想中. 是把?些看似?关紧要的内容组合到?起统?进?存储和使?. 这就是封装. 继承 ? ?类可以?动拥有?类中除了私有属性外的其他所有内容. 说?了, ??可以随便?爹的东?. 但是朋友们, ?定要认清楚?个事情. 必须先有爹, 后有??. 顺序不能乱, 在py