Python: construindo sistemas eficientes com SOLID e Design Patterns

S - Princípio da responsabilidade única - Apresentação

Olá! Meu nome é Laís Urano, sou instrutora na Escola de Programação da Alura, e estarei com você neste curso de Boas Práticas com Python.

Audiodescrição: Laís se descreve como uma mulher parda, com olhos castanhos, cabelos cacheados castanho-escuro com mechas azuis. Está vestindo uma camisa verde. Ao fundo, há uma parede branca iluminada com as cores verde e azul.

Se você deseja aprender a aplicar boas práticas em projetos Python, está no lugar certo! Neste curso, vamos explorar os princípios SOLID e os padrões de projeto. Para isso, construiremos juntos um sistema de gerenciamento de pedidos, simulando um fluxo completo, incluindo um sistema de pagamentos, notificações e atualização de status.

Para aproveitar ao máximo este conteúdo, é importante ter conhecimento intermediário em Python e ter concluído o curso anterior desta formação, Python: aplicando boas práticas com PEP 8, pois este é uma continuidade dele.

Não se esqueça de explorar todos os recursos da plataforma! Além dos vídeos, você terá acesso a atividades, ao fórum e à comunidade no Discord da Alura. Vamos começar?

S - Princípio da responsabilidade única - Adicionando a primeira funcionalidade

No curso anterior desta formação, trabalhamos em um projeto de recomendação de produtos baseado nas preferências dos usuários. Desenvolvemos com a FastAPI e utilizamos o PyTest, aplicando as funcionalidades recomendadas pela PEP 8.

Estrutura Inicial do Projeto

Neste curso, vamos mudar um pouco o foco. No VS Code, temos uma pasta que contém dois arquivos:

1. .gitignore: será configurado especificamente para projetos em Python.
2. README.md: conterá a documentação do nosso projeto. Neste momento, vamos nos concentrar no conteúdo do README.md.

O projeto a ser desenvolvido é um sistema de gerenciamento de pedidos, que simulará um fluxo completo, incluindo:

• Cálculo total do pedido,
• Envio de notificações,
• Processamento de pagamentos,
• Atualização do status do pedido.

Essas funcionalidades serão abordadas ao longo do curso. Por ora, vamos focar nas tecnologias que utilizaremos, sendo a principal o Python, a partir da versão 3.10. Para verificar a versão instalada, abra o terminal com "Ctrl + J" e execute o comando:

python --version

No nosso ambiente, estamos utilizando a versão 3.13.0, a mais recente no momento. Após conferir, você pode fechar o terminal novamente com "Ctrl + J".

Conceitos Fundamentais

Dois conceitos fundamentais que abordaremos neste curso são:

1. Design Patterns (Padrões de Projeto): Estruturas padronizadas que nos ajudam a resolver problemas recorrentes no design de software.
2. Princípios SOLID: Um conjunto de cinco princípios essenciais para o desenvolvimento de projetos orientados a objetos.

Um ponto importante deste projeto é que, diferentemente dos cursos anteriores, nos quais utilizamos frameworks ou bibliotecas externas, neste curso trabalharemos exclusivamente com programação orientada a objetos (POO).

Criando o Ambiente Virtual

Para começar, abra o terminal com "Ctrl + J" e crie um ambiente virtual. Isso é feito utilizando o comando:

python -m venv venv

Após criar o ambiente virtual, ative-o com:

venv\Scripts\activate.bat

Quando o ambiente estiver ativo, você verá o nome venv entre parênteses no início da linha do terminal, antes do diretório atual.

Embora não utilizemos bibliotecas externas neste projeto, adotar um ambiente virtual é uma boa prática recomendada.

Desenvolvendo a Classe Cliente

Com "Ctrl + J" podemos fechar o terminal e observar as funcionalidades que precisamos desenvolver no sistema. A partir da linha 9 do arquivo README.md, encontramos a lista dessas funcionalidades, organizadas na ordem em que devem ser implementadas.

A primeira delas é o cadastro de clientes e itens, que será responsável por gerenciar informações de clientes e produtos. Para isso, utilizaremos classes.

Com "Ctrl + B", abrimos o explorador de arquivos e criamos um novo arquivo chamado cliente.py.

A criação do cliente.py está alinhada com a estrutura definida no README. Ao analisá-lo, percebemos que, a partir da linha 26, há uma organização pré-definida para o projeto, incluindo a presença dos arquivos cliente.py, item.py e main.py. Esses arquivos formam a base inicial do sistema. O main.py será responsável por realizar os testes das funcionalidades implementadas.

Fechamos o arquivo README com "Ctrl + B" e focamos no desenvolvimento do arquivo cliente.py, que conterá a classe responsável por representar os clientes.

Para criar a classe, utilizamos class Cliente:. Em Python, as classes seguem a convenção de nomenclatura PascalCase, ou seja, cada palavra inicia com letra maiúscula. Essa classe será responsável por definir a estrutura de um objeto cliente.

class Cliente:

Toda classe precisa de um construtor, que em Python é definido pelo método especial __init__. Esse método é utilizado para inicializar os atributos do objeto.

O primeiro parâmetro do construtor é sempre self. Apesar de ser possível utilizar outro nome, a comunidade Python padronizou o uso de self para se referir à instância do objeto dentro da classe.

Além de self, adicionamos os parâmetros que representam os atributos do objeto. No caso de um cliente, esses atributos serão nome e endereco, já que é essencial que o cliente tenha um nome e um endereço, por exemplo, para entregas.

class Cliente:
    def __init__(self, nome, endereco):  

Dentro do construtor, associamos os parâmetros recebidos aos atributos do objeto utilizando a sintaxe self.atributo = parâmetro. Por exemplo, para o atributo nome, temos self.nome = nome. O mesmo vale para o atributo endereco, com self.endereço = endereco.

class Cliente:
    def __init__(self, nome, endereco):
        self.nome = nome
        self.endereco = endereco   

Com isso, nossa estrutura básica para o objeto cliente está concluída, e ela já possui os atributos necessários para representar as informações de um cliente.

Testando a Classe Cliente

Agora que criamos a classe, é fundamental realizar um teste para garantir que ela está funcionando corretamente. Testar cada parte nova do sistema é uma boa prática que ajuda a identificar problemas desde o início.

Primeiro, precisamos abrir o explorador no VS Code. Isso pode ser feito com o atalho "Ctrl + B" ou clicando na parte superior esquerda da interface. Em seguida, criamos um novo arquivo chamado main.py, conforme indicado no README.

No arquivo main.py, para utilizar a classe criada, devemos importá-la. Fazemos isso com o comando:

from cliente import Cliente

Depois de importar, deixamos duas linhas em branco para separar os imports do restante do código, seguindo as boas práticas.

Agora, vamos criar um cliente para realizar o teste. Chamaremos essa instância de cliente, por ser um nome padrão que facilita a identificação. Para instanciá-lo, utilizamos a classe Cliente() e passamos os atributos definidos no construtor: o nome e o endereço. Por exemplo:

cliente = Cliente("Laís", "Alura")

Aqui estamos usando "Laís" como nome e "Alura" como endereço, apenas como exemplo para o teste.

Para verificar se o cliente foi criado corretamente e os atributos foram associados, podemos imprimir as informações com o comando print. Uma boa prática é utilizar f-strings para formatar a saída de forma clara. O código ficaria assim:

print(f"Cliente: {cliente.nome}, Endereço: {cliente.endereco}")

Agora que configuramos tudo, podemos testar o projeto. Para isso, basta abrir o terminal no VS Code com o atalho "Ctrl + J" e executar o comando:

python main.py

Esse comando irá executar o arquivo main.py, imprimindo as informações que conseguimos acessar. No nosso exemplo, ele exibirá "Cliente:Laís, Endereço: Alura". Isso confirma que a funcionalidade foi implementada corretamente e que conseguimos criar e acessar as informações do cliente no sistema.

Próximos Passos

Com essa etapa concluída, podemos avançar para a próxima parte do desenvolvimento: criar os itens do sistema. É exatamente isso que faremos a seguir!

S - Princípio da responsabilidade única - Criando a classe Item

Anteriormente, desenvolvemos a funcionalidade relacionada ao cliente no sistema, incluindo a criação da classe Cliente e a realização de testes no arquivo main.py. Agora, nosso próximo passo é desenvolver a funcionalidade de itens.

Uma abordagem inicial poderia ser adicionar um novo método à classe Cliente, chamado itens(), passando as informações dos itens como parâmetros. No entanto, essa abordagem não é apropriada, pois clientes e itens representam conceitos distintos no contexto do sistema: um cliente é uma pessoa, enquanto um item é um produto.

Separação de Responsabilidades: O Princípio SOLID

Se observarmos o README, veremos que há um arquivo separado para a funcionalidade de itens, o item.py. Isso está alinhado com o princípio S do SOLID, conhecido como Single Responsibility Principle, ou Princípio da Responsabilidade Única. Esse princípio estabelece que cada classe deve ter apenas uma responsabilidade ou realizar uma única tarefa.

Para entender melhor, vamos usar uma analogia do mundo real: imagine que uma única pessoa seja responsável por organizar todos os aspectos de um grande evento, como um casamento. Essa pessoa precisaria cuidar da decoração, alimentação, música, e de vários outros detalhes. Provavelmente, ela ficaria sobrecarregada, o que aumentaria as chances de erros ou esquecimentos.

Em contrapartida, se houvesse uma equipe, com cada membro responsável por uma área específica, como música ou decoração, o trabalho seria mais eficiente e com maior chance de sucesso.

No código, a lógica é a mesma: cada parte do sistema deve ser separada e dedicada a uma função específica. Se temos um cliente, ele deve ser separado de um item. E é exatamente isso que faremos agora!

Criando o Arquivo item.py

No VS Code, vamos fechar o README e, no explorador de arquivos, criar um novo arquivo chamado item.py no mesmo diretório onde está o arquivo do cliente. Essa abordagem segue o princípio S do SOLID, garantindo que cada parte do sistema tenha uma responsabilidade única.

No arquivo item.py, criaremos uma classe para representar os itens, de forma semelhante ao que fizemos com a classe de cliente. Aqui, além do parâmetro self, utilizaremos os parâmetros nome e preco, passando-os no construtor:

class Item:
    def __init__(self, nome, preco):
        self.nome = nome
        self.preco = preco

Agora que configuramos a classe do item, podemos realizar um teste no arquivo main.py. Primeiramente, faremos o import do item:

from item import Item

Logo abaixo da criação do cliente, vamos criar dois itens, que chamaremos de item_um e item_dois, utilizando a nomenclatura snake_case para variáveis, como é padrão em Python.

O item_um será uma pizza com o valor de R$30, e o item_dois será um refrigerante com o preço de R$5. Em seguida, faremos o print de um dos itens para verificar se as informações estão sendo exibidas corretamente.

from cliente import Cliente
from item import Item

cliente = Cliente("Laís", "Alura")
item_um = Item("Pizza", 30.0)
item_dois = Item("Refrigerante", 5.0)
print(f"Item: {item_um.nome}, Preço: {item_um.preco}")

Embora seja possível repetir o processo para o item_dois, como já estamos verificando um dos itens, podemos optar por testar apenas um print neste momento.

Testando a Classe Item

Para executar o teste, abrimos o terminal com "Ctrl + J" e rodamos o comando:

python main.py

Ao executar, veremos a saída "Item: Pizza, Preço: 30.0", indicando que o item é uma pizza cujo preço é R$30. Com isso, concluímos a configuração das partes do sistema referentes ao cliente e ao item.

Próximos Passos

Ao consultar o README, podemos confirmar que o cadastro de clientes e itens foi concluído com sucesso. Com essas etapas finalizadas, estamos prontos para avançar para a próxima funcionalidade: a gestão de pedidos. Esse será o próximo ponto de desenvolvimento no nosso sistema!

Sobre o curso Python: construindo sistemas eficientes com SOLID e Design Patterns

O curso Python: construindo sistemas eficientes com SOLID e Design Patterns possui 96 minutos de vídeos, em um total de 45 atividades. Gostou? Conheça nossos outros cursos de em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• S - Princípio da responsabilidade única
• O - Princípio Aberto/Fechado
• L - Princípio da substituição de Liskov
• I - Princípio da segregação de interfaces
• D - Princípio da inversão de dependências