[PYTHON] Django Girls Tutorial Hinweis
Es ist ein Lernprotokoll des Django-Girls-Tutorials https://tutorial.djangogirls.org/ja/
Testumgebung
Da es sich um ein Tutorial handelt, das mit PaaS namens PythonAnywhere bereitgestellt wird, kann es in jeder Umgebung ausgeführt werden, in der Python und Git installiert werden können. Die Umgebungskonstruktion befindet sich ebenfalls im Lernprogramm. Wenn Sie also nicht über Python und Git verfügen, lesen Sie bitte den unten stehenden Link. https://tutorial.djangogirls.org/ja/python_installation/
1. Erstellen Sie ein Projekt und führen Sie es aus
Erstellen Sie zunächst ein Projektverzeichnis an einem geeigneten Ort. Dieses Mal habe ich ein Projekt in / home / username / django / proj1 erstellt.
terminal
mkdir django
cd django
django-admin startproject proj1
Die folgenden Dateien werden automatisch erstellt.
/home/Nutzername/django/proj1/
proj1
├── manage.py
├── mysite
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
├── myvenv
│ └── ...
└── requirements.txt
Schreiben Sie die erforderlichen Einstellungen in die Einstellungsdatei settings.py.
Zeitzone und Sprache
Unten ist die japanische Standardzeit und Japanisch eingestellt.
setting.py
TIME_ZONE = 'Asia/Tokyo'
LANGUAGE_CODE = 'ja'
Statische Datei PATH
setting.py
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static')
URLs, die das Lesen ermöglichen
Wenn ALLOWED_HOST auf * gesetzt ist, können alle URLs gelesen werden, es ist jedoch anfällig für HTTP-Injection-Angriffe. Stellen Sie sicher, dass Sie nur die URLs hinzufügen, die Sie zur Liste benötigen. Dieses Mal werden wir nach dem Testen mit localhost auf einem einfachen Server auf pythonanywhere.com bereitstellen. Fügen Sie also die folgenden beiden hinzu.
setting.py
ALLOWED_HOSTS = ['127.0.0.1', '.pythonanywhere.com']
Datenbankeinstellungen
Gehen Sie bei Verwendung von sqlite3 wie folgt vor.
setting.py
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
Starten Sie den Django-Testserver
Versuchen Sie, den temporären Server auszuführen, und sehen Sie, was passiert ist.
terminal
python manage.py migrate
python manage.py runserver
Öffnen Sie http: // localhost: 8000 in Ihrem Browser und Sie sollten die Django-Beispielseite sehen.
Da der Teil, der sich auf den angezeigten Inhalt bezieht, nicht geändert wurde, wird die Standardbeispielseite angezeigt.
2. Erstellen Sie ein Modell
Da es möglich ist, mehrere Apps im Projekt zu erstellen, erstellen wir Blog-Apps in einem Verzeichnis namens Blog.
terminal
python manage.py startapp blog
Ein Verzeichnis mit dem Namen blog wird wie unten gezeigt hinzugefügt.
/home/Nutzername/django/proj1/
proj1
├── blog
│ ├── admin.py
│ ├── apps.py
│ ├── __init__.py
│ ├── migrations
│ │ └── __init__.py
│ ├── models.py
│ ├── tests.py
│ └── views.py
├── db.sqlite3
├── manage.py
├── mysite
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
├── myvenv
│ └── ...
└── requirements.txt
Fügen Sie die hinzugefügte App zu INSTALLED_APPS in settings.py hinzu, damit Django sie lesen kann.
setting.py
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'blog.apps.BlogConfig',
]
Ich werde den Modellteil schreiben, der M des MVC-Modells von models.py entspricht. model ist für Back-End-Teile wie das Lesen und Schreiben der Datenbank und die Verarbeitung von Daten verantwortlich.
Vererbung der Klasse django.db.models.Model
models.py
from django.conf import settings
from django.db import models
from django.utils import timezone
class Post(models.Model):
author = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
title = models.CharField(max_length=200)
text = models.TextField()
created_date = models.DateTimeField(default=timezone.now)
published_date = models.DateTimeField(blank=True, null=True)
def publish(self):
self.published_date = timezone.now()
self.save()
def __str__(self):
return self.title
models.CharField - Ein Feld, das Text mit einer begrenzten Anzahl von Zeichen definiert
models.TextField - Dies ist für langen, uneingeschränkten Text. Es ist ein ideales Feld für Blogpost-Inhalte, oder?
models.DateTimeField - Datums- und Zeitfelder
models.ForeignKey - Dies ist ein Link zu einem anderen Modell
Fügen Sie das von Ihnen erstellte Modell zur Datenbank hinzu.
terminal
python manage.py makemigrations blog
python manage.py migrate blog
Ergebnis
Operations to perform:
Apply all migrations: blog
Running migrations:
Applying blog.0001_initial... OK
Wenn es wie oben angezeigt wird, ist die Migration erfolgreich.
3. Modell zur Administrationsseite hinzufügen
Um das zuvor erstellte Modell auf dem Verwaltungsbildschirm sichtbar zu machen, importieren Sie die zuvor erstellte Post-Klasse mit .models import Post und fügen Sie admin.site.register (Post) zu admin.py hinzu.
blog/admin.py
from django.contrib import admin
from .models import Post
admin.site.register(Post)
Erstellen Sie einen Django-Superuser, der sich beim Admin-Bildschirm anmelden kann.
python manage.py createsuperuser
Öffnen Sie den Verwaltungsbildschirm.
http://localhost:8000/admin/
Geben Sie Ihren Benutzernamen und Ihr Passwort ein, um den Verwaltungsbildschirm aufzurufen.
Sie können Beiträge hinzufügen, indem Sie auf die Schaltfläche Hinzufügen rechts neben Beiträge klicken.
Ich werde einen geeigneten Beitrag ausfüllen.
Anscheinend funktioniert das Modell einwandfrei.
Die obere Seite ist übrigens immer noch eine Rakete, da ich die Ansicht noch nicht geändert habe.
http://localhost:8000/
4. Bereitstellen
In diesem Kapitel erstellen wir ein Repository auf Github und stellen ein Blog auf PythonAnywhere bereit.
Zum Github drücken
Melden Sie sich zunächst bei github an und erstellen Sie ein Repository. Der Name des Repositorys sollte mein erster Blog sein. Wenn Sie kein Konto haben, können Sie eines kostenlos erstellen. Erstellen Sie also eines. https://github.com/
Öffnen Sie das Terminal und installieren Sie git.
terminal
sudo apt install git
Nach der Installation git init im Projektverzeichnis (in diesem Fall / home / Benutzername / django / proj1 /) und registriert dann den Benutzernamen und die E-Mail-Adresse. Das Folgende gilt für den Benutzernamen "hoge" und die E-Mail-Adresse "[email protected]".
terminal
git init
git config --global user.name hoge
git config --global user.email [email protected]
Registrieren Sie Dateien / Verzeichnisse, die nicht in git enthalten sind, in .gitignore.
/home/Nutzername/django/proj1/.gitignore
*.pyc
*~
/.vscode
__pycache__
myvenv
db.sqlite3
/static
.DS_Store
Stellen Sie sicher, dass .gitignore angezeigt wird.
terminal
git status
Ausgabe
On branch master
No commits yet
Untracked files:
(use "git add <file>..." to include in what will be committed)
.gitignore
blog/
manage.py
mysite/
nothing added to commit but untracked files present (use "git add" to track)
Es scheint, dass es sicher reflektiert wird, also schieben Sie es zu Github.
terminal
git add --all
git commit -m "first commit"
git remote add origin https://github.com/Nutzername/my-first-blog.git
git push -u origin master
Wenn der Push erfolgreich ist, wird die Datei im Github-Repository angezeigt.
Bereitstellung in PythonAnywhere
Erstellen Sie ein Konto für PythonAnyWhere https://www.pythonanywhere.com/
Gehen Sie nach dem Erstellen eines Kontos im Menü oben rechts zur Seite Konto und erstellen Sie ein API-Token.
Öffnen Sie die neue Konsole unten links im Dashboard.
Beim Öffnen wird die Konsole wie unten gezeigt geöffnet.
Installieren Sie das Hilfsprogramm und stellen Sie den Inhalt von Github mit dem Hilfsprogramm bereit.
PythonAnywhere_command-line
pip3.6 install --user pythonanywhere
pa_autoconfigure_django.py --python=3.6 https://github.com/Github Benutzername/my-first-blog.git
Lassen Sie uns die mit dem Befehl ls synchronisierten Dateien überprüfen.
PythonAnywhere_command-line
$ ls
blog db.sqlite3 manage.py proj1 static
$ ls blog/
__init__.py __pycache__ admin.py apps.py migrations models.py tests.py views.py
Sie können dies auch auf der Seite "Dateien" von PythonAnywhere überprüfen.
Da das Hilfsprogramm eine neue virtuelle Umgebung mit dem Code von github erstellt, wurde der zuvor erstellte Django-Superuser noch nicht registriert. Registrieren Sie ihn daher mit dem folgenden Befehl.
PythonAnywhere_command-line
python manage.py createsuperuser
Jetzt wird das, was Sie lokal gemacht haben, im Internet veröffentlicht. Wenn Sie über das PythonAnywhere-Dashboard zur Seite "Web Apps" wechseln, finden Sie einen Link zu der Site, die Sie von dort aus öffnen können.
Wenn Sie den Verwaltungsbildschirm aufrufen, sehen Sie, dass noch kein Beitrag vorhanden ist. Dies liegt daran, dass die Datenbank nicht mit github synchronisiert ist, da sie in .gitignore geschrieben ist. Die Einstellung .gitignore ist sehr wichtig, damit Sie die Produktionsdatenbank nicht versehentlich überschreiben.
5. Machen Sie eine Ansicht
Erstellen Sie hier eine Ansicht, um die Seite tatsächlich anzuzeigen, und schreiben Sie einen Link zur Ansicht.
Schreiben Sie einen Link zum Anzeigen
Wenn ich urls.py öffne, heißt es ungefähr so, und wenn ich zu http: // localhost / admin / komme, wird angegeben, dass auf admin.site.urls verwiesen wird. Ich habe noch keinen Link zur Blog-Ansicht angegeben, daher schreibe ich diesen.
proj1/urls.py
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('blog.urls')),
]
Wenn Sie zur Startseite http: // localhost / gelangen, fügen Sie sie hinzu, um auf proj1 / blog / urls.py zu verweisen.
proj1/urls.py
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('blog.urls')),
]
Erstellen Sie blog.urls.py und weisen Sie es an, auf die Ansicht mit dem Namen post_list aus blog / views.py zu verweisen, wenn Sie zu http: // localhost / gelangen.
proj1/blog/urls.py
from django.urls import path
from . import views
urlpatterns = [
path('', views.post_list, name='post_list'),
]
Schreiben Sie den Funktionssatz post_list, auf den oben in views.py verwiesen wird. Hier wird der Inhalt von blog / post_list.html unverändert zurückgegeben.
blog/views.py
from django.shortcuts import render
def post_list(request):
return render(request, 'blog/post_list.html', {})
Wenn Sie jetzt zu http: // localhost / kommen, wird der Link mit proj1 / urls.py → proj1 / blog / urls.py → proj1 / blog / views.py → proj1 / blog / post_list.html verbunden. ..
Wenn ich jetzt die Seite mit dem Runserver python manage.py öffne, wird eine Fehlerseite angezeigt, da proj1 / blog / post_list.html noch nicht vorhanden ist.
Wenn der Runserver fehlschlägt und die Seite nicht angezeigt wird, ist etwas, das Sie bisher geschrieben haben, falsch. Überprüfen Sie es daher.
Erstellen Sie eine Ansichtsvorlage
Nachdem Sie proj1 / blog / templates / blog / post_list.html erstellt und die Seite erneut mit dem Runserver python manage.py überprüft haben, wird die Seite schließlich fehlerfrei angezeigt. Da jedoch noch nichts geschrieben wurde, ist die Seite leer.
Wenn Sie HTML richtig schreiben, wird es so angezeigt, wie es ist.
proj1/blog/templates/blog/post_list.html
<html>
<body>
<p>Hi there!</p>
<p>It works!</p>
</body>
</html>
Lassen Sie uns eine Seite erstellen, die wie ein Blog aussieht.
proj1/blog/templates/blog/post_list.html
<html>
<head>
<title>Django Girls blog</title>
</head>
<body>
<div>
<h1><a href="/">Django Girls Blog</a></h1>
</div>
<div>
<p>published: 14.06.2014, 12:14</p>
<h2><a href="">My first post</a></h2>
<p>Aenean eu leo quam.Hallo! Vielen Dank!</p>
</div>
<div>
<p>Veröffentlichungsdatum: 2014/06/14, 12:14</p>
<h2><a href="">Zweiter Beitrag</a></h2>
<p>Hallo! Vielen Dank!</p>
</div>
</body>
</html>
Bereitstellen
Lassen Sie uns die bisherigen Inhalte für PythonAnywhere bereitstellen.
/home/Nutzername/django/proj1/
git add --all
git commit -m "changed the html for the site"
git push
Öffnen Sie die PythonAnywhere-Befehlszeile und ziehen Sie sie ab.
terminal:~/PythonAnywhere-Benutzername.pythonanywhere.com
git pull
Wenn Sie über das PythonAnywhere-Dashboard zu einer Webseite wechseln, diese neu laden und dann die Site öffnen, sollte derselbe Inhalt angezeigt werden.
6. Verwendung des Abfragesatzes
Sie können den Abfragesatz zum Lesen und Schreiben in die Datenbank verwenden, sobald Django darauf zugreift. Auf diese Weise können Sie eine Beschreibung in view.py schreiben, die wie erwartet funktioniert, wenn Sie sie tatsächlich verschieben.
Öffnen Sie den Abfragesatz in der Django-Shell.
terminal
python manage.py shell
Importieren wir die Post-Klasse und zeigen alle Post-Daten mit Post.objects.all () an.
command-line
>>> from blog.models import Post
>>> Post.objects.all()
<QuerySet [<Post:Taitoru 1>, <Post:Taitoru 2>, <Post:Taitoru 3>]>
Fügen wir einen Beitrag hinzu.
command-line
>>> from django.contrib.auth.models import User
>>> me = User.objects.get(username='Nutzername')
>>> Post.objects.create(author=me, title='Sample title', text='Test')
>>> Post.objects.all()
<QuerySet [<Post:Taitoru 1>, <Post:Taitoru 2>, <Post:Taitoru 3>, <Post: Sample title>]>
Der hinzugefügte Beitrag wird am Ende hinzugefügt. Als nächstes werde ich nur Beiträge anzeigen, deren Titel "Titel" enthält.
command-line
>>> Post.objects.filter(title__contains='title')
<QuerySet [<Post: Sample title>]>
Lassen Sie uns den veröffentlichten Beitrag anzeigen.
command-line
>>> from django.utils import timezone
>>> Post.objects.filter(published_date__lte=timezone.now())
<QuerySet []>
Ich werde es veröffentlichen.
command-line
>>> post = Post.objects.get(title="Sample title")
>>> post.publish()
>>> Post.objects.filter(title__contains='title')
<QuerySet [<Post: Sample title>]>
Sie können auch eine Liste der in Django registrierten Superuser anzeigen.
command-line
>>> User.objects.all()
<QuerySet [<User:Nutzername>]>
Sie können sie auch in der Reihenfolge der Buchung oder in umgekehrter Reihenfolge anzeigen.
command-line
>>> Post.objects.order_by('created_date')
<QuerySet [<Post:Taitoru 1>, <Post:Taitoru 2>, <Post:Taitoru 3>, <Post: Sample title>]>
>>> Post.objects.order_by('-created_date')
<QuerySet [<Post: Sample title>, <Post:Taitoru 3>, <Post:Taitoru 2>, <Post:Taitoru 1>]>
Sie können auch eine Reihe von Abfragen schreiben.
command-line
>>> Post.objects.filter(published_date__lte=timezone.now()).order_by('published_date')
<QuerySet [<Post: Sample title>]>
Sie können den Abfragesatz mit exit () beenden.
command-line
exit()
7. Erstellen Sie eine dynamische Ansichtsvorlage
Wir werden eine Ansichtsvorlage schreiben, um den Inhalt des in der Datenbank gespeicherten Beitrags anzuzeigen. Ich habe geschrieben, um die veröffentlichten Post-Daten an die Vorlage zu übergeben und sie wie im vorherigen Abfragesatz anzuzeigen.
proj1/blog/views.py
from django.shortcuts import render
from django.utils import timezone
from .models import Post
def post_list(request):
posts = Post.objects.filter(published_date__lte=timezone.now()).order_by('published_date')
return render(request, 'blog/post_list.html', {'posts': posts})
Das zuvor erstellte blog / post_list.html war ein statisches HTML, aber ich werde es neu schreiben, um den von der Datenbank empfangenen Wert anzuzeigen.
Das Python-Skript wird in dem in {%%} eingeschlossenen Bereich ausgeführt, und der Wert des übergebenen Objekts wird in den in {{}} eingeschlossenen Bereich eingefügt, sodass der Beitrag der Reihe nach angezeigt wird. ..
proj1/blog/templates/blog/post_list.html
<html>
<head>
<title>Django Girls blog</title>
</head>
<body>
<div>
<h1><a href="/">Django Girls Blog</a></h1>
</div>
{% for post in posts %}
<div>
<p>published: {{ post.published_date }}</p>
<h2><a href="">{{ post.title }}</a></h2>
<p>{{ post.text|linebreaksbr }}</p>
</div>
{% endfor %}
</body>
</html>
Sie sollten nun in der Lage sein, den auf der Administrationsseite eingegebenen Post-Inhalt anzuzeigen. Überprüfen Sie daher die Anzeige mit dem Runserver python manage.py.
Es ist sicher abgeschlossen.
8. Süß mit CSS
Ich werde ein süßes Design mit Bootstrap machen.
Fügen Sie zunächst einen Link in den Kopf von post_list.html ein, damit Sie Bootstrap verwenden können.
proj1/blog/templates/blog/post_list.Von HTML<head>Hinzufügen
<link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css">
<link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css">
Dies allein legt das Standard-CSS für Bootstrap fest, sodass sich das Design etwas ändert.
Erstellen Sie eine CSS-Datei
Da django den Ordner mit dem Namen static als statische Datei erkennt, erstellen Sie ein CSS-Verzeichnis im statischen Verzeichnis und legen Sie blog.css darin ab.
proj1
└─── blog
└─── static
└─── css
└─── blog.css
CSS wird normalerweise in diese Datei geschrieben. Lassen Sie uns vorerst die Farbe des a-Tags in der Überschrift ändern.
proj1/blog/static/css/blog.css
h1 a, h2 a {
color: #C25100;
}
Fügen Sie {% load static%} und {% static'css / blog / css '%} zu post_list.html hinzu, um blog.css wiederzugeben.
proj1/blog/post_list.html
{% load static %}
<html>
<head>
<title>Django Girls blog</title>
<link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css">
<link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css">
<link rel="stylesheet" href="{% static 'css/blog.css' %}">
</head>
<body>
<div>
<h1><a href="/">Django Girls Blog</a></h1>
</div>
{% for post in posts %}
<div>
<p>published: {{ post.published_date }}</p>
<h2><a href="">{{ post.title }}</a></h2>
<p>{{ post.text|linebreaksbr }}</p>
</div>
{% endfor %}
</body>
</html>
Das CSS wird reflektiert und die Textfarbe des a-Tags der Überschrift ist jetzt orange.
Ich werde verschiedene Dinge hinzufügen
proj1/blog/static/css/blog.css
h1 a, h2 a {
color: #C25100;
font-family: 'Lobster';
}
body {
padding-left: 15px;
}
.page-header {
background-color: #C25100;
margin-top: 0;
padding: 20px 20px 20px 40px;
}
.page-header h1, .page-header h1 a, .page-header h1 a:visited, .page-header h1 a:active {
color: #ffffff;
font-size: 36pt;
text-decoration: none;
}
.content {
margin-left: 40px;
}
h1, h2, h3, h4 {
font-family: 'Lobster', cursive;
}
.date {
color: #828282;
}
.save {
float: right;
}
.post-form textarea, .post-form input {
width: 100%;
}
.top-menu, .top-menu:hover, .top-menu:visited {
color: #ffffff;
float: right;
font-size: 26pt;
margin-right: 20px;
}
.post {
margin-bottom: 70px;
}
.post h2 a, .post h2 a:visited {
color: #000000;
}
proj1/blog/templates/blog/post_list.html
{% load static %}
<html>
<head>
<title>Django Girls blog</title>
<link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css">
<link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css">
<link href="//fonts.googleapis.com/css?family=Lobster&subset=latin,latin-ext" rel="stylesheet" type="text/css">
<link rel="stylesheet" href="{% static 'css/blog.css' %}">
</head>
<body>
<div class="page-header">
<h1><a href="/">Django Girls Blog</a></h1>
</div>
{% for post in posts %}
<div class="post">
<p>published: {{ post.published_date }}</p>
<h2><a href="">{{ post.title }}</a></h2>
<p>{{ post.text|linebreaksbr }}</p>
</div>
{% endfor %}
</body>
</html>
Es wurde gut
9. Vorlagenerweiterung
Die Ansichtsvorlage kann allgemeine Teile wiederverwenden.
Teilen wir als Beispiel die zuvor erstellte post_list.html in zwei Ansichten. Schreiben Sie den Teil, der das grundlegende Design festlegt, in base.html und den Teil, der die Post-Liste anzeigt, in post_list.html.
blog
└───templates
└───blog
base.html
post_list.html
Fügen Sie den Inhalt von post_list.html von {% block content%} bis {% endblock%} ein.
proj1/blog/templates/blog/base.html
{% load static %}
<html>
<head>
<title>Django Girls blog</title>
<link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css">
<link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css">
<link href="//fonts.googleapis.com/css?family=Lobster&subset=latin,latin-ext" rel="stylesheet" type="text/css">
<link rel="stylesheet" href="{% static 'css/blog.css' %}">
</head>
<body>
<div class="page-header">
<h1><a href="/">Django Girls Blog</a></h1>
</div>
<div class="content container">
<div class="row">
<div class="col-md-8">
{% block content %}
{% endblock %}
</div>
</div>
</div>
</body>
</html>
Durch Schreiben von {% extens'blog / base.html '%} in die erste Zeile auf der Seite post_list.html wird angewiesen, base.html zu erweitern und zu verwenden.
proj1/blog/templates/blog/post_list.html
{% extends 'blog/base.html' %}
{% block content %}
{% for post in posts %}
<div class="post">
<div class="date">
{{ post.published_date }}
</div>
<h2><a href="">{{ post.title }}</a></h2>
<p>{{ post.text|linebreaksbr }}</p>
</div>
{% endfor %}
{% endblock %}
Wenn Sie den Server neu starten und die Seite anzeigen, sollten Sie dasselbe wie zuvor sehen.
10. Anwendungserweiterung
Fügen Sie eine Seite hinzu, um jeden Blog-Beitrag anzuzeigen.
Erstellen Sie einen Link zur Vorlage
Gibt an, dass auf die Funktion view.post_detail () verwiesen wird, wenn es um HTML geht: // localhost / post / **** /. <int: pk> bedeutet, dass die Zeichenfolge in den Typ int konvertiert, pk zugewiesen und als Argument wie views.post_detail (request, pk) angegeben wird.
proj1/blog/urls.py
from django.urls import path
from . import views
urlpatterns = [
path('', views.post_list, name='post_list'),
path('post/<int:pk>/', views.post_detail, name='post_detail'),
]
Fügen Sie die Funktion post_detail zu proj1 / blog / views.py hinzu. Ich verwende auch get_object_or_404 (), um 404 zurückzugeben, wenn das Post-Objekt keinen entsprechenden Artikel enthält. Das zweite Argument der Renderfunktion gibt an, dass 'blog / post_detail.html' als Ansichtsvorlage verwendet wird.
proj1/blog/views.py
from django.shortcuts import render, get_object_or_404
def post_detail(request, pk):
post = get_object_or_404(Post, pk=pk)
return render(request, 'blog/post_detail.html', {'post': post})
Fügen Sie eine Ansichtsvorlage hinzu, um den Artikel anzuzeigen. Da ich base.html verwende, kann ich es kurz schreiben.
proj1/blog/templates/blog/post_detail.html
{% extends 'blog/base.html' %}
{% block content %}
<div class="post">
{% if post.published_date %}
<div class="date">
{{ post.published_date }}
</div>
{% endif %}
<h2>{{ post.title }}</h2>
<p>{{ post.text|linebreaksbr }}</p>
</div>
{% endblock %}
Fügen Sie abschließend einen Link zum
-Tag hinzu, auf dem der Artikeltitel von post_list.html angezeigt wird.
proj1/blog/templates/blog/post_list.html
<h2><a href="{% url 'post_detail' pk=post.pk %}">{{ post.title }}</a></h2>
proj1/blog/templates/blog/post_list.html
<h2><a href="{% url 'post_detail' pk=post.pk %}">{{ post.title }}</a></h2>
Eine Seite zum Anzeigen von Artikeln wurde erstellt.
Bereitstellen
Lassen Sie uns den Inhalt so weit verschieben, dass er git und bereitgestellt wird.
terminal
git status
git add --all .
git status
git commit -m "Added view and template for detailed blog post as well as CSS for the site."
git push
terminal:~/Nutzername.pythonanywhere.com
cd ~/Domainname.pythonanywhere.com
git pull
Es spiegelt nicht das CSS wider, da PythonAnywhere einen anderen Speicherort für statische Dateien hat. Wenn Sie das Tool verwenden, wird es automatisch platziert.
terminal:~/PythonAnywhere-Benutzername.pythonanywhere.com
Workon Benutzername.pythonanywhere.com
python manage.py collectstatic
11-1. Erstellen Sie ein Post-Formular
In der bisherigen Operation wurde der Blog-Beitrag über den Verwaltungsbildschirm http: // localhost / admin / eingegeben. Sie können jedoch ein Formular erstellen, um die Eingabe zu vereinfachen.
Machen Sie ein Post-Formular
blog
└── forms.py
Erben Sie die forms.ModelForm-Klasse und fügen Sie nur einen Teil hinzu, um ein Formular zu erstellen. Hier wird das Formular zur Eingabe von Titel und Text verwendet.
proj1/blog/forms.py
from django import forms
from .models import Post
class PostForm(forms.ModelForm):
class Meta:
model = Post
fields = ('title', 'text',)
Fügen Sie einen Link zum Post-Formular in base.html ein
Fügen Sie die folgende Zeile hinzu, um einen Link zum Buchungsformular oben in base.html einzufügen. Wenn class = "glyphicon glyphicon-plus" gesetzt ist, wird + mit der Bootstrap-Funktion angezeigt.
proj1/blog/templates/blog/base.Zu HTML hinzugefügt
<a href="{% url 'post_new' %}" class="top-menu"><span class="glyphicon glyphicon-plus"></span></a>
proj1/blog/templates/blog/base.Nach HTML-Änderung
{% load static %}
<html>
<head>
<title>Django Girls blog</title>
<link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css">
<link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css">
<link href='//fonts.googleapis.com/css?family=Lobster&subset=latin,latin-ext' rel='stylesheet' type='text/css'>
<link rel="stylesheet" href="{% static 'css/blog.css' %}">
</head>
<body>
<div class="page-header">
<a href="{% url 'post_new' %}" class="top-menu"><span class="glyphicon glyphicon-plus"></span></a>
<h1><a href="/">Django Girls Blog</a></h1>
</div>
<div class="content container">
<div class="row">
<div class="col-md-8">
{% block content %}
{% endblock %}
</div>
</div>
</div>
</body>
</html>
Zu urls.py hinzugefügt
Wenn Sie zu http: // localhost: 8000 / post / new / kommen, rufen Sie die Funktion views.post_new auf.
blog/urls.Zum py hinzufügen
path('post/new/', views.post_new, name='post_new'),
blog/urls.Nach py Modifikation
from django.urls import path
from . import views
urlpatterns = [
path('', views.post_list, name='post_list'),
path('post/<int:pk>/', views.post_detail, name='post_detail'),
path('post/new/', views.post_new, name='post_new'),
]
Fügen Sie die von urls.py aufgerufene Funktion zu views.py hinzu
blog/views.Zum py hinzufügen
from django.shortcuts import redirect
def post_new(request):
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post.published_date = timezone.now()
post.save()
return redirect('post_detail', pk=post.pk)
else:
form = PostForm()
return render(request, 'blog/post_edit.html', {'form': form})
Wenn Sie python manage.py runserver ausführen und http: // localhost: 8000 / post / new / in Ihrem Browser öffnen, wird die neue Post-Seite wie unten gezeigt angezeigt.
11-2. Erstellen Sie ein Bearbeitungsformular für veröffentlichte Beiträge
Fügen wir die Artikelbearbeitungsfunktion auf die gleiche Weise wie zuvor hinzu.
Formular bearbeiten
Das Formular selbst verwendet dasselbe wie das neue Post-Formular.
Platzieren Sie eine Schaltfläche zum Bearbeiten
blog/templates/blog/post_detail.Zu HTML hinzufügen
<a class="btn btn-default" href="{% url 'post_edit' pk=post.pk %}"><span class="glyphicon glyphicon-pencil"></span></a>
blog/templates/blog/post_detail.Nach HTML-Änderung
{% extends 'blog/base.html' %}
{% block content %}
<div class="post">
{% if post.published_date %}
<div class="date">
{{ post.published_date }}
</div>
{% endif %}
<a class="btn btn-default" href="{% url 'post_edit' pk=post.pk %}"><span class="glyphicon glyphicon-pencil"></span></a>
<h2>{{ post.title }}</h2>
<p>{{ post.text|linebreaksbr }}</p>
</div>
{% endblock %}
Link zu urls.py hinzufügen
python:proj1.blog/urls.Zum py hinzufügen
path('post/<int:pk>/edit/', views.post_edit, name='post_edit'),
Fügen Sie views.py eine Funktion hinzu
proj1/blog/views.Zum py hinzufügen
def post_edit(request, pk):
post = get_object_or_404(Post, pk=pk)
if request.method == "POST":
form = PostForm(request.POST, instance=post)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post.published_date = timezone.now()
post.save()
return redirect('post_detail', pk=post.pk)
else:
form = PostForm(instance=post)
return render(request, 'blog/post_edit.html', {'form': form})
11-3. Nur beim Login bearbeitbar
Neuer Post-Button
proj1/blog/templates/blog/base.Vor dem Bearbeiten von HTML
<a href="{% url 'post_new' %}" class="top-menu"><span class="glyphicon glyphicon-plus"></span></a>
proj1/blog/templates/blog/base.Nach dem Bearbeiten von HTML
{% if user.is_authenticated %}
<a href="{% url 'post_new' %}" class="top-menu"><span class="glyphicon glyphicon-plus"></span></a>
{% endif %}
Schaltfläche zum Bearbeiten von Artikeln
proj1/blog/templates/blog/post_detail.Vor dem Bearbeiten von HTML
<a class="btn btn-default" href="{% url 'post_edit' pk=post.pk %}"><span class="glyphicon glyphicon-pencil"></span></a>
proj1/blog/templates/blog/post_detail.Nach dem Bearbeiten von HTML
{% if user.is_authenticated %}
<a class="btn btn-default" href="{% url 'post_edit' pk=post.pk %}"><span class="glyphicon glyphicon-pencil"></span></a>
{% endif %}
Die Schaltfläche Bearbeiten wird nicht mehr angezeigt, wenn Sie nicht angemeldet sind.
Bereitstellen
terminal
git status
git add --all .
git status
git commit -m "Added view and template for detailed blog post as well as CSS for the site."
git push
terminal:~/Nutzername.pythonanywhere.com
cd ~/Domainname.pythonanywhere.com
git pull
Deshalb ist es abgeschlossen.
Ich habs gemacht
Recommended Posts