MongoDB_with_python
January 15, 2025
[ ]: #
1 COURS SUR MongoDB
1.1 Module 1 : Introduction à MongoDB
1.2 Objectifs du module
1. Comprendre ce qu’est MongoDB.
2. Comprendre la différence entre bases de données relationnelles et non relation-
nelles.
3. Installer MongoDB et MongoDB Compass (l’interface graphique).
1.3 1. Qu’est-ce que MongoDB ?
MongoDB est une base de données NoSQL orientée documents, ce qui signifie qu’elle ne suit
pas la structure de tables et de lignes comme dans les bases de données relationnelles. Contrairement
à des systèmes comme MySQL ou PostgreSQL, MongoDB est conçu pour stocker et gérer de grandes
quantités de données non structurées, semi-structurées ou à structure flexible.
1.3.1 Caractéristiques principales de MongoDB :
• NoSQL : Non relationnelle, flexible, ne nécessite pas de schéma prédéfini pour les données.
• Orientée document : Les données sont stockées sous forme de documents (format BSON)
plutôt que sous forme de lignes et de colonnes (comme dans SQL).
• Scalabilité horizontale : MongoDB peut gérer une croissance importante des données grâce
à la répartition des données sur plusieurs serveurs (sharding).
• Haute disponibilité : Grâce aux réplicas, MongoDB permet de garantir la disponibilité des
données même en cas de panne d’un serveur.
1.3.2 Pourquoi MongoDB est utilisé ?
• Scalabilité : MongoDB permet de gérer des données qui augmentent rapidement en volume.
Il peut être déployé sur plusieurs serveurs pour supporter une montée en charge horizontale.
• Flexibilité des données : Contrairement aux bases de données relationnelles qui imposent
un schéma rigide, MongoDB permet de stocker des données de types divers (texte, dates,
images, etc.), sans avoir besoin de les structurer au préalable.
1
• Haute disponibilité : MongoDB peut être configuré pour répliquer les données sur plusieurs
serveurs, ce qui assure que les données restent accessibles en cas de défaillance d’un serveur.
1.4 2. Comparaison avec les bases de données relationnelles (SQL)
1.4.1 Bases de données relationnelles (SQL) :
Les bases de données relationnelles sont basées sur le modèle relationnel où les données sont organ-
isées sous forme de tables (lignes et colonnes) avec des clés primaires et étrangères pour établir
des relations entre elles.
Caractéristiques des bases de données relationnelles :
• Schéma rigide : Les tables doivent être définies avec des colonnes fixes, ce qui nécessite une
planification préalable.
• Relations entre tables : Les données sont liées entre elles via des clés primaires et
étrangères.
• SQL (Structured Query Language) : Le langage de requête utilisé pour interagir avec
ces bases de données est le SQL.
Exemple de base de données relationnelle (SQL) : Imaginez une table students qui con-
tient des informations sur les étudiants :
student_id name age course
1 Alice 20 Math
2 Bob 22 Physics
3 Charlie 19 Chemistry
Les relations entre les tables sont gérées par des clés étrangères.
1.4.2 Bases de données NoSQL (comme MongoDB) :
Contrairement aux bases relationnelles, MongoDB utilise une structure orientée document, où les
données sont stockées sous forme de documents JSON (BSON).
Caractéristiques de MongoDB :
• Schéma flexible : Vous n’avez pas à définir de schéma à l’avance. Chaque document peut
avoir des champs différents.
• Données orientées document : Au lieu d’une table, les données sont stockées sous forme
de documents dans des collections.
• Pas de relations complexes : Il n’y a pas de concept direct de jointures. Les données
peuvent être imbriquées directement dans les documents.
2
Exemple de structure de données dans MongoDB : Dans MongoDB, vous pourriez stocker
un document pour un étudiant comme ceci :
“‘json { “_id”: ObjectId(“some_id”), “name”: “Alice”, “age”: 20, “courses”: [“Math”, “Physics”]
}
[2]: from pymongo import MongoClient
# Connexion à MongoDB local
client = MongoClient('mongodb://localhost:27017/')
db = client['school'] # Crée ou se connecte à la base de données 'school'
collection = db['students'] # Crée ou se connecte à la collection 'students'
1.5 Module 2 : Manipulation de données avec MongoDB
1.5.1 Objectifs du module
1. Apprendre à insérer, trouver, mettre à jour et supprimer des documents dans une
base de données MongoDB en utilisant Python et la bibliothèque pymongo.
1.5.2 1. Insertion de documents
Méthodes insertOne() et insertMany() MongoDB vous permet d’insérer des documents
dans une collection en utilisant les méthodes insertOne() pour insérer un seul document et
insertMany() pour insérer plusieurs documents à la fois.
Exemple en Python :
[3]: from pymongo import MongoClient
# Connexion à la base de données
client = MongoClient("mongodb://localhost:27017/") # Remplacez par votre URL␣
↪MongoDB
db = client['School'] # Base de données "School"
collection = db['Students'] # Collection "Students"
[4]: # Insertion d'un seul document
student = {
"name": "Alice",
"age": 20,
"subjects": ["Math", "Physics"]
}
collection.insert_one(student)
[4]: InsertOneResult(ObjectId('678793ac38ac07df65682c06'), acknowledged=True)
[5]: # Insertion de plusieurs documents
students = [
{"name": "Bob", "age": 22, "subjects": ["Chemistry", "Math"]},
3
{"name": "Charlie", "age": 19, "subjects": ["Physics", "Biology"]}
]
collection.insert_many(students)
[5]: InsertManyResult([ObjectId('678793ac38ac07df65682c07'),
ObjectId('678793ac38ac07df65682c08')], acknowledged=True)
1.5.3 2. Recherche de documents
Méthode find() et opérateurs de recherche
La méthode find() vous permet de rechercher plusieurs documents qui correspondent à des critères
spécifiques. Vous pouvez utiliser des opérateurs comme $gt (plus grand que), $lt (moins que), $in
(dans une liste), etc.
[6]: # Trouver tous les étudiants ayant plus de 18 ans
age_filter = {"age": {"$gt": 18}}
students_above_18 = collection.find(age_filter)
for student in students_above_18:
print(student)
# Trouver les étudiants qui suivent des matières spécifiques
subject_filter = {"subjects": {"$in": ["Math"]}}
students_in_math = collection.find(subject_filter)
for student in students_in_math:
print(student)
{'_id': ObjectId('6787905d131a4c6a56db2ebb'), 'name': 'Alice', 'age': 20,
'subjects': ['Math', 'Physics']}
{'_id': ObjectId('67879060131a4c6a56db2ebc'), 'name': 'Bob', 'age': 22,
'subjects': ['Chemistry', 'Math']}
{'_id': ObjectId('67879060131a4c6a56db2ebd'), 'name': 'Charlie', 'age': 19,
'subjects': ['Physics', 'Biology']}
{'_id': ObjectId('678793ac38ac07df65682c06'), 'name': 'Alice', 'age': 20,
'subjects': ['Math', 'Physics']}
{'_id': ObjectId('678793ac38ac07df65682c07'), 'name': 'Bob', 'age': 22,
'subjects': ['Chemistry', 'Math']}
{'_id': ObjectId('678793ac38ac07df65682c08'), 'name': 'Charlie', 'age': 19,
'subjects': ['Physics', 'Biology']}
{'_id': ObjectId('6787905d131a4c6a56db2ebb'), 'name': 'Alice', 'age': 20,
'subjects': ['Math', 'Physics']}
{'_id': ObjectId('67879060131a4c6a56db2ebc'), 'name': 'Bob', 'age': 22,
'subjects': ['Chemistry', 'Math']}
{'_id': ObjectId('678793ac38ac07df65682c06'), 'name': 'Alice', 'age': 20,
'subjects': ['Math', 'Physics']}
{'_id': ObjectId('678793ac38ac07df65682c07'), 'name': 'Bob', 'age': 22,
'subjects': ['Chemistry', 'Math']}
4
1.5.4 Méthode findOne()
La méthode findOne() est utilisée pour obtenir un seul document correspondant aux
critères spécifiés. #### Exemple en Python :
[7]: # Trouver un seul étudiant avec le nom "Alice"
student_alice = collection.find_one({"name": "Alice"})
print(student_alice)
{'_id': ObjectId('6787905d131a4c6a56db2ebb'), 'name': 'Alice', 'age': 20,
'subjects': ['Math', 'Physics']}
1.5.5 3. Mise à jour de documents
Méthodes updateOne() et updateMany()
Les méthodes updateOne() et updateMany() vous permettent de mettre à jour un ou plusieurs
documents dans une collection. #### Exemple en Python :
[8]: # Mettre à jour un seul document : Ajouter une nouvelle matière à "Alice"
collection.update_one(
{"name": "Alice"},
{"$push": {"subjects": "Computer Science"}}
)
# Mettre à jour plusieurs documents : Augmenter l'âge de tous les étudiants de␣
↪1 an
collection.update_many(
{"age": {"$lt": 25}}, # Sélectionner les étudiants de moins de 25 ans
{"$inc": {"age": 1}} # Incrémenter l'âge de 1
)
[8]: UpdateResult({'n': 6, 'nModified': 6, 'ok': 1.0, 'updatedExisting': True},
acknowledged=True)
Opérateurs de mise à jour $set : Met à jour le champ spécifié avec une nouvelle
valeur.
$inc : Incrémente une valeur numérique.
$push : Ajoute un élément à un tableau.
$pull : Retire un élément d’un tableau.
1.5.6 4. Suppression de documents
Méthodes deleteOne() et deleteMany()
Les méthodes deleteOne() et deleteMany() permettent de supprimer un ou plusieurs documents de
la collection. #### Exemple en Python :
[9]: # Supprimer un seul document : Supprimer l'étudiant "Alice"
collection.delete_one({"name": "Alice"})
5
# Supprimer plusieurs documents : Supprimer tous les étudiants âgés de plus de␣
↪25 ans
collection.delete_many({"age": {"$gt": 25}})
[9]: DeleteResult({'n': 0, 'ok': 1.0}, acknowledged=True)
1.6 Module 3 : Gestion des index et des performances avec MongoDB
1.6.1 Objectifs du module
1. Comprendre le rôle des index dans MongoDB pour améliorer les performances des
requêtes.
2. Apprendre à créer, gérer et supprimer des index dans MongoDB.
3. Optimiser les performances des requêtes à l’aide des index et des outils d’analyse.
1.6.2 1. Les index dans MongoDB
Qu’est-ce qu’un index ? Un index est une structure de données qui permet d’accélérer les
recherches dans une base de données. MongoDB utilise des index pour améliorer les performances
des requêtes en permettant d’éviter les scans complets de collections.
Par défaut, MongoDB crée un index sur le champ _id pour chaque document. Toutefois, pour
améliorer les performances des requêtes sur d’autres champs, vous pouvez créer des index supplé-
mentaires.
Types d’index
1. Index simple : Un index sur un seul champ. Par exemple, un index sur le champ name dans
la collection Students.
2. Index composé : Un index sur plusieurs champs. Utilisé pour les requêtes qui filtrent sur
plusieurs critères.
3. Index unique : Garantit que les valeurs dans un champ indexé sont uniques (comme sur le
champ _id).
4. Index multiclés : Utilisé pour indexer des tableaux (arrays).
5. Index géospatial : Utilisé pour les requêtes qui impliquent des données géographiques.
1.6.3 2. Création et suppression d’index
Création d’un index La création d’un index dans MongoDB se fait avec la méthode
create_index(). Voici comment créer un index simple et un index composé.
Exemple en Python :
[10]: from pymongo import MongoClient
# Connexion à MongoDB
6
client = MongoClient("mongodb://localhost:27017/")
db = client['School']
collection = db['Students']
# Création d'un index sur le champ "name"
collection.create_index([("name", 1)]) # 1 pour l'ordre croissant
# Création d'un index composé sur les champs "age" et "subjects"
collection.create_index([("age", 1), ("subjects", 1)])
[10]: 'age_1_subjects_1'
1.6.4 Suppression d’un index
Pour supprimer un index, utilisez la méthode drop_index(), en spécifiant l’index à
supprimer. #### Exemple en Python :
[11]: # Supprimer l'index sur le champ "name"
collection.drop_index([("name", 1)])
# Supprimer tous les index de la collection (sauf _id)
collection.drop_indexes()
1.6.5 3. Optimisation des performances des requêtes
Analyse des performances avec explain()
MongoDB permet d’analyser l’exécution d’une requête grâce à la méthode explain(). Cette méthode
fournit des informations sur la façon dont MongoDB exécute une requête, y compris les index
utilisés. ##### Exemple en Python :
[12]: # Utiliser explain() pour analyser une requête
query = {"age": {"$gt": 20}}
explanation = collection.find(query).explain()
# Afficher l'explication de la requête
print(explanation)
{'explainVersion': '1', 'queryPlanner': {'namespace': 'School.Students',
'parsedQuery': {'age': {'$gt': 20}}, 'indexFilterSet': False,
'planCacheShapeHash': 'CCB4CABA', 'planCacheKey': 'F26D2852',
'optimizationTimeMillis': 0, 'maxIndexedOrSolutionsReached': False,
'maxIndexedAndSolutionsReached': False, 'maxScansToExplodeReached': False,
'prunedSimilarIndexes': False, 'winningPlan': {'isCached': False, 'stage':
'COLLSCAN', 'filter': {'age': {'$gt': 20}}, 'direction': 'forward'},
'rejectedPlans': []}, 'executionStats': {'executionSuccess': True, 'nReturned':
3, 'executionTimeMillis': 4, 'totalKeysExamined': 0, 'totalDocsExamined': 5,
'executionStages': {'isCached': False, 'stage': 'COLLSCAN', 'filter': {'age':
{'$gt': 20}}, 'nReturned': 3, 'executionTimeMillisEstimate': 0, 'works': 6,
7
'advanced': 3, 'needTime': 2, 'needYield': 0, 'saveState': 0, 'restoreState': 0,
'isEOF': 1, 'direction': 'forward', 'docsExamined': 5}, 'allPlansExecution':
[]}, 'queryShapeHash':
'D771FDA8A4698FAE631AEED240EF45E229B4BFFD0482C79EF0977F84BD93F6AD', 'command':
{'find': 'Students', 'filter': {'age': {'$gt': 20}}, '$db': 'School'},
'serverInfo': {'host': 'DESKTOP-04PE08F', 'port': 27017, 'version': '8.0.4',
'gitVersion': 'bc35ab4305d9920d9d0491c1c9ef9b72383d31f9'}, 'serverParameters':
{'internalQueryFacetBufferSizeBytes': 104857600,
'internalQueryFacetMaxOutputDocSizeBytes': 104857600,
'internalLookupStageIntermediateDocumentMaxSizeBytes': 104857600,
'internalDocumentSourceGroupMaxMemoryBytes': 104857600,
'internalQueryMaxBlockingSortMemoryUsageBytes': 104857600,
'internalQueryProhibitBlockingMergeOnMongoS': 0,
'internalQueryMaxAddToSetBytes': 104857600,
'internalDocumentSourceSetWindowFieldsMaxMemoryBytes': 104857600,
'internalQueryFrameworkControl': 'trySbeRestricted',
'internalQueryPlannerIgnoreIndexWithCollationForRegex': 1}, 'ok': 1.0}
[16]: from faker import Faker
fake = Faker()
# Générer 1000 étudiants fictifs
students_data = []
for _ in range(1000):
student = {
"name": fake.name(),
"age": fake.random_int(min=18, max=30),
"courses": [fake.word(), fake.word()]
}
students_data.append(student)
# Afficher les 5 premiers éléments pour vérifier
students_data[:5]
[16]: [{'name': 'Edward Holder', 'age': 27, 'courses': ['arrive', 'suffer']},
{'name': 'Rhonda Warren', 'age': 20, 'courses': ['physical', 'on']},
{'name': 'Thomas Anderson', 'age': 26, 'courses': ['success', 'since']},
{'name': 'Mrs. Rachel Rowe', 'age': 28, 'courses': ['soldier', 'attack']},
{'name': 'Matthew Chavez', 'age': 23, 'courses': ['top', 'final']}]
[17]: from pymongo import MongoClient
# Connexion à MongoDB (assurez-vous que MongoDB est en cours d'exécution sur␣
↪localhost)
client = MongoClient('mongodb://localhost:27017/')
8
# Accéder à la base de données 'school' ou la créer si elle n'existe pas
db = client['school']
# Créer ou accéder à la collection 'students'
students_collection = db['students']
[20]: # Supprimer la base de données existante 'School' si nécessaire
client.drop_database('School')
[21]: from pymongo import MongoClient
from faker import Faker
# Connexion à MongoDB
client = MongoClient('mongodb://localhost:27017/')
# Supprimer la base de données existante 'School' (si elle existe)
client.drop_database('School')
# Créer ou accéder à la base de données 'school' (en minuscules)
db = client['school']
# Créer ou accéder à la collection 'students'
students_collection = db['students']
# Générer 1000 étudiants fictifs
fake = Faker()
students_data = []
for _ in range(1000):
student = {
"name": fake.name(),
"age": fake.random_int(min=18, max=30),
"courses": [fake.word(), fake.word()]
}
students_data.append(student)
# Insérer les 1000 étudiants dans MongoDB
students_collection.insert_many(students_data)
# Vérification - afficher les 5 premiers étudiants insérés
for student in students_collection.find().limit(5):
print(student)
{'_id': ObjectId('6787a73b38ac07df656833dd'), 'name': 'Misty Dennis', 'age': 24,
'courses': ['reduce', 'sure']}
{'_id': ObjectId('6787a73b38ac07df656833de'), 'name': 'Elizabeth Moore', 'age':
18, 'courses': ['raise', 'spend']}
{'_id': ObjectId('6787a73b38ac07df656833df'), 'name': 'Dana Wilson', 'age': 29,
'courses': ['difficult', 'several']}
9
{'_id': ObjectId('6787a73b38ac07df656833e0'), 'name': 'Christopher Parker',
'age': 19, 'courses': ['future', 'difference']}
{'_id': ObjectId('6787a73b38ac07df656833e1'), 'name': 'Emily Morrow', 'age': 28,
'courses': ['wear', 'mean']}
1.6.6 Inserer les données
[22]: student = {
"name": "John Doe",
"age": 20,
"courses": ["Mathematics", "Physics"]
}
students_collection.insert_one(student)
[22]: InsertOneResult(ObjectId('6787a88438ac07df656837c5'), acknowledged=True)
Exemple d’insertion de plusieurs documents :
[23]: students_data = [
{"name": "Jane Doe", "age": 22, "courses": ["Biology", "Chemistry"]},
{"name": "Sam Smith", "age": 19, "courses": ["History", "English"]}
]
students_collection.insert_many(students_data)
[23]: InsertManyResult([ObjectId('6787a8b238ac07df656837c6'),
ObjectId('6787a8b238ac07df656837c7')], acknowledged=True)
1.7 Rechercher des documents
Pour rechercher des documents, utilisez la méthode find(). Vous pouvez passer un
filtre pour spécifier quels documents rechercher. Recherche de tous les documents :
[41]: for student in students_collection.find().limit(5):
print(student)
{'_id': ObjectId('6787a73b38ac07df656833dd'), 'name': 'Misty Dennis', 'age': 24,
'courses': ['reduce', 'sure']}
{'_id': ObjectId('6787a73b38ac07df656833df'), 'name': 'Dana Wilson', 'age': 29,
'courses': ['difficult', 'several']}
{'_id': ObjectId('6787a73b38ac07df656833e1'), 'name': 'Emily Morrow', 'age': 28,
'courses': ['wear', 'mean']}
{'_id': ObjectId('6787a73b38ac07df656833e2'), 'name': 'Melissa Douglas', 'age':
23, 'courses': ['development', 'meet']}
{'_id': ObjectId('6787a73b38ac07df656833e4'), 'name': 'Michelle Payne', 'age':
24, 'courses': ['growth', 'staff']}
Recherche avec un filtre (ex. étudiants de plus de 18 ans) :
10
[42]: query = {"age": {"$gt": 18}} # Trouver les étudiants ayant plus de 18 ans
for student in students_collection.find(query).limit(5):
print(student)
{'_id': ObjectId('6787a73b38ac07df656833dd'), 'name': 'Misty Dennis', 'age': 24,
'courses': ['reduce', 'sure']}
{'_id': ObjectId('6787a73b38ac07df656833df'), 'name': 'Dana Wilson', 'age': 29,
'courses': ['difficult', 'several']}
{'_id': ObjectId('6787a73b38ac07df656833e1'), 'name': 'Emily Morrow', 'age': 28,
'courses': ['wear', 'mean']}
{'_id': ObjectId('6787a73b38ac07df656833e2'), 'name': 'Melissa Douglas', 'age':
23, 'courses': ['development', 'meet']}
{'_id': ObjectId('6787a73b38ac07df656833e4'), 'name': 'Michelle Payne', 'age':
24, 'courses': ['growth', 'staff']}
Recherche d’un seul document avec find_one() :
[26]: student = students_collection.find_one({"name": "John Doe"})
print(student)
{'_id': ObjectId('6787a88438ac07df656837c5'), 'name': 'John Doe', 'age': 20,
'courses': ['Mathematics', 'Physics']}
1.8 Mise à jour de documents
Pour mettre à jour des documents, utilisez les méthodes update_one() ou up-
date_many(). ### Exemple de mise à jour d’un seul document :
[27]: students_collection.update_one(
{"name": "John Doe"}, # Filtre
{"$set": {"age": 21}} # Mise à jour (ici, on change l'âge)
)
[27]: UpdateResult({'n': 1, 'nModified': 1, 'ok': 1.0, 'updatedExisting': True},
acknowledged=True)
Exemple de mise à jour de plusieurs documents :
[28]: students_collection.update_many(
{"age": {"$lt": 20}}, # Filtre pour trouver les étudiants de moins de 20␣
↪ans
{"$set": {"status": "Minor"}} # Mise à jour : ajout d'un champ "status"
)
[28]: UpdateResult({'n': 155, 'nModified': 155, 'ok': 1.0, 'updatedExisting': True},
acknowledged=True)
11
1.9 Suppression de documents
Pour supprimer des documents, vous pouvez utiliser delete_one() ou delete_many().
### Suppression d’un seul document :
[29]: students_collection.delete_one({"name": "John Doe"})
[29]: DeleteResult({'n': 1, 'ok': 1.0}, acknowledged=True)
1.9.1 Suppression de plusieurs documents :
[30]: students_collection.delete_many({"age": {"$lt": 20}})
[30]: DeleteResult({'n': 155, 'ok': 1.0}, acknowledged=True)
1.10 Requêtes d’agrégation
Les requêtes d’agrégation permettent de réaliser des opérations plus complexes,
comme le filtrage, la transformation ou le calcul sur les données. La méthode
d’agrégation principale est aggregate(). ### 2.1. Filtrer et regrouper
Par exemple, pour obtenir le nombre d’étudiants par âge, vous pouvez utiliser l’agrégation avec
$group et $count.
[31]: pipeline = [
{"$group": {"_id": "$age", "count": {"$sum": 1}}} # Grouper par âge et␣
↪compter
]
result = students_collection.aggregate(pipeline)
for r in result:
print(r)
{'_id': 24, 'count': 87}
{'_id': 27, 'count': 58}
{'_id': 21, 'count': 74}
{'_id': 25, 'count': 85}
{'_id': 30, 'count': 64}
{'_id': 26, 'count': 74}
{'_id': 22, 'count': 79}
{'_id': 29, 'count': 90}
{'_id': 23, 'count': 74}
{'_id': 28, 'count': 84}
{'_id': 20, 'count': 78}
1.10.1 Filtrage et projection
Si vous souhaitez filtrer et seulement afficher certains champs, vous pouvez utiliser
$project.
12
[43]: pipeline = [
{"$match": {"age": {"$gt": 18}}}, # Filtrer pour les étudiants de plus de␣
↪18 ans
{"$project": {"name": 1, "age": 1}}, # Projeter seulement les champs␣
↪'name' et 'age'
{"$limit": 5} # Limiter à 5 résultats
]
result = students_collection.aggregate(pipeline)
for r in result:
print(r)
{'_id': ObjectId('6787a73b38ac07df656833dd'), 'name': 'Misty Dennis', 'age': 24}
{'_id': ObjectId('6787a73b38ac07df656833df'), 'name': 'Dana Wilson', 'age': 29}
{'_id': ObjectId('6787a73b38ac07df656833e1'), 'name': 'Emily Morrow', 'age': 28}
{'_id': ObjectId('6787a73b38ac07df656833e2'), 'name': 'Melissa Douglas', 'age':
23}
{'_id': ObjectId('6787a73b38ac07df656833e4'), 'name': 'Michelle Payne', 'age':
24}
1.11 Ordre de tri (sort)
Vous pouvez également trier les résultats avec $sort. Par exemple, pour trier les
étudiants par âge :
[46]: pipeline = [
{"$sort": {"age": 1}}, # Trier les étudiants par âge en ordre croissant
{"$limit": 5} # Limiter à 5 résultats
]
result = students_collection.aggregate(pipeline)
for r in result:
print(r)
{'_id': ObjectId('6787a73b38ac07df65683410'), 'name': 'Ashley Greer', 'age': 20,
'courses': ['artist', 'into']}
{'_id': ObjectId('6787a73b38ac07df6568340b'), 'name': 'Curtis Lopez', 'age': 20,
'courses': ['computer', 'have']}
{'_id': ObjectId('6787a73b38ac07df65683439'), 'name': 'Tony Brown', 'age': 20,
'courses': ['imagine', 'eye']}
{'_id': ObjectId('6787a73b38ac07df65683428'), 'name': 'Gina Kelley', 'age': 20,
'courses': ['small', 'think']}
{'_id': ObjectId('6787a73b38ac07df656833fd'), 'name': 'Lisa Fowler', 'age': 20,
'courses': ['paper', 'somebody']}
13
1.12 Limite et saut (limit et skip)
Vous pouvez limiter le nombre de résultats ou sauter certains résultats avec $limit et
$skip.
[34]: pipeline = [
{"$limit": 5} # Limiter à 5 premiers résultats
]
result = students_collection.aggregate(pipeline)
for r in result:
print(r)
{'_id': ObjectId('6787a73b38ac07df656833dd'), 'name': 'Misty Dennis', 'age': 24,
'courses': ['reduce', 'sure']}
{'_id': ObjectId('6787a73b38ac07df656833df'), 'name': 'Dana Wilson', 'age': 29,
'courses': ['difficult', 'several']}
{'_id': ObjectId('6787a73b38ac07df656833e1'), 'name': 'Emily Morrow', 'age': 28,
'courses': ['wear', 'mean']}
{'_id': ObjectId('6787a73b38ac07df656833e2'), 'name': 'Melissa Douglas', 'age':
23, 'courses': ['development', 'meet']}
{'_id': ObjectId('6787a73b38ac07df656833e4'), 'name': 'Michelle Payne', 'age':
24, 'courses': ['growth', 'staff']}
[35]: pipeline = [
{"$skip": 5}, # Sauter les 5 premiers résultats
{"$limit": 5} # Limiter ensuite à 5 résultats après avoir sauté les 5␣
↪premiers
]
result = students_collection.aggregate(pipeline)
for r in result:
print(r)
{'_id': ObjectId('6787a73b38ac07df656833e6'), 'name': 'Lawrence Brewer', 'age':
24, 'courses': ['major', 'probably']}
{'_id': ObjectId('6787a73b38ac07df656833e7'), 'name': 'Robin Bentley', 'age':
24, 'courses': ['measure', 'television']}
{'_id': ObjectId('6787a73b38ac07df656833e8'), 'name': 'Karen Glenn', 'age': 30,
'courses': ['any', 'investment']}
{'_id': ObjectId('6787a73b38ac07df656833e9'), 'name': 'Travis Fuller', 'age':
30, 'courses': ['phone', 'yard']}
{'_id': ObjectId('6787a73b38ac07df656833ea'), 'name': 'Michael Ellis', 'age':
26, 'courses': ['attention', 'but']}
1.13 Agrégation avec plusieurs étapes
Vous pouvez combiner plusieurs étapes d’agrégation dans un même pipeline. ###
Par exemple, pour trouver les étudiants de plus de 18 ans, les trier par âge et n’afficher que les 5
14
premiers résultats :
[36]: pipeline = [
{"$match": {"age": {"$gt": 18}}}, # Filtrer les étudiants de plus de 18 ans
{"$sort": {"age": 1}}, # Trier par âge
{"$limit": 5} # Limiter à 5 résultats
]
result = students_collection.aggregate(pipeline)
for r in result:
print(r)
{'_id': ObjectId('6787a73b38ac07df65683410'), 'name': 'Ashley Greer', 'age': 20,
'courses': ['artist', 'into']}
{'_id': ObjectId('6787a73b38ac07df6568340b'), 'name': 'Curtis Lopez', 'age': 20,
'courses': ['computer', 'have']}
{'_id': ObjectId('6787a73b38ac07df65683439'), 'name': 'Tony Brown', 'age': 20,
'courses': ['imagine', 'eye']}
{'_id': ObjectId('6787a73b38ac07df65683428'), 'name': 'Gina Kelley', 'age': 20,
'courses': ['small', 'think']}
{'_id': ObjectId('6787a73b38ac07df656833fd'), 'name': 'Lisa Fowler', 'age': 20,
'courses': ['paper', 'somebody']}
1.14 Calculs avec $avg, $sum, etc.
Vous pouvez également effectuer des calculs dans le cadre de l’agrégation, par exemple
pour calculer la moyenne d’âge des étudiants.
[37]: pipeline = [
{"$group": {"_id": None, "average_age": {"$avg": "$age"}}} # Calcul de␣
↪l'âge moyen
]
result = students_collection.aggregate(pipeline)
for r in result:
print(r)
{'_id': None, 'average_age': 24.95749704840614}
[ ]:
15
