Udostępnij za pośrednictwem

Wprowadzenie do tworzenia aplikacji internetowych w systemie Windows przy użyciu języka Python

Poniżej przedstawiono przewodnik krok po kroku, który zawiera instrukcje dotyczące rozpoczynania pracy z językiem Python na potrzeby tworzenia aplikacji internetowych w systemie Windows przy użyciu podsystemu Windows dla systemu Linux (WSL).

Konfigurowanie środowiska projektowego

Zalecamy zainstalowanie języka Python w programie WSL podczas kompilowania aplikacji internetowych. Wiele samouczków i instrukcji dotyczących tworzenia aplikacji internetowych w języku Python jest napisanych dla użytkowników systemu Linux i korzysta z narzędzi do tworzenia pakietów i instalacji opartych na systemie Linux. Większość aplikacji internetowych jest również wdrażana w systemie Linux, więc zapewni to spójność między środowiskami deweloperskimi i produkcyjnymi.

Jeśli używasz języka Python do tworzenia aplikacji innych niż tworzenie aplikacji internetowych, zalecamy zainstalowanie języka Python bezpośrednio w systemie Windows przy użyciu sklepu Microsoft Store. System WSL nie obsługuje komputerów stacjonarnych ani aplikacji gui (takich jak PyGame, Gnom, KDE itp.). W tych przypadkach zainstaluj i użyj języka Python bezpośrednio w systemie Windows. Jeśli dopiero zaczynasz korzystać z języka Python, zobacz nasz przewodnik: Wprowadzenie do korzystania z języka Python w systemie Windows dla początkujących. Jeśli interesuje Cię automatyzacja typowych zadań w systemie operacyjnym, zobacz nasz przewodnik: Rozpoczynanie pracy z językiem Python w systemie Windows w celu wykonywania skryptów i automatyzacji. W przypadku niektórych zaawansowanych scenariuszy warto rozważyć pobranie konkretnej wersji języka Python bezpośrednio z python.org lub rozważyć zainstalowanie alternatywy, takiej jak Anaconda, Jython, PyPy, WinPython, IronPython itp. Zalecamy to tylko wtedy, gdy jesteś bardziej zaawansowanym programistą języka Python z określonym powodem wyboru alternatywnej implementacji.

Instalowanie podsystemu Windows dla systemu Linux

Program WSL umożliwia uruchamianie środowiska wiersza polecenia GNU/Linux zintegrowanego bezpośrednio z systemem Windows i ulubionymi narzędziami, takimi jak Visual Studio Code, Outlook itp. Ogólnie zalecamy używanie protokołu WSL 2 na potrzeby pracy nad tworzeniem aplikacji internetowych w języku Python.

Aby włączyć i zainstalować program WSL 2, zobacz dokumentację instalacji programu WSL. Te kroki obejmują wybór dystrybucji systemu Linux (na przykład Ubuntu).

Po zainstalowaniu programu WSL i dystrybucji systemu Linux otwórz dystrybucję systemu Linux (można ją znaleźć w menu Start systemu Windows) i sprawdź wersję i nazwę kodu przy użyciu polecenia : lsb_release -dc.

Zalecamy regularne aktualizowanie dystrybucji systemu Linux, w tym natychmiast po zainstalowaniu, aby upewnić się, że masz najnowsze pakiety. System Windows nie obsługuje automatycznie tej aktualizacji. Aby zaktualizować dystrybucję, użyj polecenia : sudo apt update && sudo apt upgrade.

Wskazówka

Rozważ zainstalowanie nowego terminalu systemu Windows ze sklepu Microsoft Store, aby włączyć wiele kart (szybkie przełączanie między wieloma wierszami poleceń systemu Linux, wierszem polecenia systemu Windows, programem PowerShell, interfejsem wiersza polecenia platformy Azure itp.), tworzenie niestandardowych powiązań kluczy (skrótów do otwierania lub zamykania kart, kopiowania i wklejania itp.), używanie funkcji wyszukiwania i konfigurowanie motywów niestandardowych (schematy kolorów, style czcionek i rozmiary, obraz tła/rozmycie/przezroczystość). Dowiedz się więcej.

Konfigurowanie programu Visual Studio Code

Skorzystaj z IntelliSense, Linting, Pomocy przy debugowaniu, Fragmentów koduoraz Testowania jednostkowego, korzystając z programu VS Code. VS Code dobrze integruje się z Windows Subsystem for Linux, zapewniając wbudowany terminal, umożliwiając bezproblemowy przepływ pracy między edytorem kodu a wierszem polecenia, oprócz obsługi Git dla kontroli wersji z typowymi poleceniami Git (dodawanie, zatwierdzanie, wypychanie, ściąganie) wbudowane w interfejs użytkownika.

  1. Pobierz i zainstaluj program VS Code dla systemu Windows. Program VS Code jest również dostępny dla systemu Linux, ale podsystem Windows dla systemu Linux nie obsługuje aplikacji graficznego interfejsu użytkownika, dlatego musimy zainstalować go w systemie Windows. Nie martw się, nadal będziesz w stanie zintegrować się z wierszem polecenia i narzędziami systemu Linux przy użyciu rozszerzenia Remote - WSL.

  2. Zainstaluj Remote — WSL Extension w programie VS Code. Dzięki temu można używać WSL jako zintegrowanego środowiska deweloperskiego, które automatycznie zajmie się zgodnością i ścieżkami. Dowiedz się więcej.

Ważne

Jeśli masz już zainstalowany program VS Code, upewnij się, że masz wersję 1.35 maja lub nowszą, aby zainstalować rozszerzenie WSL. Nie zalecamy używania WSL w programie VS Code bez rozszerzenia Remote-WSL, ponieważ utracisz obsługę autouzupełniania, debugowania, lintingu itp. Ciekawostka: to rozszerzenie jest zainstalowane w $HOME/.vscode-server/extensions.

Tworzenie nowego projektu

Utwórzmy nowy katalog projektu w naszym systemie plików Systemu Linux (Ubuntu), na który będziemy pracować z aplikacjami i narzędziami systemu Linux przy użyciu programu VS Code.

  1. Zamknij program VS Code i otwórz system Ubuntu (wiersz polecenia WSL), przechodząc do menu Start (ikona w lewym dolnym rogu systemu Windows) i wpisując: "Ubuntu".

  2. W wierszu polecenia systemu Ubuntu przejdź do lokalizacji, w której chcesz umieścić projekt, i utwórz dla niego katalog: mkdir HelloWorld.

terminal systemu Ubuntu

Wskazówka

Ważne jest, aby pamiętać, że podczas korzystania z podsystemu Windows dla systemu Linux (WSL) pracujesz teraz między dwoma różnymi systemami plików: 1) systemem plików Systemu Windows i 2) systemem plików Linux (WSL), który jest ubuntu dla naszego przykładu. Należy zwrócić uwagę na miejsce instalowania pakietów i przechowywania plików. Można zainstalować jedną wersję narzędzia lub pakietu w systemie plików Windows i zupełnie inną wersję w systemie plików Linux. Aktualizacja narzędzia w systemie plików systemu Windows nie będzie miała wpływu na narzędzie w systemie plików Linux i na odwrót. Program WSL montuje dyski stałe na komputerze w folderze /mnt/<drive> w dystrybucji Linux. Na przykład dysk Windows C: jest zamontowany w /mnt/c/. Dostęp do plików systemu Windows można uzyskać z poziomu terminalu systemu Ubuntu i korzystać z aplikacji i narzędzi systemu Linux w tych plikach i odwrotnie. Zalecamy pracę w systemie plików Systemu Linux na potrzeby tworzenia aplikacji internetowych w języku Python, biorąc pod uwagę, że większość narzędzi internetowych jest pierwotnie napisana dla systemu Linux i wdrożona w środowisku produkcyjnym systemu Linux. Unika również mieszania semantyki systemu plików (jak w przypadku systemu Windows, który jest niezależny od wielkości liter w nazwach plików). Oznacza to, że WSL obsługuje teraz skoki między systemami plików Linux i Windows, dzięki czemu można hostować pliki na jednym z nich. Dowiedz się więcej.

Instaluj Python, pip i venv

System Ubuntu jest już zainstalowany z zainstalowanym językiem Python 3.6, ale nie zawiera niektórych modułów, których można oczekiwać w przypadku innych instalacji języka Python. Nadal będziemy musieli zainstalować pip, standardowy menedżer pakietów dla języka Python, oraz venv, standardowy moduł używany do tworzenia i zarządzania lekkimi środowiskami wirtualnymi. Pamiętaj, że może być konieczne zaktualizowanie dystrybucji systemu Linux w taki sposób, aby korzystała z najnowszej wersji przy użyciu polecenia : sudo apt update && sudo apt upgrade.

  1. Upewnij się, że język Python3 jest już zainstalowany, otwierając terminal systemu Ubuntu i wprowadzając polecenie : python3 --version. Powinno to zwrócić numer wersji Twojego języka Python. Jeśli musisz zaktualizować wersję języka Python, najpierw zaktualizuj wersję systemu Ubuntu, wprowadzając polecenie : sudo apt update && sudo apt upgrade, a następnie zaktualizuj język Python przy użyciu polecenia sudo apt upgrade python3.

  2. Zainstaluj , wprowadzając: sudo apt install python3-pip. Narzędzie umożliwia instalowanie dodatkowych pakietów, które nie są częścią standardowej biblioteki języka Python i zarządzanie nimi.

  3. Zainstaluj venv, wpisując polecenie: sudo apt install python3-venv.

Tworzenie środowiska wirtualnego

Używanie środowisk wirtualnych jest zalecanym najlepszym rozwiązaniem dla projektów programistycznych języka Python. Tworząc środowisko wirtualne, możesz odizolować narzędzia projektu i uniknąć konfliktów wersji z narzędziami dla innych projektów. Na przykład możesz utrzymywać starszy projekt internetowy, który wymaga platformy internetowej Django 1.2, ale następnie nowy nowy projekt jest dostarczany przy użyciu platformy Django 2.2. Jeśli zaktualizujesz platformę Django globalnie poza środowiskiem wirtualnym, możesz napotkać pewne problemy z przechowywaniem wersji później. Oprócz zapobiegania przypadkowym konfliktom wersji środowiska wirtualne umożliwiają instalowanie pakietów i zarządzanie nimi bez uprawnień administracyjnych.

  1. Otwórz terminal i w folderze projektu HelloWorld użyj następującego polecenia, aby utworzyć środowisko wirtualne o nazwie .venv: python3 -m venv .venv.

  2. Aby aktywować środowisko wirtualne, wprowadź: source .venv/bin/activate. Jeśli to zadziałało, powinien zostać wyświetlony (.venv) przed wierszem polecenia. Masz teraz gotowe środowisko samodzielne do pisania kodu i instalowania pakietów. Po zakończeniu pracy ze środowiskiem wirtualnym wprowadź następujące polecenie, aby go dezaktywować: deactivate.

    Tworzenie środowiska wirtualnego

Wskazówka

Zalecamy utworzenie środowiska wirtualnego wewnątrz katalogu, w którym planujesz mieć projekt. Ponieważ każdy projekt powinien mieć własny oddzielny katalog, każdy będzie miał własne środowisko wirtualne, więc nie ma potrzeby unikatowego nazewnictwa. Nasza sugestia polega na użyciu nazwy venv , aby postępować zgodnie z konwencją języka Python. Niektóre narzędzia (takie jak pipenv) domyślnie używają tej nazwy, jeśli zainstalujesz je w katalogu projektu. Nie chcesz używać pliku env , ponieważ powoduje konflikt z plikami definicji zmiennych środowiskowych. Zazwyczaj nie zalecamy nazw, które nie zaczynają się od kropki, ponieważ nie trzeba mieć ls, aby stale przypominać sobie, że katalog istnieje. Zalecamy również dodanie pliku venv do pliku .gitignore. (Oto domyślny szablon gitignore usługi GitHub dla języka Python do celów referencyjnych). Aby uzyskać więcej informacji na temat pracy ze środowiskami wirtualnymi w programie VS Code, zobacz Using Python environments in VS Code (Używanie środowisk języka Python w programie VS Code).

Otwieranie okna terminalu programu WSL w programie VS Code

Program VS Code używa rozszerzenia WSL (zainstalowanego wcześniej) do traktowania podsystemu Linux jako serwera zdalnego. Dzięki temu można używać biblioteki WSL jako zintegrowanego środowiska projektowego. Dowiedz się więcej.

  1. Otwórz folder projektu w programie VS Code z terminalu systemu Ubuntu, wprowadzając polecenie code . "" informuje program VS Code o otwarciu bieżącego folderu.

  2. Zamknij terminal systemu Ubuntu. W przyszłości użyjemy terminalu WSL zintegrowanego z programem VS Code.

  3. Otwórz terminal programu WSL w programie VS Code, naciskając Ctrl+' (przy użyciu znaku backtick) lub wybierając pozycję View>Terminal. Spowoduje to otwarcie wiersza poleceń Bash (WSL) w ścieżce folderu projektu, który utworzyłeś w terminalu Ubuntu.

    VS Code z terminalem WSL

Instalowanie rozszerzenia Microsoft Python

Może być konieczne zainstalowanie rozszerzeń programu VS Code dla instalacji programu WSL. Niektóre rozszerzenia zainstalowane lokalnie w programie VS Code nie będą automatycznie dostępne. Dowiedz się więcej.

  1. Otwórz okno Rozszerzenia programu VS Code, wprowadzając Ctrl+Shift+X (lub użyj menu, aby przejść do pozycji Wyświetl>rozszerzenia).

  2. W górnym polu Szukaj rozszerzeń w witrynie Marketplace wprowadź: Python.

  3. Znajdź rozszerzenie języka Python (ms-python.python) firmy Microsoft i wybierz przycisk Zainstaluj w programie WSL: [nazwa dystrybucji].

  4. Po zakończeniu instalacji rozszerzenia w oknie Rozszerzenia programu VS Code zostanie wyświetlona sekcja WSL: [nazwa dystrybucji] — zainstalowana, co oznacza, że zainstalowano rozszerzenie języka Python.

Uruchamianie prostego programu w języku Python

Język Python jest językiem interpretowanym i obsługuje różne typy interpreterów (Python2, Anaconda, PyPy itp.). Program VS Code powinien domyślnie korzystać z interpretera skojarzonego z projektem. Jeśli masz powód, aby go zmienić, wybierz interpreter aktualnie wyświetlany na niebieskim pasku w dolnej części okna programu VS Code lub otwórz paletę poleceń (Ctrl+Shift+P) i wprowadź polecenie Python: Wybierz interpreter. Spowoduje to wyświetlenie listy aktualnie zainstalowanych interpreterów języka Python. Dowiedz się więcej o konfigurowaniu środowisk języka Python.

Utwórzmy i uruchomimy prosty program w języku Python jako test i upewnijmy się, że wybrano prawidłowy interpreter języka Python.

  1. Otwórz okno Eksploratora plików programu VS Code, wprowadzając Ctrl+Shift+E (lub użyj menu, aby przejść do Eksploratora widoków>).

  2. Jeśli nie jest jeszcze otwarty, otwórz zintegrowany terminal WSL, wprowadzając Ctrl+Shift+' i upewnij się, że bieżący katalog jest folderem projektu HelloWorld python.

  3. Utwórz plik w języku Python, wprowadzając polecenie : touch test.py. Powinieneś zobaczyć właśnie utworzony plik w oknie Eksploratora, pod folderami .venv i .vscode, które znajdują się już w katalogu projektu.

  4. Wybierz plik test.py utworzony właśnie w oknie Eksploratora, aby otworzyć go w programie VS Code. Ponieważ .py w nazwie pliku informuje program VS Code, że jest to plik języka Python, załadowane wcześniej rozszerzenie języka Python automatycznie wybierze i załaduje interpreter języka Python, który będzie wyświetlany w dolnej części okna programu VS Code.

    Wybieranie interpretera języka Python w programie VS Code

  5. Wklej ten kod w języku Python do pliku test.py, a następnie zapisz plik (Ctrl+S):

    print("Hello World")

  6. Aby uruchomić właśnie utworzony program "Hello World" języka Python, wybierz plik test.py w oknie Eksplorator programu VS Code, a następnie kliknij prawym przyciskiem myszy plik, aby wyświetlić menu opcji. Wybierz pozycję Uruchom plik języka Python w terminalu. Alternatywnie w zintegrowanym oknie terminalu programu WSL wprowadź polecenie : python test.py aby uruchomić program "Hello World". Interpreter języka Python wyświetli komunikat "Hello World" w oknie terminalu.

Gratulacje. Wszystko jest skonfigurowane do tworzenia i uruchamiania programów w języku Python! Teraz spróbujmy utworzyć aplikację Hello World z dwoma najpopularniejszymi platformami internetowymi języka Python: Flask i Django.

Samouczek Hello World dla platformy Flask

Flask jest frameworkiem aplikacji internetowych dla Pythona. Dokumentacja platformy Flask zawiera wskazówki dotyczące rozpoczynania pracy i bardziej szczegółowego samouczka dotyczącego tworzenia małej, ale kompletnej aplikacji.

Wykonując poniższe kroki, możesz utworzyć małą aplikację platformy Flask "Hello World" przy użyciu programu VS Code i programu WSL.

  1. Otwórz Ubuntu (wiersz polecenia WSL), przechodząc do menu Start (ikona w lewym dolnym rogu systemu Windows) i wpisując "Ubuntu".

  2. Utwórz katalog dla projektu: mkdir HelloWorld-Flask, a następnie cd HelloWorld-Flask, aby wejść do katalogu.

  3. Utwórz środowisko wirtualne, aby zainstalować narzędzia projektu: python3 -m venv .venv

  4. Otwórz projekt HelloWorld-Flask w programie VS Code, wprowadzając polecenie: code .

  5. W programie VS Code otwórz zintegrowany terminal WSL (aka Bash), wprowadzając Ctrl+Shift+` (folder projektu HelloWorld-Flask powinien być już wybrany). Zamknij wiersz polecenia systemu Ubuntu, ponieważ będziemy pracować w terminalu WSL zintegrowanym z programem VS Code.

  6. Aktywuj środowisko wirtualne tworzone w kroku 3 przy użyciu terminala Bash w VS Code: source .venv/bin/activate. Jeśli to zadziałało, przed wierszem polecenia powinno pojawić się (.venv).

  7. Zainstaluj Flask w środowisku wirtualnym, wpisując: python3 -m pip install flask. Sprawdź, czy jest zainstalowany, wprowadzając: python3 -m flask --version.

  8. Utwórz nowy plik dla kodu w języku Python: touch app.py

  9. Otwórz plik app.py w Eksploratorze plików programu VS Code (Ctrl+Shift+Ea następnie wybierz plik app.py). Spowoduje to aktywowanie rozszerzenia języka Python w celu wybrania interpretera. Domyślnie Python 3.6.8 64-bit ('.venv': venv). Zauważ, że wykryto także twoje środowisko wirtualne.

    Aktywowane środowisko wirtualne

  10. W app.pydodaj kod, aby zaimportować Flask i utworzyć instancję obiektu Flask.

    from flask import Flask
app = Flask(__name__)

  11. Ponadto w app.py dodaj funkcję zwracającą zawartość, w tym przypadku prosty ciąg. Użyj dekoratora Flask app.route, aby zamapować trasę adresu URL "/" na tę funkcję.

    @app.route("/")
def home():
    return "Hello World! I'm using Flask."

    Wskazówka

    Można użyć wielu dekoratorów w tej samej funkcji, po jednym na wiersz, w zależności od liczby różnych tras, które chcesz mapować na tę samą funkcję.

  12. Zapisz plik app.py (Ctrl+S).

  13. W terminalu uruchom aplikację, wprowadzając następujące polecenie:

    python3 -m flask run

    Spowoduje to uruchomienie serwera programistycznego platformy Flask. Serwer developerski wyszukuje app.py domyślnie. Po uruchomieniu platformy Flask powinny zostać wyświetlone dane wyjściowe podobne do następujących:

    (env) user@USER:/mnt/c/Projects/HelloWorld$ python3 -m flask run
 * Environment: production
   WARNING: This is a development server. Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: off
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

  14. Program Visual Studio uruchomi powiadomienie z informacją, że Twoja aplikacja działa teraz na porcie 5000 i jest dostępna. Kliknij przycisk Otwórz w przeglądarce. Możesz też nacisnąć Ctrl+Kliknijhttp://127.0.0.1:5000/ adres URL w terminalu. W przeglądarce powinien zostać wyświetlony następujący komunikat:

    Cześć, świecie! Używam platformy Flask.

  15. Zwróć uwagę, że podczas odwiedzania adresu URL, takiego jak "/", w terminalu debugowania wyświetlany jest komunikat z żądaniem HTTP:

    127.0.0.1 - - [19/Jun/2019 13:36:56] "GET / HTTP/1.1" 200 -

  16. Zatrzymaj aplikację za pomocą Ctrl+C w terminalu.

Wskazówka

Jeśli chcesz użyć innej nazwy pliku niż app.py, takiej jak program.py, zdefiniuj zmienną środowiskową o nazwie FLASK_APP i ustaw jej wartość na wybrany plik. Następnie serwer deweloperski platformy Flask używa wartości FLASK_APP zamiast domyślnego pliku app.py. Aby uzyskać więcej informacji, zobacz dokumentację platformy Flask.

Gratulacje, utworzono aplikację internetową platformy Flask przy użyciu programu Visual Studio Code i podsystemu Windows dla systemu Linux! Aby uzyskać bardziej szczegółowy samouczek dotyczący używania programu VS Code i platformy Flask, zobacz Samouczek platformy Flask w programie Visual Studio Code.

Samouczek Hello World dla platformy Django

Django to platforma aplikacji internetowej dla języka Python. W tym krótkim samouczku utworzysz małą aplikację Django "Hello World" przy użyciu programu VS Code i programu WSL.

  1. Otwórz Ubuntu (wiersz polecenia WSL), przechodząc do menu Start (ikona w lewym dolnym rogu systemu Windows) i wpisując "Ubuntu".

  2. Utwórz katalog dla projektu: mkdir HelloWorld-Django, a następnie cd HelloWorld-Django, aby wejść do katalogu.

  3. Utwórz środowisko wirtualne, aby zainstalować narzędzia projektu: python3 -m venv .venv

  4. Otwórz projekt HelloWorld-Django w programie VS Code, wprowadzając polecenie: code .

  5. Wewnątrz programu VS Code otwórz zintegrowany terminal WSL (aka Bash), wprowadzając Ctrl+Shift+" (folder projektu HelloWorld-Django powinien już być zaznaczony). Zamknij wiersz polecenia systemu Ubuntu, ponieważ będziemy pracować w terminalu WSL zintegrowanym z programem VS Code.

  6. Aktywuj środowisko wirtualne tworzone w kroku 3 przy użyciu terminala Bash w VS Code: source .venv/bin/activate. Jeśli to zadziałało, przed wierszem polecenia powinno pojawić się (.venv).

  7. Zainstaluj platformę Django w środowisku wirtualnym za pomocą polecenia : python3 -m pip install django. Sprawdź, czy jest zainstalowany, wprowadzając: python3 -m django --version.

  8. Następnie uruchom następujące polecenie, aby utworzyć projekt Django:

    django-admin startproject web_project .

    Polecenie startproject zakłada (przy użyciu . na końcu), że bieżący folder jest folderem projektu i tworzy w nim następujące elementy:

    • manage.py: narzędzie administracyjne wiersza polecenia Django dla projektu. Ty uruchamiasz polecenia administracyjne dla projektu przy użyciu python manage.py <command> [options].

    • Podfolder o nazwie web_project, który zawiera następujące pliki:

      • __init__.py: pusty plik, który informuje język Python, że ten folder jest pakietem języka Python.
      • wsgi.py: punkt wejścia dla serwerów webowych zgodnych z WSGI umożliwiających obsługę twojego projektu. Zazwyczaj pozostawiasz ten plik bez zmian, ponieważ zapewnia on punkty zaczepienia dla serwerów internetowych w środowisku produkcyjnym.
      • asgi.py: punkt wejścia dla serwerów internetowych zgodnych z ASGI do obsługiwania projektu. Zazwyczaj pozostawiasz ten plik bez zmian, ponieważ zapewnia on punkty zaczepienia dla serwerów internetowych w środowisku produkcyjnym.
      • settings.py: zawiera ustawienia projektu Django, które można zmodyfikować w trakcie tworzenia aplikacji internetowej.
      • urls.py: zawiera spis treści projektu Django, który można również zmodyfikować w trakcie programowania.

  9. Aby zweryfikować projekt Django, uruchom serwer deweloperów Django przy użyciu polecenia python3 manage.py runserver. Serwer działa na domyślnym porcie 8000 i powinny zostać wyświetlone dane wyjściowe podobne do następujących w oknie terminalu:

    Performing system checks...

System check identified no issues (0 silenced).

June 20, 2019 - 22:57:59
Django version 2.2.2, using settings 'web_project.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

    Po pierwszym uruchomieniu serwera program tworzy domyślną bazę danych SQLite w pliku db.sqlite3, która jest przeznaczona do celów programistycznych, ale może być używana w środowisku produkcyjnym w przypadku aplikacji internetowych o małym woluminie. Ponadto wbudowany serwer internetowy Django jest przeznaczony tylko na potrzeby programowania lokalnego. Jednak podczas wdrażania na hoście internetowym usługa Django używa zamiast tego serwera internetowego hosta. Moduł wsgi.py w projekcie Django zajmuje się podłączaniem do serwerów produkcyjnych.

    Jeśli chcesz użyć innego portu niż domyślny 8000, określ numer portu w wierszu polecenia, na przykład python3 manage.py runserver 5000.

  10. Program Visual Studio uruchomi powiadomienie z informacją: "Twoja aplikacja, która teraz działa na porcie 8000, jest dostępna." Kliknij przycisk Otwórz w przeglądarce. Ctrl+click Lub http://127.0.0.1:8000/ adres URL w oknie danych wyjściowych terminalu, aby otworzyć domyślną przeglądarkę na ten adres. Jeśli program Django jest poprawnie zainstalowany, a projekt jest prawidłowy, zostanie wyświetlona strona domyślna. Okno danych wyjściowych terminalu programu VS Code zawiera również dziennik serwera.

  11. Gdy skończysz, zamknij okno przeglądarki i zatrzymaj serwer w programie VS Code przy użyciu polecenia Ctrl+C wskazanego w oknie danych wyjściowych terminalu.

  12. Teraz, aby utworzyć aplikację Django, uruchom polecenie narzędzia startapp administracyjnego w folderze projektu (gdzie manage.py się znajduje):

    python3 manage.py startapp hello

    Polecenie tworzy folder o nazwie hello zawierający wiele plików kodu i jeden podfolder. Z nich często pracujesz z views.py (która zawiera funkcje definiujące strony w aplikacji internetowej) i models.py (które zawierają klasy definiujące obiekty danych). Folder migrations jest używany przez narzędzie administracyjne Django do zarządzania wersjami bazy danych zgodnie z opisem w dalszej części tego samouczka. Istnieją również pliki apps.py (konfiguracja aplikacji), admin.py (do tworzenia interfejsu administracyjnego) i tests.py (dla testów), które nie są tutaj omówione.

  13. Zmodyfikuj hello/views.py , aby dopasować go do następującego kodu, który tworzy pojedynczy widok strony głównej aplikacji:

    from django.http import HttpResponse

def home(request):
    return HttpResponse("Hello, Django!")

  14. Utwórz plik , hello/urls.pyz poniższą zawartością. Plik urls.py służy do określania wzorców rozmieszczania różnych adresów URL do odpowiednich widoków. Poniższy kod zawiera jedną trasę służącą do mapowania adresu URL głównego katalogu aplikacji ("") na funkcję views.home, którą właśnie dodano do hello/views.py :

    from django.urls import path
from hello import views

urlpatterns = [
    path("", views.home, name="home"),
]

  15. Folder web_project również zawiera plik urls.py, który jest odpowiedzialny za obsługę routingu adresów URL. Otwórz web_project/urls.py i zmodyfikuj go tak, aby był zgodny z poniższym kodem (możesz zachować komentarze instruktażowe, jeśli chcesz). Ten kod pobiera hello/urls.py aplikacji za pomocą django.urls.include, które sprawia, że trasy aplikacji są zawarte w aplikacji. Ta separacja jest przydatna, gdy projekt zawiera wiele aplikacji.

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

urlpatterns = [
    path("", include("hello.urls")),
]

  16. Zapisz wszystkie zmodyfikowane pliki.

  17. W terminalu programu VS Code uruchom serwer deweloperski z python3 manage.py runserver i otwórz przeglądarkę, aby w http://127.0.0.1:8000/ zobaczyć stronę renderującą "Hello, Django".

Gratulacje, utworzono aplikację internetową Django przy użyciu programu VS Code i podsystemu Windows dla systemu Linux! Aby uzyskać bardziej szczegółowy samouczek dotyczący używania programu VS Code i platformy Django, zobacz Django Tutorial in Visual Studio Code (Samouczek Django w programie Visual Studio Code).

Dodatkowe zasoby