Python et MongoDB :connexion aux bases de données NoSQL

MongoDB est une solution de base de données orientée document et NoSQL qui offre une grande évolutivité et flexibilité ainsi qu'un système de requête puissant. Avec MongoDB et Python, vous pouvez développer rapidement de nombreux types d'applications de base de données. Donc, si votre application Python a besoin d'une base de données aussi flexible que le langage lui-même, alors MongoDB est fait pour vous.

Dans ce didacticiel, vous apprendrez :

• Qu'est-ce que MongoDB est
• Comment installer et exécuter MongoDB
• Comment travailler avec les bases de données MongoDB
• Comment utiliser le pilote PyMongo de bas niveau pour s'interfacer avec MongoDB
• Comment utiliser le mappeur objet-document MongoEngine (ODM) de haut niveau

Tout au long de ce didacticiel, vous écrirez quelques exemples qui démontreront la flexibilité et la puissance de MongoDB et son excellent support Python. Pour télécharger le code source de ces exemples, cliquez sur le lien ci-dessous :

Obtenez le code source : Cliquez ici pour obtenir le code source que vous utiliserez pour en savoir plus sur l'utilisation de MongoDB avec Python dans ce didacticiel.

Utilisation des bases de données SQL et NoSQL

Pendant des décennies, les bases de données SQL ont été l'un des seuls choix pour les développeurs cherchant à créer des systèmes de bases de données volumineux et évolutifs. Cependant, le besoin croissant de stocker des structures de données complexes a conduit à la naissance de NoSQL bases de données. Ce nouveau type de système de base de données permet aux développeurs de stocker efficacement des données hétérogènes et sans structure.

En général, les systèmes de bases de données NoSQL stockent et récupèrent les données d'une manière très différente des systèmes de gestion de bases de données relationnelles (SGBDR) SQL.

Lorsqu'il s'agit de choisir parmi les technologies de base de données actuellement disponibles, vous devrez peut-être choisir entre l'utilisation de systèmes SQL ou NoSQL. Les deux ont des caractéristiques spécifiques que vous devez prendre en compte lors du choix de l'un ou de l'autre. Voici quelques-unes de leurs différences les plus substantielles :

Il existe de nombreuses autres différences entre les deux types de bases de données, mais celles mentionnées ci-dessus sont parmi les plus importantes à connaître.

Lors du choix d'une base de données, vous devez examiner attentivement ses forces et ses faiblesses. Vous devez également tenir compte de la manière dont la base de données s'intègre à votre scénario spécifique et aux exigences de votre application. Parfois, la bonne solution consiste à utiliser une combinaison de bases de données SQL et NoSQL pour gérer différents aspects d'un système plus large.

Voici quelques exemples courants de bases de données SQL :

• SQLite
• MySQL
• Oracle
• PostgreSQL
• Microsoft SQL Server

Les exemples de bases de données NoSQL incluent :

• DynamoDB
• Cassandre
• Redis
• CouchDB
• Repenser la base de données
• RavenDB
• MongoDB

Ces dernières années, les bases de données SQL et NoSQL ont même commencé à fusionner. Par exemple, les systèmes de base de données, tels que PostgreSQL, MySQL et Microsoft SQL Server prennent désormais en charge le stockage et l'interrogation des données JSON, tout comme les bases de données NoSQL. Avec cela, vous pouvez maintenant obtenir bon nombre des mêmes résultats avec les deux technologies. Mais vous ne bénéficiez toujours pas de la plupart des fonctionnalités NoSQL, telles que la mise à l'échelle horizontale et l'interface conviviale.

Avec ce bref aperçu des bases de données SQL et NoSQL, vous pouvez vous concentrer sur le sujet principal de ce tutoriel :la base de données MongoDB et comment l'utiliser en Python.

Gestion des bases de données NoSQL avec MongoDB

MongoDB est orienté document base de données classée comme NoSQL. Il est devenu populaire dans l'ensemble de l'industrie ces dernières années et s'intègre extrêmement bien à Python. Contrairement aux SGBDR SQL traditionnels, MongoDB utilise des collections de documents au lieu de tableaux de lignes pour organiser et stocker des données.

MongoDB stocke les données dans des documents de type JSON sans schéma et flexibles. Ici, sans schéma signifie que vous pouvez avoir des documents avec un ensemble différent de champs dans la même collection, sans avoir besoin de satisfaire un schéma de table rigide .

Vous pouvez modifier la structure de vos documents et données au fil du temps, ce qui se traduit par un système flexible qui vous permet de vous adapter rapidement aux changements d'exigences sans avoir besoin d'un processus complexe de migration des données. Cependant, le compromis lié à la modification de la structure des nouveaux documents est que les documents existants deviennent incompatibles avec le schéma mis à jour. C'est donc un sujet qui doit être géré avec soin.

Remarque : JSON signifie JavaScript Object Notation . Il s'agit d'un format de fichier avec une structure lisible par l'homme composée de paires clé-valeur qui peuvent être imbriquées à une profondeur arbitraire.

MongoDB est écrit en C++ et activement développé par MongoDB Inc. Il fonctionne sur toutes les principales plates-formes, telles que macOS, Windows, Solaris et la plupart des distributions Linux. En général, il y a trois principaux objectifs de développement derrière la base de données MongoDB :

1. Bien évoluer
2. Stocker des structures de données riches
3. Fournir un mécanisme de requête sophistiqué

MongoDB est un distribué base de données, de sorte que la haute disponibilité, la mise à l'échelle horizontale et la distribution géographique sont intégrées au système. Il stocke les données dans des documents flexibles de type JSON. Vous pouvez modéliser ces documents pour mapper les objets dans vos applications, ce qui permet de travailler efficacement avec vos données.

MongoDB fournit un langage de requête puissant qui prend en charge les requêtes ad hoc, l'indexation, l'agrégation, la recherche géospatiale, la recherche de texte et bien plus encore. Cela vous présente un kit d'outils puissant pour accéder et travailler avec vos données. Enfin, MongoDB est disponible gratuitement et offre un excellent support Python.

Examen des fonctionnalités de MongoDB

Jusqu'à présent, vous avez appris ce qu'est MongoDB et quels sont ses principaux objectifs. Dans cette section, vous découvrirez certaines des fonctionnalités les plus importantes de MongoDB. Côté gestion de la base de données, MongoDB propose les fonctionnalités suivantes :

• Prise en charge des requêtes : Vous pouvez utiliser de nombreux types de requête standard, tels que la correspondance (== ), comparaison (< , > ), et des expressions régulières.
• Hébergement des données : Vous pouvez stocker pratiquement n'importe quel type de données, qu'elles soient structurées, partiellement structurées ou même polymorphes.
• Évolutivité : Il gère plus de requêtes simplement en ajoutant plus de machines au cluster de serveurs.
• Flexibilité et agilité : Vous pouvez développer rapidement des applications avec.
• Orientation du document et absence de schéma : Vous pouvez stocker toutes les informations concernant un modèle de données dans un seul document.
• Schéma ajustable : Vous pouvez modifier le schéma de la base de données à la volée, ce qui réduit le temps nécessaire pour fournir de nouvelles fonctionnalités ou résoudre des problèmes existants.
• Fonctionnalités de la base de données relationnelle : Vous pouvez effectuer des actions communes aux bases de données relationnelles, comme l'indexation.

En ce qui concerne les opérations, MongoDB fournit quelques outils et fonctionnalités que vous ne trouverez pas dans d'autres systèmes de base de données :

• Évolutivité : Que vous ayez besoin d'un serveur autonome ou de clusters complets de serveurs indépendants, vous pouvez adapter MongoDB à la taille dont vous avez besoin.
• Prise en charge de l'équilibrage de charge : MongoDB déplacera automatiquement les données sur différents fragments.
• Prise en charge du basculement automatique : Si votre serveur principal tombe en panne, un nouveau serveur principal sera automatiquement opérationnel.
• Outils de gestion : Vous pouvez suivre vos machines à l'aide du service de gestion MongoDB (MMS) basé sur le cloud.
• Efficacité de la mémoire : Grâce aux fichiers mappés en mémoire, MongoDB est souvent plus efficace que les bases de données relationnelles.

Toutes ces fonctionnalités sont bien utiles. Par exemple, si vous tirez parti de la fonction d'indexation, une grande partie de vos données sera conservée en mémoire pour une récupération rapide. Même sans indexer des clés de document spécifiques, MongoDB met en cache un certain nombre de données en utilisant la technique la moins récemment utilisée.

Installation et exécution de MongoDB

Maintenant que vous êtes familiarisé avec MongoDB, il est temps de vous salir les mains et de commencer à l'utiliser. Mais d'abord, vous devez l'installer sur votre machine. Le site officiel de MongoDB propose deux éditions du serveur de base de données :

1. L'édition communautaire offre le modèle de document flexible ainsi que les requêtes ad hoc, l'indexation et l'agrégation en temps réel pour fournir des moyens puissants d'accéder à vos données et de les analyser. Cette édition est disponible gratuitement.
2. L'édition entreprise offre les mêmes fonctionnalités que l'édition communautaire, ainsi que d'autres fonctionnalités avancées liées à la sécurité et à la surveillance. Il s'agit de l'édition commerciale, mais vous pouvez l'utiliser gratuitement pendant une durée illimitée à des fins d'évaluation et de développement.

Si vous utilisez Windows, vous pouvez lire le didacticiel d'installation pour obtenir des instructions complètes. En général, vous pouvez vous rendre sur la page de téléchargement, sélectionner la plateforme Windows dans la case Téléchargements disponibles, choisir le .msi programme d'installation correspondant à votre système actuel, puis cliquez sur Télécharger .

Exécutez le programme d'installation et suivez les instructions à l'écran de l'assistant d'installation. Cette page fournit également des informations sur l'exécution de MongoDB en tant que service Windows.

Si vous utilisez macOS, vous pouvez utiliser Homebrew pour installer MongoDB sur votre système. Voir le tutoriel d'installation pour obtenir le guide complet. Assurez-vous également de suivre les instructions pour exécuter MongoDB en tant que service macOS.

Si vous êtes sous Linux, le processus d'installation dépendra de votre distribution spécifique. Pour un guide détaillé sur l'installation de MongoDB sur différents systèmes Linux, accédez à la page du didacticiel d'installation et sélectionnez le didacticiel correspondant à votre système d'exploitation actuel. Assurez-vous d'exécuter le démon MongoDB, mongod , à la fin de l'installation.

Enfin, vous pouvez également installer MongoDB à l'aide de Docker. C'est pratique si vous ne voulez pas encombrer votre système avec une autre installation. Si vous préférez cette option d'installation, vous pouvez lire le didacticiel officiel et suivre ses instructions. Notez qu'une connaissance préalable de l'utilisation de Docker serait requise dans ce cas.

Avec la base de données MongoDB installée et en cours d'exécution sur votre système, vous pouvez commencer à travailler avec de vraies bases de données en utilisant le mongo coque.

Créer des bases de données MongoDB avec le mongo Coque

Si vous avez suivi les instructions d'installation et d'exécution, vous devriez déjà avoir une instance de MongoDB en cours d'exécution sur votre système. Vous pouvez maintenant commencer à créer et à tester vos propres bases de données. Dans cette section, vous apprendrez à utiliser le mongo shell pour créer, lire, mettre à jour et supprimer des documents sur une base de données.

Exécuter le mongo Coque

Le mongo shell est une interface JavaScript interactive pour MongoDB. Vous pouvez utiliser cet outil pour interroger et manipuler vos données ainsi que pour effectuer des opérations administratives. Comme il s'agit d'une interface JavaScript, vous n'utiliserez pas le langage SQL familier pour interroger la base de données. À la place, vous utiliserez du code JavaScript.

Pour lancer le mongo shell, ouvrez votre terminal ou votre ligne de commande et exécutez la commande suivante :

$ mongo

Cette commande vous amène au mongo coquille. À ce stade, vous verrez probablement un tas de messages contenant des informations sur la version du shell et sur l'adresse et le port du serveur. Enfin, vous serez présenté avec l'invite du shell (> ) pour entrer des requêtes et des commandes.

Vous pouvez passer l'adresse de la base de données comme argument au mongo commande. Vous pouvez également utiliser plusieurs options, telles que la spécification de l'hôte et du port pour accéder à une base de données distante, etc. Pour plus de détails sur l'utilisation du mongo commande, vous pouvez exécuter mongo --help .

Établir une connexion

Lorsque vous exécutez le mongo commande sans arguments, elle lance le shell et se connecte au serveur local par défaut fourni par le mongod processus à mongod://127.0.0.1:27017 . Cela signifie que vous êtes connecté à l'hôte local via le port 27017 .

Par défaut, le mongo shell démarre la session en établissant une connexion au test base de données. Vous pouvez accéder à la base de données actuelle via le db objet :

> db
test
>

Dans ce cas, db contient une référence à test , qui est la base de données par défaut. Pour changer de base de données, lancez la commande use , en fournissant un nom de base de données comme argument.

Par exemple, supposons que vous souhaitiez créer un site Web pour publier du contenu Python et que vous envisagez d'utiliser MongoDB pour stocker vos didacticiels et articles. Dans ce cas, vous pouvez basculer vers la base de données du site avec la commande suivante :

> use rptutorials
switched to db rptutorials

Cette commande bascule votre connexion vers les rptutorials base de données. MongoDB ne crée pas le fichier de base de données physique sur le système de fichiers tant que vous n'insérez pas de données réelles dans la base de données. Donc dans ce cas, rptutorials n'apparaîtra pas dans votre liste de bases de données actuelle :

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

Le mongo shell fournit de nombreuses fonctionnalités et options. Il vous permet d'interroger et de manipuler vos données et également de gérer le serveur de base de données lui-même.

Au lieu d'utiliser un langage de requête standardisé tel que SQL, le mongo shell utilise le langage de programmation JavaScript et une API conviviale. Cette API vous permet de jouer avec vos données, ce qui est le sujet de la section suivante.

Créer des collections et des documents

Une base de données MongoDB est un conteneur physique pour des collections de documents. Chaque base de données obtient son propre ensemble de fichiers sur le système de fichiers. Ces fichiers sont gérés par le serveur MongoDB, qui peut gérer plusieurs bases de données.

Dans MongoDB, une collection est un groupe de documents . Les collections sont quelque peu analogues aux tables d'un SGBDR traditionnel, mais sans imposer de schéma rigide. En théorie, chaque document d'une collection peut avoir une structure ou un ensemble de champs complètement différent.

En pratique, les documents d'une collection partagent généralement une structure similaire pour permettre des processus uniformes de récupération, d'insertion et de mise à jour. Vous pouvez appliquer une structure de document uniforme en utilisant des règles de validation de document lors des mises à jour et des insertions.

Autoriser différentes structures de documents est une caractéristique clé des collections MongoDB. Cette fonctionnalité offre de la flexibilité et permet d'ajouter de nouveaux champs aux documents sans avoir à modifier un schéma de table formel.

Pour créer une collection en utilisant le mongo shell, vous devez pointer db à votre base de données cible, puis créez les collections en utilisant la notation par points :

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

Dans cet exemple, vous utilisez la notation par points pour créer un tutorial en tant que collection dans rptutorials , qui est votre base de données actuelle. Il est important de noter que MongoDB crée des bases de données et des collections paresseusement . En d'autres termes, ils ne sont créés physiquement qu'après l'insertion du premier document.

Une fois que vous avez une base de données et une collection, vous pouvez commencer à insérer des documents. Les documents sont l'unité de stockage dans MongoDB. Dans un SGBDR, cela équivaudrait à une ligne de tableau. Cependant, les documents de MongoDB sont bien plus polyvalents que les lignes car ils peuvent stocker des informations complexes, telles que des tableaux, des documents intégrés et même des tableaux de documents.

MongoDB stocke les documents dans un format appelé Binary JSON (BSON), qui est une représentation binaire de JSON. Les documents de MongoDB sont composés de paires champ-valeur et ont la structure suivante :

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

La valeur d'un champ peut être n'importe quel type de données BSON, y compris d'autres documents, tableaux et tableaux de documents. En pratique, vous spécifierez vos documents au format JSON.

Lorsque vous créez une application de base de données MongoDB, votre décision la plus importante concerne probablement la structure des documents. En d'autres termes, vous devrez décider quels champs et quelles valeurs vos documents auront.

Dans le cas des tutoriels pour votre site Python, vos documents pourraient être structurés comme ceci :

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

Un document est essentiellement un ensemble de noms de propriétés et de leurs valeurs. Les valeurs peuvent être des types de données simples, tels que des chaînes et des nombres, mais elles peuvent également être des tableaux tels que contributors dans l'exemple ci-dessus.

Le modèle de données orienté document de MongoDB représente naturellement les données complexes comme un seul objet. Cela vous permet de travailler avec des objets de données de manière holistique, sans avoir besoin de consulter plusieurs emplacements ou tables.

Si vous utilisiez un SGBDR traditionnel pour stocker vos tutoriels, vous auriez probablement une table pour stocker vos tutoriels et une autre table pour stocker vos contributeurs. Ensuite, vous devrez établir une relation entre les deux tables afin de pouvoir récupérer les données ultérieurement.

Travailler avec des collections et des documents

Jusqu'à présent, vous connaissez les bases de l'exécution et de l'utilisation de mongo coquille. Vous savez également comment créer vos propres documents en utilisant le format JSON. Il est maintenant temps d'apprendre à insérer des documents dans votre base de données MongoDB.

Pour insérer un document dans une base de données en utilisant le mongo shell, vous devez d'abord choisir une collection, puis appeler .insertOne() sur la collection avec votre document en argument :

> 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")
}

Avec la première commande, vous passez à la base de données que vous souhaitez utiliser. La deuxième commande est un appel de méthode JavaScript qui insère un document simple dans la collection sélectionnée, tutorial . Une fois que vous avez appuyé sur Entrée , vous obtenez un message sur votre écran qui vous informe du document nouvellement inséré et de son insertedId .

Tout comme les bases de données relationnelles ont besoin d'une clé primaire pour identifier de manière unique chaque ligne d'une table, les documents MongoDB doivent avoir un _id champ qui identifie de manière unique le document. MongoDB vous permet de saisir un _id personnalisé tant que vous garantissez son unicité. Cependant, une pratique largement acceptée consiste à autoriser MongoDB à insérer automatiquement un _id pour vous.

De même, vous pouvez ajouter plusieurs documents en une seule fois en utilisant .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")
    ]
}

Ici, l'appel à .insertMany() prend une liste de tutoriels et les insère dans la base de données. Encore une fois, la sortie du shell affiche des informations sur les documents nouvellement insérés et leur _id ajouté automatiquement champs.

Le mongo shell fournit également des méthodes pour effectuer des opérations de lecture, de mise à jour et de suppression sur la base de données. Par exemple, vous pouvez utiliser .find() pour récupérer les documents d'une collection :

> 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/" }

Le premier appel à .find() récupère tous les documents du tutorial le recueil. Par contre, le deuxième appel à .find() récupère les didacticiels rédigés par Joanna.

Avec cette connaissance de base sur la façon d'utiliser MongoDB via son mongo shell, vous êtes prêt à commencer à utiliser MongoDB avec Python. Les prochaines sections vous guideront à travers différentes options pour utiliser les bases de données MongoDB dans vos applications Python.

Utiliser MongoDB avec Python et PyMongo

Maintenant que vous savez ce qu'est MongoDB et comment créer et gérer des bases de données à l'aide de mongo shell, vous pouvez commencer à utiliser MongoDB, mais cette fois avec Python. MongoDB fournit un pilote Python officiel appelé PyMongo.

Dans cette section, vous allez passer en revue quelques exemples qui vous aideront à comprendre comment utiliser PyMongo pour créer vos propres applications de base de données avec MongoDB et Python.

Chaque module de PyMongo est responsable d'un ensemble d'opérations sur la base de données. Vous aurez des modules pour au moins les tâches suivantes :

• Établir des connexions à la base de données
• Travailler avec des bases de données
• Travailler avec des collections et des documents
• Manipuler le curseur
• Travailler avec le chiffrement des données

En général, PyMongo fournit un riche ensemble d'outils que vous pouvez utiliser pour communiquer avec un serveur MongoDB. Il fournit des fonctionnalités pour interroger, récupérer des résultats, écrire et supprimer des données et exécuter des commandes de base de données.

Installer PyMongo

Pour commencer à utiliser PyMongo, vous devez d'abord l'installer dans votre environnement Python. Vous pouvez utiliser un environnement virtuel ou utiliser votre installation Python à l'échelle du système, bien que la première option soit préférée. PyMongo est disponible sur PyPI, donc le moyen le plus rapide de l'installer est avec pip . Lancez votre terminal et exécutez la commande suivante :

$ pip install pymongo==3.11.2

Après quelques téléchargements et autres étapes connexes, cette commande installe PyMongo sur votre environnement Python. Notez que si vous ne fournissez pas de numéro de version spécifique, alors pip installera la dernière version disponible.

Remarque : Pour un guide complet sur l'installation de PyMongo, consultez la page Installation/Mise à jour de sa documentation officielle.

Une fois l'installation terminée, vous pouvez démarrer une session interactive Python et exécuter l'importation suivante :

>>> import pymongo

Si cela s'exécute sans lever d'exception dans le shell Python, votre installation fonctionne parfaitement. Si ce n'est pas le cas, répétez soigneusement les étapes.

Établir une connexion

Pour établir une connexion à une base de données, vous devez créer un MongoClient exemple. Cette classe fournit un client pour une instance ou un serveur MongoDB. Chaque objet client possède un pool de connexions intégré, qui gère par défaut jusqu'à une centaine de connexions au serveur.

Revenez à votre session interactive Python et importez MongoClient de pymongo . Créez ensuite un objet client pour communiquer avec votre instance MongoDB en cours d'exécution :

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

Le code ci-dessus établit une connexion à l'hôte par défaut (localhost ) et port (27017 ). MongoClient prend un ensemble d'arguments qui vous permet de spécifier un hôte, un port et d'autres paramètres de connexion personnalisés. Par exemple, pour fournir un hôte et un port personnalisés, vous pouvez utiliser le code suivant :

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

C'est pratique lorsque vous devez fournir un host et port qui diffèrent de la configuration par défaut de MongoDB. Vous pouvez également utiliser le format d'URI MongoDB :

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

Toutes ces instances de MongoClient fournissez la même configuration client pour connecter votre instance MongoDB actuelle. Lequel vous devez utiliser dépend simplement de la façon dont vous voulez être explicite dans votre code.

Une fois que vous avez instancié MongoClient , vous pouvez utiliser son instance pour faire référence à cette connexion de base de données spécifique, comme vous l'avez fait avec le mongo db du shell objet dans la section ci-dessus.

Travailler avec des bases de données, des collections et des documents

Une fois que vous avez une instance connectée de MongoClient , vous pouvez accéder à n'importe quelle base de données gérée par le serveur MongoDB spécifié. Pour définir quelle base de données vous souhaitez utiliser, vous pouvez utiliser la notation par points comme vous l'avez fait dans le mongo coque :

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

Dans ce cas, rptutorials est le nom de la base de données avec laquelle vous allez travailler. Si la base de données n'existe pas, MongoDB la crée pour vous, mais uniquement lorsque vous effectuez la première opération sur la base de données.

Vous pouvez également utiliser un accès de type dictionnaire si le nom de la base de données n'est pas un identifiant Python valide :

>>> db = client["rptutorials"]

Cette instruction est pratique lorsque le nom de votre base de données n'est pas un identifiant Python valide. Par exemple, si votre base de données s'appelle rp-tutorials , vous devez utiliser un accès de type dictionnaire.

Remarque : Lorsque vous utilisez le mongo shell, vous avez accès à la base de données via le db objet global. Lorsque vous utilisez PyMongo, vous pouvez affecter la base de données à une variable appelée db pour obtenir un comportement similaire.

Le stockage de données dans votre base de données à l'aide de PyMongo est similaire à ce que vous avez fait avec le mongo coquille dans les sections ci-dessus. Mais d'abord, vous devez créer vos documents. En Python, vous utilisez des dictionnaires pour créer des documents :

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

Une fois que vous avez créé le document en tant que dictionnaire, vous devez spécifier la collection que vous souhaitez utiliser. Pour ce faire, vous pouvez utiliser la notation par points sur l'objet de la base de données :

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

Dans ce cas, tutorial est une instance de Collection et représente une collection physique de documents dans votre base de données. Vous pouvez insérer des documents dans le tutorial en appelant .insert_one() dessus avec un document en argument :

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

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

Ici, .insert_one() prend tutorial1 , l'insère dans le tutorial collection et renvoie un InsertOneResult objet. Cet objet fournit des commentaires sur le document inséré. Notez que puisque MongoDB génère le ObjectId dynamiquement, votre sortie ne correspondra pas à ObjectId ci-dessus.

Si vous avez de nombreux documents à ajouter à la base de données, vous pouvez utiliser .insert_many() pour les insérer en une seule fois :

>>> 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')
]

C'est plus rapide et plus simple que d'appeler .insert_one() plusieurs fois. L'appel à .insert_many() prend un itérable de documents et les insère dans le tutorial collection dans vos rptutorials base de données. La méthode renvoie une instance de InsertManyResult , qui fournit des informations sur les documents insérés.

Pour récupérer des documents d'une collection, vous pouvez utiliser .find() . Sans arguments, .find() renvoie un Cursor objet qui donne les documents de la collection à la demande :

>>> 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 instance:

>>> 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 déclaration. 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 commande :

$ 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.

Remarque : 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.