For AI agents: a documentation index is available at https://www.mongodb.com/docs/llms.txt — markdown versions of all pages are available by appending .md to any URL path.
Docs Menu
Docs Home
/ /
PyMongo
Docs Home
/
Client Libraries
/
Python
/
PyMongo
Docs Home
/
Client Libraries
/
Python
/
PyMongo

CRUD Operations

Overview

This page contains code examples that show how to connect your Python application to MongoDB with various settings.

Tip

To learn more about the connection options on this page, see the link provided in each section.

To use a connection example from this page, copy the code example into the sample application or your own application. Be sure to replace all placeholders in the code examples, such as <hostname>, with the relevant values for your MongoDB deployment.

Sample Application

You can use the following sample application to test the code examples on this page. To use the sample application, perform the following steps:

  1. Ensure you have PyMongo installed.

  2. Copy the following code and paste it into a new .py file.

  3. Copy a code example from this page and paste it on the specified lines in the file.

Select the Synchronous or Asynchronous tab to see the corresponding code:

1import pymongo
2from pymongo import MongoClient
3
4try:
5    uri = "<connection string URI>"
6    client = MongoClient(uri)
7
8    database = client["<database name>"]
9    collection = database["<collection name>"]
10
11    # start example code here
12
13    # end example code here
14
15    client.close()
16
17except Exception as e:
18    raise Exception(
19        "The following error occurred: ", e)
1import asyncio
2import pymongo
3from pymongo import AsyncMongoClient
4
5async def main():
6    try:
7        uri = "<connection string URI>"
8        client = AsyncMongoClient(uri)
9
10        database = client["<database name>"]
11        collection = database["<collection name>"]
12
13        # start example code here
14
15        # end example code here
16
17        await client.close()
18
19    except Exception as e:
20        raise Exception(
21            "The following error occurred: ", e)
22
23asyncio.run(main())

Insert One

result = collection.insert_one({ "<field name>" : "<value>" })
print(result.acknowledged)
result = await collection.insert_one({ "<field name>" : "<value>" })
print(result.acknowledged)

To learn more about the insert_one() method, see the Insert Documents guide.

Insert Multiple

document_list = [
   { "<field name>" : "<value>" },
   { "<field name>" : "<value>" }
]
result = collection.insert_many(document_list)
print(result.acknowledged)
document_list = [
   { "<field name>" : "<value>" },
   { "<field name>" : "<value>" }
]
result = await collection.insert_many(document_list)
print(result.acknowledged)

To learn more about the insert_many() method, see the Insert Documents guide.

Update One

query_filter = { "<field to match>" : "<value to match>" }
update_operation = { "$set" : 
    { "<field name>" : "<value>" }
}
result = collection.update_one(query_filter, update_operation)
print(result.modified_count)
query_filter = { "<field to match>" : "<value to match>" }
update_operation = { "$set" : 
    { "<field name>" : "<value>" }
}
result = await collection.update_one(query_filter, update_operation)
print(result.modified_count)

To learn more about the update_one() method, see the Update Documents guide.

Update Multiple

query_filter = { "<field to match>" : "<value to match>" }
update_operation = { "$set" : 
    { "<field name>" : "<value>" }
}
result = collection.update_many(query_filter, update_operation)
print(result.modified_count)
query_filter = { "<field to match>" : "<value to match>" }
update_operation = { "$set" : 
    { "<field name>" : "<value>" }
}
result = await collection.update_many(query_filter, update_operation)
print(result.modified_count)

To learn more about the update_many() method, see the Update Documents guide.

Replace One

query_filter = { "<field to match>" : "<value to match>" }
replace_document = { "<new document field name>" : "<new document value>" }
result = collection.replace_one(query_filter, replace_document)
print(result.modified_count)
query_filter = { "<field to match>" : "<value to match>" }
replace_document = { "<new document field name>" : "<new document value>" }
result = await collection.replace_one(query_filter, replace_document)
print(result.modified_count)

To learn more about the replace_one() method, see the Replace Documents guide.

Delete One

query_filter = { "<field to match>" : "<value to match>" }
result = collection.delete_one(query_filter)
print(result.deleted_count)
query_filter = { "<field to match>" : "<value to match>" }
result = await collection.delete_one(query_filter)
print(result.deleted_count)

To learn more about the delete_one() method, see the Delete Documents guide.

Delete Multiple

query_filter = { "<field to match>" : "<value to match>" }
result = collection.delete_many(query_filter)
print(result.deleted_count)
query_filter = { "<field to match>" : "<value to match>" }
result = await collection.delete_many(query_filter)
print(result.deleted_count)

To learn more about the delete_many() method, see the Delete Documents guide.

Bulk Write

operations = [
    pymongo.InsertOne(
        {
            "<field name>" : "<value>"
        }
    ),
    pymongo.UpdateMany(
        { "<field to match>" : "<value to match>" },
        { "$set" : { "<field name>" : "<value>" }},
    ),
    pymongo.DeleteOne(
        { "<field to match>" : "<value to match>" }
    ),
]
result = collection.bulk_write(operations)
print(result)
operations = [
    pymongo.InsertOne(
        {
            "<field name>" : "<value>"
        }
    ),
    pymongo.UpdateMany(
        { "<field to match>" : "<value to match>" },
        { "$set" : { "<field name>" : "<value>" }},
    ),
    pymongo.DeleteOne(
        { "<field to match>" : "<value to match>" }
    ),
]
result = await collection.bulk_write(operations)
print(result)

To learn more about the bulk_write() method, see the Bulk Write guide.

Find One

results = collection.find_one({ "<field name>" : "<value>" })
print(results)
results = await collection.find_one({ "<field name>" : "<value>" })
print(results)

To learn more about the find_one() method, see Find One Document in the Retrieve Data guide.

Find Multiple

results = collection.find({ "<field name>" : "<value>" })
for document in results:
    print(document)
results = collection.find({ "<field name>" : "<value>" })
async for document in results:
    print(document)

To learn more about the find() method, see Find Multiple Documents in the Retrieve Data guide.

Count Documents in a Collection

count = collection.count_documents({})
print(count)
count = await collection.count_documents({})
print(count)

To learn more about the count_documents() method, see the Retrieve an Accurate Count guide.

Count Documents Returned from a Query

count = collection.count_documents({ "<field name>": "<value>" })
print(count)
count = await collection.count_documents({ "<field name>": "<value>" })
print(count)

To learn more about the count_documents() method, see the Retrieve an Accurate Count guide.

Estimated Document Count

count = collection.estimated_document_count()
print(count)
count = await collection.estimated_document_count()
print(count)

To learn more about the estimated_document_count() method, see the Retrieve an Estimated Count guide.

Retrieve Distinct Values

results = collection.distinct("<field name>")
for document in results:
    print(document)
results = await collection.distinct("<field name>")
for document in results:
    print(document)

To learn more about the distinct() method, see the Retrieve Distinct Field Values guide.

Back
Databases & Collections
Next
Insert Documents
Rate this page

On this page