python：类的基本特征------继承、多态与封装_python

概述一、继承1，什么是继承继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类python中类的继承分为：单继承和多继承class ParentClass1: #定义父类passclass ParentClass2: #定义父类passclass SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClasspassclass SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类，SubClass2就是多继承pass2，查看继承>>> 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，继承与抽象（先抽象再继承）抽象即抽取类似或者说比较像的部分。抽象分成两个层次： 1.将奥巴马和梅西这俩对象比较像的部分抽取成类； 2.将人，猪，狗这三个类比较像的部分抽取成父类。继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。4，继承与重用性==========================第一部分例如猫可以：喵喵叫、吃、喝、拉、撒狗可以：汪汪叫、吃、喝、拉、撒如果我们要分别为猫和狗创建一个类，那么就需要为猫和狗实现他们所有的功能，伪代码如下：#猫和狗有大量相同的内容class 猫：def 喵喵叫(self):print '喵喵叫'def 吃(self):# do somethingdef 喝(self):# do somethingdef 拉(self):# do somethingdef 撒(self):# do somethingclass 狗：def 汪汪叫(self):print '汪汪叫'def 吃(self):# do somethingdef 喝(self):# do somethingdef 拉(self):# do somethingdef 撒(self):# do something==========================第二部分上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用继承的思想，如下实现：动物：吃、喝、拉、撒猫：喵喵叫（猫继承动物的功能）狗：汪汪叫（狗继承动物的功能）伪代码如下：class 动物:def 吃(self):# do somethingdef 喝(self):# do somethingdef 拉(self):# do somethingdef 撒(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 = nameself.breed = '猫'def cry(self):print('喵喵叫')class Dog(Animal):def __init__(self, name):self.name = nameself.breed='狗'def cry(self):print('汪汪叫')# ######### 执行 #########c1 = Cat('小白家的小黑猫')c1.eat()c2 = Cat('小黑的小白猫')c2.drink()d1 = Dog('胖子家的小瘦狗')d1.eat()使用继承来重用代码比较好的例子使用继承来解决代码重用的例子继承与重用性在开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时我们不可能从头开始写一个类B，这就用到了类的继承的概念。通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用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):passclass Person(Animal):passegg = Person('egon',10,1000)ha2 = Dog('二愣子',50,1000)egg.eat()ha2.eat()5，派生当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。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.aggressivityclass Person(Animal):'''人类，继承Animal'''def attack(self, dog):'''派生：人有攻击的技能:param dog:'''dog.life_value -= self.aggressivityegg = Person('egon',10,1000)ha2 = Dog('二愣子',50,1000)print(ha2.life_value)print(egg.attack(ha2))print(ha2.life_value)在子类中，新建的重名的函数属性，在编辑函数内功能的时候，有可能需要重用父类中重名的那个函数功能，应该是用调用普通函数的方式，即：类名.func()，此时就与调用普通函数无异了，因此即便是self参数也要为其传值.6，superclass 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 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()帮你了解super通过继承建立了派生类与基类之间的关系，它是一种'是'的关系，比如白马是马，人是动物。当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如教授是老师>>> 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()teaching7，钻石继承继承顺序当类是经典类时，多继承情况下，会按照深度优先方式查找当类是新式类时，多继承情况下，会按照广度优先方式查找经典类和新式类：从写法上类或者父类继承了object类，那么该类便是新式类，否则便是经典类。class A(object):def test(self):print('from A')class B(A):def test(self):print('from B')class C(A):def test(self):print('from C')class D(B):def test(self):print('from D')class E(C):def test(self):print('from E')class F(D,E):# def test(self):# pri

<h2 >一、继承

1，什么是继承

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

ParentClass1:

class ParentClass2: #定义父类
pass

class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
pass

class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类，SubClass2就是多继承

2，查看继承

>>> SubClass1. (< >>>> SubClass2.< >,< >)

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

>>> ParentClass1.< >>>> ParentClass2.< >,)

3，继承与抽象（先抽象再继承）

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

抽象分成两个层次：

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

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

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

4，继承与重用性

==========================　　猫可以：喵喵叫、吃、喝、拉、撒

　　狗可以：汪汪叫、吃、喝、拉、撒

如果我们要分别为猫和狗创建一个类，那么就需要为猫和狗实现他们所有的功能，伪代码如下：

#猫和狗有大量相同的内容
class 猫：

</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; 喵喵叫(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;print</span> <span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;喵喵叫</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; 吃(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt;#</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt; do something</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; 喝(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt;#</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt; do something</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; 拉(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt;#</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt; do something</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; 撒(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt;#</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt; do something</span>

class 狗：

</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; 汪汪叫(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;print</span> <span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;汪汪叫</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; 吃(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt;#</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt; do something</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; 喝(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt;#</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt; do something</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; 拉(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt;#</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt; do something</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; 撒(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt;#</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt; do something</span>

==========================第二部分
上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用继承的思想，如下实现：

　　动物：吃、喝、拉、撒

　　猫：喵喵叫（猫继承动物的功能）

　　狗：汪汪叫（狗继承动物的功能）

伪代码如下：
class 动物:

</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; 吃(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt;#</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt; do something</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; 喝(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt;#</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt; do something</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; 拉(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt;#</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt; do something</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; 撒(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt;#</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt; do something</span>

# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 猫(动物)：

</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; 喵喵叫(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;print</span> <span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;喵喵叫</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span>

# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 狗(动物)：

</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; 汪汪叫(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;print</span> <span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;汪汪叫</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span>

==========================第三部分
#继承的代码实现
class Animal:

</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; eat(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;print</span>(<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;"</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;<a href="https://www.jb51.cc/tag/s/" target="_blank" >%s</a> 吃 </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;"</span> %<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;self.<a href="https://m.jb51.cc/tag/name/" target="_blank" >name</a>)</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; drink(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;print</span> (<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;"</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;<a href="https://www.jb51.cc/tag/s/" target="_blank" >%s</a> 喝 </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;"</span> %<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;self.<a href="https://m.jb51.cc/tag/name/" target="_blank" >name</a>)</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; shit(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;print</span> (<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;"</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;<a href="https://www.jb51.cc/tag/s/" target="_blank" >%s</a> 拉 </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;"</span> %<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;self.<a href="https://m.jb51.cc/tag/name/" target="_blank" >name</a>)</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; pee(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;print</span> (<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;"</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;<a href="https://www.jb51.cc/tag/s/" target="_blank" >%s</a> 撒 </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;"</span> %<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;self.<a href="https://m.jb51.cc/tag/name/" target="_blank" >name</a>)

class Cat(Animal):

</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span> <span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800080"&gt;<a href="https://www.jb51.cc/tag/init/" target="_blank" >__init__</a></span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;(self,<a href="https://m.jb51.cc/tag/name/" target="_blank" >name</a>):    self.<a href="https://m.jb51.cc/tag/name/" target="_blank" >name</a> </span>=<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; <a href="https://m.jb51.cc/tag/name/" target="_blank" >name</a>    self.breed </span>= <span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;猫</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; cry(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;print</span>(<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;喵喵叫</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;)

class Dog(Animal):

</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span> <span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800080"&gt;<a href="https://www.jb51.cc/tag/init/" target="_blank" >__init__</a></span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;(self,<a href="https://m.jb51.cc/tag/name/" target="_blank" >name</a>):    self.<a href="https://m.jb51.cc/tag/name/" target="_blank" >name</a> </span>=<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; <a href="https://m.jb51.cc/tag/name/" target="_blank" >name</a>    self.breed</span>=<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;狗</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; cry(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;print</span>(<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;汪汪叫</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;)

# ######### 执行 #########

c1 = Cat('小白家的小黑猫')
c1.eat()

c2 = Cat('小黑的小白猫')
c2.drink()

d1 = Dog('胖子家的小瘦狗')
d1.eat()

使用继承来重用代码比较好的例子

使用继承来解决代码重用的例子

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

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

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

= name self.aggressivity = aggressivity self.life_value = life_value

<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; eat(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;print</span>(<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;<a href="https://www.jb51.cc/tag/s/" target="_blank" >%s</a> is eating</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span>%<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;self.<a href="https://m.jb51.cc/tag/name/" target="_blank" >name</a>)

class Dog(Animal):
pass

class Person(Animal):
pass

egg = Person('egon',10,1000)
ha2 = Dog('二愣子',50,1000)
egg.eat()
ha2.eat()

5，派生

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

= name self.aggressivity = aggressivity self.life_value = life_value

<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; eat(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;print</span>(<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;<a href="https://www.jb51.cc/tag/s/" target="_blank" >%s</a> is eating</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span>%<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;self.<a href="https://m.jb51.cc/tag/name/" target="_blank" >name</a>)

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',1000)
print(ha2.life_value)
print(egg.attack(ha2))
print(ha2.life_value)

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

6，super

(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 B(A):
def hahaha(self):
super().hahaha()
#super(B,b).hahaha()

帮你了解super

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

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

>>> ==(>>> >>> >>> p1=Professor(,>>>

7，钻石继承

继承顺序

当类是经典类时，多继承情况下，会按照深度优先方式查找

当类是新式类时，多继承情况下，会按照广度优先方式查找

经典类和新式类：

从写法上类或者父类继承了object类，那么该类便是新式类，否则便是经典类。

(class B(A):
def test(self):
print('from B')

class C(A):
def test(self):
print('from C')

class D(B):
def test(self):
print('from D')

class E(C):
def test(self):
print('from E')

class F(D,E):
# def test(self):
# print('from F')
pass
f1=F()
f1.test()
print(F.mro) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性

#新式类继承顺序:F->D->B->E->C->A

经典类继承顺序:F->D->B->A->E->Cpython3中统一都是新式类pyhon2中才分新式类与经典类

8，继承原理

python到底是如何实现继承的，对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列

>>> F.mro() [< >,< >,< >,< >,< >,< >,< >]

为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:1.子类会先于父类被检查2.多个父类会根据它们在列表中的顺序被检查3.如果对下一个类存在两个合法的选择,选择第一个父类

二、多态1，抽象类与接口类

继承有两种用途：

一：继承基类的方法，并且做出自己的改变或者扩展（代码重用）

二：声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能

(%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 Wechatpay:
def fuqian(self,money):
'''
实现了pay的功能，但是名字不一样
'''
print('微信支付了%s元'%money)

def pay(payment,money):
'''
支付函数，总体负责支付
对应支付的对象和要支付的金额
'''
payment.pay(money)

p = Wechatpay()
pay(p,200) #执行会报错

借用abc模块来实现接口

abc class Payment(Metaclass=ABCMeta):
@abstractmethod
def pay(self,money):
pass

class Wechatpay(Payment):
def fuqian(self,money):
print('微信支付了%s元'%money)

p = Wechatpay() #不调就报错了

实践中，继承的第一种含义意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。

继承的第二种含义非常重要。它又叫“接口继承”。接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。

归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。

抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化

abc

class All_file(Metaclass=abc.ABCMeta):
all_type='file'
@abc.abstractmethod #定义抽象方法，无需实现功能
def read(self):
'子类必须定义读功能'
pass

@abc.abstractmethod </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt;#</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #008000"&gt;定义抽象<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" >方法</a>，无需实现<a href="https://www.jb51.cc/tag/gongneng/" target="_blank" >功能</a></span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; write(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;子类必须定义写<a href="https://www.jb51.cc/tag/gongneng/" target="_blank" >功能</a></span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span>    <span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;pass</span>

# class Txt(All_file):

pass t1=Txt() #报错,子类没有定义抽象方法

class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
def read(self):
print('文本数据的读取方法')

</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; write(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;print</span>(<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;文本数据的读取<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" >方法</a></span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;)

class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
def read(self):
print('硬盘数据的读取方法')

</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; write(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;print</span>(<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;硬盘数据的读取<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" >方法</a></span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;)

class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
def read(self):
print('进程数据的读取方法')

</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; write(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;print</span>(<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;进程数据的读取<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" >方法</a></span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800000"&gt;'</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;)

wenbenwenjian=Txt()

yingpanwenjian=Sata()

jinchengwenjian=Process()

#这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()

print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

<div >

12<span >.方法的实现
在抽象类中，我们可以对一些抽象方法做出基础实现；
而在接口类中，任何方法都只是一种规范，具体的功能需要子类实现

python中没有接口类，有抽象类，abc模块中的Metaclass =ABCMeta,@abstrutmethod

本质是做代码规范用的，希望在子类中实现和父类方法名字完全一样的方法

在Java的角度来看是有区别的：

　　Java本来就支持单继承，所以就有了抽象类

　　Java没有多继承，所以为了接口隔离原则，设计了接口这个概念

　　python即支持单继承页支持多继承，所以对于接口类和抽象类的区别就不明显了。

甚至在python中没有内置接口类。

2，多态

多态指的是一类事物有多种形态

动物有多种形态：人，狗，猪

Animal(Metaclass=abc.ABCMeta):

class People(Animal): #动物的形态之一:人
def talk(self):
print('say hello')

class Dog(Animal): #动物的形态之二:狗
def talk(self):
print('say wangwang')

class Pig(Animal): #动物的形态之三:猪
def talk(self):
print('say aoao')

3，多态性peo===#peo、dog、pig都是动物,只要是动物肯定有talk方法

于是我们可以不用考虑它们三者的具体是什么类型,而直接使用

peo.talk()
dog.talk()
pig.talk()

#更进一步,我们可以定义一个统一的接口来使用
def func(obj):
obj.talk()

4，鸭子类型---不依赖父类的情况下实现两个相似的类中的同名方法

<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; write(self):    </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;pass</span>

class diskfile:
def read(self):
pass
def write(self):
pass

三、封装--私有的

在python中只要___名字，就把这个名字私有化了

私有化之后，就不能从类的外部直接调用了

静态属性、方法对象属性、都可以私有化

这种私有化只是从代码级别做了变性并没有真的约束

变形机制：_类名__名字，在类外用这个调用，在累得内部直接__名字调用

在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）

class A:
N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_AN
def init(self):
self.X=10 #变形为self._AX
def foo(self): #变形为_Afoo
print('from A')
def bar(self):
self.foo() #只有在类内部才可以通过foo的形式访问到.

#A._A__N是可以访问到的，即这种 *** 作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形

这种自动变形的特点：

1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。

2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。

3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

这种变形需要注意的问题是：

1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N

2.变形的过程只在类的内部生效,在定义后的赋值 *** 作，不会变形

3.在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

= = = self. type(newname) str newname.isdigit() == =( self. * self.jin = Room('金老板',2,1)
print(jin.area())
jin.set_name('2')
print(jin.get_name())

并不能修改私有化属性

>>> (>>> (>>> b=>>>#把fa定义成私有的，即__fa

class A:
... def fa(self): #在定义时就变形为_Afa
... print('from A')
... def test(self):
... self.fa() #只会与自己所在的类为准,即调用_A__fa
...
>>> class B(A):
... def fa(self):
... print('from B')
...
>>> b=B()
>>> b.test()
from A

会用到私有的这个概念de场景1.隐藏起一个属性 不想让类的外部调用2.我想保护这个属性，不想让属性随意被改变3.我想保护这个属性，不被子类继承2，property属性什么是特性propertyproperty是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值

例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）

成人的BMI数值：
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：28-32
非常肥胖,高于32
　　体质指数（BMI）=体重（kg）÷身高^2（m）
　　EX：70kg÷（1.75×1.75）=22.86

<div >
<img ID="code_img_closedaa5a0c36-9180-4c4a-abe7-e2e317620b44" src="https://www.jb51.cc/res/2019/02-25/18/1c53668bcee393edac0d7b3b3daff1ae.gif" alt=""><img ID="code_img_openedaa5a0c36-9180-4c4a-abe7-e2e317620b44" src="https://www.jb51.cc/res/2019/02-25/18/405b18b4b6584ae338e0f6ecaf736533.gif" alt=""><div ID="cnblogs_code_open_aa5a0c36-9180-4c4a-abe7-e2e317620b44" >
== self.weight/(self.length)**2=Bmi(62,1.8(a.bmi)
(self,radius): self.radius=@propertycolor</a>: #0000ff">defcolor</a>: #000000"> area(self): color</a>: #0000ff">return math.pi * self.radius**2 color</a>: #008000">#color</a>: #008000">计算面积

@property
def perimeter(self):
return 2math.piself.radius #计算周长

c=Circle(10)
print(c.radius)
print(c.area) #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值
print(c.perimeter) #同上
'''
输出结果:
314.1592653589793
62.83185307179586
'''
例二：圆的周长和面积
为什么要用property
将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则
python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现
=val self. isinstance(value,str): TypeError( %=value TypeError(f=Foo('egon')
print(f.name)
# f.name=10 #抛出异常'TypeError: 10 must be str'
del f.name #抛出异常'TypeError: Can not delete'
一个静态属性property本质就是实现了get，set，delete三种方法
(@AAA.settercolor</a>: #0000ff">defcolor</a>: #000000"> AAA(self,value): color</a>: #0000ff">print(color</a>: #800000">'color</a>: #800000">set的时候运行我啊color</a>: #800000">'color</a>: #000000">)@AAA.deletercolor</a>: #0000ff">defcolor</a>: #000000"> AAA(self): color</a>: #0000ff">print(color</a>: #800000">'color</a>: #800000">delete的时候运行我啊color</a>: #800000">'color</a>: #000000">)
#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA
(color</a>: #0000ff">defcolor</a>: #000000"> set_AAA(self,value): color</a>: #0000ff">print(color</a>: #800000">'color</a>: #800000">set的时候运行我啊color</a>: #800000">'color</a>: #000000">)color</a>: #0000ff">defcolor</a>: #000000"> delete_AAA(self): color</a>: #0000ff">print(color</a>: #800000">'color</a>: #800000">delete的时候运行我啊color</a>: #800000">'color</a>: #000000">)AAA=property(get_AAA,set_AAA,delete_AAA) color</a>: #008000">#color</a>: #008000">内置property三个<a href="https://m.jb51.cc/tag/canshu/" target="_blank" >参数</a>与get,set,delete一一对应

f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA
怎么用？
color</a>: #0000ff">def color</a>: #800080"><a href="https://www.jb51.cc/tag/init/" target="_blank" >__init__</a>color</a>: #000000">(self): color</a>: #008000">#color</a>: #008000"> 原价 self.original_price = 100 color</a>: #008000">#color</a>: #008000"> 折扣 self.<a href="https://www.jb51.cc/tag/dis/" target="_blank" >dis</a>count = 0.8color</a>: #000000">@propertycolor</a>: #0000ff">defcolor</a>: #000000"> price(self): color</a>: #008000">#color</a>: #008000"> 实际价格 = 原价 * 折扣 new_price = self.original_price *color</a>: #000000"> self.<a href="https://www.jb51.cc/tag/dis/" target="_blank" >dis</a>count color</a>: #0000ff">returncolor</a>: #000000"> [email protected]color</a>: #0000ff">defcolor</a>: #000000"> price(self,value): self.original_price =color</a>: #000000"> [email protected]color</a>: #0000ff">defcolor</a>: #000000"> price(self): color</a>: #0000ff">delcolor</a>: #000000"> self.original_price
obj = Goods()
obj.price # 获取商品价格
obj.price = 200 # 修改商品原价
print(obj.price)
del obj.price # 删除商品原价
3，classmethod= @classmethodcolor</a>: #0000ff">defcolor</a>: #000000"> func(cls): color</a>: #0000ff">printcolor</a>: #000000">(cls.r<a href="https://m.jb51.cc/tag/ol/" target="_blank" >ol</a>e)
Classmethod_Demo.func()
4，staticmethod= @stati<a href="https://www.jb51.cc/tag/cme/" target="_blank" >cme</a>thodcolor</a>: #0000ff">defcolor</a>: #000000"> func(): color</a>: #0000ff">print(color</a>: #800000">"color</a>: #800000">当<a href="https://www.jb51.cc/tag/putongfangfa/" target="_blank" >普通方法</a>用color</a>: #800000">"color</a>: #000000">)
Staticmethod_Demo.func()

总结
以上是内存溢出为你收集整理的python：类的基本特征------继承、多态与封装全部内容，希望文章能够帮你解决python：类的基本特征------继承、多态与封装所遇到的程序开发问题。
如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。

欢迎分享，转载请注明来源：内存溢出
原文地址: https://outofmemory.cn/langs/1208000.html

python：类的基本特征------继承、多态与封装

发表评论

评论列表（0条）