1. Définition de l'héritage
L'héritage est un moyen de créer une nouvelle classe. En python, une nouvelle classe peut hériter d'une ou plusieurs classes parentes.
2. Héritage unique et héritage multiple
class ParentClass1: #定义父类
pass
class ParentClass2: #定义父类
pass
class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
pass
class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
pass
Afficher l'héritage
>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)
Astuce : Si aucune classe de base n'est spécifiée, la classe python héritera par défaut de la classe d'objet. Object est la classe de base de toutes les classes python, qui fournit l'implémentation de certaines méthodes courantes (telles que __str__).
>>> ParentClass1.__bases__
(<class 'object'>,)
>>> ParentClass2.__bases__
(<class 'object'>,)
3. Héritage et abstraction (d'abord abstraction puis héritage)
L'abstraction consiste à extraire des parties similaires ou plus similaires.
Il existe deux niveaux d'abstraction :
Extraire les parties similaires d'Obama et de Messi en classes ;
Extrayez les parties similaires des trois classes de personnes, de porcs et de chiens en tant que classe parent.
La fonction principale de l'abstraction est de diviser les catégories (ce qui permet d'isoler les préoccupations et de réduire la complexité). L'
héritage : il est basé sur le résultat de l'abstraction. Pour y parvenir via un langage de programmation, il doit d'abord passer par le processus d'abstraction avant de pouvoir exprimer l'abstraction par héritage Structure.
L'abstraction n'est qu'une action ou une compétence dans le processus d'analyse et de conception, grâce à l'abstraction, des classes peuvent être obtenues
4. Héritage et réutilisabilité
première partie
Par exemple
Les chats peuvent : miauler, manger, boire, tirer, saupoudrer
Les chiens peuvent : aboyer, manger, boire, tirer, saupoudrer
Si nous voulons créer une classe pour chat et chien respectivement, nous devons implémenter toutes leurs fonctions pour chat et chien. Le pseudo-code est le suivant :
#猫和狗有大量相同的内容
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
La seconde partie
Il n'est pas difficile de voir à partir du code ci-dessus que manger, boire, tirer et lancer sont des fonctions que les chats et les chiens ont, mais nous les avons écrites deux fois dans nos classes séparées pour les chats et les chiens. Si l'idée d'héritage est utilisée, elle est implémentée comme suit:
Animaux : manger, boire, tirer, saupoudrer
Chats : Miaou (les chats héritent des fonctions des animaux)
Chien : aboiements (les chiens héritent des fonctions des animaux)
Le pseudo code est le suivant :
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 '汪汪叫'
la troisième partie
#继承的代码实现
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()
Bon exemple d'utilisation de l'héritage pour réutiliser le code
Dans le processus de développement d'un programme, si nous définissons une classe A, puis voulons créer une autre classe B, mais la plupart du contenu de la classe B est le même que celui de la classe A
Nous ne pouvons pas écrire une classe B à partir de zéro, qui utilise le concept d'héritage de classe.
Créez une nouvelle classe B par héritage, laissez B hériter de A, et B 'héritera' de tous les attributs (attributs de données et attributs de fonction) de A pour réaliser la réutilisation du code
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：660193417
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
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()
Astuce : Utilisez une classe existante pour créer une nouvelle classe, qui réutilise une partie du logiciel existant et la plupart des paramètres, ce qui augmente considérablement la charge de travail de programmation. Ceci est souvent appelé réutilisation de logiciel. Non seulement vous pouvez réutiliser vos propres classes , Vous pouvez également hériter d'autres, telles que des bibliothèques standard, pour personnaliser de nouveaux types de données, ce qui raccourcit considérablement le cycle de développement logiciel et revêt une grande importance pour le développement logiciel à grande échelle.
5. Dérivation des classes
Bien sûr, les sous-classes peuvent également ajouter leurs propres nouveaux attributs ou redéfinir ces attributs par eux-mêmes (n'affectera pas la classe parente).En ce qui concerne les propriétés, c'est à vous de décider.
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)
Remarque : Les références d'attributs telles que ha2.life_value rechercheront d'abord life_value dans l'instance, puis dans la classe, puis dans la classe parent... jusqu'à la classe parent de niveau supérieur.
Dans la sous-classe, l'attribut de fonction nouvellement créé avec le même nom, lors de l'édition de la fonction dans la fonction, il peut être nécessaire de réutiliser la fonction de fonction du même nom dans la classe parente, ce qui devrait être le moyen d'appeler la fonction ordinaire , à savoir : classname.func (), à ce stade, ce n'est pas différent d'appeler une fonction normale, donc même le paramètre self doit recevoir une valeur.
En python3, la méthode de la sous-classe exécutant la classe parent peut également utiliser directement la super méthode
.
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：660193417
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
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()
(2) Combat homme-chien
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()
La relation entre la classe dérivée et la classe de base est établie par héritage. C'est une relation "oui", comme un cheval blanc est un cheval et une personne est un animal.
Lorsqu'il existe de nombreuses fonctions communes entre les classes, il est préférable d'utiliser l'héritage pour extraire ces fonctions communes et en faire des classes de base.Par exemple, un professeur est un enseignant.
>>> 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()