Python od podstaw:stwórz dynamiczną stronę internetową

Jeśli kiedykolwiek pracowałeś wcześniej z PHP, mogłeś użyć PhpMyAdmin do tworzenia tabel MySQL, a następnie ręcznie zapisywać zapytania SQL w skryptach PHP. W Django jest o wiele łatwiej. Definiujemy wszystkie potrzebne struktury danych w tym pliku modeli, a następnie uruchamiamy polecenie i wszystkie niezbędne bazy danych są dla nas tworzone.

Gdy chcesz uzyskać dostęp do tych danych, przechodzisz przez te modele, wywołując na nich metodę, zamiast uruchamiać nieprzetworzone zapytania. Jest to bardzo pomocne, ponieważ Django może korzystać z kilku programów bazodanowych. Będziemy używać MySQL dzisiaj, ponieważ jest najpotężniejszy i zapewnia to większość hostów, ale gdybyśmy musieli w przyszłości przełączyć się na inną bazę danych, cały kod nadal byłby poprawny! W innych językach, jeśli chciałbyś przełączyć się na SQLite lub coś podobnego, musiałbyś przepisać kod, który uzyskuje dostęp do Twojej bazy danych.

W pliku widoków piszemy kod, który faktycznie generuje strony internetowe. To spaja wszystkie pozostałe części. Gdy użytkownik wpisuje adres URL, jest on wysyłany przez urls skrypt, który widzieliśmy wcześniej w views skrypt, który następnie pobiera odpowiednie dane z modeli, przetwarza je i przekazuje do szablonu, który w końcu jest wyświetlany jako strona, którą widzi użytkownik. Wkrótce przyjrzymy się tym szablonom. To najłatwiejsza część — głównie HTML.

Dodaj aplikację bloga do listy INSTALLED_APPS w settings.py plik.

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'blog',
]

W przypadku bloga potrzebujemy tabeli postów z kilkoma polami na tytuł, treść, autora, godzinę napisania i tak dalej. Prawdziwy blog miałby komentarze, ale to wykracza poza zakres dzisiejszego demo.

from django.db import models

class posts(models.Model):
    author = models.CharField(max_length = 30)
    title = models.CharField(max_length = 100)
    bodytext = models.TextField()
    timestamp = models.DateTimeField()

MySQL

Te modele to tylko opis. Musimy zrobić z nich rzeczywistą bazę danych. Najpierw jednak potrzebujemy MySQL działającego w naszym systemie. Na rzeczywistym serwerze internetowym nie stanowiłoby to problemu, ponieważ zwykle mają go preinstalowane.

Aby zainstalować MySQL, wpisz:

sudo apt install mysql-server

Aby sprawdzić, czy instalacja się powiodła, użyj:

mysql --version

To powinno zwrócić coś takiego:

mysql  Ver 14.14 Distrib 5.7.33, for Linux (x86_64) using  EditLine wrapper

Teraz utwórz bazę danych MySQL dla projektu Django. Uruchom MySQL z sudo mysql i po monicie wpisz:

CREATE DATABASE django_blog;
CREATE USER 'django'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';
GRANT ALL ON django_blog.* TO 'django'@'localhost';

FLUSH PRIVILEGES;

Uruchom serwer deweloperski

Możesz teraz uruchomić python3.8 manange.py runserver w nowej karcie, aby uruchomić serwer deweloperski.

Ale najpierw musimy skonfigurować ustawienia bazy danych. Rzućmy okiem na settings.py .

Najpierw musisz zmienić ustawienia bazy danych.

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql', # Add 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'oracle'.
        'NAME': 'django_blog',                      # Or path to database file if using sqlite3.
        'USER': 'django_user',                      # Not used with sqlite3.
        'PASSWORD': 'password',                  # Not used with sqlite3.
        'HOST': '',                      # Set to empty string for localhost. Not used with sqlite3.
        'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
    }
}

Teraz uruchom serwer i przejdź do 127.0.0.1:8000 w Twojej przeglądarce internetowej. Powinieneś zobaczyć domyślną stronę Django.

Skonfiguruj bloga w Django

Teraz zamieńmy naszą stronę Django w blog. Najpierw musimy użyć naszych modeli do utworzenia tabel w bazie danych, tworząc następującą migrację, aby wprowadzić zmiany w modelach.

python3.8 manage.py makemigrations
Migrations for 'blog':
  blog/migrations/0003_post.py
    - Create model Post

Teraz uruchom migrację, aby utworzyć tabele w bazie danych.

python3.8 manage.py migrate

Utwórz superużytkownika

Teraz możesz utworzyć superużytkownika do administrowania Twoją aplikacją Django.

python3.8 manage.py createsuperuser

Skonfiguruj adresy URL aplikacji

Skonfigurujmy adresy URL aplikacji w urls.py plik. Uwzględnimy adresy URL blogów z osobnego pliku.

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

urlpatterns = [
    path('admin/', admin.site.urls),
     path("", include('blog.urls')),
]

Utwórz pierwszy widok

Stwórzmy nasz pierwszy widok, który wyrenderuje prostą stronę HTML. Otwórz blog/views.py i dodaj następujący kod.

from django.shortcuts import render

from .models import Post

def home(request):
    return render('index.html')

Utwórz szablon widoku

Ten index.html plik jeszcze nie istnieje. Django automatycznie załaduje szablony z katalogu szablonów. Utwórz folder o nazwie szablony w aplikacji blogowej i wewnątrz niej utwórz plik o nazwie index.html . Katalog folderów powinien wyglądać tak:

blog
  -templates
     -blog
        -index.html
      

Dodaj następujący kod w index.html .

<!DOCTYPE html>

<html lang="en">

<head>
    <meta charset="utf-8" />
    <link rel="stylesheet" href="css/style.css">
    <link href="images/favicon.ico" rel="shortcut icon">
    <title>First Blog</title>
</head>

<body>

<div class="container">
    <h1>First Blog</h1>
    <h2>Title</h2>
    <h3>Posted on date by author</h3>
    <p>Body Text</p>

</div>

</body>
    
</html>

Teraz utworzymy adresy URL naszych blogów. Utwórz plik urls.py w katalogu blogów i wpisz ścieżkę URL do obsługi strony indeksu.

from django.urls import path

from . import views

urlpatterns = [
  
   path('', views.home),
  
   
]

Teraz, jeśli przejdziesz do http://127.0.0.1:8000/home , powinieneś zobaczyć następującą stronę zaktualizowaną o nową zawartość.

Umieść dane z bazy danych

Następnym krokiem jest dodanie dynamicznej zawartości z bazy danych. Aby to osiągnąć, Django ma język szablonów, który umożliwia osadzanie zmiennych w nawiasach klamrowych. Zmień środkową sekcję strony, aby wyglądała tak:

<div class="container">
    <h1>First Blog</h1>
    <h2>{{ title }}</h2>
    <h3>Posted on {{ date }} by {{ author }}</h3>
    <p>{{ body }}</p>

</div>

Następnie możemy przekazać wartości do tych zmiennych zastępczych z views.py pliku, tworząc słownik wartości.

def home(request):
    content = {
        'title' : 'My First Post',
        'author' : 'Giles',
        'date' : '18th September 2011',
        'body' : 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Etiam cursus tempus dui, ut vulputate nisl eleifend eget. Aenean justo felis, dapibus quis vulputate at, porta et dolor. Praesent enim libero, malesuada nec vestibulum vitae, fermentum nec ligula. Etiam eget convallis turpis. Donec non sem justo.',
    }
    return render(request,'blog/index.html', content)

Zapisz i odśwież, a powinieneś zobaczyć, że teraz przekazujesz zawartość do szablonu z pliku widoków. Ostatnim krokiem jest pobranie danych z naszej bazy danych i przekazanie ich w zamian. Na szczęście możemy to zrobić bez zapytań SQL, korzystając z modeli Django. Przejdź do blog/views.py i zaktualizuj kod, aby pobrać dane z bazy danych.

def home(request):
    posts = Post.objects.all()[:10]
    return render(request,'blog/index.html', {"posts":  posts})

Następnie zaktualizuj szablon, aby uzyskać dostęp do tych danych.

<body>

    <div class="container">
        <h1>First Blog</h1>
        <hr />
        {% for post in posts %}
            <div class="post">
            <h2>{{ post.title }}</h2>
            <h3>Posted on {{ post.timestamp }} by {{ post.author }}</h3>
            <p>{{ post.bodytext }}</p>
            </div>
            <hr />
        {% endfor %}
    </div>
    

</body>

Tutaj możemy uzyskać dostęp do wszystkich danych w naszej tabeli w views.py plik, a następnie wybierz tylko pierwszych dziesięć wpisów. Przekazujemy te dane do szablonu, przechodzimy przez wpisy i wyświetlamy dane w kodzie HTML naszej witryny.

System administracyjny Django

Ostatnią rzeczą, jaką musimy dzisiaj zrobić, jest przegląd systemu administracyjnego Django. Jest to naprawdę potężna funkcja Django, która pozwala zarządzać witryną bez pisania kodu, tak jak w przypadku tworzenia witryny od podstaw. Aby administrator mógł kontrolować Twoje posts tabeli, zarejestrujemy nasz Post model w admin Django i dodać trochę danych do bazy danych. Otwórz blog/admin.py i dodaj następujący kod.

from django.contrib import admin
from .models import Post

# Register your models here.

admin.site.register(Post)

Powinieneś teraz móc dodawać nowe wpisy na blogu, odwiedzając http://127.0.0.1:8000/admin/blog/post/.

To wszystko, co można zrobić. Właśnie stworzyłeś w pełni funkcjonalnego, choć prostego bloga. Aby zakończyć tę lekcję, przyjrzymy się instalacji Django na serwerze WWW.

Instalacja na serwerze WWW

Istnieją dwa rodzaje hostingu, a to, który masz, będzie miało wpływ na to, czy możesz korzystać z Django. Jeśli korzystasz z hostingu współdzielonego, jesteś całkowicie na łasce swojego gospodarza.

Wiele tanich hostów internetowych nie obsługuje Pythona. Chociaż PHP jest prawie gwarantowane, obsługa innych języków często nie jest. Będziesz musiał sprawdzić panel sterowania, aby określić, czy Python (i Django) są dostępne. Oczywiście proces jest nieco inny u każdego gospodarza. Prawie cały hosting działa na Apache i możemy go użyć do obsługi Django, używając mod_wsgi lub mod_python Moduły Apache.

Większość hostów internetowych uruchamia skrypty w kilku językach przy użyciu CGI. Django może działać na FastCGI, a także teoretycznie na CGI, ale nie jest to oficjalnie obsługiwane i byłoby zbyt wolne dla rzeczywistej witryny produkcyjnej. Musisz sprawdzić, czy są one zainstalowane. Zwykle można je znaleźć pod nagłówkiem, takim jak „Obsługa CGI i języka skryptowego”.

Jeśli masz hosting VPS lub masz szczęście, że masz serwer dedykowany, twoje życie jest znacznie łatwiejsze. Zwykle są one dostarczane z preinstalowanym Pythonem, a następnie wystarczy wykonać te same kroki, które przeszliśmy, aby uruchomić lokalną kopię Django. Jeśli nie masz Pythona, możesz zainstalować go za pomocą menedżera pakietów. Twój system może być nawet wyposażony w Django.

Po zainstalowaniu Django na serwerze, prześlij stronę, którą właśnie stworzyłeś, używając dowolnego klienta przesyłania plików. Możesz umieścić pliki w dowolnym miejscu, ale trzymaj je z dala od public folderu lub każdy będzie mógł zobaczyć kod źródłowy Twojej witryny. Używam /home dla wszystkich moich projektów.

Następnie utwórz bazę danych MySQL o nazwie django_blog na twoim serwerze. Będziesz musiał ponownie utworzyć konto w administracyjnym panelu sterowania, ale jest to jednorazowa sprawa.

Jeśli spróbujesz to uruchomić, może pojawić się błąd, a to dlatego, że ustawienia serwera różnią się od ustawień na komputerze lokalnym. Może być konieczna zmiana hasła bazy danych w settings.py , ale w zależności od konfiguracji serwera możesz napotkać również inne problemy. Google jest Twoim przyjacielem w takich sytuacjach!

Aby uruchomić serwer tym razem, polecenie jest nieco inne. Musisz podać adres IP i port, aby móc uzyskać dostęp do witryny przez Internet.

python.8 manage.py runserver your-server-ip:8000

Jeśli odwiedzasz swoją witrynę w przeglądarce internetowej na porcie 8000, powinieneś zobaczyć swoją witrynę!