Composition Over Inheritance in Python

Contenido del curso

Fundamentos de Clases y Objetos

Encapsulación y Comportamiento de Objetos

Implementar Protocolos con Métodos Especiales

Relaciones entre Clases y Polimorfismo

Diseño Avanzado y Patrones de Software

17
Loading JSON Data to Restore App State
11:43 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:005:24

Composition Over Inheritance in Python

Curso de Python Orientado a Objetos

Clase 8 de 17

Clase 8 / 17

Recursos

Building software is a lot like building a house: you don't shape every brick from scratch, you assemble pieces that already exist. Composition in Python lets you do exactly that, combining existing objects inside other objects to model complex systems without leaning on inheritance. If you're learning object oriented programming and want cleaner, more flexible relationships between your classes, this is the technique you need.

What is composition in Python and why does it matter?

Composition is a design approach where one class contains instances of other classes as part of its own state. Instead of saying a class is a type of another (inheritance), you say it has one or many.

What is composition in object oriented programming? It's a relationship where an object holds other objects as attributes and uses their behavior. A Library that stores a list of Book objects is composition in action.

In the example we built, a Library class holds a list of books and a list of users. That single decision changes how you scale the system, because the library becomes the central piece that administers everything else.

How do you implement composition with a Library class?

We started from the previous challenge, which already had a LibroProtocol defining prestar, devolver and calcular_duracion, plus two implementations: LibroFisico with a 7 day loan and LibroDigital with a 14 day loan. With those building blocks ready, we created a new class to compose them.

Designing the constructor and its attributes

The Biblioteca class receives a name and initializes two empty lists by default. That setup is the entire foundation of composition here.

nombre: a string identifying the library, for example Platzi Biblioteca.
libros: a list that will hold Libro objects, empty by default.
usuarios: a list that will hold user objects, also empty by default.

Once you instantiate the library, you assign the list of books directly to biblioteca.libros. In our test we added three: Mi libro, Mi libro no disponible (with disponible=False) and Otro libro. Two available, one not.

Adding methods that use the composed objects

Here's where composition pays off. You can write methods inside Biblioteca that operate on the contained objects without duplicating code in another class.

python def libros_disponibles(self): return [libro.titulo for libro in self.libros if libro.disponible]

Notice how the method reaches into each libro to read its disponible and titulo attributes. The Library doesn't need to know how a book is built internally, it just uses what the book exposes. When you run print(biblioteca.libros_disponibles()) you get only the titles that are actually available, and toggling disponible to True or False changes the output instantly.

When should you choose composition over inheritance?

This is the question that trips up most developers learning OOP. The rule is simpler than it looks once you frame it as a sentence about the relationship.

Composition vs inheritance: which one do I use? Use inheritance when the relationship is is a, like a professor is a user. Use composition when it's has a, like a library has many users.

A few signals that point you toward composition:

You need one class to coordinate several others, like Biblioteca administering books and users.
You want flexibility to swap or extend the contained objects without rewriting hierarchies.
The relationship is about ownership or aggregation, not about specialization.

Inheritance locks you into a vertical chain. Composition gives you horizontal flexibility, which is exactly what a system that grows in features needs.

How does composition give you flexibility that inheritance can't?

In our library project, Biblioteca is becoming one of the most important classes because it manages multiple types of objects at once. It can hold LibroFisico and LibroDigital instances side by side, since both follow the same protocol, and it can also manage users. That kind of orchestration is hard to express with inheritance alone.

And here's the interesting part: the same libros_disponibles pattern can be reused for users, loans, reservations or any other entity you add later. You're not extending a class, you're composing capabilities.

Can a class use composition and inheritance at the same time? Yes. A Profesor can inherit from Usuario (is a) while a Biblioteca composes a list of Profesor objects (has many). They solve different problems.

Now it's your turn. What other composition relationship would make sense in this library system? Think about loans, reservations, categories or anything else that a library has. Drop your idea in the comments.

Diego Mauricio Zuluaga Rodríguez

Hace 8 meses

He añadido la composición Préstamo–Usuario y métodos en .

Qué objetos se combinan

Usuario + Prestamo + Libro + Biblioteca.

Métodos expuestos (principales)

Biblioteca.registrar_usuario(usuario) : registra un Usuario.
Biblioteca.prestar_a_usuario(libro, usuario) : crea un Prestamo, marca el Libro como no disponible y lo asocia al Usuario.
Biblioteca.devolver_libro(libro, usuario=None) : marca el préstamo como devuelto y deja el Libro disponible.
Biblioteca.prestamos_por_usuario(usuario) : lista préstamos (activos o históricos) de un Usuario.
Biblioteca.prestamos_activos() : lista todos los préstamos activos de la biblioteca.
Usuario.agregar_prestamo(prestamo), Usuario.eliminar_prestamo(prestamo), Usuario.lista_prestamos() : gestión local de préstamos por usuario.
Prestamo.devolver(), Prestamo.is_active() : operaciones y estado del préstamo.
Libro.prestar(), Libro.devolver(), Libro.es_popular(), Libro.get_veces_prestado() : operaciones sobre el libro.

"""
# Proyecto Biblioteca

Proyecto de catálogo de libros
Este proyecto define una clase Libro para representar libros en un catálogo.
Cada libro tiene un título, autor, ISBN y disponibilidad.
Se crean dos instancias de libros y se almacenan en una lista que representa el catálogo.
Finalmente, se imprime el catálogo de libros.    
"""

from typing import Protocol # Protocol ayuda en que el código sea más flexible y menos acoplado
from datetime import datetime

# Definición del Protocolo
class LibroProtocol(Protocol):
    def prestar(self) -> str: 
        """Método para prestar el libro. Devuelve un mensaje indicando si el préstamo fue exitoso o si el libro no está disponible."""
        ... # "-> str" significa que el método prestar devuelve una cadena de texto (str). El uso de "..." indica que el cuerpo del método no está implementado en esta definición de protocolo, lo que es común en los protocolos para indicar que las clases que implementen este protocolo deben proporcionar su propia implementación de este método. 
    
    def devolver(self) -> str: ...
    
    def calcular_duracion(self) -> str: ...

# Implementación de la clase Libro que cumple con el protocolo LibroProtocol
class Libro:
    def __init__(self, titulo, autor, isbn, disponible=True):
        self.titulo = titulo
        self.autor = autor
        self.isbn = isbn
        self.disponible = disponible
        self.veces_prestado = 0

    def __str__(self):
        estado = "Disponible" if self.disponible else "No disponible"
        return f"{self.titulo} — {self.autor} (ISBN: {self.isbn}) — {estado}"

    def prestar(self):
        if not self.disponible:
            return f"El libro '{self.titulo}' no está disponible."
        self.disponible = False
        self.veces_prestado += 1
        return f"Prestado: {self.titulo}"

    def devolver(self):
        if self.disponible:
            return f"El libro '{self.titulo}' ya está en la biblioteca."
        self.disponible = True
        return f"Devuelto: {self.titulo}"

    def es_popular(self):
        return self.veces_prestado > 5

    def get_veces_prestado(self):
        return self.veces_prestado

    def set_veces_prestado(self, veces_prestado):
        self.veces_prestado = int(veces_prestado)


# Nueva composición: Usuarios y Préstamos
class Usuario:
    def __init__(self, nombre, id_usuario):
        self.nombre = nombre
        self.id_usuario = id_usuario
        self.prestamos = []

    def __str__(self):
        return f"{self.nombre} ({self.id_usuario})"

    def agregar_prestamo(self, prestamo):
        self.prestamos.append(prestamo)

    def eliminar_prestamo(self, prestamo):
        if prestamo in self.prestamos:
            self.prestamos.remove(prestamo)

    def lista_prestamos(self):
        return [p for p in self.prestamos]


class Prestamo:
    def __init__(self, libro, usuario, fecha_prestamo=None):
        self.libro = libro
        self.usuario = usuario
        self.fecha_prestamo = fecha_prestamo or datetime.now()
        self.devuelto = False

    def devolver(self):
        if self.devuelto:
            return f"El préstamo de '{self.libro.titulo}' ya fue devuelto."
        self.devuelto = True
        return f"Préstamo devuelto: {self.libro.titulo}"

    def is_active(self):
        return not self.devuelto

    def __str__(self):
        estado = "activo" if not self.devuelto else "devuelto"
        fecha = self.fecha_prestamo.strftime('%Y-%m-%d %H:%M')
        return f"{self.libro.titulo} -> {self.usuario.nombre} ({estado}, {fecha})"

# Implementación de las clases LibroFisico y LibroDigital que heredan de Libro y cumplen con el protocolo LibroProtocol
class LibroFisico(Libro):
    def calcular_duracion(self):
        return "7 días"

class LibroDigital(Libro):
    def calcular_duracion(self):
        return "14 días"
    
# Implementación de la clase Biblioteca que contiene una lista de libros y usuarios, y métodos para gestionar los libros disponibles en la biblioteca.
class Biblioteca:
    def __init__(self, nombre):
        self.nombre = nombre
        self.libros = []
        self.usuarios = []
        self.prestamos = []

    def libros_disponibles(self):
        return [
            libro.titulo 
            for libro in self.libros 
            if libro.disponible]

    # Métodos para gestionar usuarios y préstamos
    def registrar_usuario(self, usuario: Usuario):
        if usuario not in self.usuarios:
            self.usuarios.append(usuario)
            return f"Usuario registrado: {usuario.nombre}"
        return f"Usuario {usuario.nombre} ya registrado"

    def prestar_a_usuario(self, libro: Libro, usuario: Usuario):
        if libro not in self.libros:
            return f"El libro '{libro.titulo}' no pertenece a esta biblioteca."
        if not libro.disponible:
            return f"El libro '{libro.titulo}' no está disponible."
        # Realizar préstamo
        msg = libro.prestar()
        prestamo = Prestamo(libro, usuario)
        self.prestamos.append(prestamo)
        usuario.agregar_prestamo(prestamo)
        return msg

    def devolver_libro(self, libro: Libro, usuario: Usuario = None):
        # Buscar préstamo activo
        for p in self.prestamos:
            if p.libro == libro and not p.devuelto:
                p.devolver()
                libro.devolver()
                if p in p.usuario.prestamos:
                    p.usuario.eliminar_prestamo(p)
                return f"Libro '{libro.titulo}' devuelto correctamente."
        return f"No se encontró un préstamo activo para '{libro.titulo}'."

    def prestamos_por_usuario(self, usuario: Usuario):
        return [p for p in self.prestamos if p.usuario == usuario]

    def prestamos_activos(self):
        return [p for p in self.prestamos if not p.devuelto]



mi_libro = LibroFisico(
    "100 Años de Soledad",
    "Gabriel Garcia Marquez",
    "9781644734728",
    True,
)

mi_libro_no_disponible = LibroFisico(
    "No disponible",
    "Diego",
    "12345678901234",
    True,
)

otro_libro = LibroFisico(
    "El Principito",
    "Saint-Exupéry",
    "9781644731234728",
    True,
)

biblioteca = Biblioteca("Biblioteca Central")

biblioteca.libros = [
    mi_libro, 
    mi_libro_no_disponible, 
    otro_libro
    ]

print(biblioteca.libros_disponibles())

# Ejemplo: registrar un usuario, prestar y devolver un libro
usuario1 = Usuario("Ana Pérez", "u1")
print(biblioteca.registrar_usuario(usuario1))

# Prestar `mi_libro` a `usuario1`
print(biblioteca.prestar_a_usuario(mi_libro, usuario1))
print("Préstamos activos:", [str(p) for p in biblioteca.prestamos_activos()])
print("Préstamos de usuario:", [str(p) for p in usuario1.lista_prestamos()])
print("Disponibles:", biblioteca.libros_disponibles())

# Devolver el libro
print(biblioteca.devolver_libro(mi_libro, usuario1))
print("Préstamos activos después de devolución:", [str(p) for p in biblioteca.prestamos_activos()])
print("Disponibles después de devolución:", biblioteca.libros_disponibles())

Fundamentos de Clases y Objetos

OOP in Python: Modeling Real World Systems

Classes and Objects in Python Explained

Instance Methods That Make Python Objects Act

Private Attributes and Data Integrity in Python

Encapsulación y Comportamiento de Objetos

Herencia en Python para evitar duplicación de código

Simple Inheritance With Python Classes

Python Protocol for Flexible Polymorphism

Implementar Protocolos con Métodos Especiales

Composition Over Inheritance in Python

Organizing Python Projects Into Modules

Custom Exceptions That Make Python Errors Clear

Sistema de préstamos con identificación de usuarios en Python

Relaciones entre Clases y Polimorfismo

Book Search and Lending Flow in Python OOP

Clases abstractas en Python con ABC y @abstractmethod

Decoradores property en Python para atributos con validación

Decoradores @staticmethod y @classmethod en Python

Serialización de objetos Python a JSON para persistencia de datos

Diseño Avanzado y Patrones de Software

Loading JSON Data to Restore App State

Composition Over Inheritance in Python

Progreso del curso

Fundamentos de Clases y Objetos

Encapsulación y Comportamiento de Objetos

Implementar Protocolos con Métodos Especiales

Relaciones entre Clases y Polimorfismo

Diseño Avanzado y Patrones de Software

Recursos

Recursos