MongoDB is a NoSQL database that offers flexibility and scalability, making it a popular choice for many developers. Unlike traditional SQL databases, which rely on a rigid schema, MongoDB uses a document-oriented data model. This means that data is stored in JSON-like documents, which can have varying structures. It allows for nested data and arrays, making it particularly suited for applications that require dynamic and complex data.
To interact with MongoDB using Python, we typically use a library known as pymongo. This library provides a rich set of functionalities to connect to a MongoDB database and perform various operations. To get started, you’ll need to install pymongo if you haven’t already.
pip install pymongo
Once installed, you can connect to your MongoDB server. By default, MongoDB runs on port 27017. Here’s how you can establish a connection:
from pymongo import MongoClient
# Create a MongoClient to the running mongod instance
client = MongoClient('localhost', 27017)
# Access the database
db = client.mydatabase
With the client established and a database selected, you can start working with collections. Collections are essentially the equivalent of tables in SQL. They hold documents, which are the individual records. Here’s how you can create a collection:
# Create a collection collection = db.mycollection
Now that you have a collection, it’s worthwhile to understand how to perform various operations. One of the core principles of MongoDB is its ability to handle CRUD operations-Create, Read, Update, and Delete. Each of these operations can be performed easily with pymongo.
WHOOP 5.0/MG Activity Tracker - 12 Month Membership - Health and Fitness Wearable – 24/7 Activity and Sleep Tracker, Personalized Coaching, Menstrual Cycle Insights – 14+ Days Battery Life
$239.00 (as of July 17, 2026 15:16 GMT +00:00 - More infoProduct prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on [relevant Amazon Site(s), as applicable] at the time of purchase will apply to the purchase of this product.)Creating your first database and collection
One of the interesting things about MongoDB is that databases and collections are created lazily. This means they aren’t actually created until you insert the first document into them. In the previous example, neither mydatabase nor mycollection physically exist on the server yet. They are just objects in our Python code. The moment we add data, MongoDB springs into action and creates them for us. This is a neat feature that saves you from having to run explicit CREATE DATABASE or CREATE TABLE commands like you would in the SQL world.
Let’s insert our first document. A document in pymongo is just a standard Python dictionary. The keys are strings, and the values can be various data types that map to BSON types, like strings, numbers, booleans, lists, and even other dictionaries.
# A sample document
post = {
"author": "Mike",
"text": "My first blog post!",
"tags": ["mongodb", "python", "pymongo"],
"date": "2024-01-01"
}
# Insert the document into the collection
post_id = collection.insert_one(post).inserted_id
print(f"First post inserted with id: {post_id}")
The insert_one() method returns an instance of InsertOneResult. We are accessing its inserted_id attribute to get the unique _id of the document we just inserted. MongoDB automatically adds an _id field to every document if you don’t provide one yourself. This _id must be unique within the collection and acts as the primary key. It’s usually an ObjectId, which is a special 12-byte BSON type that guarantees uniqueness across your entire distributed system, which is pretty clever.
Of course, you’ll often want to insert more than one document at a time. Doing this in a loop with insert_one() would be inefficient because each call would involve a round trip to the database server. For this, pymongo provides the insert_many() method, which takes a list of dictionaries.
# A list of new documents
new_posts = [
{
"author": "Mike",
"text": "Another post!",
"tags": ["bulk", "insert"],
"date": "2024-01-02"
},
{
"author": "Eliot",
"text": "MongoDB is fun",
"tags": ["mongodb", "developer"],
"date": "2024-01-03"
}
]
# Insert the list of documents
result = collection.insert_many(new_posts)
print(f"Inserted post IDs: {result.inserted_ids}")
Similar to insert_one(), the insert_many() method returns an instance of InsertManyResult. The list of generated _id values is available through the inserted_ids attribute. This bulk operation is significantly faster for inserting large amounts of data. Now that we have some data in our collection, the next logical step is to figure out how to get it back out. This is the “Read” part of CRUD.
Performing CRUD operations in MongoDB with pymongo
To retrieve data, you have two primary methods: find_one() to get a single document, and find() to get multiple documents. The find_one() method is straightforward; it returns the first document that matches a query, or None if no match is found. The query itself is specified as a dictionary, where you define the criteria for the fields you want to match.
# Find a single document authored by "Mike"
mikes_post = collection.find_one({"author": "Mike"})
print(mikes_post)
This will find one of the documents we inserted earlier. If you need to find a document by its unique _id, you’ll have to import ObjectId from the bson.objectid module, since the ID is not a simple string.
from bson.objectid import ObjectId
# Find a document by its _id (replace with an actual ID from your collection)
post_by_id = collection.find_one({"_id": ObjectId("your_object_id_here")})
To retrieve multiple documents, you use the find() method. This is where things get interesting. The find() method doesn’t return a list of documents. Instead, it returns a Cursor instance. This is a smart design choice. If your query matched a million documents, loading them all into memory at once would be a disaster. The cursor is like a pointer to the result set on the server. You iterate over it, and pymongo fetches the documents from the server in batches, which is much more memory-efficient.
# Find all posts by Mike
for post in collection.find({"author": "Mike"}):
print(post)
You can also build more complex queries. For example, to find all documents where the tags array contains the value “mongodb”, you can query the array directly.
# Find all posts tagged with "mongodb"
for post in collection.find({"tags": "mongodb"}):
print(post['text'])
Now for the “Update” part of CRUD. You can modify existing documents using update_one() and update_many(). These methods take two arguments: a query filter to select the document(s) to update, and an update document that specifies the modifications. It’s critical to use MongoDB’s update operators, like $set, to modify specific fields.
# Update a single document. Let's change Eliot's post.
result = collection.update_one(
{"author": "Eliot"},
{"$set": {"text": "MongoDB is really fun and powerful"}}
)
print(f"Matched {result.matched_count} document(s) and modified {result.modified_count} document(s).")
Notice the $set operator. This is crucial. If you forget it and just pass a dictionary like {"text": "..."}, MongoDB will replace the *entire* document with your new one, wiping out all other fields like author, tags, and the all-important _id. The update operators are your safety net. To update multiple documents at once, you use update_many().
# Add a new field to all of Mike's posts
result = collection.update_many(
{"author": "Mike"},
{"$set": {"status": "published"}}
)
print(f"Matched {result.matched_count} document(s) and modified {result.modified_count} document(s).")
Finally, we have the “Delete” operations. As you might guess, the methods are delete_one() and delete_many(), and they work similarly to the update methods, taking a query filter to specify which documents to remove.
# Delete a single document from Eliot
result = collection.delete_one({"author": "Eliot"})
print(f"Deleted {result.deleted_count} document.")
# Delete all documents from Mike
result = collection.delete_many({"author": "Mike"})
print(f"Deleted {result.deleted_count} documents.")
Both methods return a DeleteResult object, which contains a deleted_count attribute telling you how many documents were removed. If you wanted to wipe out an entire collection, you could pass an empty dictionary {} to delete_many(), which matches all documents. Be careful with that one.
