Herencia de pitón

Introducción

La herencia es otro concepto clave en la programación orientada a objetos, y juega un papel vital en la construcción de clases. Permite que una clase se base en una existente.

Cuando comenzaste a escribir clases de Python, te dijeron que pusieras "objeto" en el paréntesis de la definición de clase y no pienses demasiado en ello. Bueno, ahora es el momento de comenzar a pensar en ello.

"Objeto" es en realidad la clase base que todas las clases de Python heredan de. Define un conjunto básico de funcionalidad que todas las clases de Python deberían tener. Al heredar de ella cuando crea una nueva clase, se asegura de que esa clase tenga esa funcionalidad básica.

En resumen, la herencia es una buena manera de clasificar las clases y asegurarse de que no se repita innecesariamente.

Que es la herencia?

La herencia también existe en el mundo real. La primera par de guías usó un automóvil como ejemplo de una clase. Bueno, ¿qué pasa si quieres tipos de automóviles más específicos que compartan esos principios básicos de un automóvil?? La herencia puede ayudar.

Puede comenzar con una clase básica de "automóvil" que tiene todas las propiedades que comparte cada automóvil. Todos estos serían muy generales.

Después de tener su "automóvil", puede crear nuevas clases y pasarlas "coche."Todos tendrán las mismas propiedades que la clase de" automóvil "base. Luego, puede agregar cualquier propiedad adicional que desee a esas clases más especializadas. Por ejemplo, puede tener clases de "camión", "muscle car" y "SUV" que heredan de "automóvil."

Cuando lo piensas en términos del mundo real, los camiones, los muscle cars y los SUV tienen las mismas propiedades básicas que cualquier otro automóvil, pero también tienen propiedades especializadas.

También puedes especializarte más. Hay toneladas de diferentes tipos de camiones. Entonces, puede crear clases más especializadas que hereden de "Truck."Todo comenzará con todo el" auto "y todo, desde" camión."

Usar la herencia en Python

Muy bien, así que ahora puedes probar esto con un código real. Configure una clase básica de "automóvil" que hereda de "Objeto."Intenta trabajar con el ejemplo a continuación.

Class Car (objeto): def __init __ (self, make = 'ford', model = 'Pinto', año = '1971', kilometraje = 253812, color = 'naranja'): self.__make = hacerse yo.__model = modelo yo.__ años = año yo.__mileage = kilometraje.__color = color def move_forward (self, velocidad): imprime ("su %s está avanzando en %s" %(self.__model, velocidad)) def move_backward (self, velocidad): imprimir ("moverse hacia atrás en % s" % velocidad) class musclecar (automóvil): __hp = 300 def set_hp (self, hp): self.__hp = hp def get_hp (self): return yo.__hp def drag_race (yo, oponente): if (self.__HP> oponente.get_hp ()): devuelve "ganas!"Else: regresa" pierdes!"mynewcar = musclecar ('ford', 'mustang', '2016', 3000, 'rojo') mynewcar.set_hp (687) oponente = musclecar ('ford', 'mustang', '2014', 6400, 'verde') oponente.set_hp (465) mynewcar.Move_forward ('25mph') Impresión (MyNewCar.drag_race (oponente)) 

Observe que el Musclecar Los objetos pudieron usar el constructor y el Move_Forward método de la clase de "automóvil" a pesar de que la clase de la que fueron instanciadas no los tienen explícitamente.

Primordial

Solo porque una clase hereda de otra, no estás atrapado con toda la funcionalidad de la clase principal. Puede sobrescribir partes de la clase principal dentro de las clases de niños. Los cambios aplicados a la clase infantil no se aplicarán a la clase principal original, por lo que no tiene que preocuparse por estropear otras clases.

En el ejemplo anterior, el "musclecar" solo tenía una variable, __HP Simplemente flotando allí sin forma de configurarlo en instanciación. Mira el mismo ejemplo, pero con el constructor anulado.

Class Car (objeto): def __init __ (self, make = 'ford', model = 'Pinto', año = '1971', kilometraje = 253812, color = 'naranja'): self.__make = hacerse yo.__model = modelo yo.__ años = año yo.__mileage = kilometraje.__color = color def move_forward (self, velocidad): imprime ("su %s está avanzando en %s" %(self.__model, velocidad)) def move_backward (self, velocidad): imprimir ("moverse hacia atrás en % s" % velocidad) clase musclecar (automóvil): def __init __ (self, make = 'ford', model = 'mustang', año = '1965', kilometraje = 54032, color = 'azul', hp = 325): yo.__make = hacerse yo.__model = modelo yo.__ años = año yo.__mileage = kilometraje.__color = color yo.__hp = hp def set_hp (self, hp): self.__hp = hp def get_hp (self): return yo.__hp def drag_race (yo, oponente): if (self.__HP> oponente.get_hp ()): devuelve "ganas!"Else: regresa" pierdes!"mynewcar = musclecar ('ford', 'mustang', '2016', 3000, 'rojo', 687) opponente = musclecar () mynewcar.Move_forward ('25mph') Impresión (MyNewCar.drag_race (oponente)) 

Hay dos cosas que notar. Primero, __HP se ha convertido ser.__HP y se incorpora al constructor. Debido a esto, establecerlo es mucho más fácil. En segundo lugar, se han cambiado los valores predeterminados para un nuevo "musclecar". Un pinto no es un muscle car por defecto muy bueno, ¿es??

Puede hacer esto con cualquier variable o método en una clase de subclase o niño. Agrega un grado adicional de flexibilidad y evita que se bloquee en la funcionalidad del padre o la súper clase.

El super método

A veces, debe acceder a los métodos que se encuentran en la clase principal desde la clase infantil. Tome el ejemplo anterior que anula ese constructor. Mucho de ese código es redundante. Usando súper() Llamar al constructor de la clase de "automóvil" elimina esa redundancia y es una clase más simplificada.

súper() También se puede utilizar para acceder a métodos regulares para su uso en métodos de subclase. El ejemplo a continuación utilizado súper() ambos sentidos.

Class Car (objeto): def __init __ (self, make = 'ford', model = 'Pinto', año = '1971', kilometraje = 253812, color = 'naranja'): self.__make = hacerse yo.__model = modelo yo.__ años = año yo.__mileage = kilometraje.__color = color def set_make (self, make): self.__make = hacer def get_make (self): return yo.__make def set_model (self, modelo): self.__model = modelo def get_model (self): return yo.__model def set_year (self, año): self.__Year = año def get_year (self): return yo.__ años def set_mileage (self, kilometlee): self.__mileage = kilometrage def get_mileage (self): return yo.__mileage def set_color (self, color): self.__color = color def get_color (self): return yo.__color def move_forward (self, velocidad): imprime ("su %s está avanzando en %s" %(self.__model, velocidad)) def move_backward (self, velocidad): imprimir ("moverse hacia atrás en % s" % velocidad) clase musclecar (automóvil): def __init __ (self, make = 'ford', model = 'mustang', año = '1965', kilometraje = 54032, color = 'azul', hp = 325): super ().__init __ (hacer, modelo, año, kilometraje, color) yo.__hp = hp def set_hp (self, hp): self.__hp = hp def get_hp (self): return yo.__hp def drag_race (yo, oponente): if (self.__HP> oponente.get_hp ()): devuelve "ganas!"Else: regresa" pierdes!"Def Trade_Up (self, año, color): super ().set_year (año) super ().set_color (color) super ().set_mileage (0) mynewcar = musclecar ('ford', 'mustang', '2016', 3000, 'rojo', 687) opponente = musclecar () mynewcar.Move_forward ('25mph') Impresión (MyNewCar.drag_race (oponente)) mynewcar.Trade_Up ('2017', 'negro') impresión ("Mi nuevo %S Muscle Car es %s y tiene %d millas" %(MyNewCar.get_year (), mynewcar.get_color (), mynewcar.get_mileage ()))) 

Mira la forma en que el Intercambiar El método utiliza súper() Para acceder y llamar a esos métodos de setter desde la clase principal.

Pensamientos de cierre

La herencia le permite usar clases como plantillas para clases más especializadas. Puede construir clases en tal estructura que comience a parecerse a un árbol genealógico, con los miembros "mayores" y más generales que transmiten rasgos a los miembros "más jóvenes" más especializados.

Gran parte de la programación orientada a objetos está reduciendo la cantidad de código que se escribe y evita que se reescriba el mayor código posible. La herencia sirve un papel importante en hacer esto posible.

Ejercicios

1. Cree una clase básica que hereda de la clase de "automóvil".
2. Instanciar su nueva clase y llame a uno de los métodos de "Car."
3. Crea un nuevo métodos en la clase de tu hijo.
4. Llame a su nuevo método.
5. Usar súper() Para agregar variables al constructor de su clase de hijo.
6. Crear un método usando súper() Para acceder a los métodos de la clase principal.
7. Llame a su nuevo método que use súper().

Tutoriales de Linux relacionados:

• Cosas para instalar en Ubuntu 20.04
• Cosas que hacer después de instalar Ubuntu 20.04 fossa focal Linux
• Cosas para instalar en Ubuntu 22.04
• Una introducción a la automatización, herramientas y técnicas de Linux
• Ubuntu 20.04 trucos y cosas que quizás no sepas
• Ubuntu 20.04 Guía
• Cosas que hacer después de instalar Ubuntu 22.04 Jellyfish de Jammy ..
• Cómo arrancar dual Kali Linux y Windows 10
• Cómo construir una aplicación Tkinter utilizando un objeto orientado ..
• Mint 20: Mejor que Ubuntu y Microsoft Windows?