DEV Community: Jorge Silva

Tree Parsing

Jorge Silva — Mon, 22 May 2023 03:06:48 +0000

What I built

A Python library to parse node list to tree, or parse tree to node list

Category Submission:

Wacky Wildcards

App Link

https://pypi.org/project/tree-parsing/

Screenshots

Description

A library to lets work with trees and lists.

So you can:

Make a tree when you have all nodes in the list
Convert the Tree to lists of nodes
Customize how to generate 'flow key', 'children key'
Do something for each node

Link to Source Code

Source Code: https://github.com/scjorge/tree-parsing

Documentation: https://tree-parsing.readthedocs.io/en/latest/

Permissive License

MIT License

Background (What made you decide to build this particular app? What inspired you?)

One day I needed to carry out an activity that needed to work with lists and trees and when looking, I couldn't find a library that met my need. So I used inspiration to create it and make it available to the world.

How I built it (How did you utilize GitHub Actions or GitHub Codespaces? Did you learn something new along the way? Pick up a new skill?)

I discovered the real usefulness of GitHub Codespaces in this project. I had already heard about it. I looked for tutorials on Youtube and was delighted with the tool. It really meets many needs at different times.

Desempacotamento - *args e **kwargs

Jorge Silva — Thu, 23 Mar 2023 01:47:43 +0000

Vamos entender sobre o desempacotamento, ou seja, uma forma que podemos atribuir diversos valores ao mesmo tempo.

vamos primeiro entender uma habilidade que o Python nos traz. Podemos ter múltiplas atribuições de valores ao declarar variáveis e, também, podemos retornar mais de um valor em nossas funções. Vejamos:

a, b, c = 1, 2, 3

print(a, b, c, sep=" - ")

saída:

1 - 2 - 3

Maravilha! atribuímos 3 valores em 3 diferentes variáveis em uma só linha. E isso é a base pro no Post de hoje.

Agora vamos brincar um pouco com listas. Vejamos:

a, b, c = [1, 2, 3]

print(a, b, c, sep=" - ")

saída:

1 - 2 - 3

Conseguimos exatamente o mesmo resultado. Ou seja, é possível utilizar os valores de uma lista para atribuições múltiplas. E como mencionamos, funções podem fazer as mesmas coisas, olha só:

def retorno_multiplo():
    return 1, 2, 3

a, b, c = retorno_multiplo()

print(a, b, c, sep=" - ")

saída:

1 - 2 - 3

Ótimo, agora que entendemos legal essas atribuições múltiplas, vamos ao que nos interessa.

basicamente o desempacotamento é a idea de podemos realizar essas atribuições que fizemos de forma dinâmica.

Eu sei, parece estranho, então vamos de exemplo:

lista = [1, 2, 3]
a, *nova_lista = lista

print(a, nova_lista)

saída:

1 [2, 3]

Interessante ne? Atribuímos o primeiro item da lista a variável "a" e o restante automaticamente em uma nova lista chamada "nova_lista". Pronto, esse é o tal do desempacotamento. É para isso que usamos o caractere estrela "*".

Vamos brincar um pouco com funções, afinal de contas é aqui que realmente utilizamos esse conceito no dia a dia.

Que venha código então 😊

def recebe_nomes(*args):
    print(args)

recebe_nomes("akuma", "ryu", "ken")

saída:

('akuma', 'ryu', 'ken')

Olha só a mágica acontecendo. Acabamos de criar uma função que aceita vários argumentos dinamicamente. E nosso argumento "args" se tornou uma tupla com todos os argumentos que passamos da mesma forma como vimos anteriormente.

Lidando com argumentos/parâmetros em funções

Agora vamos fazer uma pequena pausa e entender como as funções lidam com argumentos no Python. Juro que essa pausa é importante 😜

Bem, o Python utiliza de dois tipos de argumentos

argumentos ordenados
argumentos nomeados

Entendendo argumentos ordenados

Os ordenados são os que acabamos de fazer. Eles são reconhecidos primeiro nas funções. Ou seja, uma vez que você utilizar um argumento nomeados, os ordenados não terão mais efeitos, mas eu explico melhor já já.

Os ordenados são quando passamos os valores diretamente para as funções, vejamos:


def recebe_tres_nomes(nome_1, nome_2, nome_3):
    print(nome_1, nome_2, nome_3)

recebe_tres_nomes("akuma", "ryu", "ken")

saída:

akuma ryu ken

Veja que interessante, utilizei o mesmo exemplo que já vimos, e, também, criei a função de forma explicita para receber 3 nomes. Mas no geral a ideia é mostrar os argumentos sendo passados um a um, e vamos nos atentar que estamos passando os valores diretamente quando estamos chamando a função. Então o *args é essa lista de parâmetros que passamos de forma ordenada.

Observe que a função "recebe_tres_nomes" não mostra uma tupla mas sim cada item isolado, isso porque definimos que seria mostrado cada item

Entendendo argumentos nomeados

Vamos lá, agora vamos utilizar o mesmo exemplo, porém vamos passar parâmetros nomeados. Observe vou mudar a ordem dos nomes, e com isso vamos ter mesmo resultado

def recebe_tres_nomes(nome_1, nome_2, nome_3):
    print(nome_1, nome_2, nome_3)

recebe_tres_nomes(nome_2="ryu", nome_3="ken", nome_1="akuma")

saída:

akuma ryu ken

Agora utilizei argumentos na ordem invertida e tivemos o mesmo resultado. Isso porque o Python consegue ler o nome de cada parâmetro e capturar o seu valor.

Mas tem um detalhe aqui. Lembra que comentei que devemos respeitar a ordem de reconhecimento dos argumentos nas funções? Bem, eu disse que devemos sempre utilizar os paramentos ordenados e depois os nomeados.

Então é possível chamar nossa função assim:

def recebe_tres_nomes(nome_1, nome_2, nome_3):
    print(nome_1, nome_2, nome_3)

recebe_tres_nomes("akuma", nome_2="ryu", nome_3="ken")

saída:

akuma ryu ken

Viu só, eu passei o primeiro ordenado e o restante através dos nomes dos argumentos. Agora não podemos inverter isso. Olha pra mim aqui 🥸 Não funciona! Veja você mesmo.

def recebe_tres_nomes(nome_1, nome_2, nome_3):
    print(nome_1, nome_2, nome_3)

recebe_tres_nomes(nome_2="ryu", nome_3="ken", "akuma")

saída:

recebe_tres_nomes(nome_2="ryu", nome_3="ken", "akuma")
                                                         ^
SyntaxError: positional argument follows keyword argumentakuma ryu ken

O Python vai reclamar da ordem dos tipos de argumentos.

Não tente isso em casa... Brincadeira, tente e veja você mesmo.

Retornando ao desempacotamento

Bem, como eu havia dito, isso foi uma pequena pausa pra que possamos entender o desempacotamento nomeado

sabemos como funciona um dicionário em Python certo? (espero que sim 🤣)

temos chave seguido de valor

então se tentarmos atribuir um dicionário a várias variáveis, essas variáveis irão receber as chaves. Olha só

nomes = {
    'nome_1': 'akuma',
    'nome_2': 'ryu',
    'nome_3': 'ken'
}

a, b, c = nomes
print(a, b, c)

saída:

nome_1 nome_2 nome_3

Agora é aqui que está o 'pulo do gato', se passamos como argumento nossa lista de nomes com 2 estrelas, iremos receber a chave e os valores na função, cada chave ira servir como um argumento nomeado para a função. Legal né?

def recebe_nomes(nome_1, nome_2, nome_3):
    print(nome_1, nome_2, nome_3)

nomes = {
    'nome_1': 'akuma',
    'nome_2': 'ryu',
    'nome_3': 'ken',
}

recebe_nomes(**nomes)

saída:

akuma ryu ken

Lembre-se que se caso você passar um argumento que não existe, uma exceção será levantada, porque não existe nos argumentos que foram definidos:

def recebe_nomes(nome_1, nome_2, nome_3):
    print(nome_1, nome_2, nome_3)

nomes = {
    'nome_1': 'akuma',
    'nome_2': 'ryu',
    'nome_3': 'ken',
    'nome_4': 'mega man',
}

recebe_nomes(**nomes)

saída:

Traceback (most recent call last):
  File "c:\DevNew\Myblog\MyBlog\posts\post_03\code.py", line 14, in <module>
    recebe_tres_nomes(**nomes)
TypeError: recebe_tres_nomes() got an unexpected keyword argument 'nome_4'

Bom, é por isso que utilizamos o **kwargs, porque aí iremos receber quantos argumentos forem precisos:

def recebe_nomes(**kwargs):
    print(kwargs)

nomes = {
    'nome_1': 'akuma',
    'nome_2': 'ryu',
    'nome_3': 'ken',
    'nome_4': 'mega man'
}

recebe_nomes(**nomes)

saída:

{'nome_1': 'akuma', 'nome_2': 'ryu', 'nome_3': 'ken', 'nome_4': 'mega man'}

E agora o argumento "kwargs" se tornou um dicionário com todos os nossos argumentos nomeados.

Bem, vamos pensar na ordem dos tipos de argumentos. Obrigatoriamente tem que ser os ordenados, e em seguida os nomeados. E como já brincamos com os dois. Que tal misturar as coisas e fazer com que a função aceite tanto um quanto o outro?

def recebe_nomes(*args, **kwargs):
    print(args)
    print(kwargs)

recebe_nomes("akuma", "ryu", "ken", jogo="street fighter")

saída:

('akuma', 'ryu', 'ken')
{'jogo': 'street fighter'}

Viu só, passamos vários argumentos ordenamos, que ficou na tupla "args", e os nomeados ficou no dicionário "kwargs"

Podemos desempacotar através de listas e dicionários também:

def recebe_nomes(*args, **kwargs):
    print(args)
    print(kwargs)

nomes = {
    'nome_1': 'akuma',
    'nome_2': 'ryu',
    'nome_3': 'ken',
    'nome_4': 'mega man'
}

jogos = ["street fighter", "Mega Man x4"] 

recebe_tres_nomes(*jogos, **nomes)

saída:

('street fighter', 'Mega Man x4')
{'nome_1': 'akuma', 'nome_2': 'ryu', 'nome_3': 'ken', 'nome_4': 'mega man'}

Bom isso foi o desempacotamento e as expressões *args e **kwargs que vemos por aí.

Considerações

Quero te lembrar que esses nomes são uma convenção, funcionária com qualquer nome. Você não é obrigado a usar as palavras args e kwargs para funcionar. Se o planeta escreve assim, vamos escrever também, certo? Vamos manter o padrão.

Por curiosidade, o nome "args" vem de "arguments" (argumentos), e "kwargs" vem de "known arguments" (argumentos conhecidos)

E é isso! Obrigado por chegar até aqui 😉

Conclusão

Usar a técnica de desempacotamento em função é muito comum no dia a dia. É um assunto que gera um pouco de confusão quando olhamos a primeira vez, por isso tentei detalhar o máximo possível para que possam realmente entender como funciona. Espero poder ter ajudado alguém.

Gerenciadores de Contexto

Jorge Silva — Thu, 09 Mar 2023 12:05:29 +0000

Aposto que as primeiras perguntas que surgem ao falar deste assunto são. O que é? E para que serve?

Bom, vamos pensar em funcionalides que devemos ficar atentos à todas as etapas, principalmente a final. Parece um pouco estranho mas eu explico.

É comum precisarmos, por exemplo, manipular um arquivo, se comunicar com banco de dados ou fazer lock em threads. Mas você pode perceber o que essas atividades tem em comum? Para todas devemos ficar atentos a finalização depois do uso.

Vejamos, é preciso lembrar de fechar um arquivo após a manipulação, fechar a conexão com o banco após o uso e dar unlock em threads.

Bloco Try

Vamos entender melhor o bloco 'try' no Python

try: Tenta executar um códido
except: Executa caso haja falha do código que está no try
finally: Esse bloco sempre será executado

Vejamos um exemplos simples:

try:
    print("Faça algo aqui")
except:
    print("Faça algo caso dê algo errado no bloco 'try'")
finally:
    print("Sempre irá ser executado")

Retono:

Faça algo aqui
Sempre irá ser executado

Percebam que uma coisa interessante aqui, temos um bloco que tentará algo, e também um bloco que sempre será executado. É esse o princípio para os Gerenciadores de contexo.

Vamos pegar o exemplo da manupulação de arquivos. Vamos abrir um arquivo mas ao mesmo tempo garantir que iremos fecha-lo. Agora temos o seguinte código.

try:
    print("Abrindo um arquivo")
    arquivo = open('teste.txt', 'w', encoding='utf-8')
    arquivo.write("Oi")
except Exception as e:
    print("Erro ao tentar escrever no arquivo:", e)
finally:
    print("Fechando Arquivo")
    arquivo.close()

Retono:

Abrindo um arquivo
Fechando Arquivo

Percebam que agora podemos ficar tranquilos em relação a deixar o arquivo aberto por qualquer motivo que venha ocorrer. Mas vamos melhorar uma pouco mais essa idea. Afinal, Gerenciadores de Contexto estão aqui para isso 😉

Classes e métodos mágicos

OBS: Para entendermos e criamos nossos próprios gerenciadores, vamos trabalhar um pouco com classes. Então vamos lá.

O Python nos fornece 2 métodos mágicos para trabalhar com os Gerenciadores de Contexto. São eles:

__enter__ : Responsavel por retornar o 'contexto', vamos pensar no arquivo.
__exit__ : Responsavel por receber as possíveis exeções que podem surgir e por finalizar a atividade (equivalente a junção do bloco except e finally que já vimos)

Para exemplificar, vamos de código:

class MeuGerenciador:
    def __init__(self, nome_arquivo, modo, encoding) -> None:
        print("Criando arquivo a ser manipulado")
        self.arquivo = open(nome_arquivo, modo, encoding=encoding)

    def __enter__(self):
        """
        Esse bloco terá seu retorno atribuido a variável criada após a palavra 'as'
        """
        print("Devolvendo arquivo para a utilização")
        return self.arquivo

    def __exit__(self, tipo, valor, traceback):
        """
        Esse bloco sempre será executado ao saírmos do gerenciador
        Caso ocorra um erro temos o valor, tipo e traceback que recebemos como parâmetro
        """
        print("Fechando arquivo e saindo do gerenciador")
        self.arquivo.close()

Bom agora vamos ver como fica a utilização dessa classe.

with MeuGerenciador("teste.txt", "w", encoding="utf-8") as arquivo:
    arquivo.write("oi")

Retono:

Criando arquivo a ser manipulado
Devolvendo arquivo para a utilização
Fechando arquivo e saindo do gerenciador

Agora ficou bem mais simples a utilização. Vamos entender o que aconteceu aqui.

A palavra 'with' basicamente acionou o método __enter__ que criamos, e, por consequencia, utilizamos a palavra 'as' para criarmos a variável(ou seja, o 'contexto') que receberá o retorno do método __enter_. E quando que acionamos o método __exit_ ? Quando ocorre um erro ou quando saimos do bloco 'with'.

Então ficou fácil gerenciarmos coisas. Ou seja, podemos criar códigos que iremos trabalhar em uma etapa e criar códigos que serão executados automaticamente depois. Legal né? 😊

Bem, isso foi apenas para entermos o funcionamento do gerenciadores de contexto, porque o próprio Python já traz um gerenciador de arquivos para nós. Eu sei, eu sei "Se já tinha por que não mostrou desde o início?". Bom, a ideia era mostrar o que o Python nos fornece por baixo dos panos e também fazer com que você consiga criar seus próprios gerenciadores.

Então vamos ver como o Python traz de forma nativa o exemplo que criamos

with open("teste.txt", "w", encoding="utf-8") as arquivo:
    arquivo.write("oi")

Isso mesmo, a própria função open já possui um gerenciador de contexto. Então é possível utilizarmos das duas formas.

Entendendo as Exceções

Bom, chegamos até aqui e falta apenas entedermos como funciona as exceções dos gerenciadores.

Para que possamos capturar uma exceção no método __exit__ precisamos já ter criado o contexo, ou seja, já ter atribuido valor à variavél que foi criada com o retorno do método __enter__. No nosso exemplo foi a variável 'arquivo'.

O método __enter__ recebe 3 parâmetros para manipulação de erros.

tipo: A classe do tipo de erro. Erros que vem a partir da BaseException
valor: A mensagem de erro. Normalmente a mensagem que nos dá a luz na hora do bug
traceback: Um objeto do tipo traceback, nele temos os seguintes atributos:
- tb_frame: Basicamente uma string com a mensagem de erro e seus detalhes do traceback
- tb_lasti: índice da última instrução tentada em bytecode
- tb_lineno: linha onde ocorreu o erro
- tb_next: próximo trackback, casa haja mais de 1

Caso não haja nenhum erro durante a execução. Todos os parâmetros será atribuidos como None

Bem agora que entendemos melhor os erros. Vamos de exemplo. Ajustei a classe que criamos para forçamos os erros, executei o método write com 2 'e', dessa forma vamos ter um erro pois o método writee não existe. Vejamos:

class MeuGerenciador:
    def __init__(self, nome_arquivo, modo, encoding) -> None:
        print("criando arquivo a ser manipulado")
        self.arquivo = open(nome_arquivo, modo, encoding=encoding)

    def __enter__(self):
        """
        Esse bloco terá seu retorno atribuido a variável criada após a palavra 'as'
        """
        print("devolvendo arquivo para a utilização")
        return self.arquivo

    def __exit__(self, tipo, valor, traceback):
        """
        Esse bloco sempre será executado ao saírmos do gerenciador
        caso ocorra um erro temos o valor, tipo e traceback que recebemos como parâmetro
        """
        print("Capturando erros")
        print("tipo -> ", tipo)
        print("valor ->", valor)
        print("traceback frame ->", traceback.tb_frame)
        print("traceback índice ->", traceback.tb_lasti)
        print("traceback linha do erro ->", traceback.tb_lineno)
        print("traceback linha do erro ->", traceback.tb_next)
        self.arquivo.close()

Executando a classe com método 'writee'

with MeuGerenciador("teste.txt", "w", encoding="utf-8") as arquivo:
    arquivo.writee("oi")

Retorno:

criando arquivo a ser manipulado
devolvendo arquivo para a utilização
Capturando erros
tipo ->  <class 'AttributeError'>
valor -> '_io.TextIOWrapper' object has no attribute 'writee'
traceback frame -> <frame at 0x000001FBC34AB050, file 'c:\\DevNew\\dev-to\\2-gerenciador-contexto\\code.py', line 43, code <module>>
traceback índice -> 32
traceback linha do erro -> 43
traceback linha do erro -> None
Traceback (most recent call last):
  File "c:\DevNew\dev-to\2-gerenciador-contexto\code.py", line 43, in <module>
    arquivo.writee("oi")
AttributeError: '_io.TextIOWrapper' object has no attribute 'writee'

Agora sim vimos os detalhes da manipulação desse recurso incrível!

Conclusão

Bem, Espero ter ajudado no entendimento de gerenciador de contexo. Tentei detalhar ao máximo essa jornada. Mas vamos lembrar que é muito útil a utilização desse recurso.

Se esse Post foi útil para você, curta e compartilhe.

S.O.L.I.D com ChatGPT

Jorge Silva — Tue, 07 Mar 2023 19:32:14 +0000

Decidi perguntar ao ChatGPT como seria um código para exibir uma mensagem de "Parabéns" utilizando S.O.L.I.D.

A perguntar que fiz foi:

"escreva um código em Python pra dar parabéns utilizando S.O.L.I.D"

Pois bem, nossa resposta foi:

"Claro! Aqui está um exemplo de como utilizar os princípios S.O.L.I.D para escrever um código em Python para dar parabéns:"

class MensagemParabens:
    def __init__(self, mensagem):
        self.mensagem = mensagem

    def enviar_mensagem(self):
        print(self.mensagem)


class ServicoParabens:
    def __init__(self, mensagem):
        self.mensagem = mensagem

    def enviar_parabens(self):
        mensagem = MensagemParabens(self.mensagem)
        mensagem.enviar_mensagem()


if __name__ == '__main__':
    mensagem = "Parabéns!"
    servico_parabens = ServicoParabens(mensagem)
    servico_parabens.enviar_parabens()

Em seguida completou a explicação com a seguida mensagem:

"Neste código, utilizamos os seguintes princípios S.O.L.I.D:

Single Responsibility Principle (Princípio da Responsabilidade Única): as classes MensagemParabens e ServicoParabens têm apenas uma responsabilidade cada, tornando-as mais fáceis de entender, modificar e testar.

Open/Closed Principle (Princípio Aberto/Fechado): o código é aberto para extensão (p. ex., podemos adicionar outras formas de envio de parabéns) e fechado para modificação (p. ex., não precisamos modificar as classes existentes quando adicionamos uma nova forma de envio).

Liskov Substitution Principle (Princípio da Substituição de Liskov): as classes MensagemParabens e ServicoParabens são intercambiáveis com suas subclasses (se houvesse alguma), sem afetar o comportamento esperado do programa.

Interface Segregation Principle (Princípio da Segregação de Interfaces): não há interfaces desnecessárias nas classes.

Dependency Inversion Principle (Princípio da Inversão de Dependência): as classes dependem de abstrações (no caso, a classe MensagemParabens) em vez de depender de implementações concretas.

Espero que isso ajude!"

Quando executamos o código temos o seguinte retorno:

Parabéns!

Vamos debater cada item e entender como o ChatGPT tratou os tópicos de S.O.L.I.D

Single Responsibility Principle (Princípio da Responsabilidade Única)

Uma classe deve fazer apenas uma coisa e, portanto, deve ter apenas uma razão para ser modificada.

O ChatGPT respondeu que "as classes MensagemParabens e ServicoParabens têm apenas uma responsabilidade cada", bem, discordo um pouquinho.

A classe 'MensagemParabens' ficou responsável por tratar e também por enviar a mensagem. Acredito que podemos melhorar isso.

Criei a classe 'Mensagem' para tratarmos apenas o texto da nossa mensagem. Dessa forma, podemos tratar quaisquer mudanças e teremos uma classe própria para a Mensagem.

Em seguida criei a classe 'Mensageiro' para ficar responsável apenas por enviar a mensagem.

Nosso novo código ficou assim:

class Mensagem:
    def __init__(self, mensagem: str):
        self.mensagem = mensagem

    @property
    def texto(self):
        return self.mensagem


class Mensageiro:
    def __init__(self, mensagem: str):
        self.mensagem = mensagem

    def enviar_mensagem(self):
        print(self.mensagem)


class ServicoParabens:
    def __init__(self, mensageiro: Mensageiro):
        self.mensageiro = mensageiro

    def enviar_parabens(self):
        self.mensageiro.enviar_mensagem()


if __name__ == "__main__":
    mensagem = Mensagem("Parabéns!")
    mensageiro = Mensageiro(mensagem.texto)
    servico_parabens = ServicoParabens(mensageiro)
    servico_parabens.enviar_parabens()

Quando executamos o código temos o mesmo retorno:

Parabéns!

Open/Closed Principle (Princípio Aberto/Fechado)

As classes devem estar abertas para extensão, mas fechadas para modificação.

Vamos pensar um pouco nos meios que iremos enviar a mensagem. Vamos imaginar que queremos enviar por meio de Whastapp ou quem sabe pela DM no Instagram.

É nessa linha de pensamento que vamos deixar nosso código aberto para novas formas de envio.

Modifiquei a classe 'Mensageiro' para se tornar abstrata, então podemos adicionar novas formas de envio sem modificar nenhuma outra parte do nosso código.

Nosso novo código ficou assim:

from abc import ABC, abstractmethod


class Mensagem:
    def __init__(self, mensagem: str):
        self.mensagem = mensagem

    @property
    def texto(self):
        return self.mensagem


class Mensageiro(ABC):
    @abstractmethod
    def __init__(self, mensagem: str):
        ...

    @abstractmethod
    def enviar_mensagem(self):
        ...


class EnviaWhatsApp(Mensageiro):
    def __init__(self, mensagem: str):
        self.mensagem = mensagem

    def enviar_mensagem(self):
        print(self.mensagem, "Enviado para WhatsApp")


class EnviaInstagram(Mensageiro):
    def __init__(self, mensagem: str):
        self.mensagem = mensagem

    def enviar_mensagem(self):
        print(self.mensagem, "Enviado para Instagram")


class ServicoParabens:
    def __init__(self, mensageiro: Mensageiro):
        self.mensageiro = mensageiro

    def enviar_parabens(self):
        self.mensageiro.enviar_mensagem()


if __name__ == "__main__":
    mensagem = Mensagem("Parabéns!")
    mensageiro_wpp = EnviaWhatsApp(mensagem.texto)
    mensageiro_insta = EnviaInstagram(mensagem.texto)
    servico_wpp = ServicoParabens(mensageiro_wpp)
    servico_insta = ServicoParabens(mensageiro_insta)
    servico_wpp.enviar_parabens()
    servico_insta.enviar_parabens()

Quando executamos o código temos um novo retorno. Agora podemos ver a diferença de cada tipo de mensageiro:

Parabéns! Enviado para WhatsApp
Parabéns! Enviado para Instagram

Liskov Substitution Principle (Princípio da Substituição de Liskov)

Nesse tópico devemos garantir que nossas classes filhas consigam executar os mesmos métodos com os mesmos comportamentos.

Em nosso exemplo o método 'enviar_mensagem' já está fazendo bem esse papel herdaddo da classe 'Mensageiro'. Acredito que não há muito o que mexer em nosso código nesse ponto.

Interface Segregation Principle (Princípio da Segregação de Interfaces)

Nesse tópico devemos pensar que nenhuma classe deve ser forçada a depender de métodos que não será utilizado.

Isso quer dizer não devemos criar classes que herdarão de classes que trazem métodos que podem quebrar nossa aplicação.

Vejamos, imagina que queremos que nossa aplicação poderá apagar a mensagem que foi enviada. Para isso devemos lembrar que nem toda forma de envio irá permitir. WhatsApp, por exemplo, permite. Mas vamos imaginar que o Instagram não permita que a mensagem enviada seja excluída. Nesse caso não podemos criar uma única classe abstrata para ambos. Devemos separar em diferentes abstrações, pois se caso tentarmos executar um método para deletar a mensagem no Instagram, teremos um problema em nossa aplicação.

Bem, criei uma nova classe abstrata 'MensageiroEditor' que herda de nossa abstração base 'Mensageiro', nela incluímos no método 'apaga_mensagem'. E como agora vamos trabalhar diretamente com a classes dos mensageiros, então retiramos a classe 'ServicoParabens' e vamos trabalhar diretamente com os nossos métodos. Dessa forma, vamos garantir a execução correta.

Nosso novo código modificado ficou assim:

from abc import ABC, abstractmethod


class Mensagem:
    def __init__(self, mensagem: str):
        self.mensagem = mensagem

    @property
    def texto(self):
        return self.mensagem


class Mensageiro(ABC):
    @abstractmethod
    def __init__(self, mensagem: str):
        ...

    @abstractmethod
    def enviar_mensagem(self):
        ...


class MensageiroEditor(Mensageiro):
    @abstractmethod
    def apaga_mensagem(self):
        ...


class EnviaWhatsApp(MensageiroEditor):
    def __init__(self, mensagem: str):
        self.mensagem = mensagem

    def enviar_mensagem(self):
        print(self.mensagem, "Enviado para WhatsApp")

    def apaga_mensagem(self):
        print("Deletando mensagem enviada", "mensagem:", self.mensagem)


class EnviaInstagram(Mensageiro):
    def __init__(self, mensagem: str):
        self.mensagem = mensagem

    def enviar_mensagem(self):
        print(self.mensagem, "Enviado para Instagram")


if __name__ == "__main__":
    mensagem = Mensagem("Parabéns!")
    mensageiro_wpp = EnviaWhatsApp(mensagem.texto)
    mensageiro_insta = EnviaInstagram(mensagem.texto)
    mensageiro_wpp.enviar_mensagem()
    mensageiro_insta.enviar_mensagem()
    mensageiro_wpp.apaga_mensagem()

Quando executamos o código temos um novo retorno. E, novamente, podemos ver a diferença de cada tipo de mensageiro:

Parabéns! Enviado para WhatsApp
Parabéns! Enviado para Instagram
Deletando mensagem enviada mensagem: Parabéns!

Dependency Inversion Principle (Princípio da Inversão de Dependência):

Este princípio recomenda que uma classe deve depender abstrações e não de implementações concretas.
Então vamos tornar nossa classe 'Mensageiro' dependente de uma interface 'Mensagem', assim podemos personalizar nossa mensagem por tipo de envio e ainda definir a utilização de interface ao usar nossa abstração 'Mensageiro'.

vamos atualizar nosso código para:

from abc import ABC, abstractmethod


class Mensagem(ABC):
    @abstractmethod
    def __init__(self, mensagem: str):
        self.mensagem = mensagem

    @property
    @abstractmethod
    def texto(self):
        return self.mensagem


class WhatsAppMensagem(Mensagem):
    def __init__(self, mensagem: str):
        self.mensagem = mensagem

    @property
    def texto(self):
        return f"Olá pessoas do WhatsApp, {self.mensagem}"


class InstagramMensagem(Mensagem):
    def __init__(self, mensagem: str):
        self.mensagem = mensagem

    @property
    def texto(self):
        return f"Olá pessoas do Instagram, {self.mensagem}"


class Mensageiro(ABC):
    @abstractmethod
    def __init__(self, mensagem: Mensagem):
        ...

    @abstractmethod
    def enviar_mensagem(self):
        ...


class MensageiroEditor(Mensageiro):
    @abstractmethod
    def apaga_mensagem(self):
        ...


class EnviaWhatsApp(MensageiroEditor):
    def __init__(self, mensagem: Mensagem):
        self.mensagem = mensagem.texto

    def enviar_mensagem(self):
        print(self.mensagem)

    def apaga_mensagem(self):
        print("Deletando mensagem enviada", "mensagem:", self.mensagem)


class EnviaInstagram(Mensageiro):
    def __init__(self, mensagem: Mensagem):
        self.mensagem = mensagem.texto

    def enviar_mensagem(self):
        print(self.mensagem)


if __name__ == "__main__":
    mensagem = "Parabéns!"
    mensageiro_wpp = EnviaWhatsApp(WhatsAppMensagem(mensagem))
    mensageiro_insta = EnviaInstagram(InstagramMensagem(mensagem))
    mensageiro_wpp.enviar_mensagem()
    mensageiro_insta.enviar_mensagem()
    mensageiro_wpp.apaga_mensagem()

Podemos ver a diferença de cada tipo de mensageiro para cada tipo de envio:

Olá pessoas do WhatsApp, Parabéns!
Olá pessoas do Instagram, Parabéns!
Deletando mensagem enviada mensagem: Olá pessoas do WhatsApp, Parabéns!

Conclusão

Espero que esses exemplos tenham sido úteis para ajudar a entender os princípios básicos do SOLID.
Conseguimos evoluir um pouco o código gerado pelo ChatGPT. É graças a essas boas práticas, que conseguimos um código mais limpo e reutilizável que pode ser muito útil quando diferentes colegas desenvolvem diferentes partes do software ou trabalharão nele no futuro. Entretando é bom que fiquemos atentos ao implementar novos padrões. Como acontece com todos os guias, também não é recomendado seguir os princípios S.O.L.I.D cegamente. Princípios, padrões e diretrizes podem facilmente se transformar em antipadrões e levar a novos problemas.