Conéctese localmente a una base de datos MongoDB usando Python

Usa PyMongo, el controlador de Python para MongoDB, para conectarte a una implementación de MongoDB, elegir una base de datos y una colección, e insertar o consultar documentos BSON. El flujo que se muestra a continuación utiliza una URI de MongoDB y una pequeña colección para una lista de compras. Sustituye los marcadores de posición de la URI por los datos de conexión de tu implementación y mantén las credenciales fuera del control de versiones. (insert_many(); insert_one())

Instalar Python y PyMongo

Instala Python y, a continuación, PyMongo con python -m pip install pymongo. El ejemplo utiliza una URI de lista de servidores DNS que comienza por mongodb+srv://; instala la compatibilidad con DNS mediante python -m pip install "pymongo[srv]" (o instala dnspython por separado). Si tu implementación proporciona una URI estándar mongodb://, úsala y sigue la configuración de red y autenticación correspondiente.

Guarda el programa como pymongo_example.py y ejecuta la demostración local con python pymongo_example.py. Para ejecutar el flujo con la base de datos, primero configura MONGODB_URI con la cadena de conexión de tu implementación de MongoDB y luego añade --database. En macOS o Linux, usa export MONGODB_URI='mongodb+srv://<username>:<password>@<cluster-name>/'; en PowerShell, usa $env:MONGODB_URI = 'mongodb+srv://<username>:<password>@<cluster-name>/'. Sustituye los marcadores de posición, codifica en URL los caracteres especiales de las credenciales cuando el formato de la URI lo requiera y no guardes credenciales reales en el control de versiones ni en el historial de una terminal compartida. Ejecuta python pymongo_example.py --database. El mismo nombre de archivo aparece en la ruta para guardar el programa y en el comando.

Conectarse a MongoDB con PyMongo

Crea un MongoClient con la URI proporcionada por tu implementación de MongoDB. Una URI de lista de servidores incluye el host del clúster y puede incluir opciones de autenticación; sustituye <username>, <password> y <cluster-name> en lugar de copiarlos literalmente. Evita imprimir la URI, ya que puede contener credenciales. El flujo con la base de datos solo se selecciona con --database y lee la URI de MONGODB_URI; sin esa opción, el programa ejecuta la demostración local independiente y no se conecta a MongoDB.

En una aplicación, lee la URI de una variable de entorno, por ejemplo MONGODB_URI, y pásala a MongoClient. En un script, coloca el trabajo bajo una condición if __name__ == "__main__": en el nivel del módulo para que importar el archivo no inicie operaciones con la base de datos. MongoClient se conecta de forma diferida, por lo que puedes crear un cliente antes de la primera operación con la base de datos; los problemas de red, DNS, autenticación y selección del servidor suelen aparecer al realizar esa primera operación. Cierra el cliente al terminar o usa un administrador de contexto en un script de corta duración.

Crear una base de datos y una colección

Selecciona una base de datos con client["user_shopping_list"] y una colección con database["items"]. Estas expresiones seleccionan referencias; por sí solas no crean datos persistentes en la base de datos ni en la colección. MongoDB las crea cuando una inserción escribe datos por primera vez. Usa nombres coherentes en los pasos de inserción y consulta.

Insertar documentos

Un diccionario de Python se corresponde de forma natural con un documento de MongoDB. El ejemplo con la base de datos usa collection.insert_many(documents) para insertar dos documentos y collection.insert_one(document) para insertar un tercero. El documento individual incluye un valor datetime.datetime de Python con zona horaria, que PyMongo codifica como una fecha BSON. Los objetos de resultado devueltos proporcionan los identificadores de los documentos insertados, que permiten consultar los documentos que se acaban de guardar. Omite _id si quieres que MongoDB lo genere; este ejemplo asigna identificadores únicos para que la consulta pueda seleccionar los registros que insertó.

Las llamadas de inserción requieren una implementación de MongoDB accesible y permisos de escritura. Evita volver a ejecutar las inserciones de ejemplo en una base de datos compartida, a menos que se acepten los registros duplicados o que el ejemplo use identificadores estables y gestione los errores de clave duplicada.

Consultar documentos y gestionar campos ausentes

Usa collection.find({}) para recorrer todos los documentos o pasa un filtro como {"category": "food"} para seleccionar los que coincidan. Cada resultado se comporta como un diccionario. Una búsqueda directa como item["category"] produce un KeyError si el documento no contiene esa clave; usa item.get("category", "(not set)") cuando corresponda proporcionar un valor alternativo. El find() de MongoDB devuelve un cursor, así que recórrelo en lugar de tratarlo como un único documento.

Ejecuta esta demostración local para ver cómo se muestran documentos con distintos campos. Funciona sin conexión; el flujo con la base de datos se habilita por separado con --database y MONGODB_URI, como se indicó antes.

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

import os
import sys
import uuid
from datetime import datetime, timezone


def show_documents(documents):
    for item in documents:
        print(item["item_name"], item.get("category", "(not set)"))


def run_database_workflow():
    from pymongo import MongoClient

    uri = os.environ.get("MONGODB_URI")
    if not uri:
        print("Set MONGODB_URI before running with --database.")
        return

    with MongoClient(uri) as client:
        collection = client["user_shopping_list"]["items"]
        many = [
            {"_id": str(uuid.uuid4()), "item_name": "Bread", "category": "food"},
            {"_id": str(uuid.uuid4()), "item_name": "Blender"},
        ]
        many_result = collection.insert_many(many)
        single = {
            "_id": str(uuid.uuid4()),
            "item_name": "Coffee",
            "category": "food",
            "added_at": datetime.now(timezone.utc),
        }
        single_result = collection.insert_one(single)
        inserted_ids = many_result.inserted_ids + [single_result.inserted_id]
        found = collection.find({"_id": {"$in": inserted_ids}})
        show_documents(found)


def main():
    if "--database" in sys.argv:
        run_database_workflow()
    else:
        # This local sample needs no MongoDB server or connection URI.
        show_documents([
            {"item_name": "Bread", "category": "food"},
            {"item_name": "Blender"},
        ])


if __name__ == "__main__":
    main()

Bread food
Blender (not set)

La salida del ejemplo local es:

En el flujo con la base de datos, se aplica el mismo patrón de acceso seguro al recorrer el cursor devuelto por find(). Si una consulta no devuelve documentos, el cursor simplemente no produce filas; comprueba el filtro y el nombre de la colección antes de suponer que ha fallado la conexión. Al importar este módulo, se definen sus funciones, pero no se llama a main() ni se realizan operaciones con la base de datos.