[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. image.png Sie können Beiträge hinzufügen, indem Sie auf die Schaltfläche Hinzufügen rechts neben Beiträge klicken. image.png Ich werde einen geeigneten Beitrag ausfüllen. image.png 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. image.png

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. image.png

Öffnen Sie die neue Konsole unten links im Dashboard. image.png Beim Öffnen wird die Konsole wie unten gezeigt geöffnet. image.png 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. image.png 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. image.png

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. image.png 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. step1.png 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>

step3.png 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>

image.png

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. image.png 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">

image.png 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. margin2.png

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>

final.png 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>

Eine Seite zum Anzeigen von Artikeln wurde erstellt. image.png

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

image.png 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

image.png

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. image.png

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

image.png Deshalb ist es abgeschlossen. Ich habs gemacht

Recommended Posts

Django Girls Tutorial Hinweis
Django Note 4
Django Note 5
Django Note 1
Django Note 3
Django Note 2
Django Girls Tutorial Zusammenfassung Erste Hälfte
Python Django Tutorial (5)
Python Django Tutorial (2)
Django Tutorial Memo
Python Django Tutorial (8)
Python Django Tutorial (6)
Starten Sie das Django Tutorial 1
Django Girls-3 Workflow
Python Django Tutorial (7)
Python Django Tutorial (1)
Python Django Tutorial Tutorial
Python Django Tutorial (3)
Python Django Tutorial (4)
Zusammenfassung des Python Django-Tutorials
Django Oscar einfaches Tutorial
GO Offizielles Tutorial Hinweis 1
Fangen Sie mit Django an! ~ Tutorial ⑤ ~
Fangen Sie mit Django an! ~ Tutorial ④ ~
Fangen Sie mit Django an! ~ Tutorial ⑥ ~
(Hinweis) Django in Vagrant-Umgebung
Python Django Tutorial Cheet Sheet
Memo
[Anmerkung] Django-Projekterstellung und Terminologie
Django
Memo
Memo
Stolpern Sie beim Django 1.7-Tutorial
Stellen Sie das Django-Lernprogramm für IIS bereit ①
[Hinweis] Führen Sie Django unter Amazon Linux 2 aus
Hinweis: Senden Sie eine E-Mail mit Django
Django Crispy Tutorial (Umgebungskonstruktion auf Mac)
(Hinweis) Suchreihenfolge der Vorlagendateien in Django
Django Tutorial Zusammenfassung für Anfänger von Anfängern ③ (Anzeigen)
Django Tutorial (Blog-App erstellen) ⑤ - Artikelerstellungsfunktion
Djangos External Key Tutorial in 10 Minuten
Hinweise zum Aktivieren von PostgreSQL mit Django
Django Tutorial (Blog App erstellen) ④ --Einheitentest
DJango Hinweis: Von Anfang an (Formularverarbeitung)
Django Tutorial Zusammenfassung für Anfänger von Anfängern ⑤ (Test)
Ein Memo, dass ich das Pyramid Tutorial ausprobiert habe