Este artigo foi originalmente publicado no LinkedIn.

Como armazenar conhecimento com bancos de dados vetoriais?​

Em um mundo inundado de dados não estruturados, como podemos armazenar não apenas informações, mas conhecimento?

Este artigo explora o conceito de bancos de dados vetoriais — uma tecnologia revolucionária que permite busca baseada em similaridade e compreensão semântica. Vamos entender o que são vetores, como são usados em Processamento de Linguagem Natural (PNL) e como embeddings permitem representações eficientes e contextualizadas da informação. Por fim, exploraremos aplicações do mundo real e por que os bancos de dados vetoriais estão se tornando essenciais em sistemas modernos de IA.

A Ascensão dos Dados Não Estruturados​

Com o avanço do Big Data, bilhões de dispositivos conectados geram informações em tempo real na forma de texto, imagens, vídeos e mais. Esses formatos não estruturados não se encaixam bem em tabelas SQL tradicionais e exigem soluções de armazenamento mais sofisticadas. É aqui que os bancos de dados vetoriais surgem como uma abordagem inovadora, permitindo buscas baseadas em similaridade e armazenamento de conhecimento a partir de dados complexos.

Antes de mergulharmos em como os bancos de dados vetoriais funcionam, vamos primeiro recapitular os fundamentos dos bancos de dados.

O que é um Banco de Dados?​

Um banco de dados é, simplificadamente, uma coleção organizada de informações que pode ser acessada, gerenciada e atualizada de forma eficiente. Ele atua como uma estrutura que armazena e organiza dados, facilitando consultas e manipulações por meio de software especializado.

Bancos de Dados Relacionais​

Os bancos de dados relacionais são o tipo mais comumente usado. Eles armazenam dados em tabelas organizadas em linhas e colunas — onde cada linha representa um registro e cada coluna representa um campo ou atributo. Esse modelo é ideal para dados estruturados, como registros de clientes, transações bancárias ou inventários de produtos.

Um exemplo clássico é um banco de dados de clientes com colunas para nome, endereço, número de telefone e e-mail. Os bancos de dados relacionais permitem consultas rápidas e precisas, como “encontrar todos os clientes que fizeram uma compra nos últimos 30 dias”, usando uma linguagem conhecida como SQL (Structured Query Language).

Bancos de Dados Não Relacionais (NoSQL)​

Ao contrário dos bancos de dados relacionais, os bancos de dados NoSQL são projetados para lidar com dados não estruturados ou semi-estruturados, oferecendo mais flexibilidade e escalabilidade. Eles armazenam informações em formatos diversos, como documentos JSON, pares chave-valor ou grafos. Isso os torna mais adequados para aplicações modernas, como plataformas de mídia social ou serviços de streaming.

Por exemplo, um banco de dados NoSQL orientado a documentos pode armazenar dados em formato JSON, permitindo estruturas de dados mais complexas e aninhadas — sem exigir um esquema rígido.

Entre as categorias de bancos de dados não relacionais, os bancos de dados vetoriais se destacam por sua capacidade de armazenar dados contextualizados — também conhecidos como conhecimento.

Bancos de Dados Vetoriais​

Os bancos de dados vetoriais introduzem uma abordagem transformadora voltada para armazenar e recuperar dados como vetores — estruturas matemáticas que representam informações em múltiplas dimensões. Ao contrário dos bancos de dados tradicionais que dependem de correspondência exata, os bancos de dados vetoriais permitem buscas por similaridade, que são ideais para recuperar conteúdos como textos, imagens ou sons com base em suas características.

Isso nos leva a uma pergunta chave: o que é um vetor?

O que é um Vetor?​

Um vetor é uma estrutura que armazena informações em várias dimensões. No caso de um vetor tridimensional, ele possui três coordenadas — (x, y, z) — que definem sua posição ou direção em um espaço 3D.

Um exemplo do mundo real é como as cores são representadas no modelo RGB (Vermelho, Verde, Azul). Uma cor é descrita por três valores, cada um representando a intensidade de vermelho, verde e azul. Por exemplo, o branco é [255, 255, 255], enquanto o preto é [0, 0, 0].

Esse conceito se estende para vetores 4D, como RGBA, onde o quarto componente “A” representa o alpha (transparência). Um vermelho semi-transparente poderia ser [255, 0, 0, 0.5].

Assim como as cores podem ser representadas por vetores em três ou quatro dimensões, os bancos de dados vetoriais usam vetores para organizar itens como palavras, imagens e sons em espaços multidimensionais, onde a distância entre vetores indica similaridade.

Representando Palavras com Vetores​

Os vetores são amplamente utilizados para representar informações mais abstratas, como palavras. Em PNL, converter palavras em números é essencial para que as máquinas possam entendê-las e manipulá-las. Uma das técnicas mais simples é a One-Hot Encoding.

One-Hot Encoding​

One-Hot Encoding é uma técnica onde cada palavra é transformada em um vetor de zeros e uns. Nesse vetor, cada posição corresponde a uma palavra específica no vocabulário, e apenas uma posição contém o valor "1" — todas as outras são definidas como "0".

Vamos considerar um conjunto de quatro palavras: cachorro, gato, pássaro e peixe. Usando One-Hot Encoding, essas palavras seriam representadas da seguinte forma:

• cachorro: [1, 0, 0, 0]
• gato: [0, 1, 0, 0]
• pássaro: [0, 0, 1, 0]
• peixe: [0, 0, 0, 1]

Cada vetor contém apenas um "1", indicando a palavra correspondente, enquanto os "0s" indicam que as outras palavras não estão presentes. Embora essa abordagem seja simples e fácil de implementar, ela apresenta algumas limitações — especialmente à medida que o vocabulário começa a crescer.

As Limitações da One-Hot Encoding​

Embora simples, a One-Hot Encoding não captura as relações semânticas entre as palavras. No exemplo acima, "cachorro" e "gato" são tratados como completamente diferentes, mesmo que ambos sejam animais de estimação, tenham quatro patas, duas orelhas e uma cauda. Outra desvantagem aparece em cenários com grandes vocabulários — digamos, 10.000 palavras. Nesses casos, cada palavra seria representada por um vetor muito longo com um único "1" entre 10.000 posições, sem oferecer nenhuma indicação de como as palavras se relacionam entre si. Essa ineficiência e falta de informação semântica destacam a necessidade de técnicas mais avançadas para representar palavras como vetores de forma mais eficiente.

Representações Avançadas: Embeddings​

Para superar essas limitações, foram introduzidos os embeddings — representações vetoriais densas e contínuas de palavras, onde palavras com significados semelhantes são colocadas próximas umas das outras no espaço vetorial. Ao contrário da One-Hot Encoding, os embeddings capturam o significado das palavras, posicionando termos relacionados — como “cachorro” e “gato” — próximos uns dos outros no espaço vetorial, uma vez que compartilham características comuns.

O Que São Embeddings?​

Embeddings são uma forma de representar dados como vetores, onde itens semelhantes são posicionados próximos uns dos outros em um espaço multidimensional. Eles são amplamente utilizados em áreas como PNL para capturar relações entre palavras, imagens ou sons de forma mais eficaz do que métodos mais simples, como One-Hot Encoding.

Esses embeddings permitem que dados com características semelhantes se agrupem, o que torna a busca por similaridade e o agrupamento de informações relacionadas muito mais eficientes.

Uma Analogia Simples: Cores em um Espaço Vetorial 3D​

Para facilitar a compreensão, vamos considerar um exemplo familiar: cores no modelo RGBA. Cada cor é representada por quatro valores — as intensidades de vermelho, verde e azul, além de um canal alfa que controla a transparência — colocando-a em um espaço quatro-dimensional (4D).

Como não podemos visualizar quatro dimensões diretamente, simplificamos plotando apenas os componentes RGB em um espaço 3D. O valor alfa ainda existe, mas não é representado visualmente nesta visão.

Por exemplo:

• Vermelho: [255, 0, 0, 1]
• Vermelho Claro: [255, 0, 0, 0.5]
• Verde: [0, 255, 0, 1]
• Azul: [0, 0, 255, 1]

Quando plotamos essas cores em um espaço 3D usando apenas os componentes RGB, podemos ver claramente que Vermelho e Vermelho Claro aparecem próximos um do outro, enquanto Verde e Azul estão localizados mais distantes. Essa proximidade espacial reflete quão semelhantes as cores são — neste caso, devido à sua intensidade vermelha compartilhada.

Representando Palavras com Embeddings​

Agora, vamos aplicar essa ideia a como representamos palavras. Em vez de usar três ou quatro dimensões como no modelo de cores RGB, as palavras são tipicamente representadas em espaços vetoriais com centenas ou até milhares de dimensões. Cada dimensão captura algum aspecto ou característica da palavra — como seu significado, contexto ou relações com outras palavras.

Por exemplo:

No exemplo acima, "cachorro" e "gato" aparecem próximos um do outro no espaço vetorial, porque ambos são animais de estimação e compartilham semelhanças contextuais. Por outro lado, "carro" e "floresta" estão posicionados mais distantes devido aos seus significados e padrões de uso muito diferentes.

Ilustrativo apenas — nenhum modelo real foi utilizado pra gerar esses vetores.

Esses espaços vetoriais de alta dimensão são gerados por modelos de embedding, que analisam grandes volumes de texto e aprendem a posicionar palavras com base nos contextos em que aparecem. Quanto mais próximas duas palavras estão no espaço, mais semanticamente semelhantes elas são.

Essa representação torna possível que as máquinas raciocinem sobre o significado — não apenas reconheçam correspondências exatas, mas entendam a relação. Essa é uma base fundamental para tarefas modernas de IA, como resposta a perguntas, tradução e busca semântica.

Explore uma Representação Real de Embedding​

Se você gostaria de ver como os embeddings se parecem na prática, pode explorar uma visualização interativa ao vivo usando o TensorFlow Embedding Projector. Esta ferramenta permite que você navegue por espaços vetoriais de alta dimensão e observe como palavras, imagens ou outros pontos de dados são organizados com base em suas relações semânticas.

Você verá algo semelhante ao exemplo abaixo, onde cada palavra é plotada em um espaço com até 200 dimensões, reduzido visualmente para 2D ou 3D usando técnicas de redução de dimensionalidade como PCA ou t-SNE.

Nesta visualização, cada ponto representa uma palavra, e a proximidade entre eles reflete quão semelhantes seus significados são de acordo com o modelo de embedding. Por exemplo, a palavra “store” está cercada por palavras como “shop,” “market,” e “retail”, indicando que o modelo aprendeu sua semelhança contextual a partir de dados textuais em larga escala.

Esse tipo de espaço de embedding permite que as máquinas não apenas reconheçam termos individuais, mas também entendam as relações entre eles — uma capacidade poderosa para tarefas como busca semântica, onde o objetivo é encontrar informações relevantes com base no significado, em vez de correspondências exatas.

Como Funciona um Banco de Dados Vetorial?​

Agora que cobrimos os conceitos básicos, podemos entender melhor como os bancos de dados vetoriais operam. Um banco de dados vetorial organiza dados na forma de vetores, que ocupam posições em espaço multidimensional. O principal objetivo é permitir a busca semântica — ou seja, encontrar itens semelhantes com base em sua proximidade vetorial, em vez de correspondências exatas como em bancos de dados tradicionais.

Por exemplo, imagine um banco de dados de imagens onde cada imagem é representada como um vetor que captura suas características visuais — como cor, forma e textura. Se você quiser encontrar imagens semelhantes a uma imagem específica de um gato, o banco de dados vetorial calculará a distância entre o vetor da imagem de consulta e os vetores de outras imagens armazenadas. Aqueles com a menor distância serão retornados como resultados, uma vez que compartilham características semelhantes.

Uma aplicação comum desse tipo é o reconhecimento facial, onde a semelhança entre o vetor de um rosto capturado e o de um rosto registrado pode indicar uma correspondência potencial.

Mas como exatamente a semelhança entre vetores é medida?

Distância Vetorial e Busca por Similaridade​

Em um banco de dados vetorial, itens com características semelhantes são agrupados próximos uns dos outros em um espaço multidimensional. A "proximidade" — ou similaridade — entre os itens é determinada por métricas de distância específicas, como distância euclidiana ou similaridade por cosseno.

No caso de buscas por palavras, como em nosso exemplo anterior de embeddings, um banco de dados vetorial pode retornar palavras que estão semanticamente próximas da consulta. Por exemplo, se você pesquisar pela palavra "feline", o banco de dados pode retornar "cat," "tiger," ou "leopard", com base em quão próximos seus vetores estão no espaço semântico.

Esse tipo de correspondência baseada em vetores permite que os sistemas vão além de palavras-chave superficiais e encontrem resultados que estão significativamente relacionados, mesmo quando as palavras exatas não correspondem — uma grande vantagem em aplicações modernas de IA.

Aplicações de Bancos de Dados Vetoriais​

Os bancos de dados vetoriais já estão sendo amplamente utilizados para resolver desafios relacionados a dados não estruturados em vários domínios. Aqui estão alguns exemplos práticos:

• Busca de Imagens: Sistemas médicos e plataformas como o Google Imagens usam bancos de dados vetoriais para encontrar imagens visualmente semelhantes com base em características como cor, forma e textura — o que ajuda em diagnósticos e descoberta de conteúdo.

• Recomendações de Produtos: No comércio eletrônico, os bancos de dados vetoriais sugerem produtos com base em buscas anteriores ou no histórico de compras do usuário, permitindo uma experiência de compra mais personalizada.

• Reconhecimento Facial: Sistemas de segurança usam bancos de dados vetoriais para comparar imagens faciais, identificando correspondências com alta precisão — tornando a autenticação e vigilância mais eficazes.

• RAG (Geração Aumentada por Recuperação): Essa técnica combina a recuperação de documentos de bancos de dados vetoriais com as capacidades de geração de respostas de grandes modelos de linguagem (LLMs). Isso permite que esses modelos se especializem em tópicos específicos sem exigir re-treinamento.

No meu trabalho de conclusão de curso, utilizei RAG para construir um chatbot focado em saúde mental. O sistema recupera informações relevantes e fornece respostas mais precisas e contextualizadas.

Conclusão​

À medida que os dados não estruturados continuam a crescer exponencialmente, os bancos de dados vetoriais estão se tornando essenciais para recuperar informações de forma eficiente e significativa. Ao permitir a busca baseada em similaridade em vez de depender de correspondências exatas, eles abrem novas possibilidades para interagir com dados complexos de maneiras mais intuitivas e inteligentes.

Desde aplicações como busca de imagens, recomendações de produtos e reconhecimento facial, até o suporte a técnicas avançadas como RAG, os bancos de dados vetoriais estão prontos para desempenhar um papel fundamental no futuro da inteligência artificial. Eles ajudam a preencher a lacuna entre dados brutos e conhecimento acionável — impulsionando a inovação em diversos setores.

Em um mundo onde contexto e significado importam mais do que nunca, os bancos de dados vetoriais oferecem uma mudança de paradigma. Ao interpretar dados semânticamente, eles têm o potencial de revolucionar a forma como armazenamos, recuperamos e entendemos informações — conectando os sistemas digitais de hoje com as tecnologias orientadas ao conhecimento de amanhã.

Referências​

Este artigo foi originalmente publicado em LinkedIn

Você sabe o que são métodos mágicos em Python? Dica: Você usa todos os dias!​

Há alguns anos, quando estava aprendendo a usar o framework Django (o primeiro framework que aprendi), me deparei com uma característica peculiar das classes Python: o método construtor deve seguir um padrão específico — ele deve ser identificado por underscores duplos (__) antes e depois da palavra init. Isso me chamou a atenção; por que essa estrutura específica?

class MinhaClasse:
    def __init__(self): # Este é o método construtor
        ...

Tentando entender de onde vieram essas funções 'diferentes', descobri que no mundo do Python, existem vários métodos que seguem esse padrão 'dunder' (um apelido derivado de Double UNDERscore). Esses métodos não são apenas comuns — eles são especiais e fundamentais para a linguagem, conhecidos como dunder methods ou métodos mágicos.

OK, mas o que esses métodos realmente fazem? O que os torna 'mágicos'?

Essas foram algumas das perguntas que me levaram a estudá-los mais profundamente e a escrever este artigo. Espero que você goste :)

O que são dunder methods?​

No mundo da programação, muitas vezes nos deparamos com conceitos que parecem complexos à primeira vista, mas que, uma vez compreendidos, fazem total sentido. Um ótimo exemplo disso em Python são os dunder methods.

Então, o que exatamente são esses métodos? Como mencionado anteriormente, a palavra 'dunder' refere-se à notação de underscore duplo no início e no final dos nomes desses métodos especiais. Por exemplo, __init__ para um construtor de classe, ou __str__ para a representação em string de um objeto.

P.S. Alguns puristas pythonicos não gostam de chamar o método __init__ de construtor, pois tecnicamente ele é um inicializador. No entanto, para simplificar, vamos nos referir a ele como construtor neste artigo.

Esses métodos não são chamados diretamente pelo nome. Em vez disso, o Python os chama internamente quando certas ações são realizadas. Por exemplo, quando adicionamos dois objetos usando o operador +, o Python chama internamente o método __add__, que lida com a lógica de adicionar um valor a outro.

Ficou confuso? Vou dar alguns exemplos para facilitar!

Imagine que você está construindo uma classe para representar um livro em uma biblioteca. Para fazer isso, você precisará implementar o método __init__, que atua como um construtor, configurando atributos iniciais como título, autor e contagem de páginas:

class Livro:
    def __init__(self, titulo, autor, paginas):
        self.titulo = titulo
        self.autor = autor
        self.paginas = paginas

O que acontece quando você tenta adicionar dois objetos Livro? Você pode esperar que eles se combinem de alguma forma, mas o Python não sabe como lidar com essa operação por padrão:

livro1 = Livro("Primeiro Livro", "Autor A", 100)
livro2 = Livro("Segundo Livro", "Autor B", 200)

print(livro1 + livro2)

Isso levantará um TypeError porque o Python não sabe como adicionar dois objetos Livro. Este código irá gerar:

>>> TypeError: unsupported operand type(s) for +: 'Livro' and 'Livro'

Para fazer essa operação funcionar, você pode definir o método __add__ na sua classe Livro. Este método especificará como dois objetos Livro devem ser adicionados. Por exemplo, você pode querer adicionar suas contagens de páginas:

class Livro:
    def __init__(self, titulo, autor, paginas):
        self.titulo = titulo
        self.autor = autor
        self.paginas = paginas

    def __add__(self, other):
        return self.paginas + other.paginas

Agora, quando você tenta adicionar dois objetos Livro, o Python chamará o método __add__, que neste caso somará a quantidade de páginas. É assim que você pode personalizar o comportamento dos operadores para suas próprias classes.

livro1 = Livro("Primeiro Livro", "Autor A", 100)
livro2 = Livro("Segundo Livro", "Autor B", 200)

print(livro1 + livro2) # Isso vai imprimir: 300

Esse comportamento não se limita apenas ao operador de adição!

Na verdade, a maioria dos operadores em Python pode ser personalizada usando dunder methods. Por exemplo, você pode definir como sua classe se comporta com o operador == implementando o método __eq__, ou com o operador - implementando o método __sub__. Um bom exemplo disso é o operador in, quando verificamos se algum valor está in uma lista, por baixo dos panos, o Python está chamando o método __contains__ da classe lista, passando o valor como argumento. Veja o exemplo abaixo:

minha_lista = [1, 2, 3, 4, 5]

print(3 in minha_lista)  # Isso vai imprimir: True
print(minha_lista.__contains__(3))  # Isso também vai imprimir: True

print(6 in minha_lista)  # Isso vai imprimir: False
print(minha_lista.__contains__(6))  # Isso também vai imprimir: False

Mais exemplos de dunder methods​

Agora que você tem uma compreensão básica do que são os dunder methods e como funcionam, vamos ver mais alguns exemplos de seu uso, ainda aplicados à classe Livro:

__str__: Customizando prints​

Seguindo o exemplo anterior, o que acontece quando você tenta imprimir um objeto Livro? Por padrão, o Python mostrará algo como <__main__.Book object at 0x...>, que não é muito informativo:

livro1 = Livro("Primeiro Livro", "Autor A", 100)
print(livro1)

Isso vai imprimir algo como:

>>> <__main__.Book object at 0x7f8c1b0d0>

Se você está se perguntando se é possível personalizar essa saída, tornando a representação mais amigável ao usuário, sim, é! Você só precisa implementar o método mágico chamado __str__ em sua classe. Esse método permite que você defina como seu objeto deve ser representado como uma string. Então, vamos fazer isso:

class Livro:
    def __init__(self, titulo, autor, paginas):
        self.titulo = titulo
        self.autor = autor
        self.paginas = paginas

    def __str__(self):
        return f"{self.titulo} por {self.autor}, {self.paginas} páginas"

Agora, quando você imprime um objeto Livro, ele exibirá o título, autor e contagem de páginas em um formato mais legível:

livro1 = Livro("Primeiro Livro", "Autor A", 100)
print(livro1) # Isso vai imprimir: Primeiro Livro por Autor A, 100 páginas

__eq__: Customizando verificações de igualdade​

E se você quiser verificar se dois objetos Livro são considerados iguais? Por padrão, o Python verifica se eles são o mesmo objeto na memória, o que pode não ser o que você deseja. Para personalizar esse comportamento, você pode implementar o método __eq__:

class Livro:
    def __init__(self, titulo, autor, paginas):
        self.titulo = titulo
        self.autor = autor
        self.paginas = paginas

    def __eq__(self, other):
        return (self.titulo == other.titulo and
                self.autor == other.autor and
                self.paginas == other.paginas)

Agora, você pode comparar a igualdade de dois objetos Livro com base em seus atributos:

livro1 = Livro("Primeiro Livro", "Autor A", 100)
livro2 = Livro("Segundo Livro", "Autor B", 200)
livro3 = Livro("Primeiro Livro", "Autor A", 100)

print(livro1 == livro2)  # Isso vai imprimir: False
print(livro1 == livro3)  # Isso vai imprimir: True
print(livro3.__eq__(livro1))  # Isso vai imprimir: True

__len__: Customizando verificações de comprimento​

E se você quiser verificar quantas páginas um livro tem? Você pode verificar manualmente o atributo paginas, mas também pode implementar o método __len__ para permitir o uso da função embutida len():

class Livro:
    def __init__(self, titulo, autor, paginas):
        self.titulo = titulo
        self.autor = autor
        self.paginas = paginas

    def __len__(self):
        return self.paginas

Agora, você pode usar a função len() em um objeto Livro:

livro1 = Livro("Primeiro Livro", "Autor A", 100)
print(len(livro1))  # Isso vai imprimir: 100

__getitem__: Customizando o acesso a itens​

Por último, e se você quiser acessar um atributo específico de um objeto Livro usando indexação, como livro[0] para o título? Você pode implementar o método __getitem__:

class Livro:
    def __init__(self, titulo, autor, paginas):
        self.titulo = titulo
        self.autor = autor
        self.paginas = paginas

    def __getitem__(self, index):
        if index == 0:
            return self.titulo
        elif index == 1:
            return self.autor
        elif index == 2:
            return self.paginas
        else:
            raise IndexError("Índice fora do alcance")

Agora, você pode acessar o título, autor e páginas de um objeto Livro usando indexação:

livro1 = Livro("Primeiro Livro", "Autor A", 100)
print(livro1[0])  # Isso vai imprimir: Primeiro Livro
print(livro1[1])  # Isso vai imprimir: Autor A
print(livro1[2])  # Isso vai imprimir: 100

Conclusão​

Esses foram apenas alguns exemplos que destacam o poder e a flexibilidade dos dunder methods em Python. Com eles, você pode moldar o comportamento de suas classes e objetos de maneiras que se alinham com a sintaxe e os paradigmas da linguagem, tornando seu código mais intuitivo e 'Pythonico'.

Então, da próxima vez que você estiver projetando uma classe Python, lembre-se da magia dos dunder methods e de como eles podem enriquecer suas abstrações!

Abaixo, deixarei uma lista de alguns dos dunder methods mais usados em Python, cada um vinculado à documentação oficial:

• __init__: O método construtor, chamado quando um objeto é criado.
• __add__: Define o comportamento do operador de adição (+).
• __contains__: Define o comportamento do operador in para um objeto.
• __str__: Define a representação em string de um objeto, usada pela função print().
• __eq__: Define o comportamento do operador de igualdade (==).
• __len__: Define o comportamento da função len() para um objeto.
• __getitem__: Define o comportamento da indexação de um objeto (por exemplo, obj[key]).
• __setitem__: Define o comportamento de definir um item em um objeto (por exemplo, obj[key] = value).
• __delitem__: Define o comportamento de deletar um item de um objeto (por exemplo, del obj[key]).
• __repr__: Define a representação oficial de um objeto, usada pela função repr().
• __ne__: Define o comportamento do operador de desigualdade (!=).
• __lt__: Define o comportamento do operador menor que (<).
• __le__: Define o comportamento do operador menor ou igual a (<=).
• __gt__: Define o comportamento do operador maior que (>).
• __ge__: Define o comportamento do operador maior ou igual a (>=).
• __sub__: Define o comportamento do operador de subtração (-).
• __mul__: Define o comportamento do operador de multiplicação (*).
• __truediv__: Define o comportamento do operador de divisão verdadeira (/).
• __bool__: Define o valor de verdade de um objeto, usado pela função bool().
• __iter__: Define o comportamento de um objeto quando usado em um loop ou com a função iter().
• __next__: Define o comportamento da função next() para um objeto, permitindo que ele seja iterável.
• __enter__: Define o comportamento de um objeto quando usado em uma instrução with, permitindo que ele configure um contexto.
• __exit__: Define o comportamento de um objeto ao sair de uma instrução with, permitindo que ele limpe recursos.
• __hash__: Define o comportamento da função hash() para um objeto, permitindo que ele seja usado em coleções baseadas em hash, como conjuntos e dicionários.
• __del__: Define o comportamento de um objeto quando está prestes a ser destruído, permitindo ações de limpeza.

Espero que este artigo tenha esclarecido um pouco sobre o fascinante mundo dos dunder methods em Python. Se você tiver alguma dúvida ou quiser compartilhar suas experiências com dunder methods, sinta-se à vontade para entrar em contato!

Referências​

Olá, mundo! 👋

Sou Marco Antônio e este é o meu Brain Blog.

Esta publicação é uma explicação do que você vai encontrar por aqui.

Por que “Brain Blog”?​

“Quem ensina aprende ao ensinar. E quem aprende ensina ao aprender.” — Paulo Freire

A ideia do Brain Blog é fazer um 'backup' do meu cérebro, onde anoto meus estudos, organizo referências e documento minhas jornadas de aprendizado.

Estrutura do conteúdo​

Meu espaço pessoal para compartilhar ideias e conhecimento.

Aqui você encontrará artigos, tutoriais e reflexões sobre temas que me interessam. Compartilharei também experiências e aprendizados que considero relevantes.