Introduction to Using PyMongo for a Student Enrollment Database

Dr. Pythonic Excel

Lecture: Introduction to Using PyMongo for a Student Enrollment Database

Part 1: Introduction and Setup

What Is PyMongo?

PyMongo is a Python distribution containing tools for working with MongoDB, which is a document-based, NoSQL database designed for ease of development and scaling. One of the primary features of MongoDB is that it stores data in flexible, JSON-like documents, meaning fields can vary from document to document and data structure can be changed over time.
PyMongo allows Python developers to perform database operations such as inserting, updating, and deleting data, as well as querying for data by constructing Python dictionaries that represent MongoDB queries.

Why Use MongoDB for a Student Enrollment Database?

MongoDB's flexible data model is well-suited for storing varied student data, which can include basic information like names and addresses, as well as more complex data types such as test scores and class schedules. MongoDB's schema-less model accommodates changes as the academic program evolves.


Before we begin, ensure you have the following installed:
Python (preferably 3.6 or higher)
MongoDB server (local or cloud-based, such as MongoDB Atlas)
PyMongo library (can be installed using pip)
pip install pymongo

Starting MongoDB

If you're running a MongoDB server locally, start it using the following command:
Make sure the MongoDB service is running in the background before you try to connect to it using PyMongo.

Part 2: Creating the Database and Collections

Connecting to MongoDB

To use PyMongo, we first need to establish a connection to our MongoDB server.
Upgrade to with pip install --upgrade openai

from pymongo import MongoClient

# Establishing a connection to the MongoDB server
client = MongoClient('localhost', 27017)

Creating the Student Enrollment Database

With the connection established, we create a new database for our student enrollment system.
Upgrade to with pip install --upgrade openai
# Creating a new database called 'enrollment'
db = client['enrollment']

Defining Collections

In MongoDB, a collection is analogous to a table in relational databases. Our student enrollment database might include collections such as students, courses, enrollments, and instructors.
Upgrade to with pip install --upgrade openai

# Creating collections
students = db['students']
courses = db['courses']
enrollments = db['enrollments']
instructors = db['instructors']

Part 3: Schema Design

MongoDB does not require a fixed schema, but it's best practice to design our document structure to reflect the relationships between data.

Students Collection

Each student document might be structured as follows:

"_id": "<ObjectId>",
"student_id": "s1001",
"name": {
"first": "John",
"last": "Doe"
"email": "",
"courses_enrolled": []

Courses Collection

Each course document might be structured as follows:

"_id": "<ObjectId>",
"course_id": "c1001",
"title": "Introduction to Python",
"description": "A beginner course on Python programming.",
"instructor": "<Instructor ObjectId>",
"students_enrolled": []

Enrollments Collection

The enrollments collection will link students and courses.
"_id": "<ObjectId>",
"student_id": "<Student ObjectId>",
"course_id": "<Course ObjectId>",
"enrollment_date": "<ISODate>"

Instructors Collection

Each instructor document might be structured as follows:
"_id": "<ObjectId>",
"instructor_id": "i1001",
"name": {
"first": "Alice",
"last": "Smith"
"email": "",
"courses_teaching": []

Part 4: Inserting and Querying Data

Inserting Data

To insert data, we can use the insert_one() or insert_many() methods.
Upgrade to with pip install --upgrade openai
# Inserting a single document into the students collection
new_student = {
"student_id": "s1001",
"name": {
"first": "John",
"last": "Doe"
"email": "",
"courses_enrolled": []

Querying Data

For querying, we can use the find() or find_one() methods to retrieve documents matching our criteria.
Upgrade to with pip install --upgrade openai
# Finding a single student by student_id
student = students.find_one({"student_id": "s1001"})

Lab Exercises

Now that you have a broad overview of how PyMongo works together with MongoDB to manage a student enrollment database, let's move on to the hands-on lab exercises. These exercises are designed to reinforce your understanding and provide practical experience.

Lab 1: Setup Your Environment

Install MongoDB locally or set up a MongoDB Atlas cluster.
Install PyMongo using pip.
Start the MongoDB server.
Test the connection in a Python script using PyMongo.

Lab 2: Database and Collections Creation

Create a Python script to establish a connection to MongoDB.
Use PyMongo to create a new database called "enrollment".
Define collections for students, courses, enrollments, and instructors.

Lab 3: Insert Data into Collections

Define Python dictionaries for at least two instances of each: students, courses, instructors.
Insert these dictionaries into the respective collections.
Verify that the data has been inserted by querying each collection.

Lab 4: Querying and Updating Data

Retrieve all students enrolled in a particular course.
Update a student's email address.
Insert a new course and enroll a student in it.
Remove a student from a course's enrollment list.

Lab 5: Advanced Queries and Aggregation

Use aggregation to count the number of students enrolled in each course.
Find all instructors who teach more than one course.
Submit your Python scripts and the output of each lab exercise for review and feedback.
With these lectures and lab exercises, you will gain a hands-on understanding of how to use PyMongo to create and manage a student enrollment database.
This knowledge will be crucial for developing real-world applications that require efficient and flexible data management.

Want to print your doc?
This is not the way.
Try clicking the ⋯ next to your doc name or using a keyboard shortcut (
) instead.