Python---面向对象
Posted hpython
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python---面向对象相关的知识，希望对你有一定的参考价值。
本文参考资料：
http://www.cnblogs.com/wupeiqi/p/4493506.html
http://www.cnblogs.com/Eva-J/articles/7293890.html
http://www.cnblogs.com/linhaifeng/articles/6182264.html#_label1
Python基础教程（二）、Python编程：从入门到实践
一 为什么要有面向对象程序设计
面向过程--适用于简单、一次性的任务
优点：复杂度的问题流程化，进而简单化（一个复杂的问题，分成一个个小的步骤去实现，实现小的步骤将会非常简单）
缺点：扩展性差，不易维护。改一个组件，牵一发而动全身。
应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，Git，以及Apache HTTP Server等。
二 面向对象简介
面向对象编程是最有效的软件编写方法之一。在面向对象编程中，
你编写表示现实世界中的事物和情景的类，并基于这些类来创建对象。
编写类时，你定义一大类对象都有的通用行为。基于类创建对象时，
每个对象都自动具备这种通用行为，然后可根据需要赋予每个对象独
特的个性。使用面向对象编程可模拟现实情景，其逼真程度达到了令
你惊讶的地步。
优点：易扩展，更加贴近人类思维的特点, 更加脱离机器思维,是一次软件设计思想上的飞跃。
缺点：复杂度高、不可预知
应用场景：互联网应用、游戏、企业内部软件
三 类与对象
类
鸟是鸟类的实例。这就是一个有很多子类的的一般（抽象）类：看到的鸟可能属于子类“百灵鸟”。可以将“鸟类”想象成所有鸟的集合，而“百灵鸟”是其中的一个子集。当一个对象所属的类是另外一个对象所属类的子集时，前者就被称为后者的子类（subclass）,所以“百灵鸟类”是“鸟类”的子类。相反，“鸟类”是“百灵鸟类”的超类（superclass）.
在现实世界中：先有对象，再有类
世界上肯定是先出现各种各样的实际存在的物体，然后随着人类文明的发展，人类站在不同的角度总结出了不同的种类，如人类、动物类、植物类等概念
也就说，对象是具体的存在，而类仅仅只是一个概念，并不真实存在
在程序中：务必保证先定义类，后产生对象
这与函数的使用是类似的，先定义函数，后调用函数，类也是一样的，在程序中需要先定义类，后调用类
不一样的是，调用函数会执行函数体代码返回的是函数体执行的结果，而调用类会产生对象，返回的是对象
PS：
1. 站的角度不同，定义出的类是截然不同的，详见面向对象实战之需求分析
2. 现实中的类并不完全等于程序中的类，比如现实中的公司类，在程序中有时需要拆分成部门类，业务类......
3. 有时为了编程需求，程序中也可能会定义现实中不存在的类，比如策略类，现实中并不存在，但是在程序中却是一个很常见的类
对象
用变量表示特征，用函数表示技能，因而具有相同特征和技能的一类事物就是‘类’，对象是则是这一类事物中具体的一个。
类的相关知识
创建类
class Person: #定义一个人类 role = \'person\' #人的角色属性都是人 def walk(self): #人都可以走路，也就是有一个走路方法，也叫动态属性 print("person is walking...")
类有两种作用：属性引用和实例化
属性引用（类名.属性）
class Person: #定义一个人类 role = \'person\' #人的角色属性都是人 def walk(self): #人都可以走路，也就是有一个走路方法 print("person is walking...") print(Person.role) #查看人的role属性 print(Person.walk) #引用人的走路方法，注意，这里不是在调用
实例化
实例化：类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征
实例化的过程就是类——>对象的过程
原本我们只有一个Person类，在这个过程中，产生了一个egg对象，有自己具体的名字、攻击力和生命值。
语法：对象名 = 类名(参数)
egg = Person(\'egon\') #类名()就等于在执行Person.__init__() #执行完__init__()就会返回一个对象。这个对象类似一个字典，存着属于这个人本身的一些属性和方法。 #你可以偷偷的理解：egg = {\'name\':\'egon\',\'walk\':walk}
对象查看属性&调用方法
print(egg.name) #查看属性直接 对象名.属性名 print(egg.walk()) #调用方法，对象名.方法名()
关于self
self：在实例化时自动将对象/实例本身传给__init__的第一个参数，你也可以给他起个别的名字，但是正常人都不会这么做。
类属性的补充
一：我们定义的类的属性到底存到哪里了？有两种方式查看 dir(类名)：查出的是一个名字列表 类名.__dict__:查出的是一个字典，key为属性名，value为属性值，当前类的命名空间中的方法和属性
{"方法名"：方法的内存地址，"属性"：属性值,"_类名__属性名":属性值或者方法地址（注意：内置的在类名前面加一个下划线）}） 二：特殊的类属性 类名.__name__# 类的名字(字符串) 类名.__doc__# 类的文档字符串 类名.__base__# 类的第一个父类(在讲继承时会讲) 类名.__bases__# 类所有父类构成的元组(在讲继承时会讲) 类名.__dict__# 类的字典属性 类名.__module__# 类定义所在的模块 类名.__class__# 实例对应的类(仅新式类中)
对象的相关知识
class Person: # 定义一个人类 role = \'person\' # 人的角色属性都是人 def __init__(self, name, aggressivity, life_value): self.name = name # 每一个角色都有自己的昵称; self.aggressivity = aggressivity # 每一个角色都有自己的攻击力; self.life_value = life_value # 每一个角色都有自己的生命值; def attack(self,dog): # 人可以攻击狗，这里的狗也是一个对象。 # 人攻击狗，那么狗的生命值就会根据人的攻击力而下降 dog.life_value -= self.aggressivit
对象是关于类而实际存在的一个例子，即实例
对象/实例只有一种作用：属性引用
egg = Person(\'egon\',10,1000) print(egg.name) print(egg.aggressivity) print(egg.life_value)
当然了，你也可以引用一个方法，因为方法也是一个属性，只不过是一个类似函数的属性，我们也管它叫动态属性。
引用动态属性并不是执行这个方法，要想调用方法和调用函数是一样的，都需要在后面加上括号
print(egg.attack())
面向对象小结——定义及调用的固定模式
class 类名: def __init__(self,参数1,参数2): self.对象的属性1 = 参数1 self.对象的属性2 = 参数2 def 方法名(self):pass def 方法名2(self):pass 对象名 = 类名(1,2) #对象就是实例，代表一个具体的东西 #类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法 #括号里传参数，参数不需要传self，其他与init中的形参一一对应 #结果返回一个对象 对象名.对象的属性1 #查看对象的属性，直接用 对象名.属性名 即可 对象名.方法名() #调用类中的方法，直接用 对象名.方法名() 即可
类命名空间与对象、实例的命名空间
创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性
而类有两种属性：静态属性和动态属性
- 静态属性就是直接在类中定义的变量
- 动态属性就是定义在类中的方法
静态属
其中类的数据属性是共享给所有对象的
>>>id(egg.role) 4341594072 >>>id(Person.role) 4341594072
动态属
而类的动态属性是绑定到所有对象的
>>>egg.attack <bound method Person.attack of <__main__.Person object at 0x101285860>> >>>Person.attack <function Person.attack at 0x10127abf8>
创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性
在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常
面向对象的组合用法
软件中重用的重要方式除了继承之外还有另外一种方式，即：组合
组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合
class Weapon: def prick(self, obj): # 这是该装备的主动技能,扎死对方 obj.life_value -= 500 # 假设攻击力是500 class Person: # 定义一个人类 role = \'person\' # 人的角色属性都是人 def __init__(self, name): self.name = name # 每一个角色都有自己的昵称; self.weapon = Weapon() # 给角色绑定一个武器; egg = Person(\'egon\') egg.weapon.prick() #egg组合了一个武器的对象，可以直接egg.weapon来使用组合类中的所有方法
使用组合计算圆环
#圆环是由两个圆组成的，圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是内部圆的周长加上外部圆的周长。 #这个时候，我们就首先实现一个圆形类，计算一个圆的周长和面积。然后在"环形类"中组合圆形的实例作为自己的属性来用 from math import pi class Circle: \'\'\' 定义了一个圆形类； 提供计算面积(area)和周长(perimeter)的方法 \'\'\' def __init__(self,radius): self.radius = radius def area(self): return pi * self.radius * self.radius def perimeter(self): return 2 * pi *self.radius circle = Circle(10) #实例化一个圆 area1 = circle.area() #计算圆面积 per1 = circle.perimeter() #计算圆周长 print(area1,per1) #打印圆面积和周长 class Ring: \'\'\' 定义了一个圆环类 提供圆环的面积和周长的方法 \'\'\' def __init__(self,radius_outside,radius_inside): self.outsid_circle = Circle(radius_outside) self.inside_circle = Circle(radius_inside) def area(self): return self.outsid_circle.area() - self.inside_circle.area() def perimeter(self): return self.outsid_circle.perimeter() + self.inside_circle.perimeter() ring = Ring(10,5) #实例化一个环形 print(ring.perimeter()) #计算环形的周长 print(ring.area()) #计算环形的面积
用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python课程
class BirthDate: def __init__(self,year,month,day): self.year=year self.month=month self.day=day class Couse: def __init__(self,name,price,period): self.name=name self.price=price self.period=period class Teacher: def __init__(self,name,gender,birth,course): self.name=name self.gender=gender self.birth=birth self.course=course def teach(self): print(\'teaching\') p1=Teacher(\'egon\',\'male\', BirthDate(\'1995\',\'1\',\'27\'), Couse(\'python\',\'28000\',\'4 months\') ) print(p1.birth.year,p1.birth.month,p1.birth.day) print(p1.course.name,p1.course.price,p1.course.period) \'\'\' 运行结果: 1 27 python 28000 4 months \'\'\'
当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好
面向对象的三大特性
继承
什么是继承
继承是另外一个懒惰（褒义）的行为。比如说有个Shape类，可以在屏幕上画出指定的形状，现在需要创建一个叫做Rectang的类，他不但可以在屏幕上画出指定的形状，而且还能计算该形状的面积。但又不想把Shape里面已经写好的draw方法再写一次。那么怎么办？ 可以让Rectang从Shape类继承方法。在Rectang上调用draw方法时，程序自动从Shape调用方法。
新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类
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\'>,)
继承与抽象（先抽象再继承）
抽象即抽取类似或者说比较像的部分。
抽象分成两个层次：
1.将奥巴马和梅西这俩对象比较像的部分抽取成类；
2.将人，猪，狗这三个类比较像的部分抽取成父类。
抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）
继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。
抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类
继承之重用性
==========================第一部分
例如
猫可以：喵喵叫、吃、喝、拉、撒
狗可以：汪汪叫、吃、喝、拉、撒
如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，伪代码如下：
#猫和狗有大量相同的内容
class 猫：
def 喵喵叫(self):
print \'喵喵叫\'
def 吃(self):
# do something
def 喝(self):
# do something
def 拉(self):
# do something
def 撒(self):
# do something
class 狗：
def 汪汪叫(self):
print \'汪汪叫\'
def 吃(self):
# do something
def 喝(self):
# do something
def 拉(self):
# do something
def 撒(self):
# do something
==========================第二部分
上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：
动物：吃、喝、拉、撒
猫：喵喵叫（猫继承动物的功能）
狗：汪汪叫（狗继承动物的功能）
伪代码如下：
class 动物:
def 吃(self):
# do something
def 喝(self):
# do something
def 拉(self):
# do something
def 撒(self):
# do something
# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 猫(动物)：
def 喵喵叫(self):
print \'喵喵叫\'
# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 狗(动物)：
def 汪汪叫(self):
print \'汪汪叫\'
==========================第三部分
#继承的代码实现
class Animal:
def eat(self):
print("%s 吃 " %self.name)
def drink(self):
print ("%s 喝 " %self.name)
def shit(self):
print ("%s 拉 " %self.name)
def pee(self):
print ("%s 撒 " %self.name)
class Cat(Animal):
def __init__(self, name):
self.name = name
self.breed = \'猫\'
def cry(self):
print(\'喵喵叫\')
class Dog(Animal):
def __init__(self, name):
self.name = name
self.breed=\'狗\'
def cry(self):
print(\'汪汪叫\')
# ######### 执行 #########
c1 = Cat(\'小白家的小黑猫\')
c1.eat()
c2 = Cat(\'小黑的小白猫\')
c2.drink()
d1 = Dog(\'胖子家的小瘦狗\')
d1.eat()
使用继承来重用代码比较好的例子
使用继承来解决代码重用的例子
class Animal:
\'\'\'
人和狗都是动物，所以创造一个Animal基类
\'\'\'
def __init__(self, name, aggressivity, life_value):
self.name = name # 人和狗都有自己的昵称;
self.aggressivity = aggressivity # 人和狗都有自己的攻击力;
self.life_value = life_value # 人和狗都有自己的生命值;
def eat(self):
print(\'%s is eating\'%self.name)
class Dog(Animal):
pass
class Person(Animal):
pass
egg = Person(\'egon\',10,1000)
ha2 = Dog(\'二愣子\',50,1000)
egg.eat()
ha2.eat()
提示：用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分设置大部分，大大生了编程工
作量，这就是常说的软件重用，不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据
类型，这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大.
派生
当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。
示例
class Animal:
\'\'\'
人和狗都是动物，所以创造一个Animal基类
\'\'\'
def __init__(self, name, aggressivity, life_value):
self.name = name # 人和狗都有自己的昵称;
self.aggressivity = aggressivity # 人和狗都有自己的攻击力;
self.life_value = life_value # 人和狗都有自己的生命值;
def eat(self):
print(\'%s is eating\'%self.name)
class Dog(Animal):
\'\'\'
狗类，继承Animal类
\'\'\'
def bite(self, people):
\'\'\'
派生：狗有咬人的技能
:param people:
\'\'\'
people.life_value -= self.aggressivity
class Person(Animal):
\'\'\'
人类，继承Animal
\'\'\'
def attack(self, dog):
\'\'\'
派生：人有攻击的技能
:param dog:
\'\'\'
dog.life_value -= self.aggressivity
egg = Person(\'egon\',10,1000)
ha2 = Dog(\'二愣子\',50,1000)
print(ha2.life_value)
print(egg.attack(ha2))
print(ha2.life_value)
注意：对象的属性引用，会先从实例中找l然后去类中找，然后再去父类中找...直到最顶级的父类。
在python3中，子类执行父类的方法也可以直接用super方法.
class A:
def hahaha(self):
print(\'A\')
class B(A):
def hahaha(self):
super().hahaha()
#super(B,self).hahaha()
#A.hahaha(self)
print(\'B\')
a = A()
b = B()
b.hahaha()
super(B,b).hahaha()
class Animal:
\'\'\'
人和狗都是动物，所以创造一个Animal基类
\'\'\'
def __init__(self, name, aggressivity, life_value):
self.name = name # 人和狗都有自己的昵称;
self.aggressivity = aggressivity # 人和狗都有自己的攻击力;
self.life_value = life_value # 人和狗都有自己的生命值;
def eat(self):
print(\'%s is eating\'%self.name)
class Dog(Animal):
\'\'\'
狗类，继承Animal类
\'\'\'
def __init__(self,name,breed,aggressivity,life_value):
super().__init__(name, aggressivity, life_value) #执行父类Animal的init方法
self.breed = breed #派生出了新的属性
def bite(self, people):
\'\'\'
派生出了新的技能：狗有咬人的技能
:param people:
\'\'\'
people.life_value -= self.aggressivity
def eat(self):
# Animal.eat(self)
#super().eat()
print(\'from Dog\')
class Person(Animal):
\'\'\'
人类，继承Animal
\'\'\'
def __init__(self,name,aggressivity, life_value,money):
#Animal.__init__(self, name, aggressivity, life_value)
#super(Person, self).__init__(name, aggressivity, life_value)
super().__init__(name,aggressivity, life_value) #执行父类的init方法
self.money = money #派生出了新的属性
def attack(self, dog):
\'\'\'
派生出了新的技能：人有攻击的技能
:param dog:
\'\'\'
dog.life_value -= self.aggressivity
def eat(self):
#super().eat()
Animal.eat(self)
print(\'from Person\')
egg = Person(\'egon\',10,1000,600)
ha2 = Dog(\'二愣子\',\'哈士奇\',10,1000)
print(egg.name)
print(ha2.name)
egg.eat()
通过继承建立了派生类与基类之间的关系，它是一种\'是\'的关系，比如白马是马，人是动物。
当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如教授是老师
>>> 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
接口类
继承有两种用途：
一：继承基类的方法，并且做出自己的改变或者扩展（代码重用）
二：声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能
class Alipay: \'\'\' 支付宝支付 \'\'\' def pay(self,money): print(\'支付宝支付了%s元\'%money) class Applepay: \'\'\' apple pay支付 \'\'\' def pay(self,money): print(\'apple pay支付了%s元\'%money) def pay(payment,money): \'\'\' 支付函数，总体负责支付 对应支付的对象和要支付的金额 \'\'\' payment.pay(money) p = Alipay() pay(p,200)
开发中容易出现的问题
class Alipay: \'\'\' 支付宝支付 \'\'\' def pay(self,money): print(\'支付宝支付了%s元\'%money) class Applepay: \'\'\' apple pay支付 \'\'\' def pay(self,money): print(\'apple pay支付了%s元\'%money) class Wechatpay: def fuqian(self,money): \'\'\' 实现了pay的功能，但是名字不一样 \'\'\' print(\'微信支付了%s元\'%money) def pay(payment,money): \'\'\' 支付函数，总体负责支付 对应支付的对象和要支付的金额 \'\'\' payment.pay(money) p = Wechatpay() pay(p,200) #执行会报错
接口初成：手动报异常：NotImplementedError来解决开发中遇到的问题
class Payment: def pay(self): raise NotImplementedError class Wechatpay(Payment): def fuqian(self,money): print(\'微信支付了%s元\'%money) p = Wechatpay() #这里不报错 pay(p,200) #这里报错了
借用abc模块来实现接口
from abc import ABCMeta,abstractmethod class Payment(metaclass=ABCMeta): @abstractmethod def pay(self,money): pass class Wechatpay(Payment): def fuqian(self,money): print(\'微信支付了%s元\'%money) p = Wechatpay() #不调就报错了
实践中，继承的第一种含义意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。
继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。
归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。
依赖倒置原则：
高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该应该依赖细节；细节应该依赖抽象。换言之，要针对接口编程，而不是针对实现编程
在python中根本就没有一个叫做interface的关键字，上面的代码只是看起来像接口，其实并没有起到接口的作用，子类完全可以不用去实现接口 ，如果非要去模仿接口的概念，可以借助第三方模块：
http://pypi.python.org/pypi/zope.interface
twisted的twisted\\internet\\interface.py里使用zope.interface
文档https://zopeinterface.readthedocs.io/en/latest/
设计模式：https://github.com/faif/python-patterns
接口提取了一群类共同的函数，可以把接口当做一个函数的集合。
然后让子类去实现接口中的函数。
这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。
归一化，让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。
比如：我们定义一个动物接口，接口里定义了有跑、吃、呼吸等接口函数，这样老鼠的类去实现了该接口，松鼠的类也去实现了该接口，由二者分别产生一只老鼠和一只松鼠送到你面前，即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑，都会吃，都能呼吸。
再比如：我们有一个汽车接口，里面定义了汽车所有的功能，然后由本田汽车的类，奥迪汽车的类，大众汽车的类，他们都实现了汽车接口，这样就好办了，大家只需要学会了怎么开汽车，那么无论是本田，还是奥迪，还是大众我们都会开了，开的时候根本无需关心我开的是哪一类车，操作手法（函数调用）都一样
理解：接口类，是用来规范子类，每个类方法是一致的，使用者在调用时，无需关心对象的类是什么，方便使用
抽象类
什么是抽象类
与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化
为什么要有抽象类
如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。
比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类抽取相同的内容就是水果这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。
从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。
从实现角度来看，抽象类与普通类的不同之处在于：抽象类中有抽象方法，该类不能被实例化，只能被继承，且子类必须实现抽象方法。这一点与接口有点类似，但其实是不同的，即将揭晓答案
在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): # pass # # t1=Txt() #报错,子类没有定义抽象方法 class Txt(All_file):以上是关于Python---面向对象的主要内容，如果未能解决你的问题，请参考以下文章