Module 1Exploiter les fonctionnalités des bases de données NoSQL MongoDB
Chapitre 5 sur 7
L'installation de PyMongo, la connexion au serveur et à une base, les requêtes simples, les index, l'agrégation et les requêtes de modification.
Objectifs
Avec ce chapitre, tu sauras…
Leçon 1
Installation de PyMongo
pip install pymongoCollecting pymongo
Downloading pymongo-4.2.0-cp310-cp310-win_amd64.whl (374 kB)
Installing collected packages: pymongo
Successfully installed pymongo-4.2.0Vidéo · À regarder
FRBase de données : MongoDB et Python (pymongo)
Algomius · YouTube
Ce que tu vas voir (3 min) : le chapitre « Installation de pymongo ». Le formateur installe la librairie pymongo avec pip.
Leçon 2
| Niveau | Objet PyMongo | Exemple |
|---|---|---|
| l'interface cliente (la connexion au serveur) | MongoClient | client = MongoClient() |
| les bases de données du serveur | Database | db = client["Examples"] |
| les collections d'une base | Collection |
Leçon 3
| Requête simple | Explications |
|---|---|
db.Stagiaires.find() | renvoie un curseur (type Cursor) sur les données : <pymongo.cursor.Cursor object at 0x000001D9D93BACE0> ; PyMongo ne renvoie pas une liste, pour économiser la mémoire |
Vidéo · À regarder
FRBase de données : MongoDB et Python (pymongo)
Algomius · YouTube
1PyMongo s'installe avec…
2La classe qui se connecte au serveur est…
3Sans paramètre, MongoClient() se connecte à…
4db.Stagiaires.find() renvoie…
5En PyMongo, la méthode qui insère un document est…
6create_index("nom") crée un index nommé…
7En Python, la valeur nulle de MongoDB s'écrit…
8Pour trier par nom puis par prénom en PyMongo, on écrit…
L'essentiel du chapitre
pip install pymongo. Se connecter : client = MongoClient() (ou MongoClient("mongodb://localhost:27017/")), puis db = client["Examples"], puis db.Stagiaires.MongoClient (le serveur) → Database (la base) → Collection.find() renvoie un curseur à parcourir avec for ; chaque document est un dictionnaire ; list(curseur) pour une liste.find_one, insert_one, insert_many, update_one, update_many, delete_one, delete_many, count_documents ; opérateurs entre guillemets ; None, True, False.create_index("champ") (nom champ_1), index_information(), drop_index("champ_1"). Agrégation : aggregate([{"$group": …}]).db.Stagiaires ou db["Stagiaires"] |
Vidéo · À regarder
FRBase de données : MongoDB et Python (pymongo)
Algomius · YouTube
| Requête | Explication | Exemple |
|---|---|---|
index_information() | renvoie la liste des index de la collection | voir ci-dessous |
create_index() | crée un index | db.Stagiaires.create_index("ind1") |
drop_index() | supprime un index | db.Stagiaires.drop_index("ind1") |
Vidéo · À regarder
FROptimisation base de données #01 : Qu'est ce qu'un index de base de données
coursaline - Rachid Saad · YouTube
Vidéo · À regarder
FRBase de données : MongoDB et Python (pymongo)
Algomius · YouTube
| Requête PyMongo | Fonctionnement |
|---|---|
insert_one() | insertion d'un document |
insert_many() | insertion d'une liste de documents |
delete_one() | suppression d'un document |
delete_many() | suppression d'une liste de documents |
update_one() | modification d'un document |
update_many() | modification d'une liste de documents |
Vidéo · À regarder
FRBase de données : MongoDB et Python (pymongo)
Algomius · YouTube
Connexion au serveur MongoDB
MongoClient. Sans chaîne de connexion, elle se connecte par défaut au serveur qui tourne sur localhost:27017.MongoClient du module pymongo, puis on affiche l'objet :>>> from pymongo import MongoClient
>>> client = MongoClient()
>>> print(client)
MongoClient(host=['localhost:27017'], document_class=dict, tz_aware=False, connect=True)Le texte dit « on commence par importer la classe MongoDB du module pymongo » : la classe s'appelle MongoClient, comme le montre le code.
Les lignes qui commencent par >>> sont tapées dans l'interpréteur Python (la commande python dans le terminal). Dans un fichier .py, on écrit les mêmes lignes sans >>>.
Connexion à une base de données
On peut donner une chaîne de connexion, ou l'hôte et le port :
>>> client = MongoClient(host="localhost", port=27017)
>>> print(client)
MongoClient(host=['localhost:27017'], document_class=dict, tz_aware=False, connect=True)L'objet client est une instance de la classe pymongo.mongo_client.MongoClient : on y retrouve les informations de connexion (hôte, port…).
Pour se connecter à la base Exemples du serveur :
>>> db = client["Exemples"]
>>> print(db)
Database(MongoClient(host=['localhost:27017'], document_class=dict, tz_aware=False, connect=True), 'Exemples')L'objet client renvoie ainsi un objet de la classe pymongo.database.Database.
Ce chapitre du résumé se connecte à la base Exemples, alors que les chapitres 4 et 6 utilisent Examples. Pour retrouver tes 4 stagiaires du chapitre 4, écris db = client["Examples"]. Comme use dans le shell, client["NomBase"] ne crée la base qu'au premier document inséré : une faute de frappe ne donne pas d'erreur, juste une base vide.
La forme MongoClient("mongodb://localhost:27017/") (une URI) est la plus utilisée : c'est la même adresse que dans Compass. On peut aussi écrire client.Examples au lieu de client["Examples"].
Récapitulons
La librairie PyMongo permet de manipuler depuis Python les trois niveaux d'objets de MongoDB :
Les requêtes simples
PyMongo utilise la même syntaxe que le shell MongoDB :
client.baseDonnees.nomDeLaCollection.requete()resultat = db.Stagiaires.find()
for r in resultat[:2]:
print(r)resultat : c'est un objet itérable en Python.for. Ici, resultat[:2] ne garde que les deux premiers documents.Chaque document est un dictionnaire Python : r["nom"] donne le nom.
Pour rendre les requêtes plus lisibles, on crée des variables Python pour la sélection et la projection :
selection={}
selection["option"]="Mobile"
resultat = db.Stagiaires.find(selection)
for i in resultat[:]:
print(i)selection de type dictionnaire ;resultat, puis on le parcourt.{'_id': ObjectId('62e0f02cd55ee92da665d213'), 'nom': 'Alami', 'prenom': 'Amina', 'filiere': {'_id': 'DD', 'intitule': 'Developpement digital'}, 'moy1A': 14.5, 'niveau': '2A', 'option': 'Mobile'}On ajoute une variable projection de type dictionnaire, avec les champs à afficher :
projection={"nom":1,"prenom":1,"_id":0}
selection={}
selection["filiere.intitule"]="Developpement digital"
resultat = db.Stagiaires.find(selection,projection)
for i in resultat[:]:
print(i){'nom': 'Alami', 'prenom': 'Amina'}
{'nom': 'Alami', 'prenom': 'Salim'}Pour appeler une méthode sur la requête, la syntaxe est toujours celle de MongoDB :
client.baseDonnees.nomDeLaCollection.requete().methode()r = db.Stagiaires.find().sort("nom",-1)
for i in r[:]:
print(i)Les stagiaires s'affichent par nom décroissant : Ennaim, Dalil, puis les deux Alami.
PyMongo suit la syntaxe du shell, avec trois différences à connaître :
{"moy1A": {"$gte": 14}}, True / False avec une majuscule, None au lieu de null ;find_one, insert_one, count_documents, create_index… (et non findOne, insertOne) ;sort("nom", -1) pour un champ, ou sort([("nom", -1), ("prenom", -1)]) pour plusieurs champs (une liste de tuples).db.Stagiaires.find_one({"nom": "Alami"}) # le premier Alami (Amina)
db.Stagiaires.find({"moy1A": {"$gte": 14}}, {"prenom": 1, "_id": 0})
db.Stagiaires.distinct("option") # ['Cyber Security', 'FullStack', 'Mobile']
db.Stagiaires.count_documents({"niveau": "2A"}) # 3
list(db.Stagiaires.find({}, {"prenom": 1, "_id": 0}).sort("moy1A", -1).limit(1)) # [{'prenom': 'Nidal'}]list(curseur) transforme le curseur en liste Python : pratique pour un petit résultat.
Écris caisse.py, connecté à la base eshop_db, avec la fonction vendre(designation, quantite) qui :
commandes (date du jour, une ligne avec la désignation, le prix unitaire et la quantité), puis affiche « Vente enregistrée : total X DH ».Teste avec vendre("Souris sans fil", 3), vendre("Smartphone Samsung", 50) et vendre("Tablette", 1).
Écris le programme stagiaires.py qui :
Examples ;Ce que tu vas voir (5 min) : le chapitre « Création de la connexion ». Il crée la connexion au serveur avec MongoClient, puis choisit la base de données et la collection.
Ce que tu vas voir (9 min) : les chapitres « Sélectionner des données dans une base », « Fonctions sur curseurs ». Il sélectionne des données depuis Python avec find, parcourt le curseur avec une boucle, puis utilise les fonctions qu'on peut appeler sur les curseurs.
L'utilisation des index
Un index est une structure de données spéciale qui range une petite partie des données de la collection sous une forme facile à parcourir. Il stocke la valeur d'un champ (ou d'un ensemble de champs), triée par valeur.
C'est l'index d'un livre : au lieu de lire toutes les pages (tous les documents), on va directement à la bonne. Comme en MySQL (partie 1), un index accélère les recherches et ralentit un peu les écritures. MongoDB crée toujours un index sur _id.
client.BasedeDonnee.Collection.requete()client.BasedeDonnee.Collection.requete()for k,v in db.Stagiaires.index_information().items():
print("index:" ,k, "valeur :",v,"\n")index: _id_ valeur : {'v': 2, 'key': [('_id', 1)]}create_index("ind1") ne crée pas un index nommé « ind1 » : il crée un index sur le champ ind1, que MongoDB nomme automatiquement ind1_1 (le nom du champ, puis 1 pour croissant). Du coup, drop_index("ind1") échoue : index not found with name [ind1]. Il faut écrire drop_index("ind1_1"). De plus, la collection n'a pas de champ ind1 : l'index ne sert à rien.
db.Stagiaires.create_index("nom") # renvoie le nom : 'nom_1'
db.Stagiaires.create_index([("moy1A", -1)], name="ind1") # on peut choisir le nom avec name=
for k, v in db.Stagiaires.index_information().items():
print("index:", k, "valeur :", v)
db.Stagiaires.drop_index("nom_1")
db.Stagiaires.drop_index("ind1")index: _id_ valeur : {'v': 2, 'key': [('_id', 1)]}
index: nom_1 valeur : {'v': 2, 'key': [('nom', 1)]}
index: ind1 valeur : {'v': 2, 'key': [('moy1A', -1)]}Dans le shell, c'est la même chose : db.Stagiaires.createIndex({"nom": 1}), db.Stagiaires.getIndexes(), db.Stagiaires.dropIndex("nom_1"). Un index unique refuse les doublons : create_index("email", unique=True).
Ce que tu vas voir (2 min) : le chapitre « Qu'est-ce qu'un index ? ». Ce qu'est un index et pourquoi il accélère les recherches. La vidéo prend un exemple en SQL : le principe est le même dans MongoDB.
Les requêtes d'agrégation
client.BasedeDonnee.Collection.aggregate()resultat = db.Stagiaires.aggregate([
{"$group":{"_id":"$filiere.intitule",
"moyenne":{"$avg":"$moy1A"}}
}])
for i in resultat:
print(i["moyenne"]," moyenne de la filiere ",i["_id"])resultat ;13.625 moyenne de la filiere Developpement digital
17.25 moyenne de la filiere Infrastructure digitale
None moyenne de la filiere Digital DesignKarima n'a pas de moyenne : $avg donne None pour Digital Design.
Le résumé répète deux fois la même diapositive sur l'agrégation, avec le même exemple. En Python, les opérateurs ("$group", "$avg") doivent être entre guillemets.
Ce que tu vas voir (4 min) : le chapitre « Agrégations ». Il lance une agrégation depuis Python et lit le résultat.
Les requêtes de modification
La syntaxe reste celle du shell MongoDB, avec les noms en snake_case :
Exemple d'insertion :
>>> db.Stagiaires.insert_one({"_id":"12345678","nom":"Jobs","prenom":"Steve","filiere":{"_id":"ID","intitule":"Infrastructure digitale"},"moy1A":14.25,"niveau":"2A","option":"Cloud"})
<pymongo.results.InsertOneResult object at 0x000001D9D93BB4F0>
>>> resultat = db.Stagiaires.find()
>>> for i in resultat[:]:
... print(i)
...{'_id': ObjectId('62e0f02cd55ee92da665d213'), 'nom': 'Alami', 'prenom': 'Amina', …}
{'_id': ObjectId('62e0f02cd55ee92da665d214'), 'nom': 'Ennaim', 'prenom': 'Nidal', …}
{'_id': ObjectId('62e0f02cd55ee92da665d215'), 'nom': 'Alami', 'prenom': 'Salim', …}
{'_id': ObjectId('62e0fe5fd55ee92da665d216'), 'nom': 'Dalil', 'prenom': 'Karima', …}
{'_id': '12345678', 'nom': 'Jobs', 'prenom': 'Steve', 'filiere': {'_id': 'ID', 'intitule': 'Infrastructure digitale'}, 'moy1A': 14.25, 'niveau': '2A', 'option': 'Cloud'}Avec les versions récentes de PyMongo (4.9 et plus), les objets s'affichent un peu autrement : InsertOneResult('12345678', acknowledged=True) pour le résultat de l'insertion, et <pymongo.synchronous.cursor.Cursor object at …> pour un curseur. Le fonctionnement ne change pas.
Steve Jobs a l'identifiant choisi '12345678' ; les autres ont un ObjectId. Si on relance la même insertion, PyMongo lève une erreur DuplicateKeyError : un _id doit être unique.
Le résumé s'arrête à l'insertion. Voici les autres requêtes du tableau, sur le même modèle :
r = db.Stagiaires.insert_many([
{"nom": "Bennani", "prenom": "Yassine", "niveau": "1A"},
{"nom": "Tazi", "prenom": "Hiba", "niveau": "1A"}
])
print(r.inserted_ids) # la liste des 2 ObjectId créés
r = db.Stagiaires.update_one({"_id": "12345678"}, {"$set": {"option": "Cloud Computing"}})
print(r.matched_count, r.modified_count) # 1 1
r = db.Stagiaires.update_many({"niveau": "1A"}, {"$set": {"organisme": "OFPPT"}})
print(r.modified_count) # 3 (Karima, Yassine, Hiba)
r = db.Stagiaires.delete_one({"_id": "12345678"})
print(r.deleted_count) # 1
r = db.Stagiaires.delete_many({"nom": {"$in": ["Bennani", "Tazi"]}})
print(r.deleted_count) # 2Chaque requête renvoie un objet résultat : inserted_id / inserted_ids, matched_count, modified_count, deleted_count. C'est ainsi que le programme vérifie que l'opération a bien eu lieu.
Ce que tu vas voir (7 min) : le chapitre « Insérer un document ». Il insère un document dans une collection depuis Python.
Ajoute à ton programme :
stagiaires_filiere(intitule) qui renvoie la liste des prénoms des stagiaires d'une filière ;moyennes_par_filiere() qui renvoie un dictionnaire {intitulé: moyenne} calculé avec aggregate ;nom, puis l'affichage de tous les index de la collection.