Python Academy · Lección

Herencia simple

Cree clases hijas que hereden atributos y métodos de una clase padre.

Herencia simple es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Python Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Python Academy incluye 4 lecciones en total.

Introducción

La herencia permite que una clase hija reutilice y amplíe el comportamiento de una clase padre sin duplicar código.

Definición de una clase hija

class Dog(Animal): hereda todo de Animal. La clase hija puede añadir métodos nuevos o sobrescribir los existentes.

class Animal:
    def __init__(self, name): self.name = name
    def speak(self): return '...'
class Dog(Animal):
    def speak(self): return 'Woof'
d = Dog('Rex')
print(d.name, d.speak())

Llamada a super().init

super().__init__(args) llama al __init__ del padre. Llámelo siempre en la clase hija cuando el padre tenga lógica de configuración.

class Animal:
    def __init__(self, name): self.name = name
class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed
d = Dog('Rex', 'Labrador')
print(d.name, d.breed)

Herencia de métodos

La clase hija hereda todos los métodos del padre. Si no los sobrescribe, funcionan sin cambios.

class Vehicle:
    def start(self): return 'starting'
class Car(Vehicle):
    pass
print(Car().start())

Sobrescritura de métodos

Defina en la clase hija un método con el mismo nombre para reemplazar la versión del padre. Se llama a la versión de la hija.

class Shape:
    def area(self): return 0
class Square(Shape):
    def __init__(self, s): self.s = s
    def area(self): return self.s**2
print(Square(4).area())

Ampliación del comportamiento del padre

Llame a super().method() dentro de la sobrescritura para ejecutar primero la versión del padre y después añadir más comportamiento.

class Animal:
    def describe(self): return 'I am an animal'
class Dog(Animal):
    def describe(self): return super().describe() + ' and a dog'
print(Dog().describe())

isinstance() e issubclass()

isinstance(obj, Parent) devuelve True también para las instancias hijas. issubclass(Child, Parent) comprueba la jerarquía de clases.

class Animal: pass
class Dog(Animal): pass
d = Dog()
print(isinstance(d, Animal))
print(issubclass(Dog, Animal))

La clase hija añade métodos nuevos

La clase hija puede definir métodos completamente nuevos que el padre no tiene.

class Animal:
    def __init__(self, name): self.name = name
class Dog(Animal):
    def fetch(self): return f'{self.name} fetches!'
print(Dog('Rex').fetch())

Atributos protegidos

La convención _name indica «no acceda desde fuera de la clase». Las subclases SÍ pueden usarlos.

class Animal:
    def __init__(self, name): self._name = name
    def name(self): return self._name
class Dog(Animal):
    def bark(self): return f'{self._name} barks'
print(Dog('Rex').bark())

Clases base abstractas

from abc import ABC, abstractmethod obliga a las subclases a implementar métodos.

from abc import ABC, abstractmethod
class Shape(ABC):
    @abstractmethod
    def area(self): pass
class Circle(Shape):
    def __init__(self, r): self.r = r
    def area(self):
        import math
        return math.pi * self.r**2
print(Circle(3).area())

bases y mro

Dog.__bases__ muestra los padres directos. Dog.__mro__ muestra el orden completo de resolución de métodos.

class A: pass
class B(A): pass
class C(B): pass
print(C.__mro__)

Comprobación rápida

¿Qué hace super().__init__() en una clase hija?

Repaso

Herencia: class Child(Parent). super() accede al padre. Sobrescriba métodos para cambiar el comportamiento. isinstance() comprueba la jerarquía. ABC impone contratos abstractos.

Continúe

¡Excelente progreso! Continúe para dominar el siguiente concepto.

Preguntas frecuentes

¿La lección «Herencia simple» es gratis?

Sí — el texto completo de «Herencia simple» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Python Academy, actualiza a CoddyKit PRO. El curso de Python Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Herencia simple»?

Cree clases hijas que hereden atributos y métodos de una clase padre. Practicas Python Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Python Academy?

No se requiere experiencia previa. Python Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Herencia simple»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Python Academy?

Sí. Cada lección de Python Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Python Academy