Kom igång med Python för webbutveckling i Windows

Följande är en stegvis guide för att komma igång med Python för webbutveckling i Windows med hjälp av Windows-undersystemet för Linux (WSL).

Konfigurera utvecklingsmiljön

Vi rekommenderar att du installerar Python på WSL när du skapar webbprogram. Många av självstudierna och instruktionerna för Python-webbutveckling är skrivna för Linux-användare och använder Linux-baserade paketerings- och installationsverktyg. De flesta webbappar distribueras också i Linux, så detta säkerställer att du har konsekvens mellan dina utvecklings- och produktionsmiljöer.

Om du använder Python för något annat än webbutveckling rekommenderar vi att du installerar Python direkt i Windows med hjälp av Microsoft Store. WSL stöder inte GUI-skrivbord eller program (till exempel PyGame, Gnome, KDE osv.). Installera och använda Python direkt i Windows för dessa fall. Om du inte har använt Python tidigare kan du läsa vår guide: Kom igång med Python i Windows för nybörjare. Om du är intresserad av att automatisera vanliga uppgifter i operativsystemet kan du läsa vår guide: Kom igång med Python i Windows för skript och automatisering. För vissa avancerade scenarier kan du överväga att ladda ned en specifik Python-version direkt från python.org eller överväga att installera ett alternativ, till exempel Anaconda, Jython, PyPy, WinPython, IronPython osv. Vi rekommenderar bara detta om du är en mer avancerad Python-programmerare med en specifik anledning till att välja en alternativ implementering.

Installera Windows-undersystem för Linux

Med WSL kan du köra en GNU/Linux-kommandoradsmiljö som är direkt integrerad med Windows och dina favoritverktyg, till exempel Visual Studio Code, Outlook osv. Vi rekommenderar vanligtvis att du använder WSL 2 för Python-webbutvecklingsarbete.

Information om hur du aktiverar och installerar WSL 2 finns i installationsdokumentationen för WSL. De här stegen omfattar att välja en Linux-distribution (till exempel Ubuntu).

När du har installerat WSL och en Linux-distribution öppnar du Linux-distributionen (den finns på Start-menyn i Windows) och kontrollerar versionen och kodnamnet med kommandot : lsb_release -dc.

Vi rekommenderar att du uppdaterar Din Linux-distribution regelbundet, även omedelbart efter installationen, för att säkerställa att du har de senaste paketen. Windows hanterar inte den här uppdateringen automatiskt. Om du vill uppdatera distributionen använder du kommandot: sudo apt update && sudo apt upgrade.

Konfigurera Visual Studio Code

Dra nytta av IntelliSense, Linting, felsökningsstöd, kodfragment och enhetstestning med hjälp av VS Code. VS Code integreras på ett bra sätt med Windows-undersystemet för Linux, vilket ger en inbyggd terminal för att upprätta ett sömlöst arbetsflöde mellan kodredigeraren och kommandoraden, förutom att stödja Git för versionskontroll med vanliga Git-kommandon (lägg till, checka in, pusha, hämta) som är inbyggda direkt i användargränssnittet.

1. Ladda ned och installera VS Code för Windows. VS Code är också tillgängligt för Linux, men Windows-undersystemet för Linux stöder inte GUI-appar, så vi måste installera det i Windows. Oroa dig inte, du kommer fortfarande att kunna integrera med linux-kommandoraden och -verktygen med hjälp av tillägget Remote - WSL.

2. Installera Remote - WSL-tillägget på VS Code. På så sätt kan du använda WSL som din integrerade utvecklingsmiljö och hantera kompatibilitet och sökvägar åt dig. Läs mer.

Skapa ett nytt projekt

Nu ska vi skapa en ny projektkatalog i vårt Linux-filsystem (Ubuntu) som vi sedan kommer att arbeta med med Linux-appar och -verktyg med VS Code.

1. Stäng VS Code och öppna Ubuntu (WSL-kommandoraden) genom att gå till Start-menyn (windowsikonen längst ned till vänster) och skriva: "Ubuntu".

2. I Ubuntu-kommandoraden navigerar du till den plats där du vill placera projektet och skapar en katalog för det: mkdir HelloWorld.

Installera Python, pip och venv

Ubuntu levereras med Python 3.6 redan installerat, men det kommer inte med några av de moduler som du kan förvänta dig att få med andra Python-installationer. Vi måste fortfarande installera pip, standardpakethanteraren för Python och venv, standardmodulen som används för att skapa och hantera lätta virtuella miljöer. Kom ihåg att du kan behöva uppdatera Linux-distributionen så att den har den senaste versionen med kommandot : sudo apt update && sudo apt upgrade.

1. Bekräfta att Python3 redan är installerat genom att öppna Ubuntu-terminalen och ange: python3 --version. Detta bör returnera python-versionsnumret. Om du behöver uppdatera din version av Python uppdaterar du först Ubuntu-versionen genom att ange: sudo apt update && sudo apt upgradeoch sedan uppdatera Python med sudo apt upgrade python3.

2. Installera pip genom att ange: sudo apt install python3-pip. Med Pip kan du installera och hantera ytterligare paket som inte ingår i Python-standardbiblioteket.

3. Installera venv genom att ange: sudo apt install python3-venv.

Skapa en virtuell miljö

Att använda virtuella miljöer är en rekommenderad metod för Python-utvecklingsprojekt. Genom att skapa en virtuell miljö kan du isolera dina projektverktyg och undvika versionskonflikter med verktyg för dina andra projekt. Du kanske till exempel underhåller ett äldre webbprojekt som kräver Webbramverket Django 1.2, men sedan kommer ett spännande nytt projekt med Django 2.2. Om du uppdaterar Django globalt, utanför en virtuell miljö, kan du stöta på problem med versionshantering senare. Förutom att förhindra oavsiktliga versionskonflikter kan du i virtuella miljöer installera och hantera paket utan administratörsbehörighet.

1. Öppna terminalen och använd följande kommando i din HelloWorld-projektmapp för att skapa en virtuell miljö med namnet .venv: python3 -m venv .venv.

2. Om du vill aktivera den virtuella miljön anger du: source .venv/bin/activate. Om det fungerade bör du se (.venv) före kommandoraden. Nu har du en fristående miljö som är redo att skriva kod och installera paket. När du är klar med din virtuella miljö anger du följande kommando för att inaktivera den: deactivate.

   

Öppna ett WSL-terminalfönster i VS Code

VS Code använder WSL-tillägget (tidigare installerat) för att behandla ditt Linux-undersystem som en fjärrserver. På så sätt kan du använda WSL som din integrerade utvecklingsmiljö. Läs mer.

1. Öppna projektmappen i VS Code från Ubuntu-terminalen genom att ange: code . ("." anger att VS Code ska öppna den aktuella mappen).

2. Stäng Ubuntu-terminalen. Framöver kommer vi att använda WSL-terminalen integrerad i VS Code.

3. Öppna WSL-terminalen i VS Code genom att trycka på Ctrl+' (med backtick-tecknet) eller välja Visa>terminal. Då öppnas en bash-kommandorad (WSL) som öppnas för sökvägen till projektmappen som du skapade i Ubuntu-terminalen.

   

Installera Microsoft Python-tillägget

Du kan behöva installera VS Code-tillägg för WSL-installationen. Vissa tillägg som redan har installerats lokalt på VS Code är inte automatiskt tillgängliga. Läs mer.

1. Öppna VS Code Extensions-fönstret genom att ange Ctrl+Skift+X (eller använd menyn för att navigera till Visa>tillägg).

2. I den översta rutan Söktillägg i Marketplace anger du: Python.

3. Leta upp Python (ms-python.python) efter Microsoft-tillägget och välj knappen Installera i WSL: [distributionsnamn] .

4. När tillägget har installerats visas ett WSL: [distributionsnamn] – Installerat i vs-kodtilläggsfönstret som visar att du har installerat Python-tillägget.

Köra ett enkelt Python-program

Python är ett tolkat språk och har stöd för olika typer av tolkar (Python2, Anaconda, PyPy osv.). VS Code ska som standard använda den tolk som är associerad med projektet. Om du har anledning att ändra den väljer du tolken som visas i det blå fältet längst ned i VS Code-fönstret eller öppnar kommandopaletten (Ctrl+Skift+P) och anger kommandot Python: Välj tolk. Då visas en lista över De Python-tolkar som du för närvarande har installerat. Läs mer om hur du konfigurerar Python-miljöer.

Nu ska vi skapa och köra ett enkelt Python-program som ett test och se till att vi har rätt Python-tolk vald.

1. Öppna VS Code File Explorer-fönstret genom att ange Ctrl+Skift+E (eller använd menyn för att navigera till Visa>utforskaren).

2. Om den inte redan är öppen öppnar du den integrerade WSL-terminalen genom att ange Ctrl+Skift+ och se till att den aktuella katalogen är Python-projektmappen HelloWorld .

3. Skapa en Python-fil genom att ange: touch test.py. Du bör se att filen som du nyss skapade visas i utforskarfönstret under mapparna .venv och .vscode som redan finns i projektkatalogen.

4. Välj den test.py fil som du nyss skapade i Utforskaren för att öppna den i VS Code. Eftersom .py i vårt filnamn talar om för VS Code att det här är en Python-fil, kommer Python-tillägget som du läste in tidigare automatiskt att välja och läsa in en Python-tolk som visas längst ned i VS Code-fönstret.

   

5. Klistra in den här Python-koden i din test.py-fil och spara sedan filen (Ctrl+S):

   print("Hello World")
   

6. Om du vill köra python-programmet "Hello World" som vi nyss skapade väljer du filen test.py i VS Code Explorer-fönstret och högerklickar sedan på filen för att visa en meny med alternativ. Välj Kör Python-fil i terminalen. I det integrerade WSL-terminalfönstret kan du också ange: python3 test.py för att köra ditt "Hello World"-program. Python-tolken skriver ut "Hello World" i terminalfönstret.

Grattis. Du har alla konfigurerats för att skapa och köra Python-program! Nu ska vi prova att skapa en Hello World-app med två av de mest populära Python-webbramverken: Flask och Django.

Hello World-handledning för Flask

Flask är ett webbprogramramverk för Python. Flask-dokumentationen ger vägledning om hur du kommer igång och en mer detaljerad självstudie om hur du skapar ett litet men komplett program.

Genom att följa stegen nedan kan du skapa en liten "Hello World"-Flask-app med VS Code och WSL.

1. Öppna Ubuntu (WSL-kommandoraden) genom att gå till Start-menyn (windowsikonen längst ned till vänster) och skriva: "Ubuntu".

2. Skapa en katalog för projektet: mkdir HelloWorld-Flask, och sedan cd HelloWorld-Flask för att gå in i katalogen.

3. Skapa en virtuell miljö för att installera dina projektverktyg: python3 -m venv .venv

4. Öppna ditt HelloWorld-Flask-projekt i VS Code genom att ange kommandot: code .

5. Öppna den integrerade WSL-terminalen (även kallad Bash) i VS Code genom att ange Ctrl+Skift+' (din HelloWorld-Flask-projektmapp bör redan vara markerad). Stäng Ubuntu-kommandoraden eftersom vi kommer att arbeta i WSL-terminalen som är integrerad med VS Code framöver.

6. Aktivera den virtuella miljö som du skapade i steg 3 med hjälp av Bash-terminalen i VS Code: source .venv/bin/activate. Om det fungerade bör du se (.venv) före kommandoprompten.

7. Installera Flask i den virtuella miljön genom att ange: python3 -m pip install flask. Kontrollera att den är installerad genom att ange: python3 -m flask --version.

8. Skapa en ny fil för Python-koden: touch app.py

9. Öppna filen app.py i VS Code-utforskaren (Ctrl+Shift+Evälj sedan filen app.py). Detta aktiverar Python-tillägget för att välja en tolk. Den bör vara standardmässigt Python 3.6.8 64-bitars ('.venv': venv). Observera att den också har identifierat din virtuella miljö.

   

10. I app.py lägger du till kod för att importera Flask och skapa en instans av Flask-objektet:

    from flask import Flask
    app = Flask(__name__)
    

11. Lägg även till en funktion som returnerar innehåll i app.py, i det här fallet en enkel sträng. Använd Flasks app.route-dekoratör för att mappa URL-vägen "/" till den funktionen:

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

    Tips/Råd

    Du kan använda flera dekoratörer på samma funktion, en per rad, beroende på hur många olika vägar du vill mappa till samma funktion.

12. Spara filen app.py (Ctrl+S).

13. Kör appen i terminalen genom att ange följande kommando:

    python3 -m flask run
    

    Detta kör Flask-utvecklingsservern. Utvecklingsservern söker som standard efter app.py . När du kör Flask bör du se utdata som liknar följande:

    (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. Visual Studio kommer att starta ett meddelande om att ditt program som nu körs på port 5000 är tillgängligt. Klicka på knappen Öppna i webbläsare . Eller så kan du Ctrl+Klicka påhttp://127.0.0.1:5000/ URL:en i terminalen. Du bör se följande meddelande i webbläsaren:

    

15. Observera att när du besöker en URL som "/" visas ett meddelande i felsökningsterminalen som visar HTTP-begäran:

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

16. Stoppa appen med hjälp av Ctrl+C i terminalen.

Grattis, du har skapat ett Flask-webbprogram med Visual Studio Code och Windows-undersystem för Linux! En mer djupgående självstudiekurs med VS Code och Flask finns i Flask-självstudie i Visual Studio Code.

Hello World-handledning för Django

Django är ett webbprogramramverk för Python. I den här korta självstudien skapar du en liten "Hello World"-Django-app med VS Code och WSL.

1. Öppna Ubuntu (WSL-kommandoraden) genom att gå till Start-menyn (windowsikonen längst ned till vänster) och skriva: "Ubuntu".

2. Skapa en katalog för projektet: mkdir HelloWorld-Django, och sedan cd HelloWorld-Django för att gå in i katalogen.

3. Skapa en virtuell miljö för att installera dina projektverktyg: python3 -m venv .venv

4. Öppna ditt HelloWorld-Django-projekt i VS Code genom att ange kommandot: code .

5. Öppna den integrerade WSL-terminalen (även kallad Bash) i VS Code genom att ange Ctrl+Skift+' (projektmappen HelloWorld-Django bör redan vara markerad). Stäng Ubuntu-kommandoraden eftersom vi kommer att arbeta i WSL-terminalen som är integrerad med VS Code framöver.

6. Aktivera den virtuella miljö som du skapade i steg 3 med hjälp av Bash-terminalen i VS Code: source .venv/bin/activate. Om det fungerade bör du se (.venv) före kommandoprompten.

7. Installera Django i den virtuella miljön med kommandot : python3 -m pip install django. Kontrollera att den är installerad genom att ange: python3 -m django --version.

8. Kör sedan följande kommando för att skapa Django-projektet:

   django-admin startproject web_project .
   

   Kommandot startproject förutsätter (med hjälp av . i slutet) att den aktuella mappen är din projektmapp och skapar följande i den:

   • manage.py: Django-kommandoradens administrativa verktyg för projektet. Du kör administrativa kommandon för projektet med hjälp av python manage.py <command> [options].

   • En undermapp med namnet web_project, som innehåller följande filer:

     • __init__.py: en tom fil som talar om för Python att den här mappen är ett Python-paket.
     • wsgi.py: en startpunkt för WSGI-kompatibla webbservrar för att hantera projektet. Du lämnar vanligtvis den här filen as-is eftersom den ger kopplingspunkter för produktionswebbservrar.
     • asgi.py: en startpunkt för ASGI-kompatibla webbservrar för att hantera projektet. Du lämnar vanligtvis den här filen as-is eftersom den ger kopplingspunkter för produktionswebbservrar.
     • settings.py: innehåller inställningar för Django-projektet, som du ändrar under utvecklingen av en webbapp.
     • urls.py: innehåller en innehållsförteckning för Django-projektet, som du också ändrar under utvecklingen.

9. Om du vill verifiera Django-projektet startar du Djangos utvecklingsserver med kommandot python3 manage.py runserver. Servern körs på standardporten 8000 och du bör se utdata som följande utdata i terminalfönstret:

   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.
   

   När du kör servern första gången skapas en standard-SQLite-databas i filen db.sqlite3, som är avsedd för utveckling, men som kan användas i produktion för webbappar med låg volym. Djangos inbyggda webbserver är också endast avsedd för lokal utveckling. När du distribuerar till en webbvärd, använder dock Django webbservern från värden i stället. Modulen wsgi.py i Django-projektet tar hand om anslutning till produktionsservrarna.

   Om du vill använda en annan port än standardvärdet 8000 anger du portnumret på kommandoraden, till exempel python3 manage.py runserver 5000.

10. Visual Studio startar ett meddelande om att "Ditt program körs nu på port 8000 är tillgängligt.". Klicka på knappen Öppna i webbläsare . Eller Ctrl+click URL:en i terminalutdatafönstret http://127.0.0.1:8000/ för att öppna standardwebbläsaren till den adressen. Om Django är korrekt installerat och projektet är giltigt visas en standardsida. Utdatafönstret för VS Code-terminalen visar även serverloggen.

11. När du är klar stänger du webbläsarfönstret och stoppar servern i VS Code med Ctrl+C enligt terminalutdatafönstret.

12. För att skapa en Django-app kör du kommandot för det administrativa verktyget startapp i projektmappen (där manage.py finns):

    python3 manage.py startapp hello
    

    Kommandot skapar en mapp med namnet hello som innehåller ett antal kodfiler och en undermapp. Av dessa arbetar du ofta med views.py (som innehåller de funktioner som definierar sidor i webbappen) och models.py (som innehåller klasser som definierar dina dataobjekt). Mappen migrations används av Djangos administrativa verktyg för att hantera databasversioner som beskrivs senare i den här självstudien. Det finns också filer apps.py (appkonfiguration), admin.py (för att skapa ett administrativt gränssnitt) och tests.py (för tester), som inte beskrivs här.

13. Ändra hello/views.py så att den matchar följande kod, vilket skapar en enda vy för appens startsida:

    from django.http import HttpResponse
    
    def home(request):
        return HttpResponse("Hello, Django!")
    

14. Skapa en fil, hello/urls.py, med innehållet nedan. I urls.py filen anger du mönster för att dirigera olika URL:er till lämpliga vyer. Koden nedan innehåller en väg för att mappa appens rot-URL ("") till den views.home funktion som du precis har lagt till i hello/views.py:

    from django.urls import path
    from hello import views
    
    urlpatterns = [
        path("", views.home, name="home"),
    ]
    

15. Mappen web_project innehåller också en urls.py fil, där URL-routning faktiskt hanteras. Öppna web_project/urls.py och ändra den så att den matchar följande kod (du kan behålla de lärorikta kommentarerna om du vill). Den här koden använder hello/urls.pyför att hämta appens django.urls.include, vilket håller appens rutter begränsade inom appen. Den här separationen är användbar när ett projekt innehåller flera appar.

    from django.contrib import admin
    from django.urls import include, path
    
    urlpatterns = [
        path("", include("hello.urls")),
    ]
    

16. Spara alla ändrade filer.

17. I VS Code-terminalen kör du utvecklingsservern med python3 manage.py runserver och öppnar en webbläsare till http://127.0.0.1:8000/ för att se en sida som visar "Hello, Django".

Grattis, du har skapat en Django-webbapp med VS Code och Windows Subsystem för Linux! En mer djupgående handledning om användning av VS Code och Django finns i Django Tutorial in Visual Studio Code.

Ytterligare resurser

• Microsoft Dev-bloggar: Python: Läs de senaste uppdateringarna om allt som rör Python på Microsoft.
• Python-självstudie med VS Code: En introduktionskurs till VS Code som en Python-miljö, främst hur du redigerar, kör och felsöker kod.
• Git-stöd i VS Code: Lär dig hur du använder grunderna för Git-versionskontroll i VS Code.
• Lär dig nya funktioner och förbättringar i WSL 2: Den här nya versionen ändrar hur Linux-distributioner interagerar med Windows, ökar filsystemets prestanda och lägger till fullständig systemanropskompatibilitet.
• Arbeta med flera Linux-distributioner i Windows: Lär dig hur du hanterar flera olika Linux-distributioner på din Windows-dator.