1. Definición de herencia
La herencia es una forma de crear una nueva clase. En Python, una nueva clase puede heredar una o más clases principales.
2. Herencia única y herencia múltiple
class ParentClass1: #定义父类
pass
class ParentClass2: #定义父类
pass
class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
pass
class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
pass
Ver herencia
>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)
Sugerencia : si no se especifica una clase base, la clase de Python heredará la clase de objeto de forma predeterminada. Object es la clase base de todas las clases de Python, que proporciona la implementación de algunos métodos comunes (como __str__).
>>> ParentClass1.__bases__
(<class 'object'>,)
>>> ParentClass2.__bases__
(<class 'object'>,)
3. Herencia y abstracción (primero abstracción y luego herencia)
La abstracción consiste en extraer partes similares o más similares.
Hay dos niveles de abstracción:
Extraiga las partes similares de Obama y Messi en clases;
Extraiga las partes similares de las tres clases de personas, cerdos y perros como la clase principal.
La función principal de la abstracción es dividir categorías (lo que puede aislar preocupaciones y reducir la complejidad).
Herencia : se basa en el resultado de la abstracción. Para lograrlo a través de un lenguaje de programación, primero debe pasar por el proceso de abstracción antes de que pueda expresar la abstracción a través de la herencia.Estructura.
La abstracción es solo una acción o una habilidad en el proceso de análisis y diseño, a través de la abstracción se pueden obtener clases
4. Herencia y reutilización
primera parte
P.ej
Los gatos pueden: maullar, comer, beber, jalar, rociar
Los perros pueden: ladrar, comer, beber, jalar, rociar
Si queremos crear una clase para gato y perro respectivamente, entonces necesitamos implementar todas sus funciones para gato y perro, el pseudocódigo es el siguiente:
#猫和狗有大量相同的内容
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 segunda parte
No es difícil ver en el código anterior que comer, beber, tirar y tirar son funciones que tienen tanto los perros como los gatos, pero las hemos escrito dos veces en nuestras clases separadas de perros y gatos. Si se utiliza la idea de herencia, se implementa de la siguiente manera:
Animales: comer, beber, tirar, rociar
Gatos: Miau (los gatos heredan funciones de los animales)
Perro: ladrar (los perros heredan las funciones de los animales)
El pseudocódigo es el siguiente:
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 tercera parte
#继承的代码实现
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()
Buen ejemplo de uso de herencia para reutilizar código.
En el proceso de desarrollo de un programa, si definimos una clase A y luego queremos crear otra clase B, pero la mayor parte del contenido de la clase B es el mismo que el de la clase A
No podemos escribir una clase B desde cero, que utiliza el concepto de herencia de clase.
Cree una nueva clase B por herencia, deje que B herede A, y B 'heredará' todos los atributos (atributos de datos y atributos de funciones) de A para lograr la reutilización del código
'''
遇到问题没人解答？小编创建了一个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()
Sugerencia: use una clase existente para crear una nueva clase, que reutiliza una parte del software existente y la mayoría de las configuraciones, lo que aumenta considerablemente la carga de trabajo de programación. Esto a menudo se denomina reutilización de software. No solo puede reutilizar sus propias clases También puede heredar de otros, como bibliotecas estándar, para personalizar nuevos tipos de datos, lo que acorta en gran medida el ciclo de desarrollo de software y es de gran importancia para el desarrollo de software a gran escala.
5. Derivación de clases
Por supuesto, las subclases también pueden agregar sus propios atributos nuevos o redefinir estos atributos por sí mismos (no afectará a la clase principal).Cuando se trata de propiedades, depende de usted.
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)
Nota : las referencias de atributos como ha2.life_value primero buscarán life_value en la instancia, luego en la clase y luego en la clase principal... hasta la clase principal de nivel superior.
En la subclase, el atributo de función recién creado con el mismo nombre, al editar la función en la función, puede ser necesario reutilizar la función función del mismo nombre en la clase principal, que debería ser la forma de llamar a la función ordinaria , a saber: classname.func (), en este punto no es diferente de llamar a una función normal, por lo que incluso al parámetro self se le debe pasar un valor.
En python3, el método de la subclase que ejecuta la clase principal también puede usar el método super directamente
.
'''
遇到问题没人解答？小编创建了一个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) Batalla hombre-perro
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 relación entre la clase derivada y la clase base se establece a través de la herencia, es una relación de 'sí', como un caballo blanco es un caballo y una persona es un animal.
Cuando hay muchas funciones comunes entre clases, es mejor usar la herencia para extraer estas funciones comunes y convertirlas en clases base.Por ejemplo, un profesor es un maestro.
>>> 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()