Django-Tutorial: Beginnen Sie mit Django 2.0

Django ist ein einheitliches Python-Webframework, das von Ruby on Rails inspiriert wurde und viele der gleichen Metaphern verwendet, um die Webentwicklung schnell und einfach zu gestalten. Django ist voll geladen und flexibel und hat sich zu einem der am häufigsten verwendeten Web-Frameworks von Python entwickelt.

Django enthält praktisch alles, was Sie zum Erstellen einer Webanwendung jeder Größe benötigen. Aufgrund seiner Beliebtheit ist es einfach, Beispiele und Hilfe für verschiedene Szenarien zu finden. Außerdem bietet Django Tools, mit denen Ihre Anwendung Funktionen ordnungsgemäß weiterentwickeln und hinzufügen sowie das Datenschema (falls vorhanden) migrieren kann.

Django hat auch den Ruf, komplex zu sein, da viele Komponenten und viel Konfiguration unter der Haube erforderlich sind. In Wahrheit können Sie eine einfache App in relativ kurzer Zeit zum Laufen bringen und von dort aus ihre Funktionalität nach Bedarf erweitern.

In diesem Handbuch werden wir die Erstellung einer rudimentären Django 2.0-App erläutern und kurz auf die wichtigsten Funktionen eingehen, die sie für Webentwickler bietet.

Upgrade von Django 1.x.

Wenn Sie Erfahrung mit einer früheren 1.x-Ausgabe von Django haben, sind dies die wichtigsten Änderungen, die Sie beachten sollten:

  • Django 2.0 unterstützt nur Python 3.4 und höher. Python 2.x wird in zukünftigen Versionen von Django nicht unterstützt.
  • Django 2 folgt dem Muster von Python 3, wo immer möglich native Unicode-Zeichenfolgen zu verwenden. Einige Django-Funktionen akzeptieren keine Bytestrings mehr als Eingabe. 

Es gibt viele andere rückwärts inkompatible Änderungen, aber diese sind zwei der wichtigsten, insbesondere beim Starten neuer Projekte.

Installation der Kernbibliotheken von Django

Um Django 2.0 zu installieren, benötigen Sie Python 3.4 oder besser. Die einfachste Möglichkeit, Django zu installieren, ist das Python- pipDienstprogramm:

pip install django

Dadurch werden die Django-Kernbibliotheken und das django-adminBefehlszeilenprogramm zum Verwalten von Django-Projekten installiert .

Wenn Sie mit mehreren Versionen von Django nebeneinander arbeiten möchten, erstellen Sie eine virtuelle Umgebung, installieren Sie dort die gewünschte Version von Django und verwenden Sie diese für das betreffende Django-Projekt.

Beachten Sie, dass Sie keine virtuellen Umgebungen verwenden müssen, um mehrere Projekte mit einer einzigen Instanz von Django zu erstellen . Sie benötigen sie nur, um unterschiedliche Punktrevisionen des Django- Frameworks  mit unterschiedlichen Projekten zu verwenden.

Erstellen eines neuen Django-Projekts

Django-Instanzen sind in zwei Ebenen organisiert: Projekte und Apps .

  • Ein Projekt ist eine Instanz von Django mit eigener Datenbankkonfiguration, Einstellungen und Apps. Stellen Sie sich ein Projekt am besten als einen Ort vor, an dem alle von Ihnen verwendeten Konfigurationen auf Site-Ebene gespeichert werden.
  • Eine App ist eine Unterteilung eines Projekts mit einer eigenen Route und Renderlogik. In einem Django-Projekt können mehrere Apps platziert werden. 

Um ein neues Django-Projekt von Grund auf neu zu erstellen, geben Sie das Verzeichnis ein, in dem Sie das Projekt speichern möchten, und geben Sie Folgendes ein:

django-admin startproject

Wo ist der Name des Projekts und des Unterverzeichnisses, in dem das Projekt gespeichert wird? Stellen Sie sicher, dass Sie einen Namen auswählen, der wahrscheinlich nicht mit einem Namen kollidiert, der von Python oder Django intern verwendet wird. Ein Name wie myprojwird gut funktionieren.

Das resultierende Verzeichnis sollte eine manage.pyDatei enthalten  , mit der das Verhalten der App über die Befehlszeile gesteuert wird, sowie ein weiteres Unterverzeichnis (ebenfalls mit dem Projektnamen), das die folgenden Dateien enthält:

  • Eine __init__.pyDatei, die von Python verwendet wird, um ein Unterverzeichnis als Codemodul festzulegen.
  • settings.py, enthält die für das Projekt verwendeten Einstellungen. Viele der am häufigsten verwendeten Einstellungen werden für Sie vorab ausgefüllt.
  • urls.pyHier werden die Routen oder URLs aufgelistet, die für Ihr Django-Projekt verfügbar sind oder für die das Projekt Antworten zurückgibt.
  • wsgi.pywird von WSGI-kompatiblen Webservern wie Apache HTTP oder Nginx verwendet, um die Apps Ihres Projekts bereitzustellen.

Testen Sie das Projekt vor allem, um sicherzustellen, dass es funktioniert. manage.pyFühren Sie in der Befehlszeile des Verzeichnisses mit der Datei Ihres Projekts Folgendes aus:

python manage.py runserver

Dies sollte einen Entwicklungswebserver starten, der unter verfügbar ist //127.0.0.1:8000/. Besuchen Sie diesen Link und Sie sollten eine einfache Begrüßungsseite sehen, die Ihnen sagt, dass die Installation erfolgreich war.

Beachten Sie, dass der Entwicklungswebserver nicht dazu verwendet werden sollte, ein Django-Projekt der Öffentlichkeit bereitzustellen. Es wird nicht skaliert, um den erforderlichen Datenverkehr zu verarbeiten.

Erstellen einer Django-App

Als nächstes müssen wir eine App in diesem Projekt erstellen. Navigieren Sie zu demselben Verzeichnis wie manage.pyund geben Sie diesen Befehl ein:

python manage.py startapp myapp

Dadurch wird ein Unterverzeichnis für eine App mit dem Namen erstellt myapp , das Folgendes enthält:

  • Ein migrationsVerzeichnis. Enthält Code, der zum Migrieren der Site zwischen Versionen des Datenschemas verwendet wird.
  • admin.py. Enthält Objekte, die von den integrierten Verwaltungstools von Django verwendet werden. Wenn Ihre App über eine Administrationsoberfläche oder privilegierte Benutzer verfügt, konfigurieren Sie die zugehörigen Objekte hier.
  • apps.py. Stellt dem gesamten Projekt Konfigurationsinformationen über die App über ein AppConfigObjekt bereit.
  • models.py. Enthält Objekte, die Datenstrukturen definieren, die von Ihrer App für die Schnittstelle mit Datenbanken verwendet werden.
  • tests.py. Enthält alle Tests, mit denen sichergestellt wird, dass die Funktionen und Module Ihrer Site wie vorgesehen funktionieren.
  • views.py. Enthält Funktionen zum Rendern und Zurückgeben von Antworten.

Um mit der App arbeiten zu können, müssen wir sie zuerst beim Projekt registrieren. Bearbeiten myproj/settings.pySie dazu eine Zeile und fügen Sie sie oben in die INSTALLED_APPSListe ein:

INSTALLED_APPS = [ ‘myapp.apps.MyappConfig’, ‘django.contrib.admin’, ... 

Wenn Sie hineinschauen myapp.apps, sehen Sie ein vorgeneriertes Objekt mit dem Namen MyappConfig, auf das wir hier verweisen.

Hinzufügen von Routen und Ansichten zu Ihrer Django-App

Django-Apps folgen einem Grundmuster für die Verarbeitung von Anfragen:

  • Wenn eine eingehende Anfrage eingeht, analysiert Django die URL für eine Route, auf die sie angewendet werden soll.
  • Routen werden definiert urls.py, wobei jede Route mit einer Ansicht verknüpft ist , dh einer Funktion, die Daten zurückgibt, die an den Client zurückgesendet werden sollen. Ansichten können sich überall in einem Django-Projekt befinden, sind jedoch am besten in eigenen Modulen organisiert.
  • Views can contain the results of a template, i.e. code that formats requested data according to a certain design.

To get an idea of how all these pieces fit together, let’s modify the default route of our sample app to return a custom message.

Routes are defined in urls.py in a list named urlpatterns. If you open the sample urls.py, you’ll see urlpatterns already predefined:

urlpatterns = [ path(‘admin/’, admin.site.urls), ] 

The path function—a Django built-in—takes a route and a view function as arguments and generates a reference to a URL path. By default, Django creates an admin path that is used for site administration, but we need to create our own routes.

Add another entry, so that the whole file looks like:

from django.contrib import admin from django.urls import include, path urlpatterns = [ path(‘admin/’, admin.site.urls), path(‘myapp/’, include(‘myapp.urls’)) ] 

The include function tells Django to look for more route pattern information in the file myapp.urls. All of the routes found in that file will be attached to the top-level route myapp (e.g., //127.0.0.1:8080/myapp).

Next, create a new urls.py in myapp and add the following:

from django.urls import path from . import views urlpatterns = [ path(‘’, views.index) ] 

Django prepends a slash to the beginning of each URL, so to specify the root of the site (/), we just supply a blank string as the URL.

Now edit the file myapp/views.py so it looks like this:

from django.http import HttpResponse def index(request): return HttpResponse(“Hello, world!”) 

django.http.HttpResponse is a Django built-in that generates an HTTP response from a supplied string. Note that request, which contains the information for an incoming HTTP request, must be passed as the first parameter to a view function.

Stop and restart the development server, and navigate to //127.0.0.1:8000/myapp/. You should see Hello, world! appear in the browser.

Adding routes with variables in Django

Django can accept routes that incorporate variables as part of their syntax. Let’s say you wanted to accept URLs that had the format year/. You could accomplish that by adding the following entry to urlpatterns:

path(‘year/’, views.year) 

The view function views.year would then be invoked through routes like year/1996, year/2010, and so on, with the variable year passed as a parameter to views.year.

To try this out for yourself, add the above urlpatterns entry to myapp/urls.py, then add this function to myapp/views.py:

def year(request, year): return HttpResponse(‘Year: {}’.format(year)) 

If you navigate to /myapp/year/2010 on your site, you should see Year: 2010 displayed in response. Note that routes like /myapp/year/rutabaga will yield an error, because the int: constraint on the variable year allows only an integer in that position. Many other formatting options are available for routes.

Earlier versions of Django had a more complex and difficult-to-parse syntax for routes. If you still need to add routes using the old syntax—for instance, for backward compatibility with an old Django project—you can do so by using the django.urls.re_path function.

Django templates

Django’s built-in template language can be used to generate web pages from data.

Templates used by Django apps are stored in a directory that is central to the project: /templates//. For our myapp project, the directory would be myapp/templates/myapp/. This directory structure may seem a little awkward, but Django can look for templates in multiple places, so this avoids name collisions between templates with the same names across multiple apps.

In your myapp/templates/myapp/ directory, create a file named year.html with the following content:

Year: {{year}} 

Any value within double curly braces in a template is treated as a variable. Everything else is treated literally.

Modify myapp/views.py to look like this:

from django.shortcuts import render from django.http import HttpResponse def index(request): return HttpResponse(“Hello, world!”) def year(request, year): data = {’year’:year} return render(request, ‘myapp/year.html’, data) 

The render function, a Django “shortcut” (a combination of multiple built-ins for convenience), takes the existing request object, looks for the template myapp/year.html in the list of available template locations, and passes the dictionary data to it as context for the template.

The amount of processing you can perform on data within Django templates is intentionally quite limited. Django’s philosophy is to enforce separation of presentation and business logic whenever possible. Thus you can loop through an iterable object, and you can perform if/then/else tests, but modifying the data within a template is frowned upon.

For instance, a simple “if” test can be encoded this way:

{% if year > 2000 %} 21st century year: {{year}} {% else %} Pre-21st century year: {{year}} {% endif %} 

The {% and %} markers delimit blocks of code that can be executed in Django’s template language.

If you want to use a more sophisticated template processing language, you can swap in others, such as Jinja2 or Mako. Django includes back-end integration for Jinja2, but any template language that returns a string can be used—for instance, by returning that string in a HttpResponse object as in the case of our ”Hello, world!” route.

Next steps with Django

What we’ve seen here covers only the most basic elements of a Django application. Django includes a great many other components that can be employed in a web project. All of these are worth discussing in detail separately, but I will leave you with a brief overview:

  • Databases and data models. Django’s built-in ORM can be used to define data structures and relationships between them for your app, as well as migration paths between versions of those structures.

  • Formulare . Django bietet eine konsistente Möglichkeit für Ansichten, einem Benutzer Eingabeformulare bereitzustellen, Daten abzurufen, die Ergebnisse zu normalisieren und konsistente Fehlerberichte bereitzustellen.

  • Sicherheit und Dienstprogramme . Django enthält viele integrierte Funktionen zum Zwischenspeichern, Protokollieren, Behandeln von Sitzungen, Behandeln statischer Dateien und Normalisieren von URLs. Außerdem werden Tools für allgemeine Sicherheitsanforderungen wie die Verwendung kryptografischer Zertifikate oder den Schutz vor standortübergreifendem Fälschungsschutz oder Clickjacking gebündelt.