sql >> Base de Datos >  >> NoSQL >> MongoDB

Python y MongoDB:conexión a bases de datos NoSQL

MongoDB es una solución de base de datos NoSQL y orientada a documentos que proporciona una gran escalabilidad y flexibilidad junto con un potente sistema de consulta. Con MongoDB y Python, puede desarrollar rápidamente muchos tipos diferentes de aplicaciones de bases de datos. Entonces, si su aplicación Python necesita una base de datos que sea tan flexible como el propio lenguaje, entonces MongoDB es para usted.

En este tutorial, aprenderá:

  • Qué MongoDB es
  • Cómo instalar y ejecutar MongoDB
  • Cómo trabajar con bases de datos MongoDB
  • Cómo usar el controlador PyMongo de bajo nivel para interactuar con MongoDB
  • Cómo utilizar el mapeador de objetos-documentos (ODM) de MongoEngine de alto nivel

A lo largo de este tutorial, escribirá un par de ejemplos que demostrarán la flexibilidad y el poder de MongoDB y su excelente compatibilidad con Python. Para descargar el código fuente de esos ejemplos, haga clic en el siguiente enlace:

Obtenga el código fuente: Haga clic aquí para obtener el código fuente que usará para aprender a usar MongoDB con Python en este tutorial.


Uso de bases de datos SQL frente a NoSQL

Durante décadas, las bases de datos SQL fueron una de las únicas opciones para los desarrolladores que buscaban crear sistemas de bases de datos grandes y escalables. Sin embargo, la creciente necesidad de almacenar estructuras de datos complejas condujo al nacimiento de NoSQL. bases de datos Este nuevo tipo de sistema de base de datos permite a los desarrolladores almacenar datos heterogéneos y sin estructura de manera eficiente.

En general, los sistemas de base de datos NoSQL almacenan y recuperan datos de una manera muy diferente a los sistemas de administración de bases de datos relacionales (RDBMS) de SQL.

Cuando se trata de elegir entre las tecnologías de base de datos actualmente disponibles, es posible que deba decidir entre usar sistemas SQL o NoSQL. Ambos tienen características específicas que debes tener en cuenta a la hora de elegir uno u otro. Estas son algunas de sus diferencias más sustanciales:

Propiedad Bases de datos SQL Bases de datos NoSQL
Modelo de datos Relacional No relacional
Estructura Basado en tablas, con columnas y filas Basado en documentos, pares clave-valor, gráfico o columna ancha
Esquema Un esquema predefinido y estricto en el que cada registro (fila) es de la misma naturaleza y posee las mismas propiedades Un esquema dinámico o sin esquema, lo que significa que los registros no necesitan ser de la misma naturaleza
Idioma de consulta Lenguaje de consulta estructurado (SQL) Varía de una base de datos a otra
Escalabilidad Verticales Horizontales
Transacciones ACID Compatible Compatible, según la base de datos NoSQL específica
Capacidad de agregar nuevas propiedades Necesita modificar el esquema primero Posible sin perturbar nada

Existen muchas otras diferencias entre los dos tipos de bases de datos, pero las mencionadas anteriormente son algunas de las más importantes que debe conocer.

Al elegir una base de datos, debe considerar cuidadosamente sus fortalezas y debilidades. También debe considerar cómo encaja la base de datos en su escenario específico y los requisitos de su aplicación. A veces, la solución correcta es usar una combinación de bases de datos SQL y NoSQL para manejar diferentes aspectos de un sistema más amplio.

Algunos ejemplos comunes de bases de datos SQL incluyen:

  • SQLite
  • MySQL
  • Oráculo
  • PostgreSQL
  • Microsoft SQL Server

Los ejemplos de bases de datos NoSQL incluyen:

  • DynamoDB
  • Casandra
  • Redis
  • CouchDB
  • Repensar DB
  • RavenDB
  • MongoDB

En los últimos años, las bases de datos SQL y NoSQL incluso han comenzado a fusionarse. Por ejemplo, los sistemas de bases de datos, como PostgreSQL, MySQL y Microsoft SQL Server ahora admiten el almacenamiento y la consulta de datos JSON, al igual que las bases de datos NoSQL. Con esto, ahora puede lograr muchos de los mismos resultados con ambas tecnologías. Pero aún no obtiene muchas de las características de NoSQL, como el escalado horizontal y la interfaz fácil de usar.

Con esta breve información sobre las bases de datos SQL y NoSQL, puede concentrarse en el tema principal de este tutorial:la base de datos MongoDB. y cómo usarlo en Python.



Administración de bases de datos NoSQL con MongoDB

MongoDB es un orientado a documentos base de datos clasificada como NoSQL. Se ha vuelto popular en toda la industria en los últimos años y se integra muy bien con Python. A diferencia de los RDBMS SQL tradicionales, MongoDB usa colecciones de documentos en lugar de tablas de filas para organizar y almacenar datos.

MongoDB almacena datos en documentos tipo JSON flexibles y sin esquema. Aquí, sin esquema significa que puede tener documentos con un conjunto diferente de campos en la misma colección, sin la necesidad de satisfacer un esquema de tabla rígido .

Puede cambiar la estructura de sus documentos y datos con el tiempo, lo que da como resultado un sistema flexible que le permite adaptarse rápidamente a los cambios de requisitos sin necesidad de un proceso complejo de migración de datos. Sin embargo, la desventaja de cambiar la estructura de los nuevos documentos es que los documentos existentes se vuelven incoherentes con el esquema actualizado. Así que este es un tema que debe manejarse con cuidado.

Nota: JSON significa Notación de objetos JavaScript. . Es un formato de archivo con una estructura legible por humanos que consta de pares clave-valor que se pueden anidar arbitrariamente en profundidad.

MongoDB está escrito en C++ y desarrollado activamente por MongoDB Inc. Se ejecuta en todas las plataformas principales, como macOS, Windows, Solaris y la mayoría de las distribuciones de Linux. En general, hay tres objetivos de desarrollo principales detrás de la base de datos MongoDB:

  1. Escala bien
  2. Almacenar ricas estructuras de datos
  3. Proporcione un mecanismo de consulta sofisticado

MongoDB es un distribuido base de datos, por lo que la alta disponibilidad, la escala horizontal y la distribución geográfica están integradas en el sistema. Almacena datos en documentos flexibles tipo JSON. Puede modelar estos documentos para mapear los objetos en sus aplicaciones, lo que hace posible trabajar con sus datos de manera efectiva.

MongoDB proporciona un potente lenguaje de consulta que admite consultas ad hoc, indexación, agregación, búsqueda geoespacial, búsqueda de texto y mucho más. Esto le presenta un poderoso conjunto de herramientas para acceder y trabajar con sus datos. Finalmente, MongoDB está disponible gratuitamente y tiene una gran compatibilidad con Python.


Revisión de las características de MongoDB

Hasta ahora, ha aprendido qué es MongoDB y cuáles son sus objetivos principales. En esta sección, aprenderá sobre algunas de las funciones más importantes de MongoDB. En cuanto a la administración de la base de datos, MongoDB ofrece las siguientes funciones:

  • Soporte de consulta: Puede utilizar muchos tipos de consultas estándar, como coincidencias (== ), comparación (< , > ), y expresiones regulares.
  • Alojamiento de datos: Puede almacenar prácticamente cualquier tipo de datos, ya sean estructurados, parcialmente estructurados o incluso polimórficos.
  • Escalabilidad: Maneja más consultas simplemente agregando más máquinas al clúster de servidores.
  • Flexibilidad y agilidad: Puede desarrollar aplicaciones con él rápidamente.
  • Orientación del documento y falta de esquema: Puede almacenar toda la información sobre un modelo de datos en un solo documento.
  • Esquema ajustable: Puede cambiar el esquema de la base de datos sobre la marcha, lo que reduce el tiempo necesario para proporcionar nuevas funciones o solucionar problemas existentes.
  • Funcionalidades de bases de datos relacionales: Puede realizar acciones comunes a las bases de datos relacionales, como la indexación.

En cuanto al lado de las operaciones, MongoDB proporciona algunas herramientas y características que no encontrará en otros sistemas de bases de datos:

  • Escalabilidad: Ya sea que necesite un servidor independiente o grupos completos de servidores independientes, puede escalar MongoDB al tamaño que necesite.
  • Soporte de equilibrio de carga: MongoDB moverá automáticamente los datos entre varios fragmentos.
  • Soporte de conmutación automática por error: Si su servidor principal deja de funcionar, se activará y ejecutará automáticamente un servidor principal nuevo.
  • Herramientas de gestión: Puede realizar un seguimiento de sus máquinas mediante el servicio de administración de MongoDB (MMS) basado en la nube.
  • Eficiencia de la memoria: Gracias a los archivos mapeados en memoria, MongoDB suele ser más eficiente que las bases de datos relacionales.

Todas estas características son bastante útiles. Por ejemplo, si aprovecha la función de indexación, gran parte de sus datos se mantendrán en la memoria para una recuperación rápida. Incluso sin indexar claves de documentos específicas, MongoDB almacena en caché una gran cantidad de datos utilizando la técnica utilizada menos recientemente.



Instalación y ejecución de MongoDB

Ahora que está familiarizado con MongoDB, es hora de ensuciarse las manos y comenzar a usarlo. Pero primero, debe instalarlo en su máquina. El sitio oficial de MongoDB proporciona dos ediciones del servidor de la base de datos:

  1. La edición comunitaria ofrece el modelo de documento flexible junto con consultas ad hoc, indexación y agregación en tiempo real para brindar formas poderosas de acceder y analizar sus datos. Esta edición está disponible gratuitamente.
  2. La edición empresarial ofrece las mismas funciones que la edición comunitaria, además de otras funciones avanzadas relacionadas con la seguridad y la supervisión. Esta es la edición comercial, pero puede usarla de forma gratuita durante un tiempo ilimitado con fines de evaluación y desarrollo.

Si está en Windows, puede leer el tutorial de instalación para obtener instrucciones completas. En general, puede ir a la página de descarga, seleccionar la plataforma Windows en el cuadro Descargas disponibles, elegir .msi instalador que se adapte a su sistema actual y haga clic en Descargar .

Ejecute el instalador y siga las instrucciones en pantalla del asistente de instalación. Esta página también brinda información sobre cómo ejecutar MongoDB como un servicio de Windows.

Si está en macOS, puede usar Homebrew para instalar MongoDB en su sistema. Consulte el tutorial de instalación para obtener la guía completa. Además, asegúrese de seguir las instrucciones para ejecutar MongoDB como un servicio de macOS.

Si está en Linux, el proceso de instalación dependerá de su distribución específica. Para obtener una guía detallada sobre cómo instalar MongoDB en diferentes sistemas Linux, vaya a la página del tutorial de instalación y seleccione el tutorial que coincida con su sistema operativo actual. Asegúrese de ejecutar el demonio MongoDB, mongod , al final de la instalación.

Finalmente, también puede instalar MongoDB usando Docker. Esto es útil si no desea saturar su sistema con otra instalación. Si prefiere esta opción de instalación, puede leer el tutorial oficial y seguir sus instrucciones. Tenga en cuenta que, en este caso, sería necesario tener conocimientos previos sobre cómo utilizar Docker.

Con la base de datos MongoDB instalada y ejecutándose en su sistema, puede comenzar a trabajar con bases de datos reales utilizando mongo concha.




Creación de bases de datos MongoDB con mongo Concha

Si siguió las instrucciones de instalación y ejecución, entonces ya debería tener una instancia de MongoDB ejecutándose en su sistema. Ahora puede comenzar a crear y probar sus propias bases de datos. En esta sección, aprenderá a usar mongo shell para crear, leer, actualizar y eliminar documentos en una base de datos.


Ejecutar mongo Concha

El mongo shell es una interfaz JavaScript interactiva para MongoDB. Puede utilizar esta herramienta para consultar y manipular sus datos, así como para realizar operaciones administrativas. Dado que es una interfaz de JavaScript, no utilizará el lenguaje SQL familiar para consultar la base de datos. En su lugar, utilizará código JavaScript.

Para iniciar el mongo shell, abra su terminal o línea de comando y ejecute el siguiente comando:

$ mongo

Este comando te lleva al mongo cáscara. En este punto, probablemente verá un montón de mensajes con información sobre la versión del shell y sobre la dirección y el puerto del servidor. Finalmente, se le presentará el indicador de shell (> ) para ingresar consultas y comandos.

Puede pasar la dirección de la base de datos como argumento a mongo dominio. También puede usar varias opciones, como especificar el host y el puerto para acceder a una base de datos remota, etc. Para más detalles sobre cómo usar el mongo comando, puede ejecutar mongo --help .



Establecer una conexión

Cuando ejecutas el mongo comando sin argumentos, inicia el shell y se conecta al servidor local predeterminado provisto por el mongod proceso en mongod://127.0.0.1:27017 . Esto significa que está conectado al host local a través del puerto 27017 .

Por defecto, el mongo shell inicia la sesión estableciendo una conexión con el test base de datos. Puede acceder a la base de datos actual a través de db objeto:

> db
test
>

En este caso, db contiene una referencia a test , que es la base de datos predeterminada. Para cambiar de base de datos, emita el comando use , proporcionando un nombre de base de datos como argumento.

Por ejemplo, supongamos que desea crear un sitio web para publicar contenido de Python y planea usar MongoDB para almacenar sus tutoriales y artículos. En ese caso, puede cambiar a la base de datos del sitio con el siguiente comando:

> use rptutorials
switched to db rptutorials

Este comando cambia su conexión a los rptutorials base de datos. MongoDB no crea el archivo de la base de datos física en el sistema de archivos hasta que inserta datos reales en la base de datos. Entonces, en este caso, rptutorials no aparecerá en la lista de su base de datos actual:

> show dbs
admin          0.000GB
config         0.000GB
local          0.000GB
>

El mongo shell proporciona muchas funciones y opciones. Le permite consultar y manipular sus datos y también administrar el propio servidor de la base de datos.

En lugar de utilizar un lenguaje de consulta estandarizado como SQL, mongo shell utiliza el lenguaje de programación JavaScript y una API fácil de usar. Esta API le permite jugar con sus datos, que es el tema de la siguiente sección.



Creación de colecciones y documentos

Una base de datos MongoDB es un contenedor físico para colecciones de documentos. Cada base de datos obtiene su propio conjunto de archivos en el sistema de archivos. Estos archivos son administrados por el servidor MongoDB, que puede manejar varias bases de datos.

En MongoDB, una colección es un grupo de documentos . Las colecciones son algo análogas a las tablas en un RDBMS tradicional, pero sin imponer un esquema rígido. En teoría, cada documento de una colección puede tener una estructura o conjunto de campos completamente diferente.

En la práctica, los documentos de una colección suelen compartir una estructura similar para permitir procesos uniformes de recuperación, inserción y actualización. Puede aplicar una estructura de documento uniforme mediante el uso de reglas de validación de documentos durante las actualizaciones e inserciones.

Permitir diferentes estructuras de documentos es una característica clave de las colecciones de MongoDB. Esta función brinda flexibilidad y permite agregar nuevos campos a los documentos sin necesidad de modificar un esquema de tabla formal.

Para crear una colección usando mongo shell, debe señalar db a su base de datos de destino y luego cree las colecciones usando la notación de puntos :

> use rptutorials
switched to db rptutorials
> db
rptutorials
> db.tutorial
rptutorials.tutorial

En este ejemplo, usa la notación de puntos para crear tutorial como una colección en rptutorials , que es su base de datos actual. Es importante tener en cuenta que MongoDB crea bases de datos y colecciones con pereza. . En otras palabras, se crean físicamente solo después de insertar el primer documento.

Una vez que tenga una base de datos y una colección, puede comenzar a insertar documentos. Los documentos son la unidad de almacenamiento en MongoDB. En un RDBMS, esto sería equivalente a una fila de tabla. Sin embargo, los documentos de MongoDB son mucho más versátiles que las filas porque pueden almacenar información compleja, como matrices, documentos incrustados e incluso matrices de documentos.

MongoDB almacena documentos en un formato llamado Binary JSON (BSON), que es una representación binaria de JSON. Los documentos de MongoDB están compuestos por pares de campo y valor y tienen la siguiente estructura:

{
   field1 → value1,
   field2 → value2,
   field3 → value3,
   ...
   fieldN → valueN
}

El valor de un campo puede ser cualquier tipo de datos BSON, incluidos otros documentos, matrices y matrices de documentos. En la práctica, especificará sus documentos utilizando el formato JSON.

Cuando está creando una aplicación de base de datos MongoDB, probablemente su decisión más importante sea sobre la estructura de los documentos. En otras palabras, tendrás que decidir qué campos y valores tendrán tus documentos.

En el caso de los tutoriales para su sitio de Python, sus documentos pueden estar estructurados de la siguiente manera:

{
    "title": "Reading and Writing CSV Files in Python",
    "author": "Jon",
    "contributors": [
        "Aldren",
        "Geir Arne",
        "Joanna",
        "Jason"
    ],
    "url": "https://realpython.com/python-csv/"
}

Un documento es esencialmente un conjunto de nombres de propiedad y sus valores. Los valores pueden ser tipos de datos simples, como cadenas y números, pero también pueden ser matrices como contributors en el ejemplo anterior.

El modelo de datos orientado a documentos de MongoDB representa naturalmente datos complejos como un solo objeto. Esto le permite trabajar con objetos de datos de manera integral, sin necesidad de buscar en varios lugares o tablas.

Si estuviera utilizando un RDBMS tradicional para almacenar sus tutoriales, probablemente tendría una tabla para almacenar sus tutoriales y otra tabla para almacenar sus colaboradores. Luego, tendría que establecer una relación entre ambas tablas para poder recuperar los datos más adelante.



Trabajar con colecciones y documentos

Hasta ahora, conoce los conceptos básicos de cómo ejecutar y usar el mongo cáscara. También sabes cómo crear tus propios documentos utilizando el formato JSON. Ahora es el momento de aprender a insertar documentos en su base de datos MongoDB.

Para insertar un documento en una base de datos utilizando mongo shell, primero debe elegir una colección y luego llamar a .insertOne() en la colección con su documento como argumento:

> use rptutorials
switched to db rptutorials

> db.tutorial.insertOne({
...     "title": "Reading and Writing CSV Files in Python",
...     "author": "Jon",
...     "contributors": [
...         "Aldren",
...         "Geir Arne",
...         "Joanna",
...         "Jason"
...     ],
...     "url": "https://realpython.com/python-csv/"
... })
{
    "acknowledged" : true,
    "insertedId" : ObjectId("600747355e6ea8d224f754ba")
}

Con el primer comando, cambia a la base de datos que desea utilizar. El segundo comando es una llamada de método JavaScript que inserta un documento simple en la colección seleccionada, tutorial . Una vez que presione Enter , recibe un mensaje en su pantalla que le informa sobre el documento recién insertado y su insertedId .

Al igual que las bases de datos relacionales necesitan una clave principal para identificar de forma única cada fila de una tabla, los documentos de MongoDB deben tener un _id campo que identifica de forma única el documento. MongoDB le permite ingresar un _id personalizado siempre y cuando garantices su singularidad. Sin embargo, una práctica ampliamente aceptada es permitir que MongoDB inserte automáticamente un _id para ti.

Del mismo modo, puede agregar varios documentos de una sola vez usando .insertMany() :

> tutorial1 = {
...     "title": "How to Iterate Through a Dictionary in Python",
...     "author": "Leodanis",
...     "contributors": [
...         "Aldren",
...         "Jim",
...         "Joanna"
...     ],
...     "url": "https://realpython.com/iterate-through-dictionary-python/"
... }

> tutorial2 = {
...      "title": "Python 3's f-Strings: An Improved String Formatting Syntax",
...      "author": "Joanna",
...      "contributors": [
...          "Adriana",
...          "David",
...          "Dan",
...          "Jim",
...          "Pavel"
...      ],
...      "url": "https://realpython.com/python-f-strings/"
... }

> db.tutorial.insertMany([tutorial1, tutorial2])
{
    "acknowledged" : true,
    "insertedIds" : [
        ObjectId("60074ff05e6ea8d224f754bb"),
        ObjectId("60074ff05e6ea8d224f754bc")
    ]
}

Aquí, la llamada a .insertMany() toma una lista de tutoriales y los inserta en la base de datos. Nuevamente, la salida del shell muestra información sobre los documentos recién insertados y su _id agregado automáticamente campos.

El mongo shell también proporciona métodos para realizar operaciones de lectura, actualización y eliminación en la base de datos. Por ejemplo, puede usar .find() para recuperar los documentos de una colección:

> db.tutorial.find()
{ "_id" : ObjectId("600747355e6ea8d224f754ba"),
"title" : "Reading and Writing CSV Files in Python",
"author" : "Jon",
"contributors" : [ "Aldren", "Geir Arne", "Joanna", "Jason" ],
"url" : "https://realpython.com/python-csv/" }
    ...

> db.tutorial.find({author: "Joanna"})
{ "_id" : ObjectId("60074ff05e6ea8d224f754bc"),
"title" : "Python 3's f-Strings: An Improved String Formatting Syntax (Guide)",
"author" : "Joanna",
"contributors" : [ "Adriana", "David", "Dan", "Jim", "Pavel" ],
"url" : "https://realpython.com/python-f-strings/" }

La primera llamada a .find() recupera todos los documentos en el tutorial recopilación. Por otro lado, la segunda llamada a .find() recupera los tutoriales creados por Joanna.

Con este conocimiento previo sobre cómo usar MongoDB a través de su mongo shell, está listo para comenzar a usar MongoDB con Python. Las próximas secciones lo guiarán a través de diferentes opciones para usar bases de datos MongoDB en sus aplicaciones de Python.




Uso de MongoDB con Python y PyMongo

Ahora que sabe qué es MongoDB y cómo crear y administrar bases de datos usando mongo shell, puede comenzar a usar MongoDB, pero esta vez con Python. MongoDB proporciona un controlador oficial de Python llamado PyMongo.

En esta sección, verá algunos ejemplos que lo ayudarán a tener una idea de cómo usar PyMongo para crear sus propias aplicaciones de base de datos con MongoDB y Python.

Cada módulo dentro de PyMongo es responsable de un conjunto de operaciones en la base de datos. Tendrá módulos para al menos las siguientes tareas:

  • Establecimiento de conexiones de base de datos
  • Trabajar con bases de datos
  • Trabajar con colecciones y documentos
  • Manipular el cursor
  • Trabajar con cifrado de datos

En general, PyMongo proporciona un amplio conjunto de herramientas que puede usar para comunicarse con un servidor MongoDB. Proporciona funcionalidad para consultar, recuperar resultados, escribir y eliminar datos y ejecutar comandos de base de datos.


Instalación de PyMongo

Para comenzar a usar PyMongo, primero debe instalarlo en su entorno de Python. Puede usar un entorno virtual o puede usar la instalación de Python en todo el sistema, aunque se prefiere la primera opción. PyMongo está disponible en PyPI, por lo que la forma más rápida de instalarlo es con pip . Inicie su terminal y ejecute el siguiente comando:

$ pip install pymongo==3.11.2

Después de algunas descargas y otros pasos relacionados, este comando instala PyMongo en su entorno de Python. Tenga en cuenta que si no proporciona un número de versión específico, entonces pip instalará la última versión disponible.

Nota: Para obtener una guía completa sobre cómo instalar PyMongo, consulte la página de instalación/actualización de su documentación oficial.

Una vez que haya terminado con la instalación, puede iniciar una sesión interactiva de Python y ejecutar la siguiente importación:

>>>
>>> import pymongo

Si esto se ejecuta sin generar una excepción en el shell de Python, entonces su instalación funciona bien. De lo contrario, vuelva a realizar los pasos con cuidado.



Establecer una conexión

Para establecer una conexión a una base de datos, debe crear un MongoClient instancia. Esta clase proporciona un cliente para una instancia o servidor de MongoDB. Cada objeto de cliente tiene un grupo de conexiones incorporado, que por defecto maneja hasta cien conexiones con el servidor.

Regrese a su sesión interactiva de Python e importe MongoClient de pymongo . Luego, cree un objeto de cliente para comunicarse con su instancia de MongoDB que se está ejecutando actualmente:

>>>
>>> from pymongo import MongoClient
>>> client = MongoClient()
>>> client
MongoClient(host=['localhost:27017'], ..., connect=True)

El código anterior establece una conexión con el host predeterminado (localhost ) y puerto (27017 ). MongoClient toma un conjunto de argumentos que le permite especificar host personalizado, puerto y otros parámetros de conexión. Por ejemplo, para proporcionar un host y un puerto personalizados, puede usar el siguiente código:

>>>
>>> client = MongoClient(host="localhost", port=27017)

Esto es útil cuando necesita proporcionar un host y port que difieren de la configuración predeterminada de MongoDB. También puede usar el formato URI de MongoDB:

>>>
>>> client = MongoClient("mongodb://localhost:27017")

Todas estas instancias de MongoClient proporcione la misma configuración de cliente para conectar su instancia actual de MongoDB. Cuál debe usar solo depende de qué tan explícito quiera ser en su código.

Una vez que haya creado una instancia de MongoClient , puede usar su instancia para referirse a esa conexión de base de datos específica, tal como lo hizo con mongo shell db objeto en la sección anterior.



Trabajar con bases de datos, colecciones y documentos

Una vez que tenga una instancia conectada de MongoClient , puede acceder a cualquier base de datos administrada por el servidor MongoDB especificado. Para definir qué base de datos desea usar, puede usar la notación de puntos tal como lo hizo en mongo concha:

>>>
>>> db = client.rptutorials
>>> db
Database(MongoClient(host=['localhost:27017'], ..., connect=True), 'rptutorials')

En este caso, rptutorials es el nombre de la base de datos con la que trabajará. Si la base de datos no existe, MongoDB la crea por usted, pero solo cuando realiza la primera operación en la base de datos.

También puede usar el acceso de estilo diccionario si el nombre de la base de datos no es un identificador de Python válido:

>>>
>>> db = client["rptutorials"]

Esta declaración es útil cuando el nombre de su base de datos no es un identificador de Python válido. Por ejemplo, si su base de datos se llama rp-tutorials , entonces necesita usar el acceso de estilo diccionario.

Nota: Cuando usas el mongo shell, tiene acceso a la base de datos a través de db objeto mundial. Cuando usa PyMongo, puede asignar la base de datos a una variable llamada db para obtener un comportamiento similar.

Almacenar datos en su base de datos usando PyMongo es similar a lo que hizo con mongo shell en las secciones anteriores. Pero primero, necesita crear sus documentos. En Python, usa diccionarios para crear documentos:

>>>
>>> tutorial1 = {
...     "title": "Working With JSON Data in Python",
...     "author": "Lucas",
...     "contributors": [
...         "Aldren",
...         "Dan",
...         "Joanna"
...     ],
...     "url": "https://realpython.com/python-json/"
... }

Una vez que haya creado el documento como un diccionario, debe especificar qué colección desea usar. Para hacerlo, puede usar la notación de puntos en el objeto de la base de datos:

>>>
>>> tutorial = db.tutorial
>>> tutorial
Collection(Database(..., connect=True), 'rptutorials'), 'tutorial')

En este caso, tutorial es una instancia de Collection y representa una colección física de documentos en su base de datos. Puede insertar documentos en tutorial llamando a .insert_one() en él con un documento como argumento:

>>>
>>> result = tutorial.insert_one(tutorial1)
>>> result
<pymongo.results.InsertOneResult object at 0x7fa854f506c0>

>>> print(f"One tutorial: {result.inserted_id}")
One tutorial: 60084b7d87eb0fbf73dbf71d

Aquí, .insert_one() toma tutorial1 , lo inserta en el tutorial colección y devuelve un InsertOneResult objeto. Este objeto proporciona comentarios sobre el documento insertado. Tenga en cuenta que dado que MongoDB genera el ObjectId dinámicamente, su salida no coincidirá con el ObjectId se muestra arriba.

Si tiene muchos documentos para agregar a la base de datos, puede usar .insert_many() para insertarlos de una sola vez:

>>>
>>> tutorial2 = {
...     "title": "Python's Requests Library (Guide)",
...     "author": "Alex",
...     "contributors": [
...         "Aldren",
...         "Brad",
...         "Joanna"
...     ],
...     "url": "https://realpython.com/python-requests/"
... }

>>> tutorial3 = {
...     "title": "Object-Oriented Programming (OOP) in Python 3",
...     "author": "David",
...     "contributors": [
...         "Aldren",
...         "Joanna",
...         "Jacob"
...     ],
...     "url": "https://realpython.com/python3-object-oriented-programming/"
... }

>>> new_result = tutorial.insert_many([tutorial2, tutorial3])

>>> print(f"Multiple tutorials: {new_result.inserted_ids}")
Multiple tutorials: [
   ObjectId('6008511c87eb0fbf73dbf71e'),
   ObjectId('6008511c87eb0fbf73dbf71f')
]

Esto es más rápido y sencillo que llamar a .insert_one() varias veces. La llamada a .insert_many() toma una iteración de documentos y los inserta en el tutorial colección en tus rptutorials base de datos. El método devuelve una instancia de InsertManyResult , que proporciona información sobre los documentos insertados.

Para recuperar documentos de una colección, puede usar .find() . Sin argumentos, .find() devuelve un Cursor objeto que cede los documentos de la colección bajo demanda:

>>>
>>> import pprint

>>> for doc in tutorial.find():
...     pprint.pprint(doc)
...
{'_id': ObjectId('600747355e6ea8d224f754ba'),
 'author': 'Jon',
 'contributors': ['Aldren', 'Geir Arne', 'Joanna', 'Jason'],
 'title': 'Reading and Writing CSV Files in Python',
 'url': 'https://realpython.com/python-csv/'}
    ...
{'_id': ObjectId('6008511c87eb0fbf73dbf71f'),
 'author': 'David',
 'contributors': ['Aldren', 'Joanna', 'Jacob'],
 'title': 'Object-Oriented Programming (OOP) in Python 3',
 'url': 'https://realpython.com/python3-object-oriented-programming/'}

Here, you run a loop on the object that .find() returns and print successive results, using pprint.pprint() to provide a user-friendly output format.

You can also use .find_one() to retrieve a single document. In this case, you can use a dictionary that contains fields to match. For example, if you want to retrieve the first tutorial by Jon, then you can do something like this:

>>>
>>> import pprint

>>> jon_tutorial = tutorial.find_one({"author": "Jon"})

>>> pprint.pprint(jon_tutorial)
{'_id': ObjectId('600747355e6ea8d224f754ba'),
 'author': 'Jon',
 'contributors': ['Aldren', 'Geir Arne', 'Joanna', 'Jason'],
 'title': 'Reading and Writing CSV Files in Python',
 'url': 'https://realpython.com/python-csv/'}

Note that the tutorial’s ObjectId is set under the _id key, which is the unique document identifier that MongoDB automatically adds when you insert a document into your database.

PyMongo also provides methods to replace, update, and delete documents from a database. If you want to dive deeper into these features, then take a look at the documentation for Collection .



Closing Connections

Establishing a connection to a MongoDB database is typically an expensive operation. If you have an application that constantly retrieves and manipulates data in a MongoDB database, then you probably don’t want to be opening and closing the connection all the time since this might affect your application’s performance.

In this kind of situation, you should keep your connection alive and only close it before exiting the application to clear all the acquired resources. You can close the connection by calling .close() on the MongoClient instancia:

>>>
>>> client.close()

Another situation is when you have an application that occasionally uses a MongoDB database. In this case, you might want to open the connection when needed and close it immediately after use for freeing the acquired resources. A consistent approach to this problem would be to use the with statement. Yes, MongoClient implements the context manager protocol:

>>>
>>> import pprint
>>> from pymongo import MongoClient

>>> with MongoClient() as client:
...     db = client.rptutorials
...     for doc in db.tutorial.find():
...         pprint.pprint(doc)
...
{'_id': ObjectId('600747355e6ea8d224f754ba'),
 'author': 'Jon',
 'contributors': ['Aldren', 'Geir Arne', 'Joanna', 'Jason'],
 'title': 'Reading and Writing CSV Files in Python',
 'url': 'https://realpython.com/python-csv/'}
    ...
{'_id': ObjectId('6008511c87eb0fbf73dbf71f'),
 'author': 'David',
 'contributors': ['Aldren', 'Joanna', 'Jacob'],
 'title': 'Object-Oriented Programming (OOP) in Python 3',
 'url': 'https://realpython.com/python3-object-oriented-programming/'}

If you use the with statement to handle your MongoDB client, then at the end of the with code block, the client’s .__exit__() method gets called, which at the same time closes the connection by calling .close() .




Using MongoDB With Python and MongoEngine

While PyMongo is a great and powerful Python driver for interfacing with MongoDB, it’s probably a bit too low-level for many of your projects. With PyMongo, you’ll have to write a lot of code to consistently insert, retrieve, update, and delete documents.

One library that provides a higher abstraction on top of PyMongo is MongoEngine. MongoEngine is an object-document mapper (ODM), which is roughly equivalent to an SQL-based object-relational mapper (ORM). MongoEngine provides a class-based abstraction, so all the models you create are classes.


Installing MongoEngine

There are a handful of Python libraries to help you work with MongoDB. MongoEngine, however, is a popular one that provides a nice set of features, flexibility, and community support. MongoEngine is available on PyPI. You can install it using the following pip comando:

$ pip install mongoengine==0.22.1

Once you’ve installed MongoEngine into your Python environment, you’re ready to start working with MongoDB databases using Python’s object-oriented features. The next step is to connect to your running MongoDB instance.



Establishing a Connection

To establish a connection with your database, you need to use mongoengine.connect() . This function takes several arguments. However, in this tutorial, you’ll use only three of them. Within your Python interactive session, type the following code:

>>>
>>> from mongoengine import connect
>>> connect(db="rptutorials", host="localhost", port=27017)
MongoClient(host=['localhost:27017'], ..., read_preference=Primary())

Here, you first set the database name db to "rptutorials" , which is the name of the database you want to work in. Then you provide a host and a port to connect to your current MongoDB instance. Since you’re using the default host and port , you can omit these two parameters and just use connect("rptutorials") .



Working With Collections and Documents

To create documents with MongoEngine, you first need to define what data you want the documents to have. In other words, you need to define a document schema. MongoEngine encourages you to define a document schema to help you reduce coding errors and to allow you to define utility or helper methods.

Similar to ORMs, ODMs like MongoEngine provide a base or model class for you to define a document schema. In ORMs, that class is equivalent to a table, and its instances are equivalent to rows. In MongoEngine, the class is equivalent to a collection, and its instances are equivalent to documents.

To create a model, you need to subclass Document and provide the required fields as class attributes. To continue with the blog example, here’s how you can create a model for your tutorials:

>>>
>>> from mongoengine import Document, ListField, StringField, URLField

>>> class Tutorial(Document):
...     title = StringField(required=True, max_length=70)
...     author = StringField(required=True, max_length=20)
...     contributors = ListField(StringField(max_length=20))
...     url = URLField(required=True)

With this model, you tell MongoEngine that you expect a Tutorial document to have a .title , an .author , a list of .contributors , and a .url . The base class, Document , uses that information along with the field types to validate the input data for you.

Note: One of the more difficult tasks with database models is data validation . How do you make sure that the input data conforms to your format requirements? That’s one of the reasons for you to have a coherent and uniform document schema.

MongoDB is said to be a schemaless database, but that doesn’t mean it’s schema free. Having documents with a different schema within the same collection can lead to processing errors and inconsistent behavior.

For example, if you try to save a Tutorial object without a .title , then your model throws an exception and lets you know. You can take this even further and add more restrictions, such as the length of the .title , and so on.

There are a few general parameters that you can use to validate fields. Here are some of the more commonly used parameters:

  • db_field specifies a different field name.
  • required ensures that the field is provided.
  • default provides a default value for a given field if no value is given.
  • unique ensures that no other document in the collection has the same value for this field.

Each specific field type also has its own set of parameters. You can check the documentation for a complete guide to the available field types.

To save a document to your database, you need to call .save() on a document object. If the document already exists, then all the changes will be applied to the existing document. If the document doesn’t exist, then it’ll be created.

Here’s an example of creating and saving a tutorial into your sample tutorials database:

>>>
>>> tutorial1 = Tutorial(
...     title="Beautiful Soup: Build a Web Scraper With Python",
...     author="Martin",
...     contributors=["Aldren", "Geir Arne", "Jaya", "Joanna", "Mike"],
...     url="https://realpython.com/beautiful-soup-web-scraper-python/"
... )

>>> tutorial1.save()  # Insert the new tutorial
<Tutorial: Tutorial object>

By default, .save() inserts the new document into a collection named after the model class, Tutorial , except using lowercase letters. In this case, the collection name is tutorial , which matches the collection you’ve been using to save your tutorials.

PyMongo performs data validation when you call .save() . This means that it checks the input data against the schema you declared in the Tutorial model class. If the input data violates the schema or any of its constraints, then you get an exception, and the data isn’t saved into the database.

For example, here’s what happens if you try to save a tutorial without providing a .title :

>>>
>>> tutorial2 = Tutorial()
>>> tutorial2.author = "Alex"
>>> tutorial2.contributors = ["Aldren", "Jon", "Joanna"]
>>> tutorial2.url = "https://realpython.com/convert-python-string-to-int/"
>>> tutorial2.save()
Traceback (most recent call last):
  ...
mongoengine.errors.ValidationError: ... (Field is required: ['title'])

In this example, first note that you can also build a Tutorial object by assigning values to its attributes. Second, since you don’t provide a .title for the new tutorial, .save() raises a ValidationError telling you that the .title field is required. Having automatic data validation is a great feature that will save you some headaches.

Each Document subclass has an .objects attribute that you can use to access the documents in the associated collection. For example, here’s how you can print the .title of all your current tutorials:

>>>
>>> for doc in Tutorial.objects:
...     print(doc.title)
...
Reading and Writing CSV Files in Python
How to Iterate Through a Dictionary in Python
Python 3's f-Strings: An Improved String Formatting Syntax (Guide)
Working With JSON Data in Python
Python's Requests Library (Guide)
Object-Oriented Programming (OOP) in Python 3
Beautiful Soup: Build a Web Scraper With Python

The for loop iterates over all your tutorials and prints their .title data to the screen. You can also use .objects to filter your documents. For example, say you want to retrieve the tutorials authored by Alex. In that case, you can do something like this:

>>>
>>> for doc in Tutorial.objects(author="Alex"):
...     print(doc.title)
...
Python's Requests Library (Guide)

MongoEngine is well suited to manage your MongoDB databases for just about any type of application. Its features make it ideal for creating efficient and scalable programs using a high-level approach. If you’re looking for more information about MongoEngine, be sure to check out its user guide.




Conclusion

If you need a robust, scalable, and flexible database solution, then MongoDB might be a good option for you. MongoDB is a mature and popular NoSQL database with great Python support. With a good understanding of how to access MongoDB with Python, you’ll be ready to create database applications that scale well and provide excellent performance.

With MongoDB, you also have the benefit of a human-readable and highly-flexible data model, so you can adapt to requirement changes quickly.

In this tutorial, you learned:

  • What MongoDB and NoSQL databases are
  • How to install and run MongoDB on your system
  • How to create and work with MongoDB databases
  • How to interface with MongoDB in Python using the PyMongo driver
  • How to use the MongoEngine object-document mapper to work with MongoDB

The examples you coded in this tutorial are available for download. To get their source code, click the link below:

Get the Source Code: Click here to get the source code you’ll use to learn about using MongoDB with Python in this tutorial.