python全栈之路,简学Python第六章__class面向对象编程与异常处理

 联系我们     |      2019-12-27 22:18

简学Python第六章__class面向对象编制程序与那么些管理,简学__class

 

八、初识面向对象

Python第六章__class面向对象编制程序与充足管理

应接到场Linux_Python学习群

 图片 1 群号:478616847

 

目录:

  • 面向对象的程序设计

  • 类和对象

  • 封装

  • 三番三回与派生

  • 多态与多态性

  • 特性property

  • 静态方法与类方式

  • 可怜管理

 

1、楔子

#面向对象编制程序

#面向对象的斟酌

#对象正是五个逼真的,能够准确描述出来的实体,比方说egg,alex

#面向对象的编制程序是大器晚成种上天视角的切换

    #事情发生前你使用的面向进程的编制程序是面向结果去编程,多个流程下来有确定地点的结果

        #好想  可扩张性差 轻便滋生代码的金昌难题

    #面向对象

 

#类:具有近似属性和措施的风流洒脱类东西

#对象:具备现实的性质的东西

黄金时代、面向对象的顺序设计

在Python中山高校家料定听过一句话,叫做一切皆对象,字典、体系、数字和字符串都是依据类来创建的,在python中面向对象(object卡塔尔(قطر‎编制程序是python的

骨干概念,类(class)最后解释了面向对象编制程序观念(OOP卡塔尔(英语:State of Qatar),同样类也是风度翩翩种对象,它是通过python中的元类(type卡塔尔(英语:State of Qatar)创立的,在此个元类中,定义了类

是什么样创建的(第七章讲明元类),上边伊始学习面向对象的编程。

 

何以要有面向对象的顺序设计?

在学习面向对象早先,我们要规定面向对象的程序设计不是编制程序,而是设计方法和编制程序思路,犹如大家搭建八个集群,首先要先规划一下,这一个服务器

设置什么,那三个服务器安装什么,面向对象的编制程序也是大器晚成律的要先规划程序,然后技艺开展编制程序,大家所写的次序都是面向进程的,也就说程序是依据

早晚的手续去解决问题,就好比一条流水生产线,到了哪个阶段该做如何事,那么这么的优点哪怕宏大地下落了程序的复杂度,缺点便是进程式编制程序是为了

解决贰个题指标,就好比生成车子的流程临盆持续小车,面向进程的编制程序,往往系统会特别安定,可是面前蒙受再三的必要变动的时候,面向进度就变

得乏力,平时的现身改三个地点,别的地点也亟需改正。

 

而面向对象的主次设计为主正是对象,在实际世界中大家的主观上,将东西分成不相同的项目,比方动物中有猫类,狗类等等,何况狗也是有分歧的品种

(举例哈士奇,藏獒卡塔尔(英语:State of Qatar),各类个体也会有非常的性质(譬如体重,毛发的颜色卡塔尔(قطر‎,所以中把这种样式引入到编制程序,面向对象的编制程序首先要把温馨正是真主,

真是成立者,大家创设二个类以前必要思虑那么些类有何样协同种性别,有何样差距性,大家得以把那几个共同种性别形成二个类,然后经过这一个协同性的类,创

造出差距性的私有。

面向对象的顺序设计并非整整。对于五个软件品质来讲,面向对象的前后相继设计只是用来减轻扩充性,何况面向对象编程的可控性差,平常能够见到

玩耍中的BUG,比方一刀几千血啊等等的。

图片 21.本性(Performance卡塔尔是指系统的响应技能,即要经过多久才具对有些事件作出响应,只怕在某段时间内系统所能管理的风云个数; 2.可用性(Availability卡塔尔(قطر‎是指系统能够健康运作的时刻比例; 3.可相信性(Reliability卡塔尔是指系统在动用大概不当前边,介思量不到照旧不当接受的状态下保持软件系统功用特色的力量; 4.强壮性(罗布ustness卡塔尔国是指在管理大概遭遇中系统能够担负的压力依旧转移技能; 5.安全性(Security卡塔尔是指系统向合法客商提供劳动的同事能够阻止非授权客户接收的绸缪恐怕谢绝服务的本事; 6.可改过性(Modification卡塔尔(英语:State of Qatar)是指能够高效地以较高的性能与价格之间比对系统进行改变的本事; 7.可变性(Changeability卡塔尔是指系列结构扩大可能转移成为新系统布局的技巧; 8.易用性(Usability卡塔尔(قطر‎是权衡客商选择软件出品成功钦命职责的难易程度; 9.可测量检验性(Testability卡塔尔(英语:State of Qatar)是指软件开采故障并割确定位其故障的力量性子,以致在早晚的小运大概资金前提下张开测验设计、测量试验施行力量; 10.成效性(Function ability卡塔尔国是指系统所能达成所期望职业的力量; 11.互操作性(Inter-Operation卡塔尔(英语:State of Qatar)是指系统与外部或系统与系统之间的相互影响技术。 软件的材料属性 软件质量属性

在python中宣示函数与表明类很日常,上边早先来创制第三个类

语法:class  类名:

     类的评释

     类体

图片 31 class Role: 2 pass 创建类

嗯是的只需求那样就创办达成了一个类,当然如此创立时聊无意义的,作者是用那几个引出其他知识点

首先:标准个中规定了类名首字母必需大写

其次:在python2在这之中类分为新式类和经文类,python3中都以新市类,python第22中学新式类需求让类世襲object那一个父类,並且我们在使用类中

尽量都用新式类,因为新式类中,新扩张了部分个性,dir(卡塔尔(英语:State of Qatar)也变得更康健。

图片 41 #python第22中学的新式类 2 class Role(object卡塔尔国: 3 pass 4 #python第22中学的优秀类 5 class Role(卡塔尔(英语:State of Qatar): 6 pass python第22中学的类

 

属性与实例化

类的效力有二种,分别是性质的援引和实例化

类属性的操成效(类名.变量名),类的习性分别数据属性和函数属性(也叫方法属性)

图片 5 1 class Role: 2 region = "China" 3 def output_region(self): 4 print("My region is China") 5 6 #引用类的数码属性,该属性是被全部指标和实例分享的 7 print(Role.region卡塔尔(英语:State of Qatar) 8 #通过类引用类的函数属性 9 Role(卡塔尔.output_region() 10 #扩展类的数目属性 11 Role.name = "Hello" 12 #援引新添的多寡属性 13 print(Role.name卡塔尔 14 #除去类中的数据属性,注意删除后有着目的和实例都不能调用 15 del Role.name 属性操作

 

实例化

大家说类最后要生成贰个目的的,那么类生成对象的进程便是实例化,实例化后的对象,能够操作类中的方法,也得以流传本人独有的性子,那样生成的

目的每一种都以个体每种都以单独的,以大胆缔盟这几个娱乐为例,大家创设三个解衣推食的类,每一种游戏的使用者操作的勇敢都有温馨的只有属性举例名字,攻击力和生

命值,並且每一个英豪都会普攻,何况铁汉都有阵营,比方德玛西亚,诺克萨斯,那些阵营是不改变的同偶然间每一个英豪都有,下边模拟达成上述的供给。

图片 6 1 class Galen: 2 camp = "Demacia" 3 def __init__(self,name,attack,life卡塔尔(قطر‎: 4 self.name = name 5 self.attack = attack 6 self.life = life 7 def slogan(self卡塔尔(英语:State of Qatar): 8 print("%s喊了口号:德玛西亚!"%self.name卡塔尔(قطر‎ 9 10 class Annie: 11 camp = "Noxus" 12 def __init__(self,name,attack,life卡塔尔(英语:State of Qatar): 13 self.name = name 14 self.attack = attack 15 self.life = life 16 def slogan(self卡塔尔: 17 print("%s喊了口号:你是自家的小熊么?"%self.name卡塔尔国 18 19 #实例化一个盖伦 20 G1 = Galen("盖伦",20,100卡塔尔 21 #实例化三个Anne 22 A1 = Annie("Anne",17,100卡塔尔国 23 24 G1.slogan(卡塔尔(قطر‎ 25 A1.slogan(卡塔尔 样例

首先创制了七个角色,三个是盖伦,一个是Anne,其次它们皆有阵营,那个阵营不改变的,所以用类的多寡属性来定义阵营,然后各种剧中人物都有谈得来的品质

所以用 __init__ 来拓宽包装,最终给这七个大胆都有贰个功效,正是喊口号,并且实例化了多少个角色,并且调用了角色中的喊口号的功用。

 

首先看__init__(构造函数)

好的上面的代码中关系了实例化,那么实例化就是  对象名 = 类名(参数),参数无关大局,不过大家开采 class Galen:并不曾要传播参数啊

反而__init__中有参数,没有错当实例化的时候,实例化的进度中便是实践了__init__函数,那一个实例化的历程是元类定义的(下章演示)所以

当实例化 A1 = Annie("Anne",17,100卡塔尔(قطر‎ 实际上正是把参数字传送给了__init__函数,

但是,看__init__函数是岗位参数,大家说地方参数是必传的,那么self是如何?,况兼为何能在艺术 slogan中调用name呢?

 

self

在实例化的经过此中会把实例本人传给init函数的第贰个值

当大家调用实例的数量属性的时候是要 A1.name,那么函数slogan想要调用,实例的数目属性是不会将在把实例传入这几个函数中,然后

通过传播的实例去调用实例的数量属性。就如上面包车型客车例证中把slogan函数拿了出来,然后把实例传入,那样技能调用name属性,所以self

便是替我们做了把实例传入到函数的操作。

图片 7 1 class Annie: 2 camp = "Noxus" 3 def __init__(self,name,attack,life): 4 self.name = name 5 self.attack = attack 6 self.life = life 7 8 def slogan(func): 9 print(func.name) 10 11 A1 = Annie("安妮",17,100) 12 slogan(A1) self

 

脾气引用

对于八个实例来讲,独有少年老成种功用就是:属性援用,上面提到的类中有数据属性和函数属性,包括__init__也是函数属性,何况对象/实例

作者唯有多少属性,有一些人会讲不对啊实例能够援用类的函数属性啊,其实原理是那般的,本来对实例是无可奈何使用函数属性的,可是python的

class机制会将类的函数绑定到目的上,称为对象的情势,恐怕叫绑定方法,上面例子中就足以知道的看来 A1.slogan,是绑定到Annie.slogan

上的。

图片 8 1 class Annie: 2 camp = "Noxus" 3 def __init__(self,name,attack,life卡塔尔(英语:State of Qatar): 4 self.name = name 5 self.attack = attack 6 self.life = life 7 8 def slogan(func卡塔尔(قطر‎: 9 print(func.name卡塔尔国 10 11 A1 = Annie("Anne",17,100卡塔尔(英语:State of Qatar) 12 print(Annie.slogan卡塔尔(قطر‎ 13 print(A1.slogan卡塔尔(英语:State of Qatar) 14 15 """ 16 输出结果 17 <function Annie.slogan at 0x0060DA08> 18 <bound method Annie.slogan of <__main__.Annie object at 0x00B112D0>> 19 """ 方法绑定

 

对象时期的互相

能够经过把对象传给函数来开展对象期间的竞相,上边例子中追加了attacks方法,何况这一个主意接纳二个值,这一个值不过是目的,所以把

被大张讨伐的指标传入进去,然后让被攻击对象的人命值减去攻击指标的攻击力,就成功了一遍对象时期的互相

图片 9 1 class Galen: 2 camp = "Demacia" 3 def __init__(self,name,attack,life卡塔尔国: 4 self.name = name 5 self.attack = attack 6 self.life = life 7 def slogan(self卡塔尔: 8 print("%s喊了口号:德玛西亚!"%self.name卡塔尔 9 10 def attacks(self,enemy卡塔尔国: 11 enemy.life-=self.attack 12 13 class Annie: 14 camp = "Noxus" 15 def __init__(self,name,attack,life卡塔尔: 16 self.name = name 17 self.attack = attack 18 self.life = life 19 def slogan(self卡塔尔(英语:State of Qatar): 20 print("%s喊了口号:你是自己的小熊么?"%self.name卡塔尔 21 22 def attacks(self,enemy卡塔尔(英语:State of Qatar): 23 enemy.life-=self.attack 24 25 #实例化二个盖伦 26 G1 = Galen("盖伦",20,100卡塔尔 27 #实例化三个安妮 28 A1 = Annie("Anne",17,100卡塔尔(英语:State of Qatar) #Annie.__init__(A1,"安妮",17,100) 29 30 #盖伦攻击Anne 31 G1.slogan(卡塔尔(英语:State of Qatar) 32 G1.attacks(A1卡塔尔(英语:State of Qatar) 33 print(A1.life卡塔尔(英语:State of Qatar) 34 #Anne攻击盖伦 35 A1.slogan(卡塔尔(英语:State of Qatar) 36 A1.attacks(G1卡塔尔 37 print(G1.life卡塔尔(قطر‎ 对象之间的相互

 

类的性质

好似列表字典同样,类也会有点艺术,一些属性,有个别暗中同意的方式来自type那么些元类中,况兼我们在类中定义的数码属性和方法属性也会

保存到 类名.__dict__中。这几个中是个字典,有着对于的关联。

图片 10 1 class Galen: 2 """ 3 那是盖伦的类 4 """ 5 camp = "德姆acia" 6 def __init__(self,name,attack,life卡塔尔国: 7 self.name = name 8 self.attack = attack 9 self.life = life 10 def slogan(self卡塔尔: 11 """ 12 喊口号的章程 13 :return:空 14 """ 15 print("%s喊了口号:德玛西亚!"%self.name卡塔尔国 16 17 def attacks(self,enemy卡塔尔(英语:State of Qatar): 18 enemy.life-=self.attack 19 20 print(Galen.__dict__) 21 print(Galen.__name__)#类名 22 print(Galen.__doc__)# 类的文书档案字符串 23 print(Galen.__base__)# 类的首先个父类(世襲时会讲卡塔尔(قطر‎ 24 print(Galen.__bases__)# 类全体父类构成的元组(世袭时会讲卡塔尔国 25 print(Galen.__dict__)# 类的字典属性 26 print(Galen.__module__)# 类定义所在的模块 27 print(Galen.__class__)# 实例对应的类(仅新式类中卡塔尔(英语:State of Qatar) 类的习性方法

 

类与实例(对象)的名称空间

始建八个类就能够创制多个类的称谓空间,用来存款和储蓄类中定义的拥著名字,那一个名字称为类的品质,而类有三种属性:数据属性和函数属性

个中类的数量属性是分享给具有目的的,而类的函数属性是绑定到全体目的的,能够看出,下边包车型客车代码中来看,属性ID是千篇意气风发律的,函数属性

的ID是不等同的。

图片 11class Galen: """ 那是盖伦的类 """ camp = "德姆acia" def __init__(self,name,attack,life卡塔尔: self.name = name self.attack = attack self.life = life def slogan(self卡塔尔: """ 喊口号的主意 :return:空 """ print("%s喊了口号:德玛西亚!"%self.name卡塔尔(قطر‎ G1 = Galen("盖伦",20,100卡塔尔国 #类的数量属性 print(id(Galen.camp卡塔尔卡塔尔(英语:State of Qatar) print(id(G1.camp卡塔尔(英语:State of Qatar)卡塔尔国 #类的多少属性 print(id(Galen.slogan卡塔尔(قطر‎卡塔尔(قطر‎ print(id(G1.slogan卡塔尔(英语:State of Qatar)卡塔尔(قطر‎ 名称空间

创制七个对象/实例就能够成立贰个目的/实例的名目空间,存放对象/实例的名字,称为对象/实例的特性

实例要找到camp,首先会在目的本身的称谓空间找,找不到则去类中找,类也找不到就找父类...最终都找不到就抛出特别  

 

2、初识类

三、类的三大特色之封装 

包裹从字面意思上知道的是把东西封起来,在类中要把包裹看的越来越空虚,封装具体分为数码封装格局封装,就疑似下边的例证一样,

举个例子Anne要暗杀盖伦,那能让盖伦见到Anne的阵营么?答案是一定非常的,所以封装不止是蒙蔽,就举例,百度地图,提须要笔者

们五个接口,让大家调用百度地图的定势功用,那么大家需求关系百度地图是怎么贯彻稳定的么?料定是无需。

所以!装进数据 是为着维护隐衷  包装方法 隔开复杂度

 

卷入分为八个层面

1、便是地点讲到的名目空间

2、正是用下划线的命名情势把质量隐蔽起来

封装数据

数码封装在底下例子中能够看出,首先把 Galen的数额属性camp封装起来,所以print(Galen.__camp卡塔尔(英语:State of Qatar)是调用不到的,然后name属性也

打包了四起,那么通过print(G1.__money卡塔尔(英语:State of Qatar)也是访谈不到的,可是在类的中间是足以调用money属性的,所以用inquire_mouney来输出

盖伦有多少钱,那么对于顾客来讲,调用那几个点子就足以博得钱,所以客商没有必要关系那几个钱是怎么来的,这几个钱是还是不是要扩充大气的演算,

也不会通晓那几个钱是指标的多寡属性,对于客户来讲只明白用那个接口就足以博得钱。

图片 12 1 #!/usr/bin/env python 2 3 class Galen: 4 __camp = "Demacia" 5 print(__camp) 6 7 def __init__(self,name,money): 8 self.name = name 9 self.__money = money 10 11 def inquire_mouney(self): 12 print(self.__money) 13 14 G1 = Galen("盖伦",1000) 15 16 print(G1.name) 17 G1.inquire_mouney() 18 19 #如此必然是访问不到的 20 #print(Galen.__camp) 21 #print(G1.__money卡塔尔(قطر‎ 数据封装

方法封装

在格局部封闭疗法装中大家把__conversion_mouney方法封装了起来,它是把RMB换算成澳元,我们发以往外场也是调用不到这几个办法的,不过

类的此中是足以调用的。

图片 13#!/usr/bin/env python class Galen: __camp = "Demacia" print(__camp) def __init__(self,name,money): self.name = name self.__money = money def __conversion_mouney(self): self.__money = self.__money*163 def inquire_mouney(self): self.__conversion_mouney() print(self.__money,"韩元") G1 = Galen("盖伦",1000) G1.inquire_mouney() #这么自然是走访不到的 # print(Galen.__conversion_mouney) # print(G1.__conversion_mouney卡塔尔国方法封装

 

装进剖判

包装,在python中实际正是把被卷入的靶子做了叁个变形,把对象的数目属性 __money 变成了 _Galen__money ,把函数方法

__conversion_mouney变成了_Galen__conversion_mouney,把类的多少属性__camp变成了_Galen__camp,所以平常的去调用

被打包的品质和章程是回天无力调用的,可以采用变形后的称号调用,当然这种调用方法知情就好了,不用那样用

再有这种变形的操作只在函数定义的时候会变形,你以往增加 __xxx 是不会变形的!

图片 14 1 #!/usr/bin/env python 2 3 class Galen: 4 __camp = "Demacia" 5 def __init__(self,name,money): 6 self.name = name 7 self.__money = money 8 9 def __conversion_mouney(self): 10 self.__money = self.__money*163 11 12 def inquire_mouney(self): 13 self.__conversion_mouney() 14 print(self.__money,"韩元") 15 16 G1 = Galen("盖伦",1000) 17 18 print(G1._Galen__money) 19 print(Galen._Galen__camp) 20 21 print(Galen.__dict__) 22 print(G1.__dict__卡塔尔国 封装剖判

三番五次,从字面上了然正是何人继续什么人,就如linux中的目录权限同样,子目录世袭了父目录的目录权限,所以接二连三是陈说了基类的脾性怎样

“遗传”给派生类。三个子类能够再三再四它的基类的其他性质,不管是多少属性仍旧艺术。举例二哈是哈士奇类,泰迪是泰迪类,它们都以狗

类,那么狗是狗类,猪是猪类,大家上升壹此中度来看它们都归于动物类,所以持续中的父类(也叫基类)有的是分裂子类共有的习性和

办法,比如猪与狗都会布帛菽粟。

接轨的语法:超轻巧class 子类名称(父类名称卡塔尔(قطر‎,并且能够通过子类实例化的靶子来调用父类的措施与品质,所以持续的最大的补益就是子类

继续了父类的全体作用

图片 15 1 #!/usr/bin/env python 2 3 class Demacia: 4 def monthly_pay(self卡塔尔(英语:State of Qatar): 5 print("笔者的每月工资是10000元"卡塔尔(英语:State of Qatar) 6 7 class Galen(德姆acia卡塔尔(英语:State of Qatar): 8 def slogan(self卡塔尔(英语:State of Qatar): 9 print("德玛西亚!"卡塔尔(قطر‎ 10 11 G1 = Galen(卡塔尔(قطر‎ 12 13 G1.slogan(卡塔尔(英语:State of Qatar) 14 G1.monthly_pay() 继承

唤醒:若无一点名基类,python的类会暗中同意世襲object类,object是装有python类的基类,它提供了一些普及方法(如__str__)的实现。

 

Super

在上边的例子中父类并不曾布局函数,有意思味的朋侪能够试试,若是在父类参加了结构函数后,再度运维就能报错,所以在开端化的时候子类

的布局方法必得调用父类的布局方法,来让父类实现伊始化的操作。

图片 16 1 class Demacia: 2 def __init__(self,salary): 3 self.salary = salary 4 def monthly_pay(self卡塔尔(英语:State of Qatar): 5 print("作者的月薪酬是%s元"%self.salary卡塔尔(英语:State of Qatar) 6 7 class Galen(德姆acia卡塔尔国: 8 def __init__(self,name,salary): 9 #充实这么黄金时代行,可能 德姆acia.__init__(self,salary) 10 super(Galen,self).__init__(salary卡塔尔(英语:State of Qatar) 11 self.name = name 12 13 def slogan(self卡塔尔: 14 print("%s喊了一声:德玛西亚!"%self.name卡塔尔 15 16 G1 = Galen("盖伦",10000卡塔尔(قطر‎ 17 18 G1.slogan(卡塔尔国 19 G1.monthly_pay() super

 

连绵起伏完结的原理(世襲顺序)

比如三个类,世袭了多少个类,然后它的父类也持续的其他的类,那么在此些被接续的类中有同一名字的措施时,调用的前期级是有各类的,在看

接轨在此以前,大家要记住 self 正是目的自作者

 

在python中,类如若接二连三了多少个类,那么寻找的措施有二种,分别是:深度优先广度优先,当类是精粹类的时候,多三番四遍的图景下,是依照深

度优先的章程查找,当类是新式类的时候会依据广度优先的措施查找,

经文类:先去D找,D未有找B,B未有找A,A未有找C,如若如故未找到,则报错

流行类:先去D找,D没有找B,B未有找C,C未有找A,假设依然未找到,则报错

 

事实上python会总结出四个措施解析顺序(MRO)列表,这么些列表正是贰个简洁明了的富有基类的线性顺类别表,也就说python依照这一个列表

的逐生龙活虎举办搜寻

图片 17 1 class A(object): 2 def prints(self): 3 print("A") 4 5 class B(A): 6 pass 7 def prints(self): 8 print("B") 9 10 class C(A): 11 def prints(self): 12 print("C") 13 14 class D(B,C): 15 pass 16 def prints(self): 17 print("D") 18 19 D().prints() 20 print(D.mro()) 继承

 

接口与归生龙活虎化设计

继续有两用

生机勃勃:世襲父类的法子,并且做出自个儿的校正可能增加(代码重用)

二:注解有些子类包容于某基类,定义二个接口类Interface,接口类中定义了有个别接口名(正是函数名)且并未有完结接口的效应,子类继承袭

口类,何况完成接口中的功能,也就说父类给子类规定了办法中必得有哪些函数。

 

何以要有接口?其实很简短,就像是制作小车轮胎雷同,不管你的车胎做的什么样,都亟待留下与汽车接连的接口,何况这么些接口各大小车轮胎厂

商就算风华正茂律的,保证小车换什么人家的车胎都足以用。

事例心爱味着 sata和Text五个类都持续Interface那些父类,然后让子类中都有read这几个办法。

图片 18 1 class Interface(卡塔尔国: 2 def read(self卡塔尔: 3 pass 4 5 class Sata(Interface卡塔尔(英语:State of Qatar): 6 def read(self卡塔尔(英语:State of Qatar): 7 print("read Sata"卡塔尔国 8 9 class Text(Interface卡塔尔国: 10 def read(self卡塔尔: 11 print("read Text"卡塔尔(英语:State of Qatar) 12 13 s = Sata(卡塔尔 14 s.read(卡塔尔(قطر‎ 接口与归大器晚成化

可是上边代码中中开掘接口类并无法节制子类必得兑现如何效力,那是因为在python中绝非接口的概念,所以想要落成这种接口,能够依靠第三方

模块,其次能够用抽象类模拟接口

twisted的twistedinternetinterface.py里使用zope.interface

文档

设计格局:

 

抽象类

抽象类是叁个特别的类,它的极度之处在于只好被持续,不能够实例化,因为python中平素不接口,所以让类世襲某些特定的说梅止渴基类,来代表它们支

持抽象基类的接口

虚幻了Interface这几个基类和抽象read那么些形式后,子类 Sata 和 Text就必须要有read这几个方法,不然会报错

图片 19 1 import abc 2 #接口类使用抽象类 3 class Interface(metaclass=abc.ABCMeta卡塔尔国: 4 #空泛方法 5 @abc.abstractclassmethod 6 def read(self卡塔尔国: 7 pass 8 9 class Sata(Interface卡塔尔: 10 def read(self卡塔尔国: 11 print("read Sata"卡塔尔国 12 13 class Text(Interface卡塔尔: 14 def read(self卡塔尔国: 15 print("read Text"卡塔尔(قطر‎ 16 17 s = Sata(卡塔尔 18 s.read(卡塔尔(قطر‎ 抽象类

 

补充

地点学习了包装与世袭,在以下的代码中B的类集成了A的类,而且实例化的目的b实行了 b.test这么些主意,那么最终输出的 func这个措施是 B.func

缘由是,先找test方法,在B类中一直不找到就找到了A类中,A类中找到了test方法,然后就实行了A中的test,A中的test又调用了func的情势,所以

python又重B类找,在B类中找到了func的点子,就实施了。

图片 20 1 class A(卡塔尔: 2 def test(self卡塔尔(قطر‎: 3 print("A.test"卡塔尔 4 self.func(卡塔尔 5 def func(self卡塔尔(قطر‎: 6 print("A.func"卡塔尔(قطر‎ 7 8 class B(A卡塔尔: 9 def func(self卡塔尔(قطر‎: 10 print("B.func"卡塔尔11 12 b = B(卡塔尔(英语:State of Qatar) 13 b.test(卡塔尔国 继承与包装的用处  

  假使,想要试行的是A类中的func,如何是好?可以使用封装,因为包装就是变形,变形后就的艺术在B类中就找不到了

图片 21 1 class A(): 2 def test(self): 3 print("A.test") 4 self.__func() 5 def __func(self): 6 print("A.func") 7 8 class B(A): 9 def __func(self卡塔尔: 10 print("B.func"卡塔尔 11 12 b = B(卡塔尔(英语:State of Qatar) 13 b.test(卡塔尔(英语:State of Qatar) 封装与后续的三个用途

 

2.1 类

#形容对象在几时用 :须求频仍传递相通的参数给部分函数的时候

#类名的首字母要大写

 图片 22

图片 23

 

class Person:
    role = 'person'     *#静态属性  类属性:全体的对象共有的品质,能够平昔被类调用
    *def __init__(self,name,sex,aggressive=200):
        #对象属性 属性   #是只归于某二个对象的,必需在实例化之后用对象调用         self.name = name         #名字  self.name =‘alex’         self.sex = sex           #性别         self.aggr = aggressive   #攻击力         self.blood = 20000       *#血
        #self = {'name':name,'sex':sex,'aggr':aggr,'blood':blood,'attack':attack}

    *def attack(self):  #类里面包车型地铁具备办法本质上正是多少个函数,具有叁个亟须传的参数self         print('%s attack'%self.name)

print(Person.role)
# print(Person.attack)
#实例化三个指标
alex = Person('alex','male',250)   #实例化 print(alex.name)
# alex.attack() egon = Person('egon','female')
egon.attack()

 图片 24

图片 25

五、类的三大特点之多态与多态性

多态的情趣便是有各类形态,举例文件这么些东西,有文件文件有数据文件等等,就如动物这种事物,有猪类,有狗类等等,在python中的类别类型

即便多态的,因为它有列表,元祖,字符串那多少个形象,那么多态与多态性,是莫衷一是的定义,多态性是风流浪漫种特色,就例如python中的len方法,len

格局中得以流传任何类别,python并未有项目标限定。

 

上面包车型地铁代码中,给func入任何类别都足以出口类别的长短,所以obj这些参数就是展现的多态性,贰个入口函数,有八种兑现情势,本质的原理便是

obj有同名的措施,相通的措施恐怕进行的不等的效应,字符串__len__就是总计字符串的尺寸,列表__len__正是总结列表的长度。

图片 26 1 a = "123" 2 b = [1,2,3] 3 c = (1,2,3) 4 5 def func(obj): 6 print(obj.__len__()) 7 8 func(a) 9 func(b) 10 func(c) 多态性

 

多态在类中的展现,首先有个动物的基类,动物的基类里面定义了shout的措施,并必要继续的子类都要促成shout的艺术,然后创建了 Dog类和Cat类

并皆有shout的点子,然后赋予五个类实例化出了dog 和cat 四个实例,到此截至以上就叫做多态大器晚成种动物的事物有二种形象(猫,狗的形态),在上边定

义了func的函数,对于利用那来讲,只须求传入,猫,狗就能够出发shout的点子,他们无需关系是怎么贯彻的,也无需改换代码,所以下面就是反映

的多态性

图片 27 1 import abc 2 3 class Animal(metaclass=abc.ABCMeta卡塔尔(قطر‎: 4 @abc.abstractclassmethod 5 def shout(self卡塔尔(英语:State of Qatar): 6 pass 7 8 class Cat(Animal卡塔尔: 9 def shout(self卡塔尔: 10 print("喵喵"卡塔尔国 11 12 class Dog(Animal卡塔尔: 13 def shout(self卡塔尔: 14 print("汪汪"卡塔尔(英语:State of Qatar) 15 dog = Dog(卡塔尔国 16 cat = Cat(卡塔尔 17 18 19 def func(obj卡塔尔国: 20 obj.shout(卡塔尔国 21 22 func(dog卡塔尔国 23 func(cat卡塔尔(英语:State of Qatar) 多态与多态性

 

多态性的亮点

1、增添了程序的圆滑

2、扩张了程序的额外可扩充性

就疑似上边的事例相通,还足以生出动物类的猪形态,驴形态等等,那么使用者都不需求改动代码,只需求把实例传入func函数就可以

 

2.2 静态属性

概念在类里面包车型地铁多个变量就是静态属性也正是类属性

具有的靶子共有的品质,能够直接被类调用

六、性情属性方法(property)

property是风姿洒脱种卓殊的性质,访谈它的时候会施行生机勃勃段功能(函数)然后再次来到值

图片 28 1 class Square(): 2 def __init__(self,side_len): 3 self.__side_len = side_len 4 5 #总结长方形的周长 6 @property 7 def perimeter(self卡塔尔: 8 return 4*self.__side_len 9 10 #总括星型的面积 11 @property 12 def area(self卡塔尔(英语:State of Qatar): 13 return self.__side_len*self.__side_len 14 15 #改为数据属性 @property 就非凡一下操作 16 #perimeter = property(perimeter) 17 #area = property(area) 18 19 s = Square(5) 20 #不改变形试行的调用形式 21 # print(s.perimeter()) 22 #print(s.area()) 23 #用调用属性的主意来调用 24 print(s.perimeter卡塔尔 25 print(s.area卡塔尔(قطر‎ property

 

上边的代码把函数属性改为了多少属性,那么数量属性可以再一次赋值,删除等操作,上边代码达成了删除,重新赋值的操作

图片 29 1 class Square(): 2 def __init__(self,side_len): 3 self.__side_len = side_len 4 5 #读取边长 6 @property#读取 7 def perimeter(self): 8 print("获取") 9 return self.__side_len 10 11 @perimeter.setter#更改 12 def perimeter(self,value): 13 print("更改") 14 self.__side_len = value 15 16 @perimeter.deleter#删除 17 def perimeter(self): 18 print("删除") 19 del self.__side_len 20 21 s = Square(5卡塔尔(英语:State of Qatar) 22 print(s.perimeter卡塔尔(قطر‎ 23 s.perimeter = 111 24 del s.perimeter properyt校订删除

那正是说实际上上面的用法意义并超级小,意义大的是,我们得以行使方面包车型地铁法子来控制数据属性的赋值,删除等只供给在相应的地点,扩充对应的逻辑

图片 30 1 class Square(): 2 def __init__(self,side_len): 3 self.__side_len = side_len 4 5 #读取边长 6 @property#读取 7 def perimeter(self): 8 print("获取") 9 return self.__side_len 10 11 @perimeter.setter#修正12 def perimeter(self,value卡塔尔(قطر‎: 13 if not isinstance(value,int卡塔尔: 14 print("改革失利"卡塔尔(قطر‎ 15 else: 16 print("修正完结"卡塔尔 17 self.__side_len = value 18 19 @perimeter.deleter#删除 20 def perimeter(self): 21 print("删除") 22 del self.__side_len 23 24 s = Square(5卡塔尔(英语:State of Qatar) 25 print(s.perimeter卡塔尔(英语:State of Qatar) 26 s.perimeter = "111" 27 s.perimeter = 11 28 print(s.perimeter卡塔尔 改过判别

 

2.3 属性

概念在类里面包车型大巴__init__里的变量便是指标属性相当于性质

是只归于某叁个对象的,必需在实例化之后用对象调用

七、静态方法与类情势

若是是艺术正是绑定到实例上的函数,类个中定义的函数都以给实例去用的,然则静态方法类方法是给类用的

 

静态方法(staticmethod)

staticmethod首若是方便外界的函数世袭到类中,美化代码布局,珍视在无需类实例化的情形下调用艺术,也无需传入self,何况在一定的

地点能够依靠静态方法帮大家实例化,如下的 Date 类,输出年月日

图片 31 1 import time 2 class Foo: 3 @staticmethod 4 def spam(x,y,z): 5 print(x,y,z) 6 7 Foo.spam(1,2,3) 8 9 class Date(): 10 def __init__(self,year,mon,day): 11 self.year = year 12 self.mon = mon 13 self.day = day 14 15 def prints(self): 16 print(self.year,self.mon,self.day) 17 18 @staticmethod #等于 now = staticmethod(now) 19 def now(): 20 t = time.localtime() 21 return Date(t.tm_year,t.tm_mon,t.tm_mday) 22 d = Date(2017,1,20) 23 c = Date.now() 24 25 d.prints() 26 c.prints() staticmethod

 

类方法(classmethod)

类情势与静态方法用法特别相同,差距正是被类措施装饰的函数,会流传cls,相当于类的小编,什么人来调用就把什么人传入进去,那么有类的本人就可

以操作类的多少属性和措施属性,上边包车型客车代码正是通过classmethod给date重新赋值

图片 32 1 import time 2 class Date(): 3 date = None 4 5 @classmethod #等于 now = staticmethod(now) 6 def now(cls): 7 t = time.localtime() 8 cls.date = [t.tm_year,t.tm_mon,t.tm_mday] 9 10 Date.now() 11 d = Date() 12 print(d.date) classmethod

classmethod也能够信任它帮咱们实例化

图片 33 1 class Date(): 2 def __init__(self,year,mon,day): 3 self.year = year 4 self.mon = mon 5 self.day = day 6 7 def prints(self): 8 print(self.year,self.mon,self.day) 9 10 @classmethod #等于 now = staticmethod(now) 11 def now(cls): 12 t = time.localtime() 13 return cls(t.tm_year,t.tm_mon,t.tm_mday卡塔尔 14 15 d=Date.now(卡塔尔(英语:State of Qatar) 16 d.prints(卡塔尔classmethod应用项景

 

2.4 动态属性

概念在类里面包车型地铁三个函数正是动态属性也正是方法

类里面的装有办法本质上正是叁个函数,具备一个亟须传的参数self

八、相当处理

在编制程序的进度中,平常会并发局地报错,那么为了保证在失误的时候程序继续运维,或然做此外的拍卖,那个时候分外管理就极为首要

语法:

  try:

    被监察和控制的代码

  except  捕获的乖谬类型 as 赋值的变量:

    其余操作

先来看二个有关捕获数据类型十分的代码,上面包车型地铁例证非常粗大略,把data做int转变,然则data是字符串所以不能调换,所以报错通过 try 和except

能够捕获错误

图片 341 data = "abc" 2 try: 3 int(data卡塔尔(英语:State of Qatar) 4 except ValueError as e: 5 print(e卡塔尔 数据类型错误

 

在地点的例证中得以看出,非凡管理的捕获的荒诞类型是成百上千的,大致好似下这一个

图片 35 1 AttributeError 试图访谈叁个对象没有的树形,举个例子foo.x,不过foo未有品质x 2 IOError 输入/输出格外;基本上是回天乏术开辟文件 3 ImportError 不可能引入模块或包;基本上是渠道难题或称谓错误 4 IndentationError 语法错误(的子类) ;代码未有科学对齐 5 IndexError 下标索引超出种类边界,比如当x只有多个要素,却策画访谈x[5] 6 KeyError 试图访谈字典里不设有的键 7 KeyboardInterrupt Ctrl+C被按下 8 NameError 使用一个还未有被付与对象的变量 9 SyntaxError Python代码违规,代码不能够编写翻译(个人以为那是语法错误,写错了) 10 TypeError 传入对象类型与需要的不合乎 11 UnboundLocalError 试图访谈一个尚未被设置的某个变量,基本上是出于另有三个同名的全局变量, 12 引致你认为正在访谈它 13 ValueError 传入三个调用者不期望的值,即便值的项目是无可反对的 常用万分 图片 36 1 ArithmeticError 2 AssertionError 3 AttributeError 4 BaseException 5 BufferError 6 BytesWarning 7 DeprecationWarning 8 EnvironmentError 9 EOFError 10 Exception 11 FloatingPointError 12 FutureWarning 13 GeneratorExit 14 ImportError 15 ImportWarning 16 IndentationError 17 IndexError 18 IOError 19 KeyboardInterrupt 20 KeyError 21 LookupError 22 MemoryError 23 NameError 24 NotImplementedError 25 OSError 26 OverflowError 27 PendingDeprecationWarning 28 ReferenceError 29 RuntimeError 30 RuntimeWarning 31 StandardError 32 StopIteration 33 SyntaxError 34 SyntaxWarning 35 SystemError 36 SystemExit 37 TabError 38 TypeError 39 UnboundLocalError 40 UnicodeDecodeError 41 UnicodeEncodeError 42 UnicodeError 43 UnicodeTranslateError 44 UnicodeWarning 45 UserWarning 46 ValueError 47 Warning 48 ZeroDivisionError 越来越多的不胜

对此上述,只可以捕获钦点项指标非常,那么现身钦赐项目外的失实就能够报错,所以python中有豆蔻梢头种万能特别(Exception)

图片 371 data = "abc" 2 try: 3 int(data卡塔尔(英语:State of Qatar) 4 tuple(data卡塔尔 5 except Exception as e: 6 print(e卡塔尔(قطر‎ 7 print(data卡塔尔(英语:State of Qatar) 万能极度

还会有一点要潜心的是,风流倜傥旦发生特别代码就能从产生极度的代码地方跳转到 except 中,所以不会继续施行 tuple(data卡塔尔国那行代码

 

充裕的其它用法

1、其余非常结构

图片 38 1 try: 2 # 主代码块 3 pass 4 except Exception as e: 5 # 格外时,实行该块 6 pass 7 else: 8 # 主代码块实行完,试行该块 9 pass 10 finally: 11 # 无论相当与否,最终施行该块 12 pass 其余十分布局

2、主动触发相当

图片 391 try: 2 raise Exception('产生了错误。。。'卡塔尔 3 except Exception as e: 4 print(e卡塔尔(قطر‎主动触发至极

3、自定义格外

图片 40 1 class MyException(Exception): 2 3 def __init__(self, msg): 4 self.message = msg 5 6 def __str__(self卡塔尔(英语:State of Qatar): 7 return self.message 8 9 try: 10 raise MyException('笔者的那三个'卡塔尔(英语:State of Qatar) 11 except MyException as e: 12 print(e卡塔尔(قطر‎ 自定义相当

4、断言

行使assert断言是上学python三个相当好的习贯,断言句语格式及用法很简短。在没到家一个主次从前,我们不亮堂程序在何地会出错,与其让

它在运转最崩溃,不比在现身谬误条件时就完蛋,当时就须要assert断言的帮带。

图片 411 a = 2 2 assert 1==1 3 assert 2+2==2*2 4 assert range(4)==[0,1,2,3] 5 assert a == 3 断言

 

 

 

 

 

作者:新加坡小远
出处
本文版权归小编和搜狐共有,款待转发,但未经作者同意必需在小说页面显著地方给出原来的小说连接,不然保留查究法律义务的职责。

Python第六章__class面向对象编制程序与丰裕管理 应接参预Linux_Python学习群 群号:478...

2.5 实例化

类()

参数1 = 1

参数2 = 2

对象名 = 类名(参数1,参数2)

2.5 例题1

打印:

'''

练习风华正茂:在尖峰输出如下音信

 

小明,10岁,男,上山去砍柴

小明,10岁,男,行驶去西北

小明,10岁,男,最爱大保养

老李,86虚岁,男,上山去砍柴

老李,八十八虚岁,男,开车去西南

老李,捌拾陆虚岁,男,最爱大保护健康

老张…

'''

class  Person:
    def __init__(self,name,age,sex='男'):
        self.name=name
        self.age=age
        self.sex = sex

    def kanchai(self):
        print('%s,%s岁,%s,上山去砍柴'%(self.name,self.age,self.sex))

        print("%s,%s岁,%s,开车去西北" % (self.name, self.age, self.sex))
        print("%s,%s岁,%s,最爱大养生" % (self.name, self.age, self.sex))

小明 = Person('小明',10)
小明.kanchai()

老张 = Person('老张',90)
老张.kanchai()

 图片 42

3、面向对象之间的竞相

例题2

人狗战漫不经心

class Person:
    role = 'person'     *#静态属性  类属性:全部的目的共有的属性,能够直接被类调用
    *def __init__(self,name,sex,aggressive=200):
        #对象属性 属性   #是只归属某一个对象的,必需在实例化之后用对象调用         self.name = name         #名字  self.name =‘alex’         self.sex = sex           #性别         self.aggr = aggressive   #攻击力         self.blood = 2000       *#血

    *def attack(self,dog):  #类里面包车型地铁装有办法本质上正是叁个函数,具备多个亟须传的参数self         print('%s attack %s'%(self.name,dog.name))
        dog.blood = dog.blood - self.aggr

class Dog:
    def __init__(self,name,aggressive=666):
        self.name = name
        self.aggr = aggressive
        self.blood = 8000

    def bite(self,person):
        print('%s 咬了 %s'%(self.name,person.name))
        person.blood = person.blood - self.aggr
        if person.blood <= 0:
            print('game over : %s'%person.name)
# alex = Person('alex','male',250)
egon = Person('egon','male')
teddy = Dog('葫芦娃')
teddy.bite(alex)
print("alex.blood:",alex.blood)
teddy.bite(alex)
print("alex.blood:",alex.blood)
teddy.bite(alex)
print("alex.blood:",alex.blood)
teddy.bite(alex)
print("alex.blood:",alex.blood)
egon.attack(teddy)
print("teddy.blood:",teddy.blood)

 图片 43

4、例题3

求圆的面积和周长

#类 : 圆
#属性 :圆半径
#办法 :总计圆的周长和面积
**
from math import pi class Circle:     def** __init__(self,r):
        self.r = r

    def area(self):
        return pi *self.r ** 2

    def round(self):
        return 2 * pi * self.r

c1 = Circle(10)
print(c1.area())
print(c1.round())

5、类的命名空间

对此类的静态属性:

  类.属性 调用的正是类中的属性

  对象.属性 先从友好的内部存款和储蓄器空间里找名字,找到了用自个儿的,没找到用类的,即使类中也未尝就报错。

对此类的动态属性(方法):

  那么些主意本人就存在类中,并不会存在对象的内部存款和储蓄器中

  不过在目的调用类中的方法的时候,要凭仗于一个地点簿去类中检索对应的不二等秘书技。

图片 44

至于目的的性质:

  对象的品质就存在对象的命名空间中

  只可以被对象调用、订正

  不能够被类调用

图片 45

例1、

class A:
    country = '印度'
    def
show_name(self):
        print(self.name)

a = A()    #实例化对象 a.name = 'alex'   *#给指标创造贰个name属性
a.show_name()      #调用了showname方法*

 图片 46

例2、

class A:
    country = '印度'
    def
show_name(self):
        print(self.name)

a = A()
a.name = 'alex' a.show_name = 'egon' a.show_name()     #报错

 图片 47

例3、

class A:
    country = '印度'
    def
show_name(self):
        print(self.name)

a = A()    #a对象 b = A()    #b对象 print(A.country)
print(a.country)   #先找a对象的内部存款和储蓄器 再找A的内部存款和储蓄器 print(b.country)
a.country = '中国'  *#给a对象成立了叁个属性
print(A.country)    #印度
print(a.country)    #中国
print(b.country)    #印度*

 图片 48

6、组合

例1、

#Ring
#圆环的习性:大圆半径和小圆半径
**
class Circle:     def** __init__(self,r):
        self.r = r

    def area(self):
        return self.r*self.r*3.14

    def perimeter(self):
        return self.r*2*3.14

*# c = Circle(10)
# c.area()
# c.perimeter()

*class Ring:
    #整合表明的是 什么有何的 意气风发种关系
    #组成加强了代码的重用性
    **
def* __init__(self,r_out,r_in):  #10,5
        *self.c_out = Circle(r_out)
        self.c_in = Circle(r_in)

    def area(self):
        return self.c_out.area() - self.c_in.area()

    def perimeter(self):
        return self.c_out.perimeter() + self.c_in.perimeter()

r1 = Ring(10,5)
print(r1.area())
print(r1.perimeter())

 图片 49

例2、

class Birthday:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day

#课程类
    #学科的名字
    #课程周期
    #传授学识的园丁
    #课程的价钱
**
class Course:     def** __init__(self,name,period,teacher,price):
        self.name=name
        self.period=period
        self.teacher=teacher
        self.price=price

class Person:
    def __init__(self,name,birth_obj,kecheng):
        self.name = name
        self.birthday = birth_obj
        self.kecheng=kecheng

bith_hai = Birthday(1988,11,11)
py=Course('python',20,'jingdao',20000)
haijiao = Person('海娇',bith_hai,py)
print(haijiao.name)
print(haijiao.birthday.year)
print(haijiao.birthday.month)
print(haijiao.kecheng.name)

 图片 50

例3、

class Birthday:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day

class Course:
    def __init__(self,name,period,teacher,price):
        self.name=name
        self.period=period
        self.teacher=teacher
        self.price=price

class Person:
    def __init__(self,name,birth_obj):
        self.name = name
        self.birthday = birth_obj

bith_hai = Birthday(1988,11,11)
py=Course('python',20,'jingdao',20000)
lux = Course('linux',20,'oldboy',20000)
haijiao = Person('海娇',bith_hai)
print(haijiao.name)
print(haijiao.birthday.year)
print(haijiao.birthday.month)
haijiao.kecheng = py
haijiao.kecheng1 = lux
print(haijiao.kecheng.name)
print(haijiao.kecheng1.name)

 图片 51

例4、

class Person:
    def __init__(self,name,sex,aggr,blood):
        self.name = name
        self.sex = sex
        self.aggr = aggr
        self.blood = blood
        self.money = 0

    def attack(self,dog):
        dog.blood -= self.aggr

    def equip(self,weapon):
        self.money -= weapon.price
        self.weapon = weapon

    def use_weapon(self,dog):
        self.weapon.hurt(dog)
        self.blood += self.weapon.back_blood

class Dog:
    def __init__(self,name,kind,aggr,blood):
        self.name = name
        self.kind = kind
        self.aggr = aggr
        self.blood = blood

    def bite(self,person):
        person.blood -= self.aggr

class Weapon:
    def __init__(self,name,attack,price,back_blood):
        self.name = name
        self.attack = attack
        self.price = price
        self.back_blood = back_blood

    def hurt(self,dog):
        dog.blood -= self.attack

egon = Person('egon','不详',250,380)
alex = Person('alex','不详',20,40000)
dog = Dog('egg','藏獒',500,20000)
#加武器 毒包子 = Weapon('毒包子',10000,200,300)
egon.money = 200
if egon.money >= 毒包子.price:
    #egon就配备上毒包子     egon.equip(毒包子)
egon.use_weapon(dog)
print(egon.blood)
print(dog.blood)

7、继承

7.1 继承

7.1.1 什么是持续

#世襲:什么是怎么的涉及

    #她大舅打二舅都是他舅

    #高桌子低板凳都以木头

连绵起伏是后生可畏种成立新类的方法,在python中,新建的类能够继续一个或两个父类,父类又可称之为基类或超类,新建的类称为派生类或子类

 

子类 派生类 (派生属性 派生方法)

子类的靶子要去调用方法大概性质:自身有些调自个儿的,自个儿从没的调父类的

self是如何:何人调用正是何人

子类的对象调用父类的诀窍,在父类方法中的self是子类的指标

 

class Animal:        #父类、超类
    **
def eat(self):         pass

class Bnimal:     #父类、超类     def drink(self):         pass

class Dog(Animal,Bnimal):   #子类、派生类     pass
class Cat(Animal):   #子类、派生类     pass**

7.1.2 查看世袭

>>> SubClass1.__bases__ #__base__只查看从左到右世襲的首先个子类,__bases__则是翻开全部继续的父类

(<class '__main__.ParentClass1'>,)

>>> SubClass2.__bases__

(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

图片 52

7.1.3 世襲与虚空

世袭:是基于抽象的结果,通过编程语言去完结它,明确是先经验抽象那么些进度,技术透过一而再的方法去发布出抽象的构造。

空洞只是解析和筹算的经过中,一个动作或许说风华正茂种本领,通过架空能够赢得类

 图片 53

图片 54

7.1.4 清除代码的重用性

#============第一片段===========
#狗
**
class Dog:     def eat(self):
        print(
'eating'**)

    def drink(self):
        print('drinking')

    def sleep(self):
        print('sleeping')

    def say(self):
        print('汪汪汪')

#猫
**
class Cat:     def eat(self):
        print(
'eating'**)

    def drink(self):
        print('drinking')

    def sleep(self):
        print('sleeping')

    def say(self):
        print('喵喵喵')

*#============第二有个别===========
#缓慢解决代码的重用性

*class Animal:
    def eat(self):
        print('eating')

    def drink(self):
        print('drinking')

    def sleep(self):
        print('sleeping')

#狗
**
class Dog(Animal):# 在类后边括号中写入其余四个类名,表示最近类世袭别的二个类     def say(self):
        print(
'汪汪汪'**)

#猫
**
class Cat(Animal):# 在类前面括号中写入此外三个类名,表示近期类世襲其余八个类     def say(self):
        print(
'喵喵喵'**)

7.2 派生

7.2.1 派生

当然子类也足以增添自个儿新的属性也许在友好这里再度定义这么些属性(不会影响到父类),需求静心的是,黄金时代旦重新定义了自个儿的习性且与父类重名,那么调用新扩张的本性时,就以友好为准了。

 

#在三回九转中

#子类可以世襲父类的持有属性和办法

#只是 当父类和子类中有同名方法的时候 一定调用子类的

#譬喻想利用父类该措施的效能必要依赖super方法

7.2.2 super()

若果子类中带有和父类中同样的艺术但是还想调用父类的艺术将要用super

#父类 animal
**
class Animal:     def** __init__(self,name):
        self.name = name

    def eat(self):
        print('%s eating %s'%(self.name,self.food))

    def drink(self):
        print('drinking')

    def sleep(self):
        print('sleeping')

#狗
**
class Dog(Animal):     def __init__(self,name):
        # Animal.__init__(self,name)    #精髓类的调用父类中方法的法子         super().__init__(name)        #新颖类调用父类中艺术的主意         self.food =
'狗粮'

    def say(self):
        print(
'汪汪汪'**)

#猫
**
class Cat(Animal):     def __init__(self,name):
        super().__init__(name)  #新式类         self.food =
'猫粮'

    def say(self):
        print(
'喵喵喵'**)

wang = Dog('alex')
ha2 = Dog('二哈')
wang.eat()
ha2.eat()

c = Cat('egon')
c.eat()

 图片 55

7.2.3 例题1

 图片 56

上一篇:使用心得之 下一篇:没有了