MongoDB-Abfrageergebnisse in Python mit PyMongo begrenzen

Die limit()-Methode in PyMongo ermöglicht es Ihnen, die Anzahl der von einer Abfrage zurückgegebenen Dokumente zu begrenzen. Diese Seite erklärt, was limit() tut, wann man es verwendet, wie man es mit skip() für die Paginierung kombiniert und wie man es mit sort() für geordnete, begrenzte Ergebnismengen verkettet.

Voraussetzungen

Sie benötigen PyMongo und eine laufende MongoDB-Instanz. Installieren Sie den Treiber mit:

pip install pymongo

Verbinden Sie sich dann mit Ihrer Datenbank:

import pymongo

client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["mydatabase"]
col = db["customers"]

Wenn Sie neu im Verbinden und Einfügen von Dokumenten sind, lesen Sie zuerst die Kapitel MongoDB Get Started und MongoDB Insert.

Was limit() macht

Der Aufruf von .limit(n) auf einem Cursor weist MongoDB an, höchstens n Dokumente zurückzugeben. Ohne diesen Aufruf gibt find() jedes passende Dokument zurück — was bei großen Collections aufwendig sein kann.

# Returns ALL documents — can be slow on large collections
all_docs = col.find()

# Returns at most 5 documents
five_docs = col.find().limit(5)

Das Übergeben von 0 an limit() wird genauso behandelt wie das Weglassen des Aufrufs: MongoDB gibt alle passenden Dokumente zurück.

# These two are equivalent — both return all documents
col.find().limit(0)
col.find()

Einfaches Beispiel

Das folgende Skript fügt zehn Beispiel-Kundendokumente ein und ruft dann nur die ersten drei ab:

import pymongo

client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["mydatabase"]
col = db["customers"]

# Insert sample data (skip if your collection already has data)
col.drop()
names = ["Alice", "Bob", "Charlie", "Diana", "Eve",
         "Frank", "Grace", "Hank", "Iris", "Jack"]
col.insert_many([{"name": n, "rank": i + 1} for i, n in enumerate(names)])

# Retrieve only the first 3 documents
results = col.find({}, {"_id": 0}).limit(3)

for doc in results:
    print(doc)

Erwartete Ausgabe:

{'name': 'Alice', 'rank': 1}
{'name': 'Bob', 'rank': 2}
{'name': 'Charlie', 'rank': 3}

Das zweite Argument für find() ist eine Projektion — {"_id": 0} unterdrückt das _id-Feld, damit die Ausgabe leichter lesbar ist.

limit() mit sort() kombinieren

limit() ist am nützlichsten in Kombination mit sort(). Ohne Sortierung gibt MongoDB Dokumente in natürlicher Reihenfolge zurück (Einfügereihenfolge bei einer neuen Collection, aber nach Aktualisierungen oder Löschungen nicht garantiert). Eine vorherige Sortierung stellt sicher, dass die „Top-N"-Ergebnisse aussagekräftig sind.

import pymongo

client = pymongo.MongoClient("mongodb://localhost:27017/")
col = client["mydatabase"]["customers"]

# Top 3 customers by rank (ascending)
top3 = col.find({}, {"_id": 0}).sort("rank", pymongo.ASCENDING).limit(3)

print("Top 3 by rank:")
for doc in top3:
    print(doc)

# Bottom 3 customers by rank (descending = highest rank number first)
bottom3 = col.find({}, {"_id": 0}).sort("rank", pymongo.DESCENDING).limit(3)

print("\nBottom 3 by rank:")
for doc in bottom3:
    print(doc)

Erwartete Ausgabe:

Top 3 by rank:
{'name': 'Alice', 'rank': 1}
{'name': 'Bob', 'rank': 2}
{'name': 'Charlie', 'rank': 3}

Bottom 3 by rank:
{'name': 'Jack', 'rank': 10}
{'name': 'Iris', 'rank': 9}
{'name': 'Hank', 'rank': 8}

Eine vollständige Anleitung zu Sortieroptionen finden Sie im Kapitel MongoDB Sort.

Paginierung mit skip() und limit()

skip(n) weist MongoDB an, die ersten n Dokumente zu überspringen, bevor limit() angewendet wird. Zusammen ermöglichen sie seitenbasierte Paginierung:

page_1 = skip(0).limit(page_size)
page_2 = skip(page_size).limit(page_size)
page_N = skip((N-1) * page_size).limit(page_size)

Hier ist ein wiederverwendbarer Helfer, der jeweils eine Seite abruft:

import pymongo

client = pymongo.MongoClient("mongodb://localhost:27017/")
col = client["mydatabase"]["customers"]

def get_page(collection, page_number, page_size, sort_field="rank"):
    """Return one page of documents (1-indexed page numbers)."""
    offset = (page_number - 1) * page_size
    cursor = (
        collection.find({}, {"_id": 0})
        .sort(sort_field, pymongo.ASCENDING)
        .skip(offset)
        .limit(page_size)
    )
    return list(cursor)

# Fetch pages of 3 documents each
page1 = get_page(col, page_number=1, page_size=3)
page2 = get_page(col, page_number=2, page_size=3)
page3 = get_page(col, page_number=3, page_size=3)

print("Page 1:", page1)
print("Page 2:", page2)
print("Page 3:", page3)

Erwartete Ausgabe:

Page 1: [{'name': 'Alice', 'rank': 1}, {'name': 'Bob', 'rank': 2}, {'name': 'Charlie', 'rank': 3}]
Page 2: [{'name': 'Diana', 'rank': 4}, {'name': 'Eve', 'rank': 5}, {'name': 'Frank', 'rank': 6}]
Page 3: [{'name': 'Grace', 'rank': 7}, {'name': 'Hank', 'rank': 8}, {'name': 'Iris', 'rank': 9}]

Leistungshinweis zu skip()

skip() funktioniert, indem es die ersten n Dokumente liest und verwirft, bevor Ergebnisse zurückgegeben werden. Bei sehr großen Collections (Millionen von Dokumenten) ist ein großer skip()-Wert langsam, weil MongoDB alle übersprungenen Dokumente trotzdem lesen muss. Für hochfrequente Paginierung über große Datenmengen verwenden Sie stattdessen eine Bereichsabfrage auf einem indizierten Feld:

# Instead of skip(1000).limit(10), remember the last _id from the previous page
# and filter: {"_id": {"$gt": last_seen_id}}
# This is O(log n) with an index rather than O(n)

limit() mit einer Filterabfrage kombinieren

limit() funktioniert mit jeder find()-Abfrage, nicht nur mit dem bloßen find({}):

import pymongo

client = pymongo.MongoClient("mongodb://localhost:27017/")
col = client["mydatabase"]["customers"]

# Find customers with rank greater than 5, return only the first 3
query = {"rank": {"$gt": 5}}
results = col.find(query, {"_id": 0}).sort("rank", pymongo.ASCENDING).limit(3)

for doc in results:
    print(doc)

Erwartete Ausgabe:

{'name': 'Frank', 'rank': 6}
{'name': 'Grace', 'rank': 7}
{'name': 'Hank', 'rank': 8}

Mehr zu Filteroperatoren ($gt, $lt, $in usw.) finden Sie im Kapitel MongoDB Query.

Reihenfolge der Methodenverkettung

PyMongo erstellt die Abfrage serverseitig, sodass die Reihenfolge, in der Sie sort(), skip() und limit() in Python verketten, das Ergebnis nicht verändert — MongoDB wendet sie stets in der Abfolge an: Filter → Sortierung → Skip → Limit. Die folgenden beiden Anweisungen sind gleichwertig:

col.find().sort("rank", 1).skip(2).limit(3)
col.find().limit(3).skip(2).sort("rank", 1)  # same result

Das Schreiben in der logischen Reihenfolge (sort → skip → limit) ist eine Konvention, die den Code leichter lesbar macht.

Kurzübersicht

Methode	Zweck	Beispiel
`.limit(n)`	Höchstens `n` Dokumente zurückgeben	`.find().limit(10)`
`.skip(n)`	Die ersten `n` Dokumente überspringen	`.find().skip(20)`
`.sort(field, dir)`	Vor dem Begrenzen sortieren	`.find().sort("rank", 1).limit(5)`
`.limit(0)`	Kein Limit (gibt alle zurück)	`.find().limit(0)`

MongoDB Limit

Voraussetzungen

Was limit() macht

Einfaches Beispiel

limit() mit sort() kombinieren

Paginierung mit skip() und limit()

Leistungshinweis zu skip()

limit() mit einer Filterabfrage kombinieren

Reihenfolge der Methodenverkettung

Kurzübersicht

Verwandte Kapitel