[PYTHON] Django zum Anfassen

Django zum Anfassen

• Ziel --Erstelle eine sehr einfache Todo-App und verstehe den Prozessablauf von Django.
• Grundkenntnisse
• Einfaches Verständnis von HTML --Verständnis der http-Methode (GET, POST) ――Was Sie mit diesem praktischen Gerät nicht tun sollten
• Bereinigen Sie das Erscheinungsbild der Anwendung (CSS, Bootstrap)

Umgebung

OS: Ubuntu 18.04 Python: 3.6.8 Django: 2.2.5　-> 2.2.8

Wir werden später mehr über Windows hinzufügen. Ich habe keinen Mac, aber es ist wahrscheinlich dasselbe wie Linux (?). Wenn möglich hinzufügen.

Lesen Sie den Artikel Letztes Mal, und es wird davon ausgegangen, dass die Verzeichnisstruktur wie folgt ist. Wenn Sie es noch nicht eingestellt haben, erstellen Sie bitte zuerst die Umgebung.

Erstellen einer Todo-App

Von hier aus erstellen wir eine App. Geben Sie django-admin startapp mytodo auf der Konsole ein. Sie können auch "python manage.py startapp mytodo" verwenden.

Nach der Erstellung wird das Verzeichnis + die Datei der Anwendung mytodo wie unten gezeigt erstellt.

.
|-- config
|   |-- __init__.py
|   |-- __pycache__
|   |-- settings.py
|   |-- urls.py
|   `-- wsgi.py
|-- db.sqlite3
|-- manage.py
|-- myenv
|   |-- bin
|   |-- include
|   `-- lib
`-- mytodo
    |-- __init__.py
    |-- admin.py
    |-- apps.py
    |-- migrations
    |-- models.py
    |-- tests.py
    `-- views.py

Stellen Sie zuerst die Django-Zeitzone und die Sprache ein.

settings.py

#Standard'EN-en'
LANGUAGE_CODE = 'ja'
#Standard'UTC'
TIME_ZONE = 'Asia/Tokyo'

Derzeit ist die erstellte Todo-App Django nicht bekannt. Damit Django die Anwendung erkennt, muss die erstellte Anwendung zu den Einstellungen in config / settings.py hinzugefügt werden.

settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'mytodo', 　　　　　　　　　　　　　　　　#hinzufügen
]

Damit ist die Registrierung der App abgeschlossen, und schließlich erstellen wir die App.

Modell erstellen

Für Todo ist es praktischer, das Erstellungsdatum und das Enddatum anzugeben, aber diesmal wird es viel einfacher. Das diesmal definierte Modell lautet wie folgt.

models.py

from django.db import models


class Task(models.Model):
    doing = 0
    done = 1
    TASK_STATUS_CHOICES = [
        (doing,'in Bearbeitung'),
        (done,'Erledigt'),
    ]
    title = models.CharField(max_length=50)
    body = models.models.TextField()
    status =models.IntegerField(default=0,choices=TASK_STATUS_CHOICES)

Führen Sie nach dem Codieren des Modells python manage.py makemigrations auf der Konsole in einer bestimmten Hierarchie in manage.py aus. Dieser Befehl erstellt die Dateien, die zum Erstellen einer Datenbank aus dem Modell erforderlich sind. Wenn es fehlerfrei erstellt wurde, wird es wie folgt angezeigt.

(myenv)~/Projects/python/django_handson$ python manage.py makemigrations
Migrations for 'mytodo':
  mytodo/migrations/0001_initial.py
    - Create model Task

Zu diesem Zeitpunkt gibt es keine Änderungen an der Datenbank. Durch Übergeben des folgenden Befehls "python manage.py migrate" wird die vorherige Migrationsdatei für die Datenbank ausgeführt.

(myenv)~/Projects/python/django_handson$ python manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, mytodo, 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 mytodo.0001_initial... OK
  Applying sessions.0001_initial... OK

Zusätzlich zu TODO wird das Wort Benutzer angezeigt. Abgesehen davon spiegelt sich das von Djnago standardmäßig bereitgestellte Benutzermodell in der Datenbank wider.

Wenn Sie dies tun können, ist die Modellerstellung abgeschlossen.

Erstellen einer Routing-Ansichtsvorlage

Wir werden CRUD basierend auf dem zuvor erstellten Modell implementieren. Wenn ich selbst entwickle, schreibe ich in der Reihenfolge Ansicht → Vorlage → Routing, aber ich denke, dass es individuelle Unterschiede gibt. Wenn Sie sich daran gewöhnen, schreiben Sie in Ihrer eigenen Reihenfolge.

Erstellen Sie zunächst eine Seite, auf der alle Todo in einer Liste angezeigt werden. Wenn Sie ein Modell in einer Spalte anzeigen, ist die Verwendung der klassenbasierten Ansicht von Django viel einfacher, da die Codemenge erheblich reduziert wird.

Ansicht erstellen

Die Ansicht hat die Aufgabe, die Daten aus der Datenbank aus der empfangenen Anforderung abzurufen und als eingebettete Antwort in die Vorlage zurückzugeben.

Es gibt zwei Möglichkeiten, eine Ansicht zu schreiben: eine funktionsbasierte Ansicht und eine klassenbasierte Ansicht. So oder so, aber dieses Mal schreibe ich in klassenbasierter Ansicht.

Klassenbasierte Ansichten umfassen ListView, DetailView als Referenz. CreateView, UpdateView, DeleteView usw. werden zum Aktualisieren bereitgestellt. Mit diesen ist es möglich, sofort eine Ansicht für die einfache Verarbeitung vorzubereiten.

Dieses Mal werde ich eine Liste erstellen, aber die notwendige Beschreibung lautet wie folgt.

mytodo/views.py

from django.views.generic import ListView

from mytodo.models import Task

class TaskListView(ListView):
    model = Task
    template = 'mytodo/list.html'

Geben Sie für model das Modell an, das Sie anzeigen möchten. Importieren und verwenden Sie das soeben erstellte Modell. Die Vorlage ist eine Datei mit in HTML eingebetteten Python-Steueranweisungen und hat die Erweiterung ".html".

Vorlage erstellen

Ins Japanische übersetzt, wird es als Vorlage oder Typ bezeichnet, aber es ist ein Typ zum Einbetten von Werten, die die Ansicht aus der Datenbank abruft. Das Einbetten der aus der Vorlage und der Datenbank erhaltenen Werte in die Ansicht wird als Rendern bezeichnet. In der Ansicht spuckt Django eine HTML-Datei mit eingebetteten Daten aus, die auf den in der Vorlagendatei geschriebenen Steuerelementen basieren.

{{}} Wird zum Anzeigen von Daten und {%%} zum Einbetten von Python-ähnlichen Steuerelementen verwendet.

Beschreiben Sie zunächst den Speicherort des Vorlagenordners in settings.py wie folgt.

config/settings.py

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR,'templates')], #Veränderung
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

Erstellen Sie einen Vorlagenordner in derselben Hierarchie wie manage.py und erstellen Sie darin einen Ordner namens mytodo.

Erstellen Sie eine Datei mit dem Namen list.html. Dieses Mal werden wir das Erscheinungsbild überhaupt nicht behandeln. Erstellen Sie daher eine entsprechende HTML-Datei

templates/mytodo/list.html

<h1>aufführen</h1>

<ul>
  {% for task in object_list %}
  <li><a href="#">{{ task.title }}</a> {{ task.get_status_display }}</li>
  {% endfor %}
</ul>

Routing-Einstellungen

Nehmen Sie Einstellungen vor, um die entsprechende Ansicht über die Anforderungs-URL aufzurufen. In der Datei urls.py festlegen.

Sie können alles in urls.py in den Ordner config schreiben, aber wenn Sie mehrere Apps erstellen, wird es mit viel Code überlaufen und die Wartbarkeit erheblich beeinträchtigen. Dies beeinträchtigt auch die Portabilität der App. Daher ist es üblich, urls.py in der mytodo App zu erstellen und auf der config Seite einzufügen.

Erstellen Sie zuerst mytodo / urls.py und bearbeiten Sie es.

urls.py

from django.urls import path

from .views import TaskListView

app_name = 'mytodo'

urlpatterns = [
    path('',TaskListView.as_view(), name='task-list'),
]

Ordnen Sie in urls.py die angeforderte URL der Ansicht zu. Fügen Sie dies auf der Konfigurationsseite hinzu.

config/urls.py

from django.contrib import admin
from django.urls import path, include


urlpatterns = [
    path('admin/', admin.site.urls),
    path('mytodo/', include('mytodo.urls',namespace='mytodo')),#hinzufügen
]

Die Funktion path kann die Zeichenfolge registrieren, die nach dem '/' der URL im ersten Argument und view und anderen URLConf im zweiten Argument registriert werden soll.

Das Routing wird abgeschlossen, indem bis zu diesem Punkt erstellt wird. Lassen Sie uns sofort überprüfen Starten Sie den Server mit python manage.py runserver und überprüfen Sie es.

Seite nicht gefunden wird angezeigt, da nichts zur Route weitergeleitet wird. Die Liste der registrierten URLs wird etwas weiter unten angezeigt.

Fügen Sie mytodo zur URL hinzu und greifen Sie als "http: //127.0.0.1: 8000 / mytodo" darauf zu. Derzeit sind keine Daten registriert, daher wird nur die Überschrift angezeigt. Es ist rein weiß.

Implementierung von Create

Gehen Sie genauso vor, um CRUD CREATE zu implementieren.

Aussicht

Create wird auch in der klassenbasierten Ansicht implementiert. Ich werde es früher zu views.py hinzufügen.

mytodo/views.py

import django.views.generic import ListView,CreateView #Nachtrag

(Unterlassung)

class TaskCreateView(CreateView):
    model = Task
    fields = '__all__'
    initial = {'status':0}
    template_name = 'mytodo/create.html'
    success_url = reverse_lazy('mytodo:task-list')

Die Implementierungsmethode besteht darin, Modell und Vorlage auf dieselbe Weise wie ListView zu registrieren. initial kann den Anfangszustand des Auswahlfelds des Task-Modells festlegen. Felder können die Daten angeben, die auf der Serverseite empfangen werden sollen. Dieses Mal sollen wir alle Daten empfangen, aber es ist auch möglich, nur den "Titel" im "Task" -Modell zu erhalten.

Vorlage

Erstellen Sie als Nächstes eine Vorlage.

templates/mytodo/create.html

<form action="" method="post">
  {% csrf_token %}
  {{ form.as_p }}
  <input type="submit" value="Anmeldung">
</form>

In {{form.as_p}} wird das HTML des Formulars generiert, das dem Modell und den Feldern von CreateView entspricht. Das Anwenden von CSS auf das generierte Formular erfordert etwas Einfallsreichtum, aber dieses Mal können wir das einzigartige Aussehen von HTML mit einem Geschmack genießen.

Mach dir keine Sorgen um {% csrf_token%}.

Routing

Registrieren Sie die Ansicht in urls.py.

mytodo/urls.py

from django.urls import path

from .views import TaskListView, TaskCreateView #Nachtrag

app_name = 'mytodo'

urlpatterns = [
    path('',TaskListView.as_view(), name='task-list'),
    path('create',TaskCreateView.as_view(), name='task-create'),#Nachtrag
]

Der letzte Name in der Pfadfunktion kann als URL bezeichnet werden. Es kann als Argument für Funktionen wie "reverse_lazy" verwendet werden, die zuvor in views.py angezeigt wurden.

Damit ist die Implementierung von Create abgeschlossen. Starten Sie den Server und greifen Sie auf diese URL http://127.0.0.1:8000/mytodo/create zu. Wenn Sie eine leckere Form wie die folgende sehen, sind Sie erfolgreich.

Lassen Sie uns einige als Test registrieren.

Erstellen eines Detailbildschirms

Der Rest ist UPDATE und DELETE of CRUD, aber erstellen Sie zuerst DetailView. Derzeit nur die Liste der Aufgaben (Listenansicht), wir erstellen jedoch eine Seite (Detailansicht), auf der detailliertere Informationen zu den Aufgaben angezeigt werden.

Erstellen Sie aus der Ansicht wie zuvor. Die Implementierung ist wie folgt sehr einfach

mytodo/views.py

from django.views.generic import ListView,CreateView,DetailView

(Unterlassung)

class TaskDetailView(DetailView):
    model = Task
    template_name = 'mytodo/detail.html'

Die Implementierung der Vorlage ist wie folgt. Erstellen Sie auf die gleiche Weise eine Datei mit dem Namen detail.html im Ordner templates / mytodo.

templates/mytodo/detail.html

<h1>Einzelheiten</h1>
<div>Titel:{{object.title}}</div>
<div>status:{{object.get_status_display}}</div>
<div>Inhalt:{{object.body}}</div>
<p><a href="#">Bearbeiten</a></p>

Registrieren Sie abschließend die URL. Pfad ('Detail', TaskDetailView.as_view (), Name = 'Task-Detail') in der Liste der URL-Muster ] Hinzufügen.

Damit ist die Implementierung von DetailView abgeschlossen.

Implementieren Sie den Übergang von der Listenseite zur Detailansicht. Bearbeiten Sie den Link a tag in list.html.

templates/mytodo/detail.html

<h1>Einzelheiten</h1>
<div>Titel:{{object.title}}</div>
<div>status:{{object.get_status_display}}</div>
<div>Inhalt:{{object.body}}</div>
<p><a href="{% url 'mytodo:task-update' object.pk%}">Bearbeiten</a></p>　#Veränderung

Mit object.pk können Sie den Primärschlüssel des an die Vorlage übergebenen Objekts abrufen.

Implementierung der Update-Funktion

Dies wird auch in View implementiert.

mytodo/views.py

from django.views.generic import ListView,CreateView,DetailView, UpdateView
from django.urls import reverse_lazy

from mytodo.models import Task

(Unterlassung)

class TaskUpdateView(UpdateView):
    model = Task
    fields = '__all__'
    template_name = 'mytodo/update.html'
    success_url = reverse_lazy('mytodo:task-list')

Es ist fast das gleiche wie bei CreateView. Wenn Sie die Felder einschränken möchten, die Aktualisierungen zulassen, können Sie mit Feldern spielen.

Da es fast die gleiche Arbeit ist, werden wir Routing und Vorlagen sofort implementieren.

Die Vorlage ist genau die gleiche wie Erstellen.

templates/mytodo/update.html

<form action="" method="post">
  {% csrf_token %}
  {{ form.as_p }}
  <input type="submit" value="Anmeldung">
</form>

Fügen Sie dem Routing eine neue UpdateView hinzu. Wie beim Detail bestimmt der Primärschlüssel, welche Daten aktualisiert werden sollen. ..

mytodo/urls.py

urlpatterns = [
    path('',TaskListView.as_view(), name='task-list'),
    path('detail/<int:pk>/',TaskDetailView.as_view(), name='task-detail'),
    path('create/', TaskCreateView.as_view(), name='task-create'),
    path('update/<int:pk>/', TaskUpdateView.as_view(), name='task-update'),                 #hinzufügen
]

Wir werden einige Änderungen vornehmen, damit der Übergang zu diesem Bearbeitungsbildschirm über den Detailbildschirm durchgeführt werden kann.

templates/mytodo/detail.html

<h1>Einzelheiten</h1>
<div>Titel:{{object.title}}</div>
<div>status:{{object.get_status_display}}</div>
<div>Inhalt:{{object.body}}</div>
<p><a href="{% url 'mytodo:task-update' object.pk%}">Bearbeiten</a></p>

Hinzufügung der Löschfunktion

Es ist endlich das Ende. Implementieren Sie eine Löschansicht. Wie im Beispiel werden wir es aus der Sicht implementieren.

Implementierung anzeigen.

mytodo/views.py

from django.views.generic import ListView,CreateView,DetailView, UpdateView
from django.urls import reverse_lazy

from mytodo.models import Task

(Unterlassung)

class TaskDeleteView(DeleteView):
    model = Task
    template_name = 'mytodo/delete.html'
    success_url = reverse_lazy('mytodo:task-list')

Implementierung der Vorlage. Dies ist sehr einfach, da Sie das Löschen verzögern können.

templates/mytodo/delete.html

<form action="" method="post">
  {% csrf_token %}
  <p>Möchten Sie dies wirklich löschen?</p>
  <p><input type="submit" value="Yes"></p>
  <p><a href="{% url 'mytodo:task-list' %}">Rückkehr</a></p>
</form>

Implementierung des Routings. Der endgültige Typ ist wie folgt.

mytodo/urls.py

from django.urls import path

from .views import TaskListView, TaskCreateView, TaskDetailView, TaskUpdateView, TaskDeleteView

app_name = 'mytodo'

urlpatterns = [
    path('',TaskListView.as_view(), name='task-list'),
    path('detail/<int:pk>/',TaskDetailView.as_view(), name='task-detail'),
    path('create/', TaskCreateView.as_view(), name='task-create'),
    path('update/<int:pk>/', TaskUpdateView.as_view(), name='task-update'),
    path('delete/<int:pk>/', TaskDeleteView.as_view(), name='task-delete'),            #hinzufügen
]

Schließlich habe ich die URL hinzugefügt, die zu dieser gelöschten Ansicht übergeht. Es tut mir übrigens leid, list.html mit der Steueranweisung der Vorlage zu verarbeiten.

templates/mytodo/list.html

<h1>aufführen</h1>

<a href="create/"><p>Neuer Zusatz</p></a>
<ul>
  {% for task in object_list %}
  {% if task.status != 0 %}
    <li><del><a href="detail/{{ task.id }}">{{ task.title }}</a>  </del>{{ task.get_status_display }} <a href="{% url 'mytodo:task-delete' task.pk %}">Löschen</a></li>
  {% else %}
    <li><a href="detail/{{ task.id }}">{{ task.title }}</a>  {{ task.get_status_display }} <a href="{% url 'mytodo:task-delete' task.pk %}">Löschen</a></li>
  {% endif %}
  
  {% empty %}
    <li>No tasks</li>
  {% endfor %}
</ul>

abschließend

Vielen Dank, dass Sie bis zum Ende des Artikels über die Verwendung von Amateur-Django bei uns bleiben. Wenn Sie Fehler haben, zögern Sie bitte nicht zu warten.