Datenbank einrichten

Einführung

Dieser Tutorial beginnt dort, wo Erstellung einer einfachen Umfrageanwendung aufgehört hat. Wir werden die Datenbank einrichten, Ihr erstes Modell erstellen und eine schnelle Einführung in die automatisch generierte Django-Admin-Site erhalten.

Skills Graph

Datenbankeinrichtung

Öffnen Sie nun mysite/settings.py. Dies ist ein normales Python-Modul mit Modul-Ebene-Variablen, die die Django-Einstellungen repräsentieren.

Standardmäßig verwendet die Konfiguration SQLite. Wenn Sie neu in Datenbanken sind oder nur daran interessiert sind, Django auszuprobieren, ist dies die einfachste Wahl. SQLite ist in Python enthalten, so dass Sie nichts weiter installieren müssen, um Ihre Datenbank zu unterstützen. Wenn Sie jedoch Ihr erstes echtes Projekt starten möchten, sollten Sie möglicherweise eine skalierbarere Datenbank wie PostgreSQL verwenden, um spätere Kopfschmerzen bei der Datenbankumstellung zu vermeiden.

Wenn Sie eine andere Datenbank verwenden möchten, installieren Sie die entsprechenden Datenbankbindung <database-installation> und ändern Sie die folgenden Schlüssel im DATABASES 'default'-Element, um Ihren Datenbankverbindungs-Einstellungen zu entsprechen:

• ENGINE <DATABASE-ENGINE> -- Entweder 'django.db.backends.sqlite3', 'django.db.backends.postgresql', 'django.db.backends.mysql' oder 'django.db.backends.oracle'. Andere Backends sind auch verfügbar <third-party-notes>.
• NAME -- Der Name Ihrer Datenbank. Wenn Sie SQLite verwenden, wird die Datenbank eine Datei auf Ihrem Computer sein; in diesem Fall sollte NAME der vollständige absolute Pfad, einschließlich Dateinamen, dieser Datei sein. Der Standardwert BASE_DIR / 'db.sqlite3' speichert die Datei im Projektverzeichnis.

Wenn Sie nicht SQLite als Ihre Datenbank verwenden, müssen zusätzliche Einstellungen wie USER, PASSWORD und HOST hinzugefügt werden. Weitere Details finden Sie in der Referenzdokumentation für DATABASES.

Für Nicht-SQLite-Datenbanken

Wenn Sie eine Datenbank außer SQLite verwenden, stellen Sie sicher, dass Sie zu diesem Zeitpunkt eine Datenbank erstellt haben. Machen Sie dies mit "CREATE DATABASE database_name;" innerhalb des interaktiven Prompts Ihrer Datenbank.

Stellen Sie auch sicher, dass der Datenbankbenutzer, der in mysite/settings.py angegeben ist, über "create database"-Rechte verfügt. Dies ermöglicht die automatische Erstellung einer Testdatenbank <the-test-database>, die in einem späteren Tutorial benötigt wird.

Wenn Sie SQLite verwenden, müssen Sie nichts im Voraus erstellen - die Datenbankdatei wird automatisch erstellt, wenn sie benötigt wird.

Während Sie mysite/settings.py bearbeiten, legen Sie TIME_ZONE auf Ihre Zeitzone fest.

Beachten Sie auch die INSTALLED_APPS-Einstellung am Anfang der Datei. Dies enthält die Namen aller Django-Anwendungen, die in dieser Django-Instanz aktiviert sind. Anwendungen können in mehreren Projekten verwendet werden, und Sie können sie verpacken und verteilen, damit andere sie in ihren Projekten verwenden können.

Standardmäßig enthält INSTALLED_APPS die folgenden Anwendungen, alle von denen mit Django mitgeliefert werden:

• django.contrib.admin -- Die Admin-Site. Sie werden sie bald verwenden.
• django.contrib.auth -- Ein Authentifizierungssystem.
• django.contrib.contenttypes -- Ein Framework für Inhaltstypen.
• django.contrib.sessions -- Ein Sitzungsframework.
• django.contrib.messages -- Ein Nachrichtenframework.
• django.contrib.staticfiles -- Ein Framework zur Verwaltung von statischen Dateien.

Diese Anwendungen werden standardmäßig als Bequemlichkeit für den üblichen Fall enthalten.

Einige dieser Anwendungen verwenden jedoch mindestens eine Datenbanktabelle, daher müssen wir die Tabellen in der Datenbank erstellen, bevor wir sie verwenden können. Führen Sie dazu den folgenden Befehl aus:

cd ~/project/mysite
python manage.py migrate

Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying admin.0003_logentry_add_action_flag_choices... OK
  Applying contenttypes.0002_remove_content_type_name... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  Applying auth.0005_alter_user_last_login_null... OK
  Applying auth.0006_require_contenttypes_0002... OK
  Applying auth.0007_alter_validators_add_error_messages... OK
  Applying auth.0008_alter_user_username_max_length... OK
  Applying auth.0009_alter_user_last_name_max_length... OK
  Applying auth.0010_alter_group_name_max_length... OK
  Applying auth.0011_update_proxy_permissions... OK
  Applying auth.0012_alter_user_first_name_max_length... OK
  Applying sessions.0001_initial... OK

Der migrate-Befehl betrachtet die INSTALLED_APPS-Einstellung und erstellt alle erforderlichen Datenbanktabellen gemäß den Datenbankeinstellungen in Ihrer mysite/settings.py-Datei und den Datenbankmigrationen, die mit der App mitgeliefert werden (wir werden diese später behandeln). Sie erhalten eine Meldung für jede Migration, die er anwendet. Wenn Sie interessiert sind, führen Sie den Befehlszeilenclient für Ihre Datenbank aus und geben Sie \dt (PostgreSQL), SHOW TABLES; (MariaDB, MySQL), .tables (SQLite) oder SELECT TABLE_NAME FROM USER_TABLES; (Oracle) ein, um die Tabellen anzuzeigen, die Django erstellt hat.

Für die Minimalisten

Wie oben erwähnt, werden die Standardanwendungen für den üblichen Fall enthalten, aber nicht jeder braucht sie. Wenn Sie keine oder alle von ihnen benötigen, können Sie die entsprechende Zeile(n) in INSTALLED_APPS vor dem Ausführen von migrate auskommentieren oder löschen. Der migrate-Befehl führt nur Migrationen für Apps in INSTALLED_APPS aus.

Modelle erstellen

Nun werden wir Ihre Modelle definieren - im Wesentlichen die Layout Ihrer Datenbank mit zusätzlichen Metadaten.

Ein Modell ist die einzige, definitive Informationsquelle über Ihre Daten. Es enthält die wesentlichen Felder und Verhaltensweisen der Daten, die Sie speichern. Django folgt dem DRY-Prinzip <dry>. Das Ziel ist, Ihr Datenmodell an einem Ort zu definieren und daraus automatisch Dinge abzuleiten.

Dies umfasst auch die Migrationen - im Gegensatz zu Ruby On Rails beispielsweise werden die Migrationen vollständig aus Ihrer Models-Datei abgeleitet und sind im Wesentlichen eine Geschichte, die Django durchlaufen kann, um Ihren Datenbank-Schema zu aktualisieren, um es Ihrem aktuellen Modell zu entsprechen.

In unserer Umfrage-App werden wir zwei Modelle erstellen: Question und Choice. Eine Question hat eine Frage und ein Veröffentlichungsdatum. Eine Choice hat zwei Felder: den Text der Wahl und eine Stimmenzählung. Jede Choice ist mit einer Question assoziiert.

Diese Konzepte werden durch Python-Klassen dargestellt. Bearbeiten Sie die Datei polls/models.py, so dass sie wie folgt aussieht:

from django.db import models


class Question(models.Model):
    question_text = models.CharField(max_length=200)
    pub_date = models.DateTimeField("date published")


class Choice(models.Model):
    question = models.ForeignKey(Question, on_delete=models.CASCADE)
    choice_text = models.CharField(max_length=200)
    votes = models.IntegerField(default=0)

Hier wird jedes Modell durch eine Klasse dargestellt, die von django.db.models.Model abgeleitet wird. Jedes Modell hat eine Reihe von Klassenvariablen, von denen jede ein Datenbankfeld im Modell repräsentiert.

Jedes Feld wird durch eine Instanz einer ~django.db.models.Field-Klasse dargestellt - z.B. ~django.db.models.CharField für Zeichenfelder und ~django.db.models.DateTimeField für Datums- und Uhrzeitangaben. Dies sagt Django, welchen Datentyp jedes Feld aufnimmt.

Der Name jeder ~django.db.models.Field-Instanz (z.B. question_text oder pub_date) ist der Feldname im maschinenlesbaren Format. Sie werden diesen Wert in Ihrem Python-Code verwenden, und Ihre Datenbank wird ihn als Spaltennamen verwenden.

Sie können einen optionalen ersten Positionsargument für eine ~django.db.models.Field verwenden, um einen menschenlesbaren Namen zu指定. Dies wird in einigen introspektiven Teilen von Django verwendet und dient gleichzeitig als Dokumentation. Wenn dieses Feld nicht angegeben wird, wird Django den maschinenlesbaren Namen verwenden. In diesem Beispiel haben wir nur einen menschenlesbaren Namen für Question.pub_date definiert. Für alle anderen Felder in diesem Modell wird der maschinenlesbare Name des Felds als menschenlesbarer Name ausreichen.

Einige ~django.db.models.Field-Klassen haben erforderliche Argumente. ~django.db.models.CharField erfordert beispielsweise, dass Sie ihm eine ~django.db.models.CharField.max_length angeben. Dies wird nicht nur im Datenbank-Schema verwendet, sondern auch bei der Validierung, wie wir bald sehen werden.

Eine ~django.db.models.Field kann auch verschiedene optionale Argumente haben; in diesem Fall haben wir den ~django.db.models.Field.default-Wert von votes auf 0 gesetzt.

Schließlich wird eine Beziehung definiert, indem ~django.db.models.ForeignKey verwendet wird. Dies sagt Django, dass jede Choice mit einer einzelnen Question verknüpft ist. Django unterstützt alle gängigen Datenbankbeziehungen: Vielzu-ein, Vielzu-viel und Eindeutig-eindeutig.

Modelle aktivieren

Dieser kleine Codeausschnitt für die Modelle liefert Django eine Menge Informationen. Mit ihm kann Django:

• Ein Datenbank-Schema (CREATE TABLE-Anweisungen) für diese App erstellen.
• Eine Python-Datenbank-Zugangs-API für das Zugreifen auf Question- und Choice-Objekte erstellen.

Aber zunächst müssen wir unserem Projekt mitteilen, dass die polls-App installiert ist.

Django-Apps sind "plugbar": Sie können eine App in mehreren Projekten verwenden und Apps verteilen, da sie nicht an eine bestimmte Django-Installation gebunden sein müssen.

Um die App in unserem Projekt zu integrieren, müssen wir in der INSTALLED_APPS-Einstellung einen Verweis auf ihre Konfigurationsklasse hinzufügen. Die PollsConfig-Klasse befindet sich in der Datei polls/apps.py, so dass ihr punktierter Pfad 'polls.apps.PollsConfig' ist. Bearbeiten Sie die Datei mysite/settings.py und fügen Sie diesen punktierten Pfad zur INSTALLED_APPS-Einstellung hinzu. Es sollte so aussehen:

INSTALLED_APPS = [
    "polls.apps.PollsConfig",
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
]

Jetzt weiß Django, die polls-App einzuschließen. Führen wir einen weiteren Befehl aus:

python manage.py makemigrations polls

Sie sollten etwas Ähnliches wie Folgendes sehen:

Migrations for 'polls':
  polls/migrations/0001_initial.py
    - Create model Question
    - Create model Choice

Durch Ausführen von makemigrations sagen Sie Django, dass Sie Änderungen an Ihren Modellen vorgenommen haben (in diesem Fall haben Sie neue Modelle erstellt) und dass Sie die Änderungen als Migration speichern möchten.

Migrationen sind die Art und Weise, wie Django Änderungen an Ihren Modellen (und damit Ihrem Datenbank-Schema) speichert - es sind Dateien auf der Festplatte. Sie können die Migration für Ihr neues Modell lesen, wenn Sie möchten; es ist die Datei polls/migrations/0001_initial.py. Machen Sie sich keine Sorgen, Sie müssen sie nicht jedes Mal lesen, wenn Django eine erstellt, aber sie sind so gestaltet, dass Sie sie manuell bearbeiten können, falls Sie möchten, wie Django Dinge ändert.

Es gibt einen Befehl, der die Migrationen für Sie ausführt und Ihr Datenbank-Schema automatisch verwaltet - das heißt migrate, und wir kommen gleich darauf zu sprechen - aber zunächst schauen wir uns an, welche SQL-Anweisungen diese Migration ausführen würde. Der sqlmigrate-Befehl nimmt Migrationsnamen und gibt ihre SQL zurück:

python manage.py sqlmigrate polls 0001

Sie sollten etwas Ähnliches wie Folgendes sehen (wir haben es für die Lesbarkeit umformatert):

BEGIN;
--
-- Create model Question
--
CREATE TABLE "polls_question" (
    "id" bigint NOT NULL PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
    "question_text" varchar(200) NOT NULL,
    "pub_date" timestamp with time zone NOT NULL
);
--
-- Create model Choice
--
CREATE TABLE "polls_choice" (
    "id" bigint NOT NULL PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
    "choice_text" varchar(200) NOT NULL,
    "votes" integer NOT NULL,
    "question_id" bigint NOT NULL
);
ALTER TABLE "polls_choice"
  ADD CONSTRAINT "polls_choice_question_id_c5b4b260_fk_polls_question_id"
    FOREIGN KEY ("question_id")
    REFERENCES "polls_question" ("id")
    DEFERRABLE INITIALLY DEFERRED;
CREATE INDEX "polls_choice_question_id_c5b4b260" ON "polls_choice" ("question_id");

COMMIT;

Beachten Sie Folgendes:

• Die genaue Ausgabe variiert je nach verwendeter Datenbank. Das obige Beispiel ist für PostgreSQL generiert.
• Tabellennamen werden automatisch generiert, indem der Name der App (polls) und der Kleinbuchstabenname des Modells kombiniert werden - question und choice. (Sie können dieses Verhalten überschreiben.)
• Primärschlüssel (IDs) werden automatisch hinzugefügt. (Sie können dies ebenfalls überschreiben.)
• Konventionell fügt Django "_id" zum Fremdschlüsselfeldnamen hinzu. (Ja, Sie können dies ebenfalls überschreiben.)
• Die Fremdschlüsselbeziehung wird durch eine FOREIGN KEY-Einschränkung explizit gemacht. Machen Sie sich keine Sorgen um die DEFERRABLE-Teile; es sagt PostgreSQL, die Fremdschlüsselbeziehung erst bis zum Ende der Transaktion zu überprüfen.
• Es ist auf die von Ihnen verwendete Datenbank zugeschnitten, so dass datenbankabhängige Feldtypen wie auto_increment (MySQL), bigint PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY (PostgreSQL) oder integer primary key autoincrement (SQLite) automatisch für Sie behandelt werden. Dasselbe gilt für die Anführungszeichen von Feldnamen - z.B. Verwendung von doppelten oder einfachen Anführungszeichen.
• Der sqlmigrate-Befehl führt die Migration auf Ihrer Datenbank tatsächlich nicht aus - stattdessen druckt er sie auf dem Bildschirm aus, damit Sie sehen können, welche SQL-Anweisungen Django benötigt. Es ist nützlich, um zu überprüfen, was Django machen wird, oder wenn Sie Datenbankadministratoren haben, die SQL-Skripte für Änderungen benötigen.

Wenn Sie interessiert sind, können Sie auch python manage.py check <check> ausführen; dies überprüft das Projekt auf Probleme, ohne Migrationen zu erstellen oder die Datenbank zu berühren.

Jetzt führen Sie migrate erneut aus, um diese Modelltabellen in Ihrer Datenbank zu erstellen:

python manage.py migrate

Operations to perform:
  Apply all migrations: admin, auth, contenttypes, polls, sessions
Running migrations:
  Applying polls.0001_initial... OK

Der migrate-Befehl nimmt alle Migrationen, die noch nicht angewendet wurden (Django verfolgt, welche angewendet wurden, mithilfe einer speziellen Tabelle in Ihrer Datenbank namens django_migrations) und führt sie auf Ihrer Datenbank aus - im Wesentlichen synchronisiert er die Änderungen, die Sie an Ihren Modellen vorgenommen haben, mit dem Schema in der Datenbank.

Migrationen sind sehr leistungsfähig und ermöglichen es Ihnen, Ihre Modelle im Laufe der Entwicklung Ihres Projekts zu ändern, ohne dass Sie Ihre Datenbank oder Tabellen löschen und neu erstellen müssen - sie sind speziell darauf ausgelegt, Ihre Datenbank live zu aktualisieren, ohne Daten zu verlieren. Wir werden sie in einem späteren Teil des Tutorials genauer behandeln, aber für jetzt halten Sie sich an die drei Schritte, um Änderungen an Modellen vorzunehmen:

• Ändern Sie Ihre Modelle (in models.py).
• Führen Sie python manage.py makemigrations <makemigrations> aus, um Migrationen für diese Änderungen zu erstellen.
• Führen Sie python manage.py migrate <migrate> aus, um diese Änderungen auf die Datenbank anzuwenden.

Der Grund, warum es separate Befehle gibt, um Migrationen zu erstellen und anzuwenden, ist, dass Sie Migrationen in Ihr Versionskontrollsystem committen und sie mit Ihrer App ausliefern können; sie erleichtern nicht nur Ihre Entwicklung, sondern sind auch für andere Entwickler und in der Produktion verwendbar.

Lesen Sie die django-admin-Dokumentation </ref/django-admin>, um vollständige Informationen über die Funktionen der manage.py-Hilfsprogramme zu erhalten.

Mit der API experimentieren

Lassen Sie uns nun in die interaktive Python-Shell springen und mit der kostenlosen API experimentieren, die Ihnen Django zur Verfügung stellt. Um die Python-Shell aufzurufen, verwenden Sie diesen Befehl:

python manage.py shell

Wir verwenden dies anstelle von einfach "python" zu tippen, weil manage.py die Umgebungsvariable DJANGO_SETTINGS_MODULE setzt, die Django den Python-Importpfad zu Ihrer mysite/settings.py-Datei gibt.

Sobald Sie in der Shell sind, erkunden Sie die Datenbank-API </topics/db/queries>:

>>> from polls.models import Choice, Question  ## Importieren Sie die Modellklassen, die wir gerade geschrieben haben.

## Es sind noch keine Fragen im System.
>>> Question.objects.all()
<QuerySet []>

## Erstellen Sie eine neue Frage.
## Die Unterstützung für Zeitzonen ist in der Standard-Einstellungsdatei aktiviert, so dass
## Django ein Datum und Uhrzeit mit Zeitzone für pub_date erwartet. Verwenden Sie timezone.now()
## anstelle von datetime.datetime.now() und es wird das Richtige tun.
>>> from django.utils import timezone
>>> q = Question(question_text="What's new?", pub_date=timezone.now())

## Speichern Sie das Objekt in der Datenbank. Sie müssen save() explizit aufrufen.
>>> q.save()

## Jetzt hat es eine ID.
>>> q.id
1

## Greifen Sie auf die Modellfeldwerte über Python-Attribute zu.
>>> q.question_text
"What's new?"
>>> q.pub_date
datetime.datetime(2023, 9, 7, 1, 18, 48, 335644, tzinfo=datetime.timezone.utc)

## Ändern Sie die Werte, indem Sie die Attribute ändern und dann save() aufrufen.
>>> q.question_text = "What's up?"
>>> q.save()

## objects.all() zeigt alle Fragen in der Datenbank an.
>>> Question.objects.all()
<QuerySet [<Question: Question object (1)>]>

Warten Sie einen Moment. <Question: Question object (1)> ist keine hilfreiche Darstellung dieses Objekts. Lassen Sie uns das beheben, indem wir das Question-Modell (in der Datei polls/models.py) bearbeiten und eine ~django.db.models.Model.__str__-Methode zu Question und Choice hinzufügen:

from django.db import models


class Question(models.Model):
    #...
    def __str__(self):
        return self.question_text


class Choice(models.Model):
    #...
    def __str__(self):
        return self.choice_text

Es ist wichtig, ~django.db.models.Model.__str__-Methoden zu Ihren Modellen hinzuzufügen, nicht nur für Ihre eigene Bequemlichkeit, wenn Sie mit dem interaktiven Prompt arbeiten, sondern auch, weil die Darstellungen von Objekten in der gesamten automatisch generierten Django-Admin verwendet werden.

Lassen Sie uns auch eine benutzerdefinierte Methode zu diesem Modell hinzufügen:

import datetime

from django.db import models
from django.utils import timezone


class Question(models.Model):
    #...
    def was_published_recently(self):
        return self.pub_date >= timezone.now() - datetime.timedelta(days=1)

Beachten Sie die Hinzufügung von import datetime und from django.utils import timezone, um auf das standardmäßige Python-datetime-Modul und die Zeitzonenbezogenen Hilfsprogramme von Django in django.utils.timezone zu verweisen. Wenn Sie nicht vertraut mit der Zeitzonenbehandlung in Python sind, können Sie mehr in den Zeitzonenunterstützungsdokumentationen </topics/i18n/timezones> lernen.

Speichern Sie diese Änderungen und starten Sie eine neue Python-interaktive Shell, indem Sie erneut python manage.py shell ausführen:

>>> from polls.models import Choice, Question

## Stellen Sie sicher, dass unsere __str__()-Hinzufügung funktioniert.
>>> Question.objects.all()
<QuerySet [<Question: What's up?>]>

## Django bietet eine umfangreiche Datenbank-Such-API, die vollständig durch
## Schlüsselwortargumente gesteuert wird.
>>> Question.objects.filter(id=1)
<QuerySet [<Question: What's up?>]>
>>> Question.objects.filter(question_text__startswith="What")
<QuerySet [<Question: What's up?>]>

## Holen Sie sich die Frage, die dieses Jahr veröffentlicht wurde.
>>> from django.utils import timezone
>>> current_year = timezone.now().year
>>> Question.objects.get(pub_date__year=current_year)
<Question: What's up?>

## Fordern Sie eine ID an, die nicht existiert, dies wird eine Ausnahme auslösen.
>>> Question.objects.get(id=2)
Traceback (most recent call last):
 ...
DoesNotExist: Question matching query does not exist.

## Das Suchen nach einem Primärschlüssel ist der häufigste Fall, daher bietet Django eine
## Abkürzung für exakte Primärschlüssel-Suchen.
## Folgendes ist identisch zu Question.objects.get(id=1).
>>> Question.objects.get(pk=1)
<Question: What's up?>

## Stellen Sie sicher, dass unsere benutzerdefinierte Methode funktioniert.
>>> q = Question.objects.get(pk=1)
>>> q.was_published_recently()
True

## Geben Sie der Question ein paar Choices. Der create-Aufruf konstruiert ein neues
## Choice-Objekt, führt die INSERT-Anweisung aus, fügt die Wahl der Menge der verfügbaren
## Wahlen hinzu und gibt das neue Choice-Objekt zurück. Django erstellt
## eine Menge, um die "andere Seite" einer ForeignKey-Beziehung
## (z.B. die Wahl einer Frage) zu speichern, die über die API abgerufen werden kann.
>>> q = Question.objects.get(pk=1)

## Zeigen Sie alle Choices aus der zugehörigen Objektmenge an - bisher keine.
>>> q.choice_set.all()
<QuerySet []>

## Erstellen Sie drei Choices.
>>> q.choice_set.create(choice_text="Not much", votes=0)
<Choice: Not much>
>>> q.choice_set.create(choice_text="The sky", votes=0)
<Choice: The sky>
>>> c = q.choice_set.create(choice_text="Just hacking again", votes=0)

## Choice-Objekte haben API-Zugang zu ihren zugehörigen Question-Objekten.
>>> c.question
<Question: What's up?>

## Und umgekehrt: Question-Objekte haben Zugang zu Choice-Objekten.
>>> q.choice_set.all()
<QuerySet [<Choice: Not much>, <Choice: The sky>, <Choice: Just hacking again>]>
>>> q.choice_set.count()
3

## Die API folgt automatisch Beziehungen, soweit Sie es benötigen.
## Verwenden Sie doppelte Unterstriche, um Beziehungen zu trennen.
## Dies funktioniert so tief wie Sie möchten; es gibt keine Grenze.
## Finden Sie alle Choices für jede Frage, deren pub_date in diesem Jahr ist
## (verwenden Sie die zuvor erstellte 'current_year'-Variable).
>>> Choice.objects.filter(question__pub_date__year=current_year)
<QuerySet [<Choice: Not much>, <Choice: The sky>, <Choice: Just hacking again>]>

## Lassen Sie uns eine der Choices löschen. Verwenden Sie dafür delete().
>>> c = q.choice_set.filter(choice_text__startswith="Just hacking")
>>> c.delete()

Weitere Informationen zu Modellbeziehungen finden Sie unter Zugreifen auf verwandte Objekte </ref/models/relations>. Weitere Informationen zu Verwendung von doppelten Unterstrichen zur Durchführung von Feldsuche über die API finden Sie unter Feldsuche <field-lookups-intro>. Vollständige Details zur Datenbank-API finden Sie in unserer Datenbank-API-Referenz </topics/db/queries>.

Einführung in die Django-Admin

Das Erstellen von Administrationsseiten für Ihr Personal oder Kunden, um Inhalte hinzuzufügen, zu ändern und zu löschen, ist mühsame Arbeit, die nicht viel Kreativität erfordert. Aus diesem Grund automatisieren Django die Erstellung von Administrationsschnittstellen für Modelle vollständig.

Django wurde in einem Redaktionsumfeld geschrieben, mit einer sehr klaren Trennung zwischen "Inhaltspublizisten" und der "öffentlichen" Website. Die Site-Manager verwenden das System, um Nachrichten, Veranstaltungen, Sportergebnisse usw. hinzuzufügen, und dieser Inhalt wird auf der öffentlichen Website angezeigt. Django löst das Problem der Erstellung einer einheitlichen Schnittstelle für die Site-Administratoren, um Inhalte zu bearbeiten.

Die Admin-Site ist nicht für die Besucher der Website gedacht. Sie ist für die Site-Manager.

Erstellen eines Admin-Benutzers

Zunächst müssen wir einen Benutzer erstellen, der sich in die Admin-Site einloggen kann. Führen Sie folgenden Befehl aus:

python manage.py createsuperuser

Geben Sie Ihren gewünschten Benutzernamen ein und drücken Sie die Eingabetaste.

Username: admin

Anschließend werden Sie aufgefordert, Ihre gewünschte E-Mail-Adresse einzugeben:

Email address: [email protected]

Der letzte Schritt ist, Ihr Passwort einzugeben. Sie werden dazu aufgefordert, Ihr Passwort zweimal einzugeben, das zweite Mal als Bestätigung des ersten.

Password: 12345678
Password (again): 12345678

This password is too common.
This password is entirely numeric.
Bypass password validation and create user anyway? [y/N]: y
Superuser created successfully.

Starten des Entwicklungsservers

Die Django-Admin-Site ist standardmäßig aktiviert. Lassen Sie uns den Entwicklungsserver starten und ihn erkunden.

Wenn der Server nicht läuft, starten Sie ihn wie folgt:

python manage.py runserver

Öffnen Sie jetzt einen Webbrowser im VNC-Tab und gehen Sie auf Ihrer lokalen Domain zu "/admin/" - z.B. http://127.0.0.1:8000/admin/. Sie sollten das Login-Screen der Admin-Site sehen:

Da translation </topics/i18n/translation> standardmäßig eingeschaltet ist, wird der Login-Screen in der angegebenen Sprache angezeigt (wenn Django passende Übersetzungen hat).

Eintreten in die Admin-Site

Versuchen Sie jetzt, sich mit dem Superuser-Konto einzuloggen, das Sie im vorherigen Schritt erstellt haben. Sie sollten die Django-Admin-Indexseite sehen:

Sie sollten einige Arten von bearbeitbarem Inhalt sehen: Gruppen und Benutzer. Sie werden von django.contrib.auth, dem Authentifizierungsframework, das von Django mitgeliefert wird, bereitgestellt.

Machen Sie die Umfrage-App im Admin veränderbar

Aber wo ist unsere Umfrage-App? Sie wird nicht auf der Admin-Indexseite angezeigt.

Es bleibt nur noch ein weiterer Schritt: Wir müssen der Admin mitteilen, dass Question-Objekte eine Admin-Schnittstelle haben. Um dies zu tun, öffnen Sie die Datei polls/admin.py und bearbeiten Sie sie, so dass sie wie folgt aussieht:

from django.contrib import admin

from.models import Question

admin.site.register(Question)

Erkunden Sie die kostenlosen Admin-Funktionalitäten

Jetzt, da wir Question registriert haben, weiß Django, dass es auf der Admin-Indexseite angezeigt werden sollte:

Klicken Sie auf "Fragen". Jetzt befinden Sie sich auf der "Änderungsliste"-Seite für Fragen. Diese Seite zeigt alle Fragen in der Datenbank an und ermöglicht es Ihnen, eine auszuwählen, um sie zu ändern. Da ist die Frage "What's up?", die wir zuvor erstellt haben:

Klicken Sie auf die Frage "What's up?", um sie zu bearbeiten:

Dinge, die hier zu beachten sind:

• Das Formular wird automatisch aus dem Question-Modell generiert.
• Die verschiedenen Modellfeldtypen (~django.db.models.DateTimeField, ~django.db.models.CharField) entsprechen dem passenden HTML-Eingabefeld. Jeder Feldtyp weiß, wie er sich in der Django-Admin anzeigt.
• Jeder ~django.db.models.DateTimeField erhält kostenlose JavaScript-Kurzschlüsse. Datumseingaben erhalten einen "Heute"-Kurzschluss und einen Kalender-Popup, und Zeitangaben erhalten einen "Jetzt"-Kurzschluss und ein bequemes Popup, das häufig eingegebene Zeiten auflistet.

Der untere Teil der Seite bietet Ihnen einige Optionen:

• Speichern - Speichert die Änderungen und kehrt zur Änderungsliste-Seite für diesen Objekttyp zurück.
• Speichern und fortfahren mit der Bearbeitung - Speichert die Änderungen und lädt die Admin-Seite für dieses Objekt neu.
• Speichern und einen anderen hinzufügen - Speichert die Änderungen und lädt ein neues, leeres Formular für diesen Objekttyp.
• Löschen - Zeigt eine Löschbestätigungsseite an.

Wenn der Wert von "Veröffentlicht am" nicht mit der Zeit übereinstimmt, zu der Sie die Frage im Erstellen einer einfachen Umfrageanwendung erstellt haben, bedeutet dies wahrscheinlich, dass Sie vergessen haben, den richtigen Wert für die TIME_ZONE-Einstellung festzulegen. Ändern Sie es, laden Sie die Seite neu und überprüfen Sie, ob der richtige Wert erscheint.

Ändern Sie das "Veröffentlicht am", indem Sie die "Heute"- und "Jetzt"-Kurzschlüsse klicken. Klicken Sie dann auf "Speichern und fortfahren mit der Bearbeitung". Klicken Sie anschließend auf "Verlauf" in der oberen rechten Ecke. Sie werden eine Seite sehen, die alle Änderungen an diesem Objekt via der Django-Admin auflistet, mit dem Zeitstempel und dem Benutzernamen der Person, die die Änderung vorgenommen hat:

Wenn Sie sich mit der Models-API vertraut machen und sich mit der Admin-Site vertraut gemacht haben, lesen Sie Erstellen der öffentlichen Schnittstellensichten, um zu erfahren, wie Sie unserer Umfrage-App weitere Sichten hinzufügen.

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das Lab "Set Up the Database" abgeschlossen. Sie können in LabEx weitere Labs ausprobieren, um Ihre Fähigkeiten zu verbessern.