Python MongoDB

MongoDB is one of the most popular NoSQL databases, widely used for its scalability, flexibility, and performance. Integrating MongoDB with Python allows developers to efficiently manage and query unstructured data. This guide will help you get started with Python and MongoDB, exploring the essential operations and best practices.

At The Coding College, we simplify coding concepts to help you excel in your programming journey.

What is MongoDB?

MongoDB is a NoSQL database that stores data in a flexible, JSON-like format called BSON. Unlike traditional SQL databases, MongoDB does not rely on rigid schemas, making it ideal for modern applications requiring fast and dynamic data handling.

Prerequisites

To follow this tutorial, ensure you have:

  1. Python Installed: Download from python.org.
  2. MongoDB Installed: Install MongoDB from mongodb.com.
  3. pymongo Installed: Use the following command to install the Python MongoDB driver: 
pip install pymongo

Setting Up MongoDB with Python

Step 1: Connecting to MongoDB

The pymongo library allows Python to interact with MongoDB. Start by creating a connection:

import pymongo

# Connect to the MongoDB server
client = pymongo.MongoClient("mongodb://localhost:27017/")

# Check available databases
print(client.list_database_names())

Replace "mongodb://localhost:27017/" with your MongoDB server address if it’s hosted remotely.

Step 2: Creating a Database

MongoDB databases are created dynamically when you insert data into them.

# Create or access a database
db = client["mydatabase"]

# Check available collections
print(db.list_collection_names())

Step 3: Creating a Collection

Collections in MongoDB are equivalent to tables in SQL databases.

# Create or access a collection
collection = db["customers"]

CRUD Operations in MongoDB

1. Insert Data

Insert a single document into a collection:

# Insert a single document
customer = {"name": "John", "address": "123 Elm St"}
collection.insert_one(customer)

Insert multiple documents:

# Insert multiple documents
customers = [
    {"name": "Alice", "address": "456 Oak St"},
    {"name": "Bob", "address": "789 Pine St"}
]
collection.insert_many(customers)

2. Read Data

Retrieve all documents:

# Find all documents
for doc in collection.find():
    print(doc)

Query specific documents:

# Find documents with a specific condition
query = {"address": "123 Elm St"}
result = collection.find(query)

for doc in result:
    print(doc)

3. Update Data

Update a single document:

# Update a document
query = {"name": "John"}
new_values = {"$set": {"address": "321 Maple St"}}
collection.update_one(query, new_values)

Update multiple documents:

# Update multiple documents
query = {"name": {"$regex": "^A"}}
new_values = {"$set": {"address": "Updated Address"}}
collection.update_many(query, new_values)

4. Delete Data

Delete a single document:

# Delete a document
query = {"name": "John"}
collection.delete_one(query)

Delete multiple documents:

# Delete multiple documents
query = {"name": {"$regex": "^A"}}
collection.delete_many(query)

Advanced MongoDB Operations

Sorting Data

Sort documents by a specific field:

# Sort by name in ascending order
for doc in collection.find().sort("name", 1):
    print(doc)

Limiting Results

Limit the number of documents returned:

# Limit results to 2 documents
for doc in collection.find().limit(2):
    print(doc)

Working with Indexes

Indexes improve query performance in MongoDB:

# Create an index on the "name" field
collection.create_index("name")

Exercises

  1. Insert Data: Create a products collection and insert 5 product details.
  2. Query Data: Retrieve all products where the price is greater than $50.
  3. Update Data: Update the stock value of a specific product.
  4. Delete Data: Remove all products with a stock of zero.

Why Use MongoDB with Python?

  • Flexibility: MongoDB’s schema-less nature pairs well with Python’s dynamic data types.
  • Scalability: Handle large datasets efficiently.
  • Ease of Use: Python’s libraries like pymongo make it easy to interact with MongoDB.

Conclusion

Integrating Python with MongoDB opens up a world of possibilities for building scalable and dynamic applications. Whether you’re managing unstructured data or creating high-performance APIs, MongoDB is a robust solution.

Leave a Comment