Django Tutorial

Wie man mit Django Tango tanzt

Wie man mit Django Tango tanzt

Veröffentlicht am 10-04-2019
Django ist ein Web-Framework, das mit der Programmiersprache Python geschrieben wurde. Im Allgemeinen lässt ein Framework dich Dinge schneller, besser und einfacher erledigen und genau das ist es, was Django ausmacht. Da Django im Vergleich zu anderen ein sehr altes Framework ist, hatte es viel Zeit zu wachsen und sich zu verbessern. Das liegt daran, dass Django eine Open-Source-Software ist, was bedeutet, dass viele Entwickler in ihrer Freizeit zusammenarbeiten, um Django zu verbessern.
 

Erste Schritte

Willkommen zu dieser Tutorial-Serie, in der du eine REST-API mit Python und Django erstellen wirst. Am Ende dieser Serie wirst du deine eigene, vollständig implementierte und produktionsreife API haben. Wir werden einen Blick auf das Webframework Django werfen und die Django REST Framework-Erweiterung abdecken, uns ansehen, wie man Django mit Docker verwendet und wie man alles auf seinem Webserver deployed. Für dieses Tutorial solltest du bereits mit den Grundlagen der Python-Programmierung vertraut sein.
 
Lass uns direkt eintauchen.
 
Wir beginnen damit, ein Django-Projekt direkt aus PyCharm heraus zu erstellen. Wähle Django auf der linken Seite in PyCharm aus und gebe dem Projekt einen Namen. Wir werden es pyblog nennen, da diese API später auf einer Blog-Website verwendet werden soll.

django-new-project
 
Als nächstes musst du die Einstellungen für deine Python-Umgebung wählen, die PyCharm für uns erstellt. Dies ist auch der Ort, an dem PyCharm die neueste Version von Django installieren wird. Wenn du anaconda installiert hast, wird es hier angezeigt, damit du neue Python-Umgebungen erstellen kannst. Wenn du anaconda noch nicht installiert hast, kannst du auch virtualenv verwenden. Stelle nur sicher, dass du Python 3.6 oder höher für dein Projekt wählst, da Django für ältere Python-Versionen ein wenig anders funktioniert. Ich werde anaconda verwenden, um meine Python-Umgebung zu erstellen und die Python-Version 3.7.
 
Öffne den Abschnitt Weitere Einstellungen und gib deiner Django-App einen Namen. Eine Django-App ist die Django-Art, benutzerdefinierten Code für ein Django-Projekt zu schreiben. Dieser sollte sich von deinem Projektnamen unterscheiden. Ich werde Posts als Namen für meine Django-App verwenden.

django-settings
 
Du kannst auch die Checkbox für die Django-Admin-Oberfläche aktiviert lassen. Damit können wir später über eine Benutzeranmeldung auf das in der Admin-Oberfläche eingebaute Django zugreifen und Daten in unserer Datenbank ändern.

Machen wir weiter und erstellen unser Projekt.
 
PyCharm erstellt eine neue Python-Umgebung und installiert alle benötigten Abhängigkeiten von Django in dieser neuen Umgebung.
 
Testen wir, ob alles funktioniert, indem wir auf die Schaltfläche “Ausführen” in der Symbolleiste klicken. Nachdem der Django-Server gestartet ist, kannst du die Ergebnisse in einem Terminal sehen, das in PyCharm erscheint. Mit einem Klick auf den blauen Link solltest du die Django-Willkommensseite erhalten.

django-installation

Wechseln wir zurück zu PyCharm.
 
Der Ordner namens pyblog ist unser Hauptprojektordner. Er enthält alle Dateien, die Django generiert, um richtig zu laufen. Die wichtigste davon ist die Datei settings.py. Sie enthält alle Einstellungen und Konfigurationen für unser Projekt.
 
Die nächste wichtige Datei ist die urls.py. Hier findest du alle URL-Konfigurationen für deine Django-App. Du kannst sehen, dass die URL-Konfiguration für die Admin-Oberfläche bereits existiert. Das liegt daran, dass wir die Checkbox für die Admin-Oberfläche aktiviert gelassen haben.

Die nächste Datei, die wsgi.py, ist die Konfiguration der Webserver-Gateway-Schnittstelle. Diese Datei wird benötigt, um unsere Django-App in der Produktion laufen zu lassen. Wir werden dies später in dieser Tutorial-Serie behandeln.

django-save
 
Wechseln wir zu unserem Django-App-Ordner. 

Hier wird unser gesamter benutzerdefinierter Code gespeichert. Werfen wir einen Blick auf die erste Datei, die models.py heisst. Dies ist der Ort, an dem du deine Anweisungen zum Erstellen von Datenbanktabellen erstellen wirst, um Daten zu speichern.

Nachdem du deine Modelle erstellt hast, werden Django Migrationsdateien dafür erstellt. Diese Dateien werden im Ordner “migrations” gespeichert. Sie enthalten die eigentlichen Anweisungen, um unser Datenbankschema zu manipulieren. Jedes Mal, wenn du also den Code deiner Modelle änderst, musst du Django anweisen, neue Migrationsdateien zu erstellen.

Die Datei admin.py wird verwendet, um Django mitzuteilen, welche Modelle, die wir erstellt haben, in der Django-Admin-Oberfläche verfügbar sind.
Die Datei views.py ist der Ort, an dem du deine Anweisungen schreibst, was Django zurückgeben soll, wenn wir eine bestimmte URL im Browser besuchen. (Dazu später mehr.)

Die app.py-Datei ist eine Konfigurationsdatei für eine Django-App. Hier konfigurierst du deine App mit Dingen wie Name, verbose_name und Pfad oder lädst deine Django-Signale. Dies wird normalerweise für fortgeschrittenere Django-Apps verwendet.

Und schliesslich haben wir die Datei tests.py. Hier schreibst du deine Unit-Tests für deine Django-App. Das können wir für den Moment ignorieren.

django-models
 
Okay, beginnen wir mit dem Schreiben einer Ansicht und zeigen wir einen benutzerdefinierten Text auf der Webseite anstelle des Django-Begrüssungsbildschirms an. Gehen wir zur Datei views.py und erstellen eine Klasse namens ListPostView. Diese Klasse wird eine Unterklasse der Django-View-Klasse. Du kannst diese Klasse in Pycharm automatisch importieren, indem du den Cursor auf den Klassennamen setzst und alt+enter oder option+enter drückst. Dadurch wird ein kleines Fenster geöffnet. Wir können nun mit den Pfeiltasten navigieren, um die Klasse an der richtige Stelle zu importieren. In unserem Fall wollen wir Django.views.View auswählen.

Fügen wir eine Definition namens get hinzu. Das ist das, was Django aufruft, wenn wir eine get-Anfrage im Browser stellen. Wir wollen auch die Anfrage als erstes Positionsargument für diese Definition hinzufügen und alle anderen Schlüsselwortargumente akzeptieren, die Django mit dem Schlüsselwort **kwargs übergeben könnte.

Jetzt wollen wir eine HttpResponse zurückgeben, die unseren benutzerdefinierten String enthält. Wie zuvor importieren wir diese HttpResponse-Klasse automatisch mit alt-enter. Bevor wir zu unseren URLs übergehen, um das Routing zu dieser View zu konfigurieren, kopieren wir den Namen unserer View-Klasse.

Erstelle in der Datei urls.py einen neuen Eintrag in der Liste urlpatterns direkt unter der Admin-URL. Folge dem Beispiel und verwende path und empty string und füge nun unsere zuvor kopierte View ein. Hier müssen wir eine Funktion auf diese Klasse mit dem Namen .as_view() aufrufen.
Wenn du diese Datei speicherst, solltest du sehen, dass der Django-Server automatisch neu geladen wird. Wenn es keine Fehler gibt, geh zu unserem Browser und lade die Seite neu. Jetzt solltest du sehen, dass unser Text aus dem View angezeigt wird.

Zurück in PyCharm können wir den View leicht anpassen, so dass er JSON anstelle von Rohtext liefert. Wir können dies tun, indem wir eine neue Variable erstellen und ihr ein Wörterbuch zuweisen. Um JSON anstelle von Text zu liefern, müssen wir die Antwortklasse in JsonResponse ändern. Auch hier verwenden wir die Auto-Import-Funktion und entfernen die HttpResponse von vorher.

Schauen wir uns das Ergebnis drüben im Browser an.

Nach unserer ersten Begegnung mit Django-Views können wir mit dem Schreiben von Modellen beginnen.

Erstellen wir eine Post-Klasse, die alle Blog-Posts enthält, indem wir die models.Model-Klasse von Django unterklassifizieren. Ausserdem fügen wir die Felder title, content und created hinzu.
 
  • Der Titel ist ein Zeichenfeld, das ein begrenztes Zeichenfeld in der Datenbank ist.
  • Der Inhalt wird ein Textfeld sein, das nicht in der Menge des Textes begrenzt ist, den man hineinschreiben kann.
  • Schliesslich erstellen wir das erstellte Feld, ein DateTimeField, und werden ein spezielles Argument "auto_now_add" haben, das Django anweist, das aktuelle Datum und die Uhrzeit zu diesem Feld hinzuzufügen, wenn ein neuer Beitrag erstellt wird.
 
Nachdem wir das Modell erstellt haben, öffne das Terminal in pycharm und aktiviere die Python-Umgebung. Wenn anaconda installiert ist, kannst du einfach conda activate pyblog eingeben. Der Name der Umgebung ist der gleiche wie dein Projektname. Wenn du mit virtualenv arbeitest, kannst du den Befehl source activate pyblog verwenden. Dies bewirkt das Gleiche.

Du kannst erkennen, dass deine Umgebung aktiv ist, wenn du ein Präfix mit dem Umgebungsnamen in Klammern hast. Nun können wir mit Python manage.py makemigrations eine neue Migrationsdatei für unser neues Modell erstellen und anschliessend mit Python manage.py migrate Migrationen auf eine neue Sqlite-Datenbank anwenden.

Da unser Modell nun erstellt ist, sollten wir es in der Datei admin.py registrieren. Erstelle eine neue Klasse namens PostAdmin, die eine Unterklasse der Klasse admin.ModelAdmin ist. Um die Verbindung zwischen unserer Model-Klasse und dieser admin.config-Klasse herzustellen, können wir einen Dekorator @admin.register(Post) verwenden. Vergiss nicht, unser Model mit dem Auto-Import zu importieren.

Um sich nun am Django-Admin-Backend anzumelden, benötigen wir einen Benutzer. Legen wir einen in der Kommandozeile mit dem Befehl Python manage.py createsuperuser an.

Dieser fragt nach Benutzernamen und Passwort. Die E-Mail können wir leer lassen, da wir sie in diesem Beispiel vorerst nicht benötigen. Du kannst diese Werte später immer noch ändern.

Gehen wir nun auf unsere Website und rufen die URL http://localhost:8000/admin/ auf. Jetzt können wir uns mit dem soeben erstellten Superuser anmelden.

Von hier aus ist es sehr einfach, zu posts zu gehen und einen neuen Beitrag zu unserer Datenbank hinzuzufügen.

Nun wollen wir unsere ListPostView aktualisieren, um aktuelle Beiträge aus unserer Datenbank im JSON-Format zu liefern. Dazu wollen wir die Datenvariable in Post.objects.all() ändern und die Funktion .values() hinzufügen. Dies wird alle Datensätze aus unserer Datenbank aus dem Post-Modell zurückgeben. Die Funktion .values() wandelt alle Posts in Dicts um, die wir dann in JSON umwandeln können.

Wenn alles gut funktioniert, wirst du eine Liste von Dictaries in deinem Browser sehen.

Lass uns ein paar weitere Posts in unserer Datenbank anlegen, um sie zu filtern.

Zurück in unserer View-Klasse können wir nun die Methode .all() auf .filter() aktualisieren. Dies erlaubt uns, die Beiträge nach allen Feldern zu filtern, die das Post-Modell hat. Ich werde das Feld title mit einer hartkodierten Zeichenkette filtern. Das Schlüsselwort __iconains ist nützlich, um auf Teile von Beitragstiteln zu filtern, anstatt auf exakte Übereinstimmungen. Es filtert auch nach Wörtern, die Gross- und Kleinschreibung nicht berücksichtigen. Ich suche hier nach allen Beiträgen, die das Schlüsselwort animal im Titel haben.

Um dies zu testen, wechsle zu unserer Website und mache einen Reload.

Als letztes musst du die URLs, die zu der jeweiligen Django-App gehören, in die Django-App selbst verschieben. Dazu erstellst du in deiner Django-App eine Datei urls.py und fügst eine Variable urlpatterns hinzu. Weise ihr eine Python-Liste zu und füge den Funktionspfad hinzu. Hier verbinden wir die URL mit dem View. Ich lasse das erste Argument einen leeren String und füge unsere ListPostView-Klasse hinzu. Wie zuvor vergiss nicht, die Funktion .as_view() aufzurufen. Jetzt können wir unserer URL einen Namen geben und die Datei mit dem Import unserer View-Klasse abschliessen.
Um Django zu sagen, dass es diese neue urls.py-Datei verwenden soll, müssen wir sie in die Hauptdatei urls.py importieren. Dazu geben wir einen URL-Präfix an, unter dem unsere Posts-Api laufen soll. Ich verwende api/ für diesen Zweck. Um die andere urls.py-Datei zu importieren, müssen wir eine Methode namens include verwenden. Wir müssen den Pfad zu dieser Datei durch einen Punkt getrennt schreiben. Das wird also posts.urls sein. Wir sollten auch einen Namespace für dieses Include hinzufügen. Ich verwende der Einfachheit halber wieder api. Das wird später nützlich sein, wenn wir Tests für unsere api schreiben.

Wir müssen auch einen App-Namen für dieses Include angeben, der das zweite Argument im Include-Tupel sein wird. Ich gebe den gleichen Namen wie unsere Django-App an, nämlich posts.

Nach einem kurzen Neuladen unseres Django-Servers sollten wir in der Lage sein, auf unsere API mit der URL api/ zuzugreifen.



Dies ist das Ende des ersten Teils dieser Tutorial-Serie. Im nächsten Beitrag werden wir mit der Verwendung des Django Rest-Frameworks beginnen, um den Aufbau unserer Blog-Api fortzusetzen.

Möchtest du mehr über die Propulsion Academy und technikbezogene Themen lesen? Dann finde hier weitere spannende Blogbeiträge.

Mehr Infos
Blog