Principio de Responsabilidad Única en Desarrollo de Software

Clase 2 de 27 • Curso de Patrones de Diseño y SOLID en Python

Resumen

El principio de responsabilidad única es uno de los pilares de la construcción de software, establecido por Robert C. Martin. Este principio indica que una clase o función debe tener solo una razón para cambiar, lo que mejora la mantenibilidad y reduce la complejidad. Implementarlo no solo facilita las pruebas unitarias, sino que también incrementa la reutilización del código y disminuye el acoplamiento, promoviendo un sistema más cohesivo y fácil de escalar.

¿Qué implica el principio de responsabilidad única?

Responsabilidad única: Una clase o función debe encargarse de una única tarea, lo que evita que se ocupe de múltiples aspectos.
Razón para cambiar: El código debe tener una única causa para ser modificado, asegurando que los cambios sean claros y controlados.

¿Qué problemas soluciona este principio?

Mantener el código: Al dividir responsabilidades, el código se vuelve más fácil de mantener y más económico de modificar.
Reutilización del código: Las funciones con una única responsabilidad pueden ser utilizadas en diferentes contextos sin necesidad de duplicar código.
Pruebas unitarias más simples: Las funciones con responsabilidades bien definidas son más fáciles de probar, reduciendo la carga de trabajo en el desarrollo.

¿Cómo saber cuándo aplicar el principio de responsabilidad única?

Múltiples razones para cambiar: Si una clase o función tiene varias razones para ser modificada, es un buen indicio de que tiene más responsabilidades de las que debería.
Alta complejidad y difícil mantenimiento: Si se encuentra complicado añadir nuevas funcionalidades o corregir errores, es probable que la falta de una clara definición de responsabilidades esté afectando el código.
Dificultad para realizar pruebas unitarias: Si preparar una prueba implica mucho trabajo o configurar demasiados elementos, es señal de que el principio no se está siguiendo correctamente.
Duplicación de código: Si una funcionalidad, como una validación, está replicada en varios lugares, se debería extraer a una única función y reutilizarla donde sea necesario.

¿Qué hacer cuando encuentras duplicación de responsabilidades?

Cuando se identifica la duplicación de código o responsabilidades mal distribuidas, el enfoque ideal es reorganizar ese código en una función específica que pueda ser reutilizada en todos los puntos necesarios. Esto no solo reduce el trabajo redundante, sino que también asegura que los cambios futuros se realicen en un solo lugar.

Jovanny Delgado

student•

Principio de Responsabilidad Única (SRP) en Python: Un Enfoque Práctico

¿Qué es el SRP?

El Principio de Responsabilidad Única (SRP, por sus siglas en inglés) establece que una clase debe tener una única razón para cambiar. En otras palabras, una clase debe tener una sola responsabilidad bien definida. Este principio es fundamental en la programación orientada a objetos, ya que promueve la creación de código más modular, mantenible y escalable.

¿Por qué es importante el SRP en Python?

Mayor claridad: Al tener clases con responsabilidades bien definidas, el código se vuelve más fácil de entender y razonar.
Menor acoplamiento: Las clases con una sola responsabilidad están menos acopladas entre sí, lo que facilita los cambios y reduce el riesgo de introducir errores.
Mayor reutilización: Clases pequeñas y enfocadas son más fáciles de reutilizar en diferentes partes de la aplicación.
Facilidad de prueba: Las clases con una sola responsabilidad son más fáciles de probar de forma aislada.

Ejemplo Práctico en Python

Ejemplo sin aplicar SRP:

Pythonclass Usuario: def __init__(self, nombre, apellido, email): self.nombre = nombre self.apellido = apellido self.email = email

def enviar_email(self, asunto, mensaje): # Código para enviar un email pass

def guardar_en_base_de_datos(self): # Código para guardar el usuario en la base de datos pass Usa el código con precaución.

En este ejemplo, la clase Usuario tiene dos responsabilidades: representar a un usuario y manejar la lógica de envío de emails y almacenamiento en base de datos. Esto viola el SRP.

Ejemplo aplicando SRP:

Pythonclass Usuario: def __init__(self, nombre, apellido, email): self.nombre = nombre self.apellido = apellido self.email = email

class EnvioEmail: def enviar(self, destinatario, asunto, mensaje): # Código para enviar un email pass

class RepositorioUsuario: def guardar(self, usuario): # Código para guardar el usuario en la base de datos pass Usa el código con precaución.

En esta versión, cada clase tiene una única responsabilidad:

Usuario: Representa a un usuario.
EnvioEmail: Maneja el envío de emails.
RepositorioUsuario: Maneja el almacenamiento de usuarios en la base de datos.

¿Cómo aplicar el SRP en tu código Python?

Identifica las responsabilidades: Analiza cada clase y determina cuáles son sus responsabilidades principales.
Separa las responsabilidades: Si una clase tiene múltiples responsabilidades, crea clases nuevas para cada una de ellas.
Utiliza interfaces o clases abstractas: Define interfaces o clases abstractas para establecer contratos entre las clases y desacoplarlas.
Refactoriza gradualmente: No trates de aplicar el SRP a todo tu código de una vez. Refactoriza gradualmente a medida que identificas oportunidades de mejora.

Conclusión

El Principio de Responsabilidad Única es una herramienta poderosa para escribir código Python de alta calidad. Al seguir este principio, crearás aplicaciones más mantenibles, escalables y fáciles de entender.

Juan Marcelo Panasiti

student•

En general trato de aplicar siempre que puedo este principio.. y como regla personal, si en algún punto de mi código tengo que hacer un copy+paste de una parte para utilizarla en otro lado, casi siempre es porque puedo extraer ese codigo en una función aparte y reutilizarlo (aunque esto suele llevar un poco más de trabajo, ya que generalmente tengo que refactorizar esa porción de código para que sea más genérica y flexible y poder reutilizarla con mayor facilidad)

Luis Quiroz Prada

student•

1. S - Principio de Responsabilidad Única (Single Responsibility Principle)

Este principio establece que una clase debe tener una y solo una razón para cambiar. Esto significa que una clase debe tener una única responsabilidad o trabajo.

Problema que resuelve: Evita crear clases "todopoderosas" que hacen demasiadas cosas. Cuando una clase tiene muchas responsabilidades, cualquier pequeño cambio puede tener efectos inesperados en otras partes del sistema.
Analogía: Imagina una navaja suiza. Es útil, pero si quieres un destornillador realmente bueno, usas un destornillador. Si quieres unas tijeras excelentes, usas unas tijeras. Cada herramienta tiene una única y clara función. En programación, cada clase debe ser como una de esas herramientas específicas.

2. O - Principio de Abierto/Cerrado (Open/Closed Principle)

Este principio dice que las entidades de software (clases, módulos, funciones, etc.) deben estar abiertas para su extensión, pero cerradas para su modificación.

¿Qué significa?: Deberías poder agregar nueva funcionalidad a una clase sin tener que cambiar su código fuente existente. Esto generalmente se logra mediante herencia o interfaces.
Analogía: Piensa en tu teléfono móvil. Está "cerrado" a modificaciones (no puedes cambiar su hardware interno fácilmente), pero está "abierto" a extensiones (puedes instalarle nuevas aplicaciones para añadir funcionalidades).

3. L - Principio de Sustitución de Liskov (Liskov Substitution Principle)

Este principio establece que los objetos de una clase derivada (hija) deben poder sustituir a los objetos de la clase base (padre) sin alterar el correcto funcionamiento del programa.

¿Qué significa?: Si tienes una clase Pajaro con un método volar(), y creas una subclase Pinguino, no deberías heredar de Pajaro si un pingüino no puede volar. Hacerlo rompería el programa en los lugares donde se espera que cualquier "pájaro" pueda volar. La clase hija no debe requerir más ni prometer menos que la clase padre.
Analogía: Si te piden un pato de goma y tú entregas un pato de verdad, aunque ambos son "patos", no se comportarán igual. El de verdad hará "cuac" y se moverá, mientras que el de goma no. No son sustituibles en todos los contextos.

4. I - Principio de Segregación de Interfaces (Interface Segregation Principle)

Este principio sugiere que ningún cliente debe ser forzado a depender de métodos que no utiliza. Es mejor tener muchas interfaces pequeñas y específicas que una sola interfaz grande y genérica.

Problema que resuelve: Evita crear interfaces "gordas" que obligan a las clases a implementar métodos que no necesitan, dejándolos vacíos o lanzando una excepción.
Analogía: Es como ir a un restaurante. No te dan un menú con absolutamente todos los platos del mundo. Te dan menús específicos: uno para postres, otro para bebidas, etc. Tú solo usas el menú que necesitas.

5. D - Principio de Inversión de Dependencias (Dependency Inversion Principle)

Este principio tiene dos partes:

Los módulos de alto nivel no deben depender de los módulos de bajo nivel. Ambos deben depender de abstracciones (como interfaces).
Las abstracciones no deben depender de los detalles. Los detalles deben depender de las abstracciones.

¿Qué significa?: En lugar de que una clase A cree directamente una instancia de una clase B, A debería depender de una interfaz que B implementa. Esto desacopla las clases y hace que el sistema sea más flexible. Permite, por ejemplo, cambiar B por otra clase C (que también implemente la misma interfaz) sin tener que modificar la clase A.
Analogía: Piensa en un enchufe de pared. Tu lámpara (módulo de alto nivel) no depende directamente de la planta de energía (módulo de bajo nivel). Ambos dependen de una "abstracción": el estándar del enchufe. Puedes conectar cualquier aparato que cumpla con ese estándar, y la lámpara no necesita saber cómo se genera la electricidad.

Juan Camilo Suarez

student•

Asegúrense de que su proyecto corra en un entorno con una versión de python igual o superior 3.11.0

Jhonatan Fernando Rubio Paez

student•

esto no solo lo podemos aplicar en programacion si no en las empresas donde le asignamos multiples tareas a un solo individuo relentizando muchas veces los procesos

Luis Quiroz Prada

student•

SRP Analogía: Imagina una navaja suiza. Es útil, pero si quieres un destornillador realmente bueno, usas un destornillador. Si quieres unas tijeras excelentes, usas unas tijeras. Cada herramienta tiene una única y clara función. En programación, cada clase debe ser como una de esas herramientas específicas.

Julian Camilo Sanchez Sosa

student•

El principio de responsabilidad única (SRP) indica que una clase debe tener una única razón para cambiar. Esto significa que si una clase está siendo afectada por múltiples factores que requieren su modificación, es una señal de que la clase está asumiendo demasiadas responsabilidades. "Cambiar una clase" se refiere a cualquier ajuste o mejora que debas realizar en su comportamiento, estructura o funciones. Por lo tanto, es crucial dividir la clase en varias más pequeñas, cada una enfocada en una tarea específica, facilitando así su mantenimiento y evitando efectos secundarios no deseados.

Jeisson Harvey Martinez Florez

company_admin•

Un ejemplo de una clase que no cumple con el principio de responsabilidad única es una clase Usuario que maneja tanto la autenticación como la gestión de datos del usuario. Esto significa que si hay un cambio en la forma de autenticar (por ejemplo, implementar OAuth), se vería afectada la gestión de datos, aumentando la complejidad y dificultando el mantenimiento.

Otro ejemplo puede ser una clase Reportes, que genera reportes y también envía correos electrónicos. Cada función debería estar en su propia clase para mantener la cohesión y facilitar el mantenimiento.

Mario Alexander Vargas Celis

student•

El **Principio de Responsabilidad Única** (SRP, por sus siglas en inglés) establece que **una clase debe tener una única razón para cambiar**, es decir, debe tener una única responsabilidad o propósito. Este principio es importante porque ayuda a mantener el código modular y fácil de entender, facilitando su mantenimiento y extensión.

En Python, podemos aplicar SRP dividiendo responsabilidades en varias clases pequeñas en lugar de concentrarlas en una sola clase.

### Ejemplo de una Clase que Viola SRP

Supongamos que queremos manejar la información de un empleado y generar reportes de esa información. Una implementación que viola SRP podría lucir así:


class Employee:

&#x20;   def \_\_init\_\_(self, name, position, salary):

&#x20;       self.name = name

&#x20;       self.position = position

&#x20;       self.salary = salary



&#x20;   def calculate\_payroll(self):

&#x20;       return self.salary \* 0.9  # salario después de impuestos



&#x20;   def save\_to\_database(self):

&#x20;       print(f"Saving {self.name} to database")



&#x20;   def generate\_report(self):

&#x20;       return f"Employee report: {self.name}, {self.position}, ${self.salary}"

En este ejemplo, la clase Employee está haciendo tres cosas:

1. **Calcular el salario** (calculate\_payroll).

2. **Guardar el empleado en la base de datos** (save\_to\_database).

3. **Generar un informe** (generate\_report).

Si necesitamos cambiar el modo en que se guarda el empleado o se genera el informe, tendremos que modificar esta clase. Esto viola el principio SRP porque la clase Employee tiene múltiples responsabilidades.

### Solución: Aplicando SRP

Para aplicar SRP, dividiremos las responsabilidades de Employee en varias clases, de modo que cada clase tenga una única responsabilidad.


class Employee:

&#x20;   def \_\_init\_\_(self, name, position, salary):

&#x20;       self.name = name

&#x20;       self.position = position

&#x20;       self.salary = salary



class PayrollCalculator:

&#x20;   @staticmethod

&#x20;   def calculate(employee: Employee):

&#x20;       return employee.salary \* 0.9



class EmployeeDatabase:

&#x20;   @staticmethod

&#x20;   def save(employee: Employee):

&#x20;       print(f"Saving {employee.name} to database")



class EmployeeReportGenerator:

&#x20;   @staticmethod

&#x20;   def generate(employee: Employee):

&#x20;       return f"Employee report: {employee.name}, {employee.position}, ${employee.salary}"

### Explicación

- **Clase Employee**: Ahora solo contiene los datos del empleado.

- **Clase PayrollCalculator**: Su única responsabilidad es calcular el salario neto.

- **Clase EmployeeDatabase**: Su única responsabilidad es guardar al empleado en la base de datos.

- **Clase EmployeeReportGenerator**: Su única responsabilidad es generar el reporte del empleado.

### Uso

Ahora podemos trabajar con estas clases de forma modular y flexible:


employee = Employee("Alice", "Developer", 7000)



\# Calcular salario

payroll = PayrollCalculator.calculate(employee)

print(f"Payroll: ${payroll}")



\# Guardar en la base de datos

EmployeeDatabase.save(employee)



\# Generar reporte

report = EmployeeReportGenerator.generate(employee)

print(report)

### Ventajas de Aplicar SRP

1. **Modularidad**: Las clases son pequeñas y cumplen una sola función, lo que hace que el código sea más fácil de entender.

2. **Facilidad de Mantenimiento**: Si cambian los requisitos, puedes modificar solo la clase correspondiente sin afectar el resto.

3. **Pruebas Unitarias**: Las pruebas para cada funcionalidad son más fáciles de implementar, ya que cada clase tiene una única responsabilidad.

Este es el núcleo del **Principio de Responsabilidad Única**: reducir el acoplamiento y aumentar la cohesión al dividir las responsabilidades en clases especializadas.

Wilbertson Mojica Cifuentes

student•

El acoplamiento de los componentes se refiere al grado de interdependencia entre ellos en un sistema. Un alto acoplamiento significa que los componentes están fuertemente conectados y dependen unos de otros, lo que dificulta su modificación o reutilización. Por el contrario, un bajo acoplamiento implica que los componentes son más independientes, facilitando el mantenimiento y la escalabilidad del sistema. Aplicar el principio de responsabilidad única ayuda a reducir el acoplamiento al definir claramente las responsabilidades de cada componente.

Wilbertson Mojica Cifuentes

student•

La cohesión en software se refiere a qué tan estrechamente relacionadas están las responsabilidades dentro de un módulo, clase o función. Un módulo altamente cohesivo realiza una única tarea específica, lo que mejora la mantenibilidad y la reusabilidad del código. Esto está relacionado con el principio de responsabilidad única (SRP) que establece que una clase debe tener una razón única para cambiar. Al incrementar la cohesión, se reduce el acoplamiento entre componentes, facilitando así la comprensión y modificación del software.

Mario Alexander Vargas Celis

student•

El Principio de Responsabilidad Única (SRP) establece que una clase debe tener una única razón para cambiar, es decir, debe tener una sola responsabilidad. Esto mejora la mantenibilidad, reusabilidad y facilita las pruebas unitarias, reduciendo la complejidad del código. Aplica SRP cuando detectes múltiples razones para cambiar una clase o función.

Pablo Torres Pérez

student•

El acoplamiento se refiere a cómo las clases o módulos dependen entre sí. Cuando se aplica el principio de responsabilidad única, se aíslan las responsabilidades, lo que reduce las interacciones entre componentes. Esto hace que cada parte del sistema sea más independiente y fácil de modificar sin afectar a otras partes, mejorando la mantenibilidad y escalabilidad del software.

Ray Trápala

student•

Pregunta:

Entonces, podría decir que SRP es:

que una función, clase o método solo debe tener una única obligación. Esto implica, que al tener una sola responsabilidad solo tiene una única razón para cambiar. Esto es, que la lógica para la que fue hecha cambio por circunstancia ya de la lógica de negocio.

Yoel Ayan

student•

En Django se puede ver bastante este problema, cuando desarrollamos Views (Vistas que pueden devolver un Response o renderizar un HTML) usualmente se desarrolla todo el comportamiento de posibles metodos GET y POST. Haciendo que tengamos que replicar toda la logica de recopilación de datos en las pruebas unitarias para verificar que el View funciona correctamente.

Alternativamente, lo ideal es desarrollar metodos especificios (O reutilizar otros de una clase heredada) para cada uno de las funcionalidades y que los parametros de estas funcionalidades esten tipadas y preparadas para recibir para procesarse sin necesidad de modificar el comportamiento de la vista entera. Asi solo tenemos que crear ese parametro especifico sin necesidad de replicar toda la view entera en nuestras pruebas unitarias

from django.views import GenericView
class ClientsViews(GenericView):
  def validate_data(self, data: dict):
    name = data.get('name', None)
    if not name > len(10):
      Raise ValueError('Name tiene que ser mas largo')
    return data
  def post(self, request):
    data = self.validate_data(request.POST)
    # resto del codigo

Este es solo un ejemplo, django tiene mejores maneras de validar datos de un formulario, pero lo importante es que si queremos probar el metodo validate_data Bastará con enviarle un dict con la información del formulario

Juan Marcelo Panasiti

student•

Como resumen, podríamos decir que el SRP dice que cada clase o función debe hacer una cosa y <u>hacerla bien</u>.