Princípio de responsabilidade única do Python

Resumo : neste tutorial, você aprenderá sobre o princípio da responsabilidade única e como implementá-lo em Python.

O que é SÓLIDO

SOLID é uma abreviatura que significa cinco princípios de design de software compilados pelo  Tio Bob :

• S  – Princípio da responsabilidade única
• O  – Princípio Aberto-Fechado
• L  – Princípio da Substituição de Liskov
• I  – Princípio de Segregação de Interface
• D  – Princípio de Inversão de Dependência

A responsabilidade única é o primeiro princípio dos princípios SOLID.

Introdução ao princípio da responsabilidade única

O princípio de responsabilidade única (SRP) afirma que cada classe , método e função deve ter apenas um trabalho ou um motivo para mudar.

Os objetivos do princípio da responsabilidade única são:

• Crie classes, métodos e funções altamente coesos e robustos.
• Promova a composição da turma
• Evite duplicação de código

Vamos dar uma olhada na seguinte Personclasse:

class Person:
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return f'Person(name={self.name})'

    @classmethod
    def save(cls, person):
        print(f'Save the {person} to the database')


if __name__ == '__main__':
    p = Person('John Doe')
    Person.save(p)Linguagem de código:  Python  ( python )

Esta Personclasse tem dois trabalhos:

• Gerencie a propriedade da pessoa.
• Armazene a pessoa no banco de dados.

Posteriormente, se quiser salvar Personem um armazenamento diferente, como um arquivo, você precisará alterar o save()método, o que também altera toda a Personclasse.

Para fazer com que a Personclasse esteja em conformidade com o princípio da responsabilidade única, você precisará criar outra classe responsável por armazenar o arquivo Personem um banco de dados. Por exemplo:

class Person:
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return f'Person(name={self.name})'


class PersonDB:
    def save(self, person):
        print(f'Save the {person} to the database')


if __name__ == '__main__':
    p = Person('John Doe')

    db = PersonDB()
    db.save(p)Linguagem de código:  Python  ( python )

Neste design, separamos a Personclasse em duas classes: Persone PersonDB:

• A classe Person é responsável por gerenciar as propriedades da pessoa.
• A classe PersonDB é responsável por armazenar a pessoa no banco de dados.

Neste design, se você quiser salvar em um Personarmazenamento diferente, poderá definir outra classe para fazer isso. E você não precisa mudar de Personclasse.

Ao projetar classes, você deve reunir métodos relacionados que tenham o mesmo motivo de mudança. Em outras palavras, você deve separar as classes se elas mudarem por motivos diferentes.

Esse design tem um problema que você precisa lidar com duas classes: Persone PersonDB.

Para torná-lo mais conveniente, você pode usar o padrão de fachada para que a Personclasse seja a fachada da PersonDBclasse assim:

class PersonDB:
    def save(self, person):
        print(f'Save the {person} to the database')


class Person:
    def __init__(self, name):
        self.name = name
        self.db = PersonDB()

    def __repr__(self):
        return f'Person(name={self.name})'

    def save(self):
        self.db.save(person=self)


if __name__ == '__main__':
    p = Person('John Doe')
    p.save()Linguagem de código:  Python  ( python )

Resumo

• O princípio de responsabilidade única (SRP) afirma que cada classe, método ou função deve ter apenas um trabalho ou um motivo para mudar.
• Use o princípio de responsabilidade única para separar classes, métodos e funções com o mesmo motivo de alterações.