Django Introduktionsguide: Bygg din första webbapplikation snabbt

Django är ett avancerat Python-webbramverk som syftar till snabb utveckling och en ren design. Det följer arkitekturen Model-Template-View (MTV) och uppmuntrar återanvändning av kod och komponentisering. Den här guiden leder dig steg för steg genom att skapa en enkel Django-applikation, så att du snabbt kommer igång.

1. Miljöuppsättning

Först måste du se till att Python är installerat på ditt system. Django rekommenderar att du använder Python 3.6 eller senare.

1.1 Installera Python

Om Python inte är installerat på ditt system kan du ladda ner och installera det från Pythons officiella webbplats.

1.2 Skapa en virtuell miljö (Virtual Environment)

För att isolera beroenden mellan olika projekt rekommenderas starkt att du använder en virtuell miljö.

Öppna en terminal eller kommandotolk.
Skapa en projektkatalog, till exempel myproject:

mkdir myproject cd myproject ```

Skapa och aktivera den virtuella miljön:

python3 -m venv venv # Eller python -m venv venv source venv/bin/activate # Linux/macOS venv\Scripts\activate # Windows ```

När den virtuella miljön är aktiverad visar din terminalprompt `(venv)`, vilket indikerar att du använder den virtuella miljön.

1.3 Installera Django

I den aktiverade virtuella miljön använder du pip för att installera Django:

pip install Django

Verifiera att installationen lyckades:

python -m django --version

Du bör kunna se Djangos versionsnummer.

2. Skapa ett Django-projekt

När du har installerat Django kan du skapa ett nytt Django-projekt.

Fortfarande i din projektkatalog (myproject), kör följande kommando:

django-admin startproject mysite ```

Detta skapar en katalog med namnet `mysite` i katalogen `myproject`, som innehåller skelettfilerna för Django-projektet.

2. Gå in i katalogen mysite:

```bash

cd mysite ```

Django-projektkatalogstrukturen är som följer:

mysite/ manage.py mysite/ init.py settings.py urls.py asgi.py wsgi.py ```

*   `manage.py`: Ett kommandoradsverktyg för att hantera Django-projekt.
*   `mysite/`: Ett Python-paket som innehåller projektkonfigurationen.
    *   `__init__.py`: En tom fil som talar om för Python att katalogen ska betraktas som ett Python-paket.
    *   `settings.py`: Projektets konfigurationsfil, till exempel databasinställningar, felsökningsläge etc.
    *   `urls.py`: URL-routningskonfiguration, som mappar URL:er till vyfunktioner.
    *   `asgi.py`: ASGI-konfigurationsfil (Asynchronous Server Gateway Interface) för distribution av asynkrona applikationer.
    *   `wsgi.py`: WSGI-konfigurationsfil (Web Server Gateway Interface) för distribution av traditionella synkrona applikationer.

3. Starta utvecklingsservern

Django levereras med en lättviktsutvecklingsserver som gör det enkelt för dig att utveckla och testa lokalt.

I katalogen mysite, kör följande kommando:
```
python manage.py runserver
```
Öppna din webbläsare och besök http://127.0.0.1:8000/. Du bör se sidan "It worked! Congratulations on your first Django-powered page.".

4. Skapa en Django-applikation

Ett Django-projekt kan innehålla flera applikationer. Låt oss skapa en applikation som heter myapp.

Öppna ett nytt terminalfönster (håll utvecklingsservern igång).
I katalogen mysite, kör följande kommando:
```
python manage.py startapp myapp
```
Detta skapar en katalog med namnet myapp i katalogen mysite, som innehåller skelettfilerna för Django-applikationen.
Django-applikationskatalogstrukturen är som följer:
```
myapp/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    views.py
```
- __init__.py: En tom fil som talar om för Python att katalogen ska betraktas som ett Python-paket.
- admin.py: Används för att konfigurera Django-administrationsgränssnittet.
- apps.py: Applikationskonfiguration.
- migrations/: Används för att hantera databas migreringar.
- models.py: Definierar datamodeller (databastabeller).
- tests.py: Skriv testfall.
- views.py: Definierar vyfunktioner, hanterar förfrågningar och returnerar svar.

I mysite/settings.py, lägg till myapp i listan INSTALLED_APPS:

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'myapp',  # Lägg till myapp
]

5. Skapa en enkel vy

Nu skapar vi en enkel vy som visar "Hello, Django!" i webbläsaren.

Redigera filen myapp/views.py och lägg till följande kod:

from django.http import HttpResponse

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

Skapa en myapp/urls.py-fil och mappa URL:en till vyfunktionen:

    from django.urls import path
    from . import views

    urlpatterns = [
        path('', views.index, name='index'),
    ]
    ```

3.  Inkludera `myapp/urls.py` i `mysite/urls.py`:

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

    urlpatterns = [
        path('admin/', admin.site.urls),
        path('myapp/', include('myapp.urls')),  # Lägg till URL-konfigurationen för myapp
    ]
    ```

4.  Besök `http://127.0.0.1:8000/myapp/`. Du borde kunna se sidan "Hello, Django!".

## 6. Skapa en modell

Låt oss skapa en enkel modell för att lagra lite data.

1.  Redigera filen `myapp/models.py` och lägg till följande kod:

    ```python
    from django.db import models

    class Question(models.Model):
        question_text = models.CharField(max_length=200)
        pub_date = models.DateTimeField('date published')

        def __str__(self):
            return self.question_text
    ```

    Detta definierar en modell som heter `Question`, som innehåller två fält: `question_text` (CharField) och `pub_date` (DateTimeField).

2.  Skapa och tillämpa databasmigreringar:

    ```bash
    python manage.py makemigrations myapp
    python manage.py migrate
    ```

    Kommandot `makemigrations` skapar migreringsfiler baserat på din modell, och kommandot `migrate` tillämpar migreringarna på databasen.

## 7. Använda Django-administrationsgränssnittet

Django erbjuder ett kraftfullt administrationsgränssnitt som gör det enkelt att hantera din data.

1.  Skapa en superanvändare:

    ```bash
    python manage.py createsuperuser
    ```

    Följ anvisningarna för att ange användarnamn, e-postadress och lösenord.

2.  Redigera filen `myapp/admin.py` och registrera modellen `Question`:

    ```python
    from django.contrib import admin
    from .models import Question

    admin.site.register(Question)
    ```

3.  Besök `http://127.0.0.1:8000/admin/` och logga in med superanvändaren du skapade. Du borde kunna se modulen "Questions", där du kan lägga till, redigera och ta bort frågor.

## 8. Använda mallar

Att använda mallar gör det mer flexibelt att generera HTML-sidor.
1. Skapa en katalog med namnet `templates` i katalogen `myapp`, och skapa sedan en katalog med namnet `myapp` i katalogen `templates` ( `myapp/templates/myapp` ).

2. Skapa en fil med namnet `index.html` i katalogen `myapp/templates/myapp` och lägg till följande kod:

    ```html
    

# Hello, Django!

    The current time is: {{ current_time }}

    ```

3. Redigera filen `myapp/views.py` och använd mallen:

    ```python
    from django.shortcuts import render
    import datetime

    def index(request):
        now = datetime.datetime.now()
        return render(request, 'myapp/index.html', {'current_time': now})
    ```

    `render`-funktionen laddar mallen och skickar data till mallen för rendering.

4. Besök `http://127.0.0.1:8000/myapp/` igen. Du bör kunna se sidan som innehåller den aktuella tiden.

## 9. Slutsats

Genom den här guiden har du lärt dig de grundläggande koncepten och användningsmetoderna för Django, inklusive miljöinstallation, skapande av projekt och applikationer, definiering av modeller, skapande av vyer och användning av mallar. Detta är bara början, Django erbjuder rika funktioner, och du kan fortsätta att lära dig och utforska för att bygga mer komplexa webbapplikationer.