Normalerweise verwende ich Laravel (PHP) oder ASP.NET MVC (C #), aber manchmal erinnere ich mich, wenn ich Django verwende.
Was ich wissen möchte ist
Ich sagte, dass. In diesem Sinne wird es hauptsächlich in dem Artikel hier behandelt (danke), aber es unterscheidet sich ein wenig von meinen Bedürfnissen. Es gibt auch, also werde ich versuchen, es auf meine eigene Weise zusammenzufassen.
Weil Sie ein anderes Framework verwenden? ?? ?? Personen, die bereits andere Frameworks verwenden, können den Unterschied im Voraus leichter verstehen.
Django verwendet ein MTV-Modell, kein MVC. Es scheint jedoch, dass kein neues Konzept erforderlich ist, da das Bild zeigt, dass der Name des VC-Teils anders ist als das Modell.
Ist die Entsprechung zwischen MVC und MTV wie folgt?
Das Durcheinander mit Viwe (views.py) ist wie das Durcheinander mit dem Controller in MVC, und Template ist wie das Durcheinander mit der Ansicht (HTML-Beschreibung) von MVC.
Es scheint, dass das große Konzept eines Projekts eine Anwendung beinhaltet.
Die Einstellungen, die dem Ganzen gemeinsam sind, werden im Rahmen des Projekts festgelegt, und die Einstellungen und Beschreibungen jeder Anwendung sind Bilder, die von der Anwendung erstellt werden.
Ich persönlich hatte den Eindruck, dass die Beziehung zwischen der Visual Studio-Lösung und dem Projekt besteht.
Ich denke, dies ist eine Frage der Vertrautheit, aber wenn Sie beispielsweise ein Projekt mit dem Namen django_test erstellen, werden die folgenden Dateien generiert.
django_test/
manage.py
django_test/
__init__.py
settings.py
urls.py
wsgi.py
Da ein Verzeichnis, das das gesamte Projekt enthält (django_test der obersten Ebene) und ein Unterverzeichnis mit demselben Namen, das die zugehörigen Dateien des Projekts enthält, generiert werden, ist es schwierig zu sagen, welches Verzeichnis django_test ist, wenn Sie einfach das Verzeichnis django_test sagen. ..
Die Operation in diesem Artikel verwendet den django_test der obersten Ebene als Kalenderverzeichnis.
Obwohl in diesem Artikel nicht behandelt, hat Django eine Kultur des "automatischen Generierens von Formularen", daher gibt es dafür Formularklassen und ModelForm-Klassen. Ohne Vorkenntnisse von "automatisch ein Formular generieren"? ?? ?? Es wird werden.
Gehen Sie so vor, als hätten Sie bereits eine Python-Umgebung (3.x). Ich erstelle und verwende eine virtuelle Umgebung mit venv auf meinem Mac. Informationen zur Einrichtung der Umgebung finden Sie unter hier.
Die Version von Python ist 3.6.1 und das Ergebnis des Pip Freeze ist wie folgt.
pip freeze
Django==1.11
django-bootstrap-form==3.2.1
PyMySQL==0.7.11
pytz==2017.2
Bevor wir uns mit der spezifischen Codierung befassen, werden wir das Projekt erstellen und konfigurieren.
Erstellen Sie zunächst ein Django-Projekt. Wenn Sie den folgenden Befehl ausführen, wird ein Verzeichnis mit dem Namen django_test erstellt und die erforderlichen Dateien werden generiert.
django-admin.py startproject django_test
Lassen Sie uns an dieser Stelle prüfen, ob es vorerst funktioniert. Starten Sie den Entwicklungsserver.
python manage.py runserver
Django verwendet manage.py als verschiedene Steuerbefehle. Es fühlt sich an wie Laravels Handwerker.
Versuchen Sie nach dem Start, auf die folgende URL zuzugreifen.
http://localhost:8000
Es ist in Ordnung, wenn [es hat funktioniert!] Auf dem Bildschirm angezeigt wird, der nicht so aussieht.
Ich kann nicht migrieren! !! !! Die Warnung wird angezeigt, es gibt jedoch kein Problem, da sie später behandelt wird. Wenn Sie interessiert sind, führen Sie bitte zuerst die folgende Migration aus.
Wenn die Bestätigung abgeschlossen ist, beenden Sie den Entwicklungsserver mit Strg + C.
Nehmen wir nun die Einstellungen für die Verwendung der Datenbank vor. Django verwendet standardmäßig SQLite, aber ich möchte MySQL verwenden.
Installieren Sie als Nächstes die Pakete, die für die Verwendung von MySQL in Python erforderlich sind. Es scheint verschiedene Typen zu geben, aber ich werde PyMySQL verwenden.
pip install PyMySQL
Sobald das Paket vorhanden ist, legen Sie die Datenbankzugriffsinformationen fest. Legen Sie in Django die Datenbankverbindungsinformationen in settings.py im Projektverzeichnis fest (in diesem Fall django_test).
Beschreiben Sie DATENBANKEN wie folgt. Ändern Sie den Datenbanknamen und die Zugriffsinformationen entsprechend.
django_test/settings.py
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'djangodb',
'USER': 'root',
'PASSWORD': 'root',
'HOST': '',
'PORT': '',
}
}
Natürlich wird davon ausgegangen, dass MySQL ausgeführt wird und eine Datenbank namens djangodb erstellt wurde.
Fügen Sie außerdem die folgende Beschreibung oben in settings.py hinzu, damit das Projekt das PyMySQL-Paket lädt.
settings.py
import pymysql
pymysql.install_as_MySQLdb()
Wo soll ich es wirklich schreiben? Lass es mich wissen, bitte.
Versuchen Sie nach dem Festlegen der Datenbankverbindungsinformationen die Migration.
python manage.py migrate
Wenn die Datenbankeinstellungen korrekt sind, sollte es korrekt funktionieren. Wenn ein Fehler auftritt, überprüfen Sie verschiedene Einstellungen. Bei korrekter Ausführung wurde anscheinend die folgende Tabelle erstellt. Es gibt nicht viele.
+----------------------------+
| Tables_in_djangodb |
+----------------------------+
| auth_group |
| auth_group_permissions |
| auth_permission |
| auth_user |
| auth_user_groups |
| auth_user_user_permissions |
| django_admin_log |
| django_content_type |
| django_migrations |
| django_session |
+----------------------------+
Spielen Sie beim Spielen mit settings.py auch mit anderen Einstellungen.
LANGUAGE_CODE = 'ja'
TIME_ZONE = 'Asia/Tokyo'
Führen Sie zu diesem Zeitpunkt runserver aus und überprüfen Sie erneut http: // localhost: 8000. Die Nachricht sollte auf Japanisch sein.
Nachdem die Einstellungen für das gesamte Projekt abgeschlossen wurden, erstellen Sie eine Anwendung. Erstellen Sie hier eine Anwendung mit dem Namen sample.
Führen Sie den folgenden Befehl aus, um eine Anwendung zu erstellen.
python manage.py startapp sample
Bei der Ausführung wird ein Verzeichnis namens sample hinzugefügt und anwendungsbezogene Dateien werden darunter generiert. Die hierarchische Struktur sollte folgendermaßen aussehen:
django_test/
sample/
__init__.py
admin.py
apps.py
migrations/
__init__.py
models.py
tests.py
views.py
manage.py
django_test/
Wenn Sie eine Anwendung erstellt haben, projizieren Sie sie? Fügen Sie es INSTALLED_APPS in settings.py hinzu, damit es erkannt werden kann. Ich denke, dieser Bereich ist ein "magischer" Typ, also werde ich fortfahren, ohne mich zu beschweren.
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
+ 'sample',
]
Es ist endlich Zeit, mit dem Codieren zu beginnen. Sie können alles schreiben, aber zuerst beginnen wir mit dem Modell.
Beschreiben Sie das Modell in models.py, das unter sample generiert wurde.
Definieren wir hier ein Member-Modell, das sich die Speicherung von Member-Informationen vorstellt. Diese Beschreibung wird als Informationen zur Tabellengenerierung beim Generieren einer Migrationsdatei verwendet.
Es scheint eine Möglichkeit zu geben, eine vorhandene Tabelle zu verwenden.
sample/models.py
class Member(models.Model):
name = models.CharField('Vollständiger Name', max_length=255)
email = models.CharField('E-Mail', max_length=255)
age = models.IntegerField('Alter', blank=True, default=0)
def __str__(self):
return self.name
Generieren Sie nun eine Migrationsdatei und führen Sie die Migration aus. Generieren Sie eine Migrationsdatei, indem Sie den Namen der Anwendung angeben, die das Modell generiert hat.
python manage.py makemigrations sample
python manage.py migrate
Tun Sie dies jedes Mal, wenn Sie Änderungen am Modell vornehmen.
Es sieht so aus, als ob die Migration erfolgreich war, also schaue ich mir die generierte Tabelle an. Anscheinend heißt der Tabellenname applicationname_tabellenname (und nicht Plural).
+----------------------------+
| Tables_in_djangodb |
+----------------------------+
| auth_group |
| auth_group_permissions |
| auth_permission |
| auth_user |
| auth_user_groups |
| auth_user_user_permissions |
| django_admin_log |
| django_content_type |
| django_migrations |
| django_session |
| sample_member |
+----------------------------+
Werfen wir einen Blick auf den Inhalt.
Es scheint, dass der Standardwert nicht 0 ist, aber ich kümmere mich nicht um die Details und fahre fort.
+-------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| name | varchar(255) | NO | | NULL | |
| email | varchar(255) | NO | | NULL | |
| age | int(11) | NO | | NULL | |
+-------+--------------+------+-----+---------+----------------+
Django hat kein Gerüst, aber eine vordefinierte Administrationsseite, um das Modell zu verwalten. Sie können die Daten direkt in die Datenbank einfügen. Da dies jedoch eine große Sache ist, aktivieren Sie die Verwaltungssite und versuchen Sie, sie zu verwenden.
Es gibt auch einen Mechanismus namens Fixture, der Daten eingibt.
Wenn Sie zu http: // localhost: 8000 / admin gehen, ohne etwas zu tun, können Sie auf die Administrationssite selbst zugreifen, diese ist jedoch nicht verfügbar, da der Benutzer und das Kennwort für die Anmeldung nicht definiert sind. Also generiere es.
Wenn der Entwicklungsserver nicht ausgeführt wird, starten Sie ihn mit runserver.
python manage.py createsuperuser
Bitte stellen Sie den Benutzernamen, die E-Mail-Adresse und das Passwort nach Bedarf ein. Wenn Sie fertig sind, melden Sie sich mit dem generierten Benutzer und Kennwort an.
Wenn ich mich auf der Verwaltungssite anmelde, gibt es Elemente, die Gruppen und Benutzer anzeigen, aber ich kann keine Mitglieder finden. Es scheint, dass Sie sich als Verwaltungsziel registrieren müssen, um es zu einem Verwaltungsziel zu machen.
Machen Sie admin.py unter sample wie folgt.
sample/admin.py
from django.contrib import admin
from sample.models import Member
# Register your models here.
admin.site.register(Member)
Wenn Sie sich erneut beim Verwaltungsbildschirm anmelden (aktualisieren), wird die Beschreibung "Mitglieder" hinzugefügt. Fügen wir nun einige Daten hinzu, da wir sie später für die Anzeige verwenden möchten.
Bevor wir die registrierten Daten anzeigen, untersuchen wir, wie sie angezeigt werden. Zur Ausstellung
Es scheint üblich zu sein, dem Ablauf zu folgen, aber zuerst verwenden wir nur die Ansichts- und Routingdefinition ohne Verwendung der Vorlage.
Definieren wir nun die Ansicht. Fügen Sie die Beschreibung unter view unter view.py hinzu. Zur Zeit habe ich eine Beschreibung geschrieben, die direkt "Index!" An die Methode namens index zurückgibt.
sample/views.py
from django.shortcuts import render
from django.http import HttpResponse
# Create your views here.
def index(request):
#Gibt die Zeichenfolge vorerst zurück.
return HttpResponse("Index!")
Ordnen Sie dann die URL und die Methode zu. Beachten Sie, dass die Definition des Routings in Django nicht alles in einer Datei beschreibt.
Es ist wie eine Art, also folge ihr.
Generieren Sie dann urls.py unter sample und beschreiben Sie es wie folgt.
sample/urls.py
from django.conf.urls import url
from sample import views
urlpatterns = [
url(r'^members/$', views.index, name='index'),
]
Die Route (URL zur Karte) scheint in einem regulären Ausdruck geschrieben zu sein. Es ist ärgerlich, wenn es um Ärger geht, aber es ist sicher, wenn es um Gewissheit geht. Außerdem scheint das erste r '' zu bedeuten, dass Sonderzeichen wie \ in '' auch als gewöhnliche Zeichen behandelt werden.
Nachdem die Beschreibung in der Anwendung abgeschlossen ist, schreiben Sie Folgendes in urls.py unter die Lösung (django_test).
urls.py
from django.conf.urls import url, include
from django.contrib import admin
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^sample/', include('sample.urls', namespace='sample'))
]
Nachdem die Definition abgeschlossen ist, führen Sie den Server aus und versuchen Sie, auf die unten stehende URL zuzugreifen.
http://localhost:8000/sample/index
Wenn die Meldung "Index!" Angezeigt wird, ist dies in Ordnung.
Nachdem wir die Beziehung zwischen views.py und urls.py kennen, definieren wir eine Vorlage (HTML) und verwenden sie.
In Django ist die übliche Vorlage
project_name/application_name/templates/base.html
Es scheint nach der Regel angeordnet zu sein. Hier,
django_test/sample/templates/base.html
Generieren und beschreiben Sie die Datei. Das Vorlagenverzeichnis ist nicht vorhanden. Erstellen Sie es daher.
Ich benutze Bootstrap häufig, daher habe ich das Bootstrap-Beispiel ein wenig geändert (geändert, um CDN zu verwenden) und es zu einer allgemeinen Vorlage gemacht.
sample/templates/base.html
{% load staticfiles %}
<!DOCTYPE html>
<html lang="ja">
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>{% block title %}My books{% endblock %}</title>
<!-- Bootstrap -->
<link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
{% block content %}
{{ content }}
{% endblock %}
</div>
<!-- jQuery (necessary for Bootstrap's JavaScript plugins) -->
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>
<!-- Include all compiled plugins (below), or include individual files as needed -->
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
</body>
</html>
Wie Sie in der obigen Beschreibung sehen können,
<title>{% block title %}My books{% endblock %}</title>
<div class="container">
{% block content %}
{{ content }}
{% endblock %}
</div>
Die Teile werden bei Bedarf dynamisch ausgetauscht.
Sie können auch ein Verzeichnis definieren, um statischen Inhalt zu speichern, aber ich werde es hier weglassen. In diesem Sinne denke ich nicht, dass die Beschreibung {% load staticfiles%} in diesem Bereich notwendig ist.
Beschreiben Sie jede Seite. In Django scheint es keine strikte Zuordnung zwischen dem Namen der Ansicht (Controller) und dem Ordnernamen für andere MVC-Frameworks zu geben, aber hier erstelle ich ein Verzeichnis mit dem Namen Mitglieder unter Vorlagen und erstelle index.html darunter. ・ Beschreiben.
Lesen wir base.html und beschreiben Sie zunächst nur den Inhalt, der dem in base.html definierten Block zugeordnet werden soll.
sample/templates/members/index.html
{% extends "base.html" %}
{% block title %}
Geplant, um eine Liste anzuzeigen
{% endblock title %}
{% block content %}
<h1>Inhalt vorerst</h1>
{% endblock content %}
In Djangos Vorlagensystem
{% block block_name %}{% endblock block_name %}
Es scheint, dass eine dynamische Anzeige realisiert wird, indem ein Block mit der Regel definiert und eine Variable vorbereitet wird, die dem Blocknamen entspricht.
Ändern Sie nun die Beschreibung von views.py so, dass Sie die erstellte index.html anstelle der Beschreibung sehen können, die direkt auf "Index!" Antwortete.
sample/views.py
def index(request):
# return HttpResponse("Index!")
return render(request, 'members/index.html')
Wenn die Bearbeitung abgeschlossen ist, führen Sie runserver und aus
http://localhost:8000/sample/members/
Bitte greifen Sie zu, um zu überprüfen, ob es korrekt angezeigt wird. Wird der Titel korrekt ersetzt?
Lassen Sie uns nun die in der Datenbank gespeicherten Daten anzeigen.
Bearbeiten Sie views.py und ändern Sie die Beschreibung, um den Wert aus der Datenbank abzurufen und an die Vorlage zurückzugeben.
sample/views.py
from django.shortcuts import render
from django.http import HttpResponse
from sample.models import Member
# Create your views here.
def index(request):
# return HttpResponse("Index!")
members = Member.objects.all().order_by('id') #Wert erhalten
return render(request, 'members/index.html', {'members':members}) #Übergeben Sie einen Wert an die Vorlage
Bearbeiten Sie auch die Anzeigeseite. Lassen Sie uns die empfangenen Daten im Tabellenformat anzeigen.
index.html
{% extends "base.html" %}
{% block title %}
Geplant, um eine Liste anzuzeigen
{% endblock title %}
{% block content %}
<h3>Listenanzeige</h3>
<table class="table table-striped table-bordered">
<thead>
<tr>
<th>ID</th>
<th>Vollständiger Name</th>
<th>E-Mail</th>
<th>Alter</th>
</tr>
</thead>
<tbody>
{% for member in members %}
<tr>
<td>{{ member.id }}</td>
<td>{{ member.name }}</td>
<td>{{ member.email }}</td>
<td>{{ member.age }}</td>
</tr>
{% endfor %}
</tbody>
</table>
{% endblock content %}
Es ist nicht besonders schwierig, aber der Loop-Teil,
{% for member in members %}
<tr><td>Was zu schleifen</td></tr>
{% endfor %}
Es wird beschrieben als.
Bitte überprüfen Sie, wann Sie fertig sind.
Zuletzt erstellen wir eine Web-API. Der Punkt ist die Antwort in json. Leider bei Django? Es scheint, dass eine Anstrengung erforderlich ist.
Ist es außerdem in vollem Umfang? Es scheint, dass Sie auch Django Rest Framework für die API verwenden können.
Fügen Sie sample / views.py die folgende Methode hinzu. Ich habe hier eine Methode namens api gewählt (nicht gut für die Benennung).
Es scheint, dass Sie nach dem Speichern der erfassten Daten in OrderedDict antworten sollten.
OrderedDict ist, wie der Name schon sagt, ein geordneter Wörterbuchtyp. Bei einem normalen Wörterbuchtyp ist die Reihenfolge der Daten nicht in der richtigen Reihenfolge, sodass sie anscheinend einmal im Typ OrderedDict gespeichert sind.
sample/views.py
def api(request):
members = []
for member in Member.objects.all().order_by('id'):
member_dict = OrderedDict([
('id',member.id),
('name',member.name),
('email',member.email),
('age',member.age),
])
members.append(member_dict)
data = OrderedDict([
('status','ok'),
('members',members),
])
json_str = json.dumps(data, ensure_ascii=False, indent=2)
return HttpResponse(json_str, content_type='application/json; charset=utf-8')
Wir verwenden keine Vorlagen und antworten direkt mit views.py. Ich habe auch so etwas wie Status zur obersten Ebene hinzugefügt (weil ich es oft persönlich benutze).
Ordnen Sie die URL zu, die der von Ihnen hinzugefügten API-Methode entspricht. Vorläufig habe ich Folgendes getan.
from django.conf.urls import url
from sample import views
urlpatterns = [
url(r'^members/$', views.index, name='Index'),
url(r'^members/api/$', views.api, name='Api'),
]
Dann runserver und
http://localhost:8000/members/api/
Bitte besuchen Sie, um zu sehen, ob der erwartete JSON zurückgegeben wird.
Der folgende json ist zurück.
{
"status": "ok",
"members": [
{
"id": 1,
"name": "hoge",
"email": "[email protected]",
"age": 20
},
{
"id": 2,
"name": "foo",
"email": "[email protected]",
"age": 40
}
]
}
Nachdem ich die grundlegende Operation verstanden habe, denke ich, dass der nächste Schritt [Ich möchte CRUD ausprobieren] ist (http://qiita.com/zaburo/items/ab7f0eeeaec0e60d6b92).
Recommended Posts