Eine Anleitung zur Nutzung von Python mit einer MongoDB-Datenbank!

Was ist MongoDB?

MongoDB ist eine Open Source Datenbank, die dokumentenorientiert arbeitet. Einfacher ausgedrückt: du kannst es dir wie ein großes JSON-Dokument vorstellen, auf das du Such-Querys anwenden kannst.

Wichtig ist, dass im Vergleich zu einer SQL-Datenbank keine Relationen gibt. Also falls du dieses Konzept in einem großen Ausmaß benötigst, solltest du dir genau überlegen, ob MongoDB das Richtige für dich ist. Falls du zwei Objekte miteinander verbinden willst, musst du das entweder programmatisch lösen oder du fügst die Daten noch einmal unter dem Objekt ein, wo du es benötigst.

Falls du schnell und ohne eine Installation deine ersten Schritte mit MongoDB machen willst, kann ich dir das "Shared"-Paket des MongoDB-Atlas empfehlen. Dort bekommst du 512mb – 5gb Speicher. Und das ganze Paket ist kostenlos und schnell eingerichtet.

MongoDB-Atlas Preise

Wofür eignet sich MongoDB?

MongoDB eignet sich vor allem für die Nutzung von Programmen, die Daten liefern, aber z.B. nicht immer dieselben Strukturen liefern. Stell dir vor, du machst in Python das Crawling von Webseiten. Die eine Webseite hat dann vielleicht einen Titel, eine andere wiederum nicht. In einer SQL-Datenbank müsstest du jetzt erlauben, dass dort ein Wert Null sein kann, in einer MongoDB lässt du das Feld in dem Fall einfach weg. So können die Strukturen auch zur Laufzeit geändert werden; ein Fehler im Design der Datenbank kann nach und nach dynamisch verändert werden.

Oder du kannst in deinem Crawling-Projekt im Nachhinein neue Werte einer Webseite abfragen beziehungsweise für eine einzelne Webseiten andere Werte ausgeben lassen.

So kannst du es zum Beispiel verwenden, um riesige Datenmengen zu sammeln und auszuwerten. Daher kommt auch der Name MongoDB vom englischen Wort "humongous" (Deutsch: gigantisch).

GUIs für MongoDB?

Eine Sache, die ich am Anfang vor allem hinderlich finde, ist, dass man PHPMyAdmin vermisst. Aber dafür gibt es natürlich auch Alternativen, die man nur kennen muss. Denn es gibt hier tolle Alternativen, mit denen du dir die Mongo-Datenbanken auch visuell anzeigen lassen kann.

MongoDB Compass

MongoDB Compass ist eine Software, die ebenfalls aus dem Hause MongoDB, Inc. stammt. Mit dieser Software kannst du dir deine Collections und Datenbanken anschauen sowie auch ein kleines Monitoring deiner MongoDB.

MongoDB Compass gibt es für alle üblichen Betriebssysteme (Windows,Linux und MacOS). Ich persönlich nutze am liebsten MongoDB Compass um mir die Daten meiner MongoDBs anzuschauen, da der Aufbau einfach und klar strukturiert ist.

Download MongoDB Compass

Das Monitoring der Performance in MongoDB Compass sieht wie folgt aus, unterteilt in 4 Bereiche.

• Operations
• Read & Write
• Network
• Memory

Robomongo (Robo 3T)

Robo 3T ist ebenfalls ein Basic Client. Ähnlich wie MongoDB Compass hat auch er keine großen Funktionen; es gibt allerdings vom gleichen Entwickler auch das Studio 3T. Dieses Programm hat deutlich mehr auf dem Kasten, unter anderem einen "Drag and Drop Query Builder", mit dem du ganz einfach MongoDB-Querys bauen und testen kannst.

Download Robo 3T

Mongo Express

Mongo Express ist ein Open Source NodeJS Client, der als Weboberfläche läuft, weshalb es wahrscheinlich dich vermutlich am ehesten an PHPMyAdmin erinnert. Persönlich finde ich das Interface, bezogen auf die UI, nicht besonders schön.

Download Mongo Express

Wo liegt der Vorteil bei MongoDB (noSQL) gegenüber einer SQL-Datenbank?

Als erstes möchte ich dir einmal die Vor- und Nachteile im Vergleich zwischen SQL und MongoDB aufzeigen.

Der große Vorteil liegt bei MongoDB definitiv in der flexiblen Struktur und in der Möglichkeit, auch unbekannte Daten ablegen zu können, die du zum Zeitpunkt der Erstellung der Datenbank nicht unbedingt kennen musst.

Wie du mit PyMongo arbeiten kannst?

Nun wollen wir aber mit MongoDB in Python starten. Dafür benötigen wir das Paket PyMongo. Dieses können wir mit Befehl über den PIP Paketmanager installieren:

python -m pip install pymongo

Mittels dieses Befehls haben wir nun PyMongo installiert. Nun können wir damit Beginnen uns mit der Datenbank zu Verbinden.

Verbinden mit der MongoDB

Um nun die Verbindung zur MongoDB aufzubauen brauchen wir ein neuen MongoClient diesen Starten wir mit der gleichnamigen Methode. Danach können wir mit der Listen Syntax eine Bestimmte Datenbank des Servers öffnen oder falls diese nicht Exestiert wird darüber eine neue Erstellt.

from pymongo import MongoClient

datenbank = MongoClient('mongodb://localhost:27017/')['datenbank-name']

Falls notwendig kann man hier auch Entsprechend mit einer Authentifizierung Arbeiten. Dabei ist zu Beachten das man auch die Datenbank in der MongoDB angeben muss wo die Authentifizerungsdaten Liegen. Die Standard Auth Datenbank ist "admin".

Ansonsten ist das Verhalten genau so wie ohne Authentifizierung.

connection = MongoClient('localhost',
  username='user',
  password='password',
  authSource='admin',
  authMechanism='SCRAM-SHA-256')

Eine Collection Auswählen

In einer Datenbank bei MongoDB gibt es sogennante Collections diese sind ähnlich zu einer Tabelle in einer SQL Datenbank. Um nun eine Collection auszuwählen können wir wieder über die Listen Syntax wieder Verfahren. In diese nun erstellte "test-collection" können wir nun Einträge Erstellen, Löschen oder Verändern.

collection = datenbank['test-collection']

Ein Elemente in die MongoDB Schreiben

Nun wollen wir Einträge in die ausgewählte Collection schreiben. Dafür nutzen wir den Dictionary Type.

Folgende Daten wollen wir nun in diese Datenbank-Collection schreiben:

nutzerInfo = {
    "name": "Felix Schürmeyer",
  "alter": 22,
  "rolle": "Gründer von HelloCoding.",
  "artikel-anzahl": 40
}

collection.insert_one(nutzerInfo)

Ich muss für mich persönlich sagen, dass ich diese Art Daten in eine Datenbank zu schreiben sehr einfach finde, vor allem wenn man einmal schnell Daten sammeln will. Im nachfolgenden Bild könnt ihr unsere Datenbank "Datenbank-name" sehen, wo unser erster Eintrag vorhanden ist.

Mehrere Elemente in die MongoDB schreiben

Manchmal ist es notwendig, mehrere Elemente auf einmal in die Collection zu schreiben. Dafür können wir eine Liste mit mehreren Dictionaries nutzen. Dafür nutzen wir die Methode "insert_many" der Collection.

testList = [
    {
        "name": "Hugo Wolf",
        "alter": 10,
        "rolle": "Ein Eintrag",
        "artikel-anzahl": 10
    },
    {
        "name": "Max Mustermann",
        "alter": 10,
        "rolle": "Nutzer",
        "artikel-anzahl": 20
    },
    {
        "name": "John",
        "alter": 30,
        "rolle": "Nutzer",
        "artikel-anzahl": 30
    }
]

collection.insert_many(testList)

So sehen unsere Ergebnisse in der MongoDB aus. Wichtig ist hier: bei MongoDB wird bei jedem Eintrag immer ein _id-Feld angelegt. Darüber können wir später natürlich auch selektieren.

Ein Element in der MongoDB lesen

Um nun ein Element zu selektieren, können wir die verschiedenen Werte nutzen, die wir in unserer Datenbank haben. Wir wollen uns nun über den Namen ein Objekt holen. Dabei nutzen wir wieder ein Dictionary und holen uns einen bestimmten Eintrag aus der Datenbank. Hierzu verwenden wir find_one; falls wir mehrere mit einem bestimmten Wert haben wollen, können wir find verwenden, ohne "_one".

daten = collection.find_one({"name": "Felix Schürmeyer"})

print(daten) 
# {'_id': ObjectId('5fc3a53911aead5c66711ebb'), 'name': 'Felix Schürmeyer', 'alter': 22, 'rolle': 'Gründer von HelloCoding.', 'artikel-anzahl': 40}

Beispielprojekt - Daten von einem Formular in einer Datenbank speichern

Nun wissen wir, wie wir Daten in die Datenbank schreiben und Einträge finden können. Um unser Wissen jetzt zu verinnerlichen, habe ich ein kleines Testprojekt erstellt. Dabei geht es darum, eine Verbindung aufzubauen, darüber Formulardaten in die Datenbank zu schreiben und im Anschluss eine Tabelle mit allen Dokumenten auszugeben.

Neben dem PyMongo-Paket benötigen wir das Flask-Paket für unseren Webserver.

Die HTML- und Flask-Basis

Unsere main.py sieht wie folgt aus. Dort definieren wir zwei Routen, eine für get- und eine für post-Daten. Die erste Route zeigt die index.html mit unserem kleinen Formular.

Die zweite Route ist ebenfalls für die Index, aber für den POST-Request. Dabei holen wir uns aus dem Request unsere angelegten Felder und geben sie in eine Funktion pushFormData. Abschließend spielen wir eine Tabelle mit allen Einträgen aus.

from flask import Flask,render_template,request
from database import pushFormData,getAllEntrys
app = Flask(__name__)

@app.route("/", methods=['GET'])
def index():
    return render_template("index.html")

@app.route('/', methods=['POST'])
def index_data():
    data = {}

    data['username'] = request.form['username'];
    data['name'] = request.form['name'];
    data['email'] = request.form['email'];
    data['hinweis'] = request.form['hinweis'];

    pushFormData(data)

    return render_template("table.html",entry=getAllEntrys())

if __name__ == "__main__":
    app.run(debug=True)

Unsere "index.html" sieht wie folgt aus. Der Bequemlichkeit halber nutze ich hier pure für etwas Styling der Formularfelder. Das hat aber mit der Funktionalität nichts zu tun.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <link rel="stylesheet" href="https://unpkg.com/purecss@2.0.3/build/pure-min.css" crossorigin="anonymous">
</head>
<body>

    <form class="pure-form pure-form-aligned" method="post">
        <fieldset>
            <div class="pure-control-group">
                <label for="aligned-name">Username</label>
                <input type="text" id="aligned-name" name="username" placeholder="Username" required />
                <span class="pure-form-message-inline">Required.</span>
            </div>
            <div class="pure-control-group">
                <label for="aligned-benutzer">Name</label>
                <input type="text" id="aligned-benutzer" placeholder="Name" name="name" required/>
                <span class="pure-form-message-inline">Required.</span>
            </div>
            <div class="pure-control-group">
                <label for="aligned-email">Email</label>
                <input type="email" id="aligned-email" placeholder="Email" name="email" />
            </div>
            <div class="pure-control-group">
                <label for="aligned-foo">Hinweis</label>
                <input type="text" id="aligned-foo" name="hinweis" placeholder="Enter something here..." />
            </div>
            <div class="pure-controls">
                <button type="submit" class="pure-button pure-button-primary">Senden</button>
            </div>
        </fieldset>
    </form>

</body>
</html>

Optisch sieht das gefüllte Formular nun wie folgt aus, wir haben 4 Felder: Username, Name, Email und Hinweis.

Unsere table.html sieht folgendermaßen aus. Wir iterieren im Template Engine alle Einträge und geben diese als HTML-Tabelle aus.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>

<table>
  <tbody>
    {% for item in entry %} 
        <tr>
        <th>{{item._id}}</th>
        <td>{{item.username}}</td>
        <td>{{item.name}}</td>
        <td>{{item.email}}</td>
        <td>{{item.hinweis}}</td>
        </tr>
    {% endfor %} 
    </tbody>
</table>

<a href="/">Zurück</a>

</body>
</html>

Das Ergebnis der HTML-Datei "table.html" könnte so aussehen. Im nächsten Schritt schauen wir uns nun unsere database.py an. In dieser geben wir unsere Daten ein und holen uns alle Einträge heraus.

Datenbankverbindung herstellen und Daten lesen/schreiben

Die Datenbankabrufe sind zu anderen Datenbanken wie SQL vergleichsweise sehr einfach. Wir benötigen nur zwei Funktionen, eine zum Einfügen und eine zum Abrufen aller Einträge.

pushFormData ist dazu da, die Einträge vom POST in die Datenbank oder genauer gesagt in die Collection userdata zu schreiben.

getAllEntrys gibt uns eine Liste aller Einträge in der Collection wieder.

connect hält den Verbindungsaufbau zu MongoDB und den Abruf der Datenbank und der Collection bereit, da diese für die beiden anderen Funktionen benötigt wird.

from pymongo import MongoClient

def pushFormData(data):
    return connect().insert_one(data)

def getAllEntrys():
    return list(connect().find())

def connect():
    datenbank = MongoClient('mongodb://localhost:27017/')['formulare']

    return datenbank['userdata']

Fazit

Ich hoffe diese Anleitung hat dir geholfen, pymongo und MongoDB in Python 3 besser zu verstehen. MongoDB ist vor allem eine Datenbank, die man auf die Schnelle nutzen kann, um Daten abzuspeichern und an anderer Stelle wieder zu verwenden.