Tutorial de MongoDB: como configurar e consultar bancos de dados MongoDB

Aprenda a conectar e analisar bancos de dados MongoDB em Python.

Atualizado 17 de set. de 2026 · 10 min lido

Explorar com IA

Você provavelmente já ouviu falar de bancos de dados relacionais ou até trabalhou com eles. O formato de linhas e tabelas é a estrutura mais popular e intuitiva para armazenar informações. Mas nem todos os dados cabem direitinho em linhas e colunas. Na prática, muitos problemas do mundo real pedem bancos de dados não relacionais. E aí, existem alternativas?

A resposta é SIM! Há quatro tipos de bancos de dados que não usam linhas nem tabelas. Eles são chamados de bancos de dados NoSQL, já que você não usa SQL para consultá-los. São eles:

Bancos de dados chave-valor
Bancos de dados de documentos
Bancos de dados de família de colunas
Bancos de dados de grafos

Este artigo foca em bancos de dados de documentos e em como usar um servidor chamado MongoDB. Antes de entrar nos detalhes técnicos, vamos ver alguns casos de uso de bancos de documentos. Se quiser se aprofundar em bancos de grafos, confira nosso guia separado sobre bancos de dados de grafos.

Quando usar bancos de dados de documentos?

Um dos principais motivos para escolher bancos de documentos é quando você tem dados que não se encaixam bem em um esquema pré-definido como o de uma tabela. Muitos processos ou aplicações em diferentes setores armazenam esse tipo de dado. Veja alguns exemplos:

Apps web e mobile: perfis de usuários, preferências, conteúdo e interações
Sistemas de gerenciamento de conteúdo: armazenamento de uma ampla variedade de mídias, como texto, imagens, vídeo, GIFs etc.
Plataformas de e-commerce: catálogos de produtos, dados de clientes, histórico de pedidos, inventário etc.
Games: armazenamento de perfis de jogadores, rankings de leaderboard
Logs e coleta de dados: grandes volumes de logs, eventos, métricas para análise etc.

Pense por um instante em como os dados coletados desses setores se encaixariam em tabelas. Por exemplo, plataformas de e-commerce teriam dificuldade para armazenar catálogos de produtos em um esquema fixo. Produtos diferentes têm atributos diferentes ou, pior, quantidades diferentes de atributos. Você precisa de 10 colunas para guardar 10 atributos físicos de drones de 100 marcas diferentes ou só 5–6 para armazenar informações de livros?

Bancos baseados em tabelas não ajudam muito nesses cenários. Usando bancos de documentos como o MongoDB, você ganha benefícios como:

Sem custo inicial de desenvolvimento para desenhar um esquema
Documentos (dados) podem variar ao longo do tempo (incluindo tipos de dados, número de atributos etc.)
Bancos de documentos evitam joins, o que resulta em consultas muito mais rápidas
É intuitivo para desenvolvedores, já que bancos de documentos são, em sua maioria, grandes arquivos JSON — basicamente dicionários enormes para quem programa em Python.
Bancos de documentos escalam horizontalmente, ou seja, não precisam de recursos computacionais cada vez maiores conforme o banco cresce.

Agora, vamos dar uma olhada nos conceitos essenciais sobre bancos de documentos e MongoDB.

Obtenha a certificação para a função de analista de dados dos seus sonhos

Nossos programas de certificação ajudam você a se destacar e a provar que suas habilidades estão prontas para o trabalho para possíveis empregadores.

Obtenha Sua Certificação

Conceitos essenciais sobre MongoDB

Falamos várias vezes em bancos de documentos até aqui, mas o que eles são na prática? Aqui vão os principais conceitos:

Documentos: os dados são armazenados em objetos chamados documentos. Em termos simples, documentos são parecidos com objetos JSON de pares chave-valor. Um único documento é equivalente a uma linha em uma tabela. Se você programa em Python, pode pensar em um documento como um dicionário — e está tudo certo. Só lembre que documentos podem conter documentos aninhados, uma das características principais dos bancos de documentos.
Coleções: coleções são como tabelas em bancos relacionais, mas em vez de conter linhas, elas contêm — adivinha — documentos. Coleções são estruturas massivas que podem ter milhares ou milhões de dicionários.
Sem esquema: aqui fica interessante. Uma coleção pode ter documentos de tamanhos variados. Por exemplo, o documento 1 pode ter 10 pares chave-valor enquanto o documento 2 pode ter 15 (desde que a informação seja da mesma categoria/assunto — como produtos — para a coleção fazer sentido).

Aqui vai uma ótima tabela resumindo as diferenças entre bancos relacionais e bancos de documentos:

Recurso	Bancos de documentos (ex.: MongoDB)	Bancos relacionais (ex.: MySQL, PostgreSQL)
Estrutura de dados	Armazena dados como documentos (ex.: JSON, BSON), permitindo estruturas flexíveis e hierárquicas.	Armazena dados em tabelas com linhas e colunas, seguindo um esquema pré-definido.
Flexibilidade de esquema	Sem esquema: documentos podem ter estruturas variadas, com campos e tipos de dados diferentes.	Esquema fixo: exige um esquema pré-definido com colunas e tipos específicos.
Linguagem de consulta	Usa MongoDB Query Language (MQL) ou similar, orientada a objetos e mais flexível.	Usa SQL (Structured Query Language) para consultar dados estruturados.
Joins	Evita joins ao incorporar dados relacionados dentro dos documentos (desnormalização).	Suporta joins complexos entre tabelas (normalização).
Desempenho	Leituras e gravações mais rápidas para dados não estruturados ou semiestruturados. Evita a sobrecarga de joins.	Ótimo desempenho para dados estruturados, mas joins podem deixar consultas mais lentas.
Escalabilidade	Escala horizontalmente: pode distribuir dados em vários servidores via sharding.	Tipicamente escala verticalmente: depende de hardware mais potente, embora alguns ofereçam escala horizontal (ex.: partições).
Transações	Suporta transações ACID multidocumento (a partir do MongoDB 4.0), embora tenha sido projetado inicialmente para operações não transacionais.	Suporte completo a transações compatíveis com ACID, oferecendo forte consistência e confiabilidade.
Casos de uso	Melhor para dados não estruturados ou semiestruturados, como perfis de usuários, logs, catálogos e estruturas flexíveis.	Ideal para dados estruturados com relacionamentos claros, como registros financeiros ou ERP.
Relacionamentos	Suporta dados incorporados (desnormalização), facilitando recuperar informações relacionadas em uma única consulta.	Depende de chaves estrangeiras para relacionamentos entre tabelas (normalização).
Indexação	Suporta indexação, mas com menos variedade e sofisticação que bancos relacionais.	Recursos avançados de indexação, com múltiplos tipos (ex.: B-tree, hash) para otimizar desempenho.
Consistência	Oferece consistência eventual em configurações distribuídas, mas também fornece consistência forte quando necessário (via transações ACID).	Garante consistência forte na maioria dos casos devido a transações ACID e integridade relacional.
Escala de volume	Escala facilmente para grandes volumes de dados adicionando servidores (sharding).	Pode escalar verticalmente; já a escala horizontal requer configuração mais complexa (ex.: particionamento).
Integridade dos dados	Integridade é gerenciada dentro de cada documento; já gerenciar relacionamentos entre documentos pode ser mais desafiador.	Suporte robusto à integridade via chaves primárias e estrangeiras e restrições como UNIQUE e NOT NULL.
Facilidade para devs	Amigável para desenvolvedores: modelagem flexível e funciona bem com apps modernas (ex.: JSON, APIs REST).	Modelagem rígida, mas bem compreendida por quem já domina SQL e dados estruturados.

Vamos colocar a mão na massa com documentos no MongoDB!

Configuração do MongoDB: conectando a fontes de dados

Para consultar bancos de documentos, precisamos instalar o servidor do MongoDB. Veja as instruções por plataforma:

Para Windows, siga as instruções neste link.
Em sistemas tipo Unix, você pode instalar o MongoDB pelo terminal:

$ sudo apt-get install -y mongodb

Depois, dentro de um ambiente virtual, instale as bibliotecas pymongo e requests. pymongo é o adaptador oficial de Python para o servidor MongoDB. Vamos precisar da requests para puxar dados de uma API.

$ pip install pymongo
$ pip install requests

Em seguida, no terminal, inicie o servidor do MongoDB com o comando:

$ sudo service mongodb start

Agora, estamos prontos para carregar dados em um banco de documentos. Há dois cenários possíveis:

Você tem dados localmente em formatos adequados como JSON, BSON, YAML ou XML.
Você precisa buscar os dados de fontes externas, geralmente APIs.

Vamos cobrir ambos. Primeiro, vamos carregar localmente uma coleção chamada drone_races.json. Aqui vai o snippet:

import json

from pymongo import MongoClient

# Establish connection to MongoDB
client = MongoClient("localhost", 27017)
# Create a database named "drones"
drones = client["drones"]
# Create a collection named "races"
races = drones["races"]

# Load dataset into MongoDB
with open("data/drone_races.json", "r") as file:
   data = json.load(file)
   races.insert_many(data)

Os dois objetos mais importantes aqui são drones (um banco de dados) e races (uma coleção). A maioria das funções e métodos se relaciona a coleções. Objetos de banco são usados principalmente para gerenciar coleções.

Agora, vamos ver como carregar os mesmos dados usando uma API. Armazenei as informações como uma API usando um serviço chamado Mockaroo. Veja o snippet:

import requests
from pymongo import MongoClient

# Fetch data from the API
api_url = (
   "https://my.api.mockaroo.com/drone_race_matches.json?key=6f5a6b50"
)
response = requests.get(api_url)

if response.status_code == 200:
   data = response.json()  # Get the JSON data from the API

   # Establish a connection to MongoDB
   client = MongoClient()

   # Access or create a specific database
   drones = client["drones"]

   # Access or create a specific collection within the database
   races = drones["races"]

   # Insert the fetched data into the MongoDB collection
   races.insert_many(data)
else:
   print("Failed to fetch data from the API.")

Carregamos alguns dados na coleção races do banco de documentos drones — ou será que não? Vamos conferir usando consultas!

Consultas básicas em MongoDB

Contar documentos no MongoDB

Precisamos contar os documentos para saber se há dados em uma coleção. Vamos usar o método count_documents para isso:

>>> races.count_documents({})
9040

Note o dicionário vazio passado para count_documents. Em MongoDB, esse dicionário é chamado de filtro. Ao longo do tutorial, você vai aprender a preencher o dicionário para criar diferentes tipos de filtros. Por enquanto, não usamos filtro nenhum. O código acima equivale a SELECT COUNT(*) FROM table_name em SQL.

Temos 9040 documentos — yay! Agora, vamos olhar alguns dados.

Extraindo um documento no MongoDB

Para visualizar um documento com pymongo, podemos usar o método find_one:

from pprint import pprint

>>> pprint(races.find_one())
{'_id': ObjectId('659d31e9255ec0cf4bab529d'),
'laps': 3,
'league': 'F1 Drones',
'location': {'city': 'Ford',
             'country': 'United Kingdom',
             'date': 'error: invalid date "2024-10-25"',
             'venue': 'Manhattan Seas'},
'name': 'Honorable',
'pilots': {'drone': 'DJI3-old',
           'finishing_position': 66,
           'name': 'Kariotta Cow',
           'qualification_time': 27.39,
           'team': 'Sky Crusaders',
           'telemetry': {'altitude': 34.3,
                         'battery_voltage': 12.1,
                         'speed': 68.3,
                         'timestamp': 'error: invalid date '
                                      '"2024-10-25T14:09:26Z"'}},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat'],
'weather_conditions': 'snowy'}

Observe os campos (chaves) deste documento. Ele guarda informações sobre uma corrida de drones e inclui dados como:

O número de voltas
Condições climáticas no momento da prova
Os pilotos (não necessariamente todos) durante a corrida
Patrocinadores da prova e por aí vai.

O documento também tem um campo obrigatório _id, que é um hash único.

Selecionando todos os documentos no MongoDB

count_documents sempre retorna um número, mas às vezes queremos ver os dados que a consulta encontrou. Para isso, podemos usar o irmão mais velho do find_one, o find:

from pprint import pprint

for race in races.find():
   pprint(race)
   break

{'_id': ObjectId('659d31e9255ec0cf4bab529d'),
'laps': 3,
'league': 'F1 Drones',
'location': {'city': 'Ford',
             'country': 'United Kingdom',
             'date': 'error: invalid date "2024-10-25"',
             'venue': 'Manhattan Seas'},
'name': 'Honorable',
'pilots': {'drone': 'DJI3-old',
           'finishing_position': 66,
           'name': 'Kariotta Cow',
           'qualification_time': 27.39,
           'team': 'Sky Crusaders',
           'telemetry': {'altitude': 34.3,
                         'battery_voltage': 12.1,
                         'speed': 68.3,
                         'timestamp': 'error: invalid date '
                                      '"2024-10-25T14:09:26Z"'}},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat'],
'weather_conditions': 'snowy'}

find com consulta vazia (sem argumentos) retorna documentos um a um, mas não é isso que queremos! Queremos fazer consultas para responder perguntas interessantes sobre nossos dados. É aqui que os documentos de filtro vão ser úteis.

Selecionando com base em uma condição no MongoDB

Comecemos pelos filtros mais simples — selecionar documentos em que algum campo seja igual a um valor. Isso seria o mesmo que:

SELECT *
 FROM table_name
WHERE field = value

Em MongoDB, fica assim:

criteria = {"sponsors": "Fat Shark"}

fat_shark_races = races.count_documents(criteria)
fat_shark_races

6194

Acima, estamos selecionando as corridas que têm "Fat Shark" como patrocinador. A sintaxe é simplesmente um dicionário que mapeia o campo sponsors para "Fat Shark".

A linguagem de consulta do MongoDB não seria uma linguagem se não tivesse operadores de desigualdade comuns. Veja como usar o operador “menor que”:

criteria = {"pilots.qualification_time": {"$lt": 10}}

quick_races = races.count_documents(criteria)
quick_races

3061

A consulta acima introduz quatro recursos novos da MongoDB Query Language (MQL):

Você pode acessar subcampos com notação de ponto. pilots.qualification_time extrai o tempo de classificação aninhado dentro de pilots.
Quase todos os operadores em MQL começam com cifrão.
Operadores são usados em um documento aninhado, como acima.
$lt é o operador "menor que".

O resultado indica que houve 3061 provas em que algum piloto teve tempo de classificação menor que 10 segundos. Essa consulta foi possível com o operador $lt. Aqui estão seus “irmãos”:

$lte: menor ou igual
$gt: maior que
$gte: maior ou igual

A sintaxe é a mesma do $lt.

Selecionando com operadores lógicos no MongoDB

A MQL também inclui operadores lógicos como $and e $or. Vamos começar pelo segundo.

Vamos retornar as corridas com Reino Unido como local OU Etisalat como patrocinador:

criteria = {
   "$or": [
       {"location.country": "United Kingdom"},
       {"sponsors": "Etisalat"},
   ]
}

>>> races.count_documents(criteria)

6223

Use o botão Explain code para uma explicação detalhada.

Há 6223 documentos que batem com nossos critérios. Para usar uma lógica OR com múltiplos valores para o mesmo campo, dá para usar o operador $in.

Por exemplo, podemos verificar condições climáticas ruins assim:

criteria = {
   "weather_conditions": {"$in": ["rainy", "snowy", "cloudy"]}
}

>>> races.count_documents(criteria)

5508

Escrever essa consulta com $or seria bem mais trabalhoso. Agora, vamos ao $and.

Desta vez, queremos encontrar as corridas com Austrália como local E Fat Shark como patrocinador. Com $and fica assim:

criteria = {
   "$and": [
       {"location.country": "Australia"},
       {"sponsors": "Fat Shark"},
   ]
}
>>> races.count_documents(criteria)
193

Mas, na prática, você quase não vai usar $and, pois dá para fazer de forma mais simples:

criteria = {
   "location.country": "Australia",
   "sponsors": "Fat Shark",
}

races.count_documents(criteria)
193

Basta adicionar mais pares chave-valor ao documento de filtro para obter o comportamento do AND.

Por fim, existe o operador $nin, que verifica não pertencimento. Por exemplo, podemos retornar todas as provas que não aconteceram nos Estados Unidos, Reino Unido ou Austrália:

criteria = {
   "location.country": {
       "$nin": ["United States", "United Kingdom", "Australia"]
   }
}

>>> races.count_documents(criteria)
126

Isso deixa apenas os Emirados Árabes Unidos como país, então a consulta acima poderia ser escrita simplesmente como:

criteria = {"location.country": "United Arab Emirates"}

>>> races.count_documents(criteria)
126

Mas você entendeu a ideia.

Consultando valores nulos ou ausentes no MongoDB

Verificar valores nulos ou ausentes é uma operação universal em qualquer análise de dados. Para isso, existe o operador $exists em MongoDB. Veja dois exemplos que checam se determinado campo existe:

criteria = {"location.district": {"$exists": True}}

>>> races.count_documents(criteria)

0

Hmm, parece que o campo district não existe em nenhum documento. Já o campo laps precisa existir em todos os documentos, pois é uma informação chave sobre as corridas.

criteria = {"laps": {"$exists": True}}

races.count_documents(criteria)
9040

Como esperado, todos os documentos têm o campo laps. E quando o campo existe, mas tem valor nulo? Dá para checar também:

criteria = {"pilots.finishing_position": None}

races.count_documents(criteria)
0

Usando o objeto embutido None do Python, conseguimos verificar se qualquer campo está ausente/nulo.

Há também cenários mais avançados que exigem checagens de nulidade ou existência. Por exemplo, você pode querer verificar se certos elementos de grandes arrays aninhados existem.

Para isso, podemos usar a sintaxe de indexação de arrays na MQL. Por exemplo, para encontrar corridas com apenas um patrocinador, precisamos checar se o segundo elemento do array sponsors existe:

# A contagem começa em 0, como sempre
criteria = {"sponsors.1": {"$exists": False}}

races.count_documents(criteria)
2929

É tão simples quanto anexar o índice do elemento à chave. Ou seja, na nossa coleção, quase 3 mil corridas foram patrocinadas por apenas uma entidade.

Essa sintaxe de indexação funciona para vários outros operadores, não só para o $exists.

Projeções (restringindo campos)

Para fechar, vamos falar de projeções. Até agora, os resultados das nossas consultas incluíam todos os campos de cada documento. Isso não é ideal quando seus documentos têm centenas de campos. Imagine o caos visual ao imprimir tudo!

Então, para escolher os campos que queremos no retorno, usamos projeções. Assim:

criteria = {"pilots.telemetry.speed": {"$gte": 20}}
projection = {
   "sponsors": 1,
   "location.country": 1,
   "pilots.telemetry.speed": 1,
   "pilots.name": 1,
}

fast_pilots = races.find(criteria, projection)

for pilot in fast_pilots:
   pprint(pilot)
   break

No exemplo acima, definimos nossos critérios de filtro como sempre, mas desta vez criamos outro documento com quatro campos definidos como 1. Ao passar esse projection como segundo argumento de find (ou count_documents), só os campos definidos como 1 aparecem na saída.

{'_id': ObjectId('659d31e9255ec0cf4bab529d'),
'location': {'country': 'United Kingdom'},
'pilots': {'name': 'Kariotta Cow', 'telemetry': {'speed': 68.3}},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat']}

Mesmo escolhendo só quatro campos, o insistente campo _id apareceu. Para suprimir esse comportamento, defina-o como 0 no dicionário projection:

criteria = {"pilots.telemetry.speed": {"$gte": 20}}
projection = {
   "sponsors": 1,
   "location.country": 1,
   "pilots.telemetry.speed": 1,
   "pilots.name": 1,
   "_id": 0,
}

fast_pilots = races.find(criteria, projection)

for pilot in fast_pilots:
   pprint(pilot)
   break

{'location': {'country': 'United Kingdom'},
'pilots': {'name': 'Kariotta Cow', 'telemetry': {'speed': 68.3}},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat']}

Agora sim, mais limpo.

Por fim, para retornar todos os campos, exceto alguns, basta defini-los como 0:

projection = {"_id": 0, "league": 0, "pilots": 0}

# Critério vazio neste caso
races.find_one({}, projection)

{'name': 'Honorable',
'location': {'venue': 'Manhattan Seas',
 'city': 'Ford',
 'country': 'United Kingdom',
 'date': 'error: invalid date "2024-10-25"'},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat'],
'laps': 3,
'weather_conditions': 'snowy'}

Como você vê, desta vez temos todos os campos, exceto _id, league e pilots.

Conclusão

Este tutorial não faz jus ao tamanho do MongoDB como ferramenta de gerenciamento de bancos de dados. Hoje, cobrimos apenas consultas GET (para recuperar informações), mas o MongoDB também permite inserir, atualizar ou deletar dados em bancos de documentos. Também deixamos de fora uma classe inteira de consultas — as agregações.

Todos esses tópicos fogem ao escopo do artigo e exigem recursos adicionais para aprender. Que tal dar uma olhada nestes:

Curso de introdução ao uso de MongoDB em data science com Python — um curso completo que também cobre consultas avançadas como agregações
Introdução ao MongoDB em Python — outro tutorial de MongoDB que cobre operações CRUD (create, read, update, delete) com pymongo.
Curso de conceitos de NoSQL — se você se interessa por bancos NoSQL, este curso é para você. Além de bancos de documentos, cobre outros bancos não relacionais.

Torne-se certificado em SQL

Comprove que suas habilidades em SQL estão prontas para o trabalho com uma certificação.

Impulsionar Minha Carreira

Como bancos de documentos como o MongoDB diferem de bancos relacionais?

Bancos de documentos, como o MongoDB, armazenam dados em documentos (geralmente em formatos parecidos com JSON), que podem conter estruturas aninhadas. Isso difere dos bancos relacionais, que guardam dados em linhas e tabelas com um esquema fixo. Bancos de documentos oferecem mais flexibilidade, pois o esquema é dinâmico — cada documento pode ter campos e tipos de dados diferentes. Isso torna o MongoDB adequado para dados não estruturados ou semiestruturados, ao contrário dos bancos relacionais, que exigem um esquema pré-definido.