• python之路_面向对象

    1 >>> dict #类型dict就是类dict
2 <class 'dict'>
3 >>> d=dict(name='egon') #实例化
4 >>> d.pop('name') #向d发一条消息，执行d的方法pop
5 'egon'

    一、什么是面向对象的程序设计及为什么要有它

    面向过程的程序设计的核心是过程（流水线式思维），过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。

    优点是：极大的降低了程序的复杂度

    缺点是：一套流水线或者流程就是用来解决一个问题，生产汽水的流水线无法生产汽车，即便是能，也得是大改，改一个组件，牵一发而动全身。

    应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。

    面向对象的程序设计的核心是对象（上帝式思维），要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也可以创造出来。面向对象的程序设计好比如来设计西游记，如来要解决的问题是把经书传给东土大唐，如来想了想解决这个问题需要四个人：唐僧，沙和尚，猪八戒，孙悟空，每个人都有各自的特征和技能（这就是对象的概念，特征和技能分别对应对象的数据属性和方法属性），然而这并不好玩，于是如来又安排了一群妖魔鬼怪，为了防止师徒四人在取经路上被搞死，又安排了一群神仙保驾护航，这些都是对象。然后取经开始，师徒四人与妖魔鬼怪神仙交互着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取。

    面向对象的程序设计的

    优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。

    缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现，一刀砍死3个人，这个游戏就失去平衡。

    应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方

    面向对象的程序设计并不是全部。对于一个软件质量来说，面向对象的程序设计只是用来解决扩展性。

    二、类和对象

    2.1、什么是对象，什么是类

    提示：python的class术语与c++有一定区别，与 Modula-3更像。

    python中一切皆为对象，且python3统一了类与类型的概念，类型就是类，所以，不管你信不信，你已经使用了很长时间的类了

    >>> dict #类型dict就是类dict
<class 'dict'>
>>> d=dict(name='egon') #实例化
>>> d.pop('name') #向d发一条消息，执行d的方法pop
'egon'

    基于面向对象设计一个款游戏：英雄联盟，每个玩家选一个英雄，每个英雄都有自己的特征和和技能，特征即数据属性，技能即方法属性，特征与技能的结合体就一个对象。

    　　从一组对象中提取相似的部分就是类，类所有对象都具有的特征和技能的结合体

    　　在python中，用变量表示特征，用函数表示技能，因而类是变量与函数的结合体，对象是变量与方法（指向类的函数）的结合体

    　　

    　　补充几个有意思的点：

    　　garen_hero.Q()称为向garen_hero这个对象发送了一条消息，让他去执行Q这个函数，完成一个功能，类似的有：

    　　garen_hero.W()

    　　garen_hero.E()

    　　garen_hero.R()

    　　一个英雄可以攻击另外一个英雄，这就是对象之间的交互

    　　garen_hero.attack(Riven)

    2、2、类相关知识

    2.2.1 初识类

    在python中声明函数与声明类很相似

    声明函数

    def functionName(args):
'函数文档字符串'
函数体 
    '''
class 类名:
    '类的文档字符串'
    类体
'''

#我们创建一个类
class Data:
    pass
    大前提：
1.只有在python2中才分新式类和经典类，python3中统一都是新式类
2.新式类和经典类声明的最大不同在于,所有新式类必须继承至少一个父类
3.所有类甭管是否显式声明父类，都有一个默认继承object父类（讲继承时会讲，先记住）
在python2中的区分
经典类：
class 类名:
    pass

经典类：
class 类名(父类):
    pass

在python3中，上述两种定义方式全都是新式类

经典类与新式类
    经典类和新式类

     在本节开头介绍得出结论，类是数据与函数的结合，二者称为类的属性

    1 class Garen:        #定义英雄盖伦的类，不同的玩家可以用它实例出自己英雄;
2     camp='Demacia'  #所有玩家的英雄(盖伦)的阵营都是Demacia;
3     def attack(self,enemy):   #普通攻击技能，enemy是敌人;
4         enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。

    2.2.2、类有两种作用：属性引用和实例化

    1、属性引用（类名.属性）

    >>> Garen.camp #引用类的数据属性，该属性与所有对象/实例共享
'Demacia'
>>> Garen.attack #引用类的函数属性，该属性也共享
<function Garen.attack at 0x101356510>
>>> Garen.name='Garen' #增加属性
>>> del Garen.name #删除属性

    2、实例化（__init__与self）

    类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征

    class Garen:        #定义英雄盖伦的类，不同的玩家可以用它实例出自己英雄;
    camp='Demacia'  #所有玩家的英雄(盖伦)的阵营都是Demacia;
    def __init__(self,nickname,aggressivity=58,life_value=455): #英雄的初始攻击力58...;
        self.nickname=nickname  #为自己的盖伦起个别名;
        self.aggressivity=aggressivity #英雄都有自己的攻击力;
        self.life_value=life_value #英雄都有自己的生命值;
    def attack(self,enemy):   #普通攻击技能，enemy是敌人;
        enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。

    实例化：类名+括号

    >>> g1=Garen('草丛伦') #就是在执行Garen.__init__(g1,'草丛伦')，然后执行__init__内的代码g1.nickname=‘草丛伦’等

    self的作用是在实例化时自动将对象/实例本身传给__init__的第一个参数，self可以是任意名字，但是瞎几把写别人就看不懂了。

    这种自动传递的机制还体现在g1.attack的调用上，后续会介绍。

    一：我们定义的类的属性到底存到哪里了？有两种方式查看
dir(类名)：查出的是一个名字列表
类名.__dict__:查出的是一个字典，key为属性名，value为属性值

二：特殊的类属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

    2.3、对象相关知识

    对象是关于类而实际存在的一个例子，即实例

    >>> g1=Garen('草丛伦') #类实例化得到g1这个实例，基于该实例我们讲解实例相关知识
>>> type(g1) #查看g1的类型就是类Garen
<class '__main__.Garen'>
>>> isinstance(g1,Garen) #g1就是Garen的实例
True

    1）对象/实例只有一种作用：属性引用

    #对象/实例本身其实只有数据属性
>>> g1.nickname
'草丛伦'
>>> g1.aggressivity
>>> g1.life_value
'''
查看实例属性
同样是dir和内置__dict__两种方式
特殊实例属性
__class__
__dict__
....
'''

    对象/实例本身只有数据属性，但是python的class机制会将类的函数绑定到对象上，称为对象的方法，或者叫绑定方法，绑定方法唯一绑定一个对象，同一个类的方法绑定到不同的对象上，属于不同的方法，内存地址都不会一样

    >>> g1.attack #对象的绑定方法
<bound method Garen.attack of <__main__.Garen object at 0x101348dd8>>

>>> Garen.attack #对象的绑定方法attack本质就是调用类的函数attack的功能，二者是一种绑定关系
<function Garen.attack at 0x101356620>

    对象的绑定方法的特别之处在于：obj.func()会把obj传给func的第一个参数。

    2.4、对象之间的交互

    我们可以仿照garen类再创建一个Riven类

    class Riven:
    camp='Noxus'  #所有玩家的英雄(锐雯)的阵营都是Noxus;
    def __init__(self,nickname,aggressivity=54,life_value=414): #英雄的初始攻击力54;
        self.nickname=nickname  #为自己的锐雯起个别名;
        self.aggressivity=aggressivity #英雄都有自己的攻击力;
        self.life_value=life_value #英雄都有自己的生命值;
    def attack(self,enemy):   #普通攻击技能，enemy是敌人;
        enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。

    实例出一个Riven来

    交互：锐雯雯攻击草丛伦，反之一样

    >>> g1.life_value
455
>>> r1.attack(g1)
>>> g1.life_value
401

    2.5、类名称空间与对象/实例名称空间

    创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性

    而类有两种属性：数据属性和函数属性

    其中类的数据属性是共享给所有对象的

    >>> id(r1.camp) #本质就是在引用类的camp属性，二者id一样
4315241024
>>> id(Riven.camp)
4315241024

    而类的函数属性是绑定到所有对象的：

    >>> id(r1.attack) 
>>> id(Riven.attack)

'''
r1.attack就是在执行Riven.attack的功能，python的class机制会将Riven的函数属性attack绑定给r1，r1相当于拿到了一个指针，指向Riven类的attack功能

除此之外r1.attack()会将r1传给attack的第一个参数
'''

    创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性

    在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常  

    总结：

    照以下思路一点一点的设计类和对象，最终你完全可以实现一个对战类游戏。

    1、定义锐雯类：

     1 class Riven:
 2     camp='Noxus'
 3     def __init__(self,nickname,
 4                  aggressivity=54,
 5                  life_value=414,
 6                  money=1001,
 7                  armor=3):
 8         self.nickname=nickname
 9         self.aggressivity=aggressivity
10         self.life_value=life_value
11         self.money=money
12         self.armor=armor
13     def attack(self,enemy):
14         damage_value=self.aggressivity-enemy.armor
15         enemy.life_value-=damage_value

    2、定义盖伦类：

     1 class Garen:
 2     camp='Demacia'
 3     def __init__(self,nickname,
 4                  aggressivity=58,
 5                  life_value=455,
 6                  money=100,
 7                  armor=10):
 8         self.nickname=nickname
 9         self.aggressivity=aggressivity
10         self.life_value=life_value
11         self.money=money
12         self.armor=armor
13     def attack(self,enemy):
14         damage_value=self.aggressivity-enemy.armor
15         enemy.life_value-=damage_value

    3、定义装备

     1 class BlackCleaver:
 2     def __init__(self,price=475,aggrev=9,life_value=100):
 3         self.price=price
 4         self.aggrev=aggrev
 5         self.life_value=life_value
 6     def update(self,obj):
 7         obj.money-=self.price #减钱
 8         obj.aggressivity+=self.aggrev #加攻击
 9         obj.life_value+=self.life_value #加生命值
10     def fire(self,obj): #这是该装备的主动技能,喷火,烧死对方
11         obj.life_value-=1000 #假设火烧的攻击力是1000

    4、测试交互

     1 r1=Riven('草丛伦')
 2 g1=Garen('盖文')
 3 b1=BlackCleaver()
 4 
 5 print(r1.aggressivity,r1.life_value,r1.money) #r1的攻击力,生命值,护甲
 6 
 7 if r1.money > b1.price:
 8     r1.b1=b1
 9     b1.update(r1)
10 
11 
12 print(r1.aggressivity,r1.life_value,r1.money) #r1的攻击力,生命值,护甲
13 
14 print(g1.life_value)
15 r1.attack(g1) #普通攻击
16 print(g1.life_value)
17 r1.b1.fire(g1) #用装备攻击
18 print(g1.life_value) #g1的生命值小于0就死了

    三、继承

    3.1、什么是继承

    继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类

    python中类的继承分为：单继承和多继承

    class ParentClass1: #定义父类
    pass
class ParentClass2: #定义父类
    pass
class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
    pass
class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
    pass

    查看继承

    >>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

    提示：如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现。

    >>> ParentClass1.__bases__
(<class 'object'>,)
>>> ParentClass2.__bases__
(<class 'object'>,)

    3.2、继承与抽象（先抽象再继承）

    抽象即抽取类似或者说比较像的部分。

    抽象分成两个层次： 

    1.将奥巴马和梅西这俩对象比较像的部分抽取成类； 

    2.将人，猪，狗这三个类比较像的部分抽取成父类。

    抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）

    继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。

    抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类

    3.3、继承与重用性

    使用继承来重用代码

      1 ==========================第一部分
  2 例如
  3 
  4 　　猫可以：喵喵叫、吃、喝、拉、撒
  5 
  6 　　狗可以：汪汪叫、吃、喝、拉、撒
  7 
  8 如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，伪代码如下：
  9  
 10 
 11 #猫和狗有大量相同的内容
 12 class 猫：
 13 
 14     def 喵喵叫(self):
 15         print '喵喵叫'
 16 
 17     def 吃(self):
 18         # do something
 19 
 20     def 喝(self):
 21         # do something
 22 
 23     def 拉(self):
 24         # do something
 25 
 26     def 撒(self):
 27         # do something
 28 
 29 class 狗：
 30 
 31     def 汪汪叫(self):
 32         print '喵喵叫'
 33 
 34     def 吃(self):
 35         # do something
 36 
 37     def 喝(self):
 38         # do something
 39 
 40     def 拉(self):
 41         # do something
 42 
 43     def 撒(self):
 44         # do something
 45 
 46 
 47 
 48 ==========================第二部分
 49 上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：
 50 
 51 　　动物：吃、喝、拉、撒
 52 
 53 　　   猫：喵喵叫（猫继承动物的功能）
 54 
 55 　　   狗：汪汪叫（狗继承动物的功能）
 56 
 57 伪代码如下：
 58 class 动物:
 59 
 60     def 吃(self):
 61         # do something
 62 
 63     def 喝(self):
 64         # do something
 65 
 66     def 拉(self):
 67         # do something
 68 
 69     def 撒(self):
 70         # do something
 71 
 72 # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
 73 class 猫(动物)：
 74 
 75     def 喵喵叫(self):
 76         print '喵喵叫'
 77         
 78 # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
 79 class 狗(动物)：
 80 
 81     def 汪汪叫(self):
 82         print '喵喵叫'
 83 
 84 
 85 
 86 
 87 ==========================第三部分
 88 #继承的代码实现
 89 class Animal:
 90 
 91     def eat(self):
 92         print("%s 吃 " %self.name)
 93 
 94     def drink(self):
 95         print ("%s 喝 " %self.name)
 96 
 97     def shit(self):
 98         print ("%s 拉 " %self.name)
 99 
100     def pee(self):
101         print ("%s 撒 " %self.name)
102 
103 
104 class Cat(Animal):
105 
106     def __init__(self, name):
107         self.name = name
108         self.breed = '猫'
109 
110     def cry(self):
111         print('喵喵叫')
112 
113 class Dog(Animal):
114 
115     def __init__(self, name):
116         self.name = name
117         self.breed='狗'
118 
119     def cry(self):
120         print('汪汪叫')
121 
122 
123 # ######### 执行 #########
124 
125 c1 = Cat('小白家的小黑猫')
126 c1.eat()
127 
128 c2 = Cat('小黑的小白猫')
129 c2.drink()
130 
131 d1 = Dog('胖子家的小瘦狗')
132 d1.eat()
133 
134 使用继承来重用代码比较好的例子
    使用继承来重用代码

     在开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时

    我们不可能从头开始写一个类B，这就用到了类的继承的概念。

    通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用

     1 class Hero:
 2     def __init__(self,nickname,aggressivity,life_value):
 3         self.nickname=nickname
 4         self.aggressivity=aggressivity
 5         self.life_value=life_value
 6 
 7     def move_forward(self):
 8         print('%s move forward' %self.nickname)
 9 
10     def move_backward(self):
11         print('%s move backward' %self.nickname)
12 
13     def move_left(self):
14         print('%s move forward' %self.nickname)
15 
16     def move_right(self):
17         print('%s move forward' %self.nickname)
18 
19     def attack(self,enemy):
20         enemy.life_value-=self.aggressivity
21 class Garen(Hero):
22     pass
23 
24 class Riven(Hero):
25     pass
26 
27 g1=Garen('草丛伦',100,300)
28 r1=Riven('锐雯雯',57,200)
29 
30 print(g1.life_value)
31 r1.attack(g1)
32 print(g1.life_value)
33 
34 '''
35 运行结果
36 243
37 '''

    提示：用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分设置大部分，大大生了编程工作量，这就是常说的软件重用，不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据类型，这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大.

    注意：像g1.life_value之类的属性引用，会先从实例中找life_value然后去类中找，然后再去父类中找...直到最顶级的父类。

    当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。

    1 class Riven(Hero):
2     camp='Noxus'
3     def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
4         print('from riven')
5     def fly(self): #在自己这里定义新的
6         print('%s is flying' %self.nickname)

    在子类中，新建的重名的函数属性，在编辑函数内功能的时候，有可能需要重用父类中重名的那个函数功能，应该是用调用普通函数的方式，即：类名.func()，此时就与调用普通函数无异了，因此即便是self参数也要为其传值

     1 class Riven(Hero):
 2     camp='Noxus'
 3     def __init__(self,nickname,aggressivity,life_value,skin):
 4         Hero.__init__(self,nickname,aggressivity,life_value) #调用父类功能
 5         self.skin=skin #新属性
 6     def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
 7         Hero.attack(self,enemy) #调用功能
 8         print('from riven')
 9     def fly(self): #在自己这里定义新的
10         print('%s is flying' %self.nickname)
11 
12 r1=Riven('锐雯雯',57,200,'比基尼')
13 r1.fly()
14 print(r1.skin)
15 
16 '''
17 运行结果
18 锐雯雯 is flying
19 比基尼
20 
21 '''

    3.4、组合与重用性

    软件重用的重要方式除了继承之外还有另外一种方式，即：组合

    组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合

    其实早在3.5小节中我们就体会了组合的用法，比如一个英雄有一个装备

    >>> class Equip: #武器装备类
...     def fire(self):
...         print('release Fire skill')
... 
>>> class Riven: #英雄Riven的类,一个英雄需要有装备,因而需要组合Equip类
...     camp='Noxus'
...     def __init__(self,nickname):
...         self.nickname=nickname
...         self.equip=Equip() #用Equip类产生一个装备,赋值给实例的equip属性
... 
>>> r1=Riven('锐雯雯')
>>> r1.equip.fire() #可以使用组合的类产生的对象所持有的方法
release Fire skill

    组合与继承都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同，

    1.继承的方式

    通过继承建立了派生类与基类之间的关系，它是一种'是'的关系，比如白马是马，人是动物。

    当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如教授是老师

    >>> class Teacher:
...     def __init__(self,name,gender):
...         self.name=name
...         self.gender=gender
...     def teach(self):
...         print('teaching')
... 
>>> 
>>> class Professor(Teacher):
...     pass
... 
>>> p1=Professor('egon','male')
>>> p1.teach()
teaching

    2、组合的方式

    用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python课程

     1 class BirthDate:
 2     def __init__(self,year,month,day):
 3         self.year=year
 4         self.month=month
 5         self.day=day
 6 
 7 class Couse:
 8     def __init__(self,name,price,period):
 9         self.name=name
10         self.price=price
11         self.period=period
12 
13 class Teacher:
14     def __init__(self,name,gender):
15         self.name=name
16         self.gender=gender
17     def teach(self):
18         print('teaching')
19 class Professor(Teacher):
20     def __init__(self,name,gender,birth,course):
21         Teacher.__init__(self,name,gender)
22         self.birth=birth
23         self.course=course
24 
25 p1=Professor('egon','male',
26              BirthDate('1995','1','27'),
27              Couse('python','28000','4 months'))
28 
29 print(p1.birth.year,p1.birth.month,p1.birth.day)
30 print(p1.course.name,p1.course.price,p1.course.period)
31 '''
32 运行结果:
33 1 27
34 python 28000 4 months
35 '''

    当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好

    3.5、抽象

    1 什么是抽象类

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

    2 为什么要有抽象类

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

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

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

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

    3. 在python中实现抽象类

     1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 #一切皆文件
 4 import abc #利用abc模块实现抽象类
 5 
 6 class All_file(metaclass=abc.ABCMeta):
 7     all_type='file'
 8     @abc.abstractmethod #定义抽象方法，无需实现功能
 9     def read(self):
10         '子类必须定义读功能'
11         pass
12 
13     @abc.abstractmethod #定义抽象方法，无需实现功能
14     def write(self):
15         '子类必须定义写功能'
16         pass
17 
18 # class Txt(All_file):
19 #     pass
20 #
21 # t1=Txt() #报错,子类没有定义抽象方法
22 
23 class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
24     def read(self):
25         print('文本数据的读取方法')
26 
27     def write(self):
28         print('文本数据的读取方法')
29 
30 class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
31     def read(self):
32         print('硬盘数据的读取方法')
33 
34     def write(self):
35         print('硬盘数据的读取方法')
36 
37 class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
38     def read(self):
39         print('进程数据的读取方法')
40 
41     def write(self):
42         print('进程数据的读取方法')
43 
44 wenbenwenjian=Txt()
45 
46 yingpanwenjian=Sata()
47 
48 jinchengwenjian=Process()
49 
50 #这样大家都是被归一化了,也就是一切皆文件的思想
51 wenbenwenjian.read()
52 yingpanwenjian.write()
53 jinchengwenjian.read()
54 
55 print(wenbenwenjian.all_type)
56 print(yingpanwenjian.all_type)
57 print(jinchengwenjian.all_type)

    4. 抽象类与接口

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

    抽象类是一个介于类和接口直接的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计
  • 相关阅读:
    TP框架中模板赋值
    使用PHP和GZip压缩网站JS/CSS文件加速网站访问速度
    测试相关知识分享（百度和其他途径查找到的）
    测试基本概念
    shell编程之重定向
    shell编程之函数
    shell编程之循环
    shell编程之测试和判断
    shell编程之变量
    Linux系统学习之正则表达式
  • 原文地址：https://www.cnblogs.com/bravexz/p/7026592.html
Copyright © 2020-2023  润新知