MongoDB Delete

PyMongo proporciona dos métodos para eliminar documentos de una colección: delete_one() elimina el primer documento que coincide, y delete_many() elimina todos los documentos que coinciden. Ambas son operaciones precisas basadas en filtros — especificas exactamente qué documentos quieres eliminar usando la misma sintaxis de consulta que find().

Este capítulo cubre:

• delete_one() — eliminar un único documento
• delete_many() — eliminar múltiples documentos (incluidos todos los documentos)
• Lectura del objeto DeleteResult
• Operadores de filtro que hacen las eliminaciones más precisas
• Manejo de errores y prácticas de seguridad
• Cuándo eliminar documentos frente a descartar toda la colección

Requisitos previos: Python 3.8+, PyMongo instalado (pip install pymongo) y un servidor MongoDB en ejecución. Consulta MongoDB: Primeros pasos para la configuración, y MongoDB Insert para entender cómo se añaden documentos a una colección.

Conectar y seleccionar una colección

Toda operación de eliminación necesita un MongoClient, una base de datos y una colección:

import pymongo

client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["mydatabase"]
col = db["customers"]

Todos los ejemplos a continuación asumen que col está definido de esta manera.

Eliminar un documento con delete_one()

delete_one(filter) encuentra el primer documento que coincide con el filtro y lo elimina. Si hay varios documentos que coinciden, solo se elimina uno (el orden natural de MongoDB determina cuál).

result = col.delete_one({"name": "Alice"})
print(result.deleted_count)  # 1 if a match was found, 0 if not

delete_one() nunca genera un error cuando no hay ningún documento coincidente — devuelve un DeleteResult con deleted_count = 0.

Coincidencia por un valor de campo específico

# Delete the customer whose name is "Bob"
result = col.delete_one({"name": "Bob"})

if result.deleted_count == 1:
    print("Document deleted.")
else:
    print("No matching document found.")

Coincidencia en un campo anidado

Usa la notación de punto para acceder a campos dentro de documentos embebidos:

# Delete the first customer whose city is "London"
result = col.delete_one({"address.city": "London"})
print(result.deleted_count)  # 1 or 0

Eliminar múltiples documentos con delete_many()

delete_many(filter) elimina todos los documentos que coinciden con el filtro. Úsalo cuando necesites limpiar un conjunto de registros en una sola llamada.

# Delete all customers whose address starts with "S"
result = col.delete_many({"address": {"$regex": "^S"}})
print(result.deleted_count, "documents deleted")

Eliminar todos los documentos de una colección

Pasa un filtro vacío {} para eliminar todos los documentos. La colección en sí misma y sus índices permanecen — solo desaparecen los documentos:

result = col.delete_many({})
print(result.deleted_count, "documents deleted")

Advertencia: delete_many({}) sobre una colección en producción es irreversible. Verifica siempre tu filtro y realiza una copia de seguridad antes de ejecutar eliminaciones masivas. Si quieres eliminar la colección por completo (documentos e índices), usa col.drop() — consulta MongoDB Drop Collection.

El objeto DeleteResult

Ambos métodos devuelven un DeleteResult. Las dos propiedades que usarás con más frecuencia son:

result = col.delete_many({"status": "inactive"})
print(f"Deleted: {result.deleted_count}")
print(f"Acknowledged: {result.acknowledged}")

Operadores de filtro para eliminaciones precisas

Los mismos operadores de consulta usados en find() funcionan dentro de los filtros de eliminación.

Eliminar por comparación

# Delete all orders with a quantity less than 10
col.delete_many({"qty": {"$lt": 10}})

# Delete all orders with a quantity greater than or equal to 100
col.delete_many({"qty": {"$gte": 100}})

Eliminar por expresión regular

# Delete all customers whose name starts with "A" (case-sensitive)
col.delete_many({"name": {"$regex": "^A"}})

Eliminar por existencia de un campo

# Delete all documents that have no "email" field
col.delete_many({"email": {"$exists": False}})

Eliminar por valor en una lista

# Delete all documents whose status is either "cancelled" or "expired"
col.delete_many({"status": {"$in": ["cancelled", "expired"]}})

Manejo de errores

Envuelve las operaciones de eliminación en un bloque try/except para gestionar los dos modos de fallo más comunes:

• pymongo.errors.OperationFailure — el servidor rechazó la operación (por ejemplo, el usuario conectado no tiene privilegios de remove sobre la colección).
• pymongo.errors.ConnectionFailure — se perdió la conexión de red con MongoDB.

import pymongo

client = pymongo.MongoClient("mongodb://localhost:27017/")
col = client["mydatabase"]["customers"]

try:
    result = col.delete_many({"status": "inactive"})
    print(f"{result.deleted_count} documents deleted.")
except pymongo.errors.OperationFailure as e:
    print(f"Server error: {e}")
except pymongo.errors.ConnectionFailure as e:
    print(f"Connection error: {e}")

Ejemplo práctico: flujo de trabajo completo

Este ejemplo inicializa una colección, ejecuta eliminaciones específicas y verifica el resultado:

import pymongo

client = pymongo.MongoClient("mongodb://localhost:27017/")
col = client["mydatabase"]["customers"]

# 1. Start clean
col.drop()

# 2. Insert sample documents
col.insert_many([
    {"name": "Alice", "city": "Oslo",   "active": True},
    {"name": "Bob",   "city": "Sydney", "active": False},
    {"name": "Carol", "city": "Seattle","active": False},
    {"name": "Dave",  "city": "Sofia",  "active": True},
])
print("Inserted:", col.count_documents({}))  # 4

# 3. Delete the one inactive customer named "Bob"
r1 = col.delete_one({"name": "Bob", "active": False})
print("delete_one:", r1.deleted_count)  # 1

# 4. Delete all customers in cities that start with "S"
r2 = col.delete_many({"city": {"$regex": "^S"}})
print("delete_many (city ^S):", r2.deleted_count)  # 2 (Carol/Seattle, Dave/Sofia)

# 5. Check what remains
remaining = list(col.find({}, {"_id": 0}))
print("Remaining:", remaining)  # [{'name': 'Alice', 'city': 'Oslo', 'active': True}]

Salida esperada:

Inserted: 4
delete_one: 1
delete_many (city ^S): 2
Remaining: [{'name': 'Alice', 'city': 'Oslo', 'active': True}]

Eliminar documentos frente a descartar una colección

Estas dos operaciones se confunden con frecuencia:

Elige delete_many({}) cuando necesites vaciar una colección pero conservar sus índices y validadores de esquema. Elige col.drop() cuando quieras empezar desde cero — por ejemplo, entre ejecuciones de pruebas o durante una migración de esquema. Consulta MongoDB Drop Collection para más detalles sobre drop().

Resumen

• delete_one(filter) elimina el primer documento coincidente; delete_many(filter) elimina todos los documentos coincidentes.
• Ambos devuelven un DeleteResult — comprueba deleted_count para confirmar qué se eliminó.
• Un filtro vacío {} en delete_many() elimina todos los documentos de la colección.
• Usa los operadores de consulta de MongoDB ($regex, $lt, $in, $exists, …) para construir filtros precisos.
• Envuelve las operaciones en try/except para manejar OperationFailure y ConnectionFailure.
• Para eliminar la colección en sí, usa col.drop() en su lugar.

Capítulos relacionados:

• MongoDB Insert — insertar documentos con insert_one() e insert_many()
• MongoDB Update — modificar documentos existentes con update_one() y update_many()
• MongoDB Drop Collection — eliminar una colección entera incluidos sus índices
• MongoDB Query — construir filtros con operadores de consulta
• MongoDB Get Started — instalar PyMongo y conectarse a MongoDB