---
title: "Skriva din första Django-app, del 1"
version: 6.1
locale: sv
source: https://docs.djangoproject.com/sv/6.1/intro/tutorial01/
canonical: https://djangodocs.dev/sv/6.1/intro/tutorial01/
---
# Skriva din första Django-app, del 1

Låt oss lära oss genom exempel.

I den här handledningen går vi igenom hur du skapar en grundläggande poll-applikation.

Den kommer att bestå av två delar:

- En publik webbplats som låter människor se omröstningar och rösta i dem.
- En administratörswebbplats där du kan lägga till, ändra och ta bort omröstningar.

Vi antar att du redan har [Django installerat](/sv/6.1/intro/install/). Du kan se om Django är installerat och vilken version det är genom att köra följande kommando i en shell-prompt (anges med prefixet $):

```console
$ python -m django --version
```

*Windows*

```doscon
...\> py -m django --version
```

Om Django är installerat bör du se versionen av din installation. Om den inte är det får du ett felmeddelande som säger ”Ingen modul med namnet django”.

This tutorial is written for Django 6.1, which supports Python 3.12 and
later. If the Django version doesn’t match, you can refer to the tutorial for
your version of Django by using the version switcher at the bottom right corner
of this page, or update Django to the newest version. If you’re using an older
version of Python, check [Vilken Python-version kan jag använda med Django?](/sv/6.1/faq/install/#faq-python-version-support) to find a compatible
version of Django.

> **Var du kan få hjälp:**
>
> Om du har problem med att gå igenom den här handledningen kan du gå till avsnittet [Att få hjälp](/sv/6.1/faq/help/) i FAQ.

## Skapa ett projekt

Om det här är första gången du använder Django måste du ta hand om en del inledande inställningar. Du måste nämligen autogenerera en del kod som upprättar ett Django [project](/sv/6.1/glossary/#term-project) \- en samling inställningar för en instans av Django, inklusive databaskonfiguration, Django-specifika alternativ och applikationsspecifika inställningar.

From the command line, `cd` into a directory where you’d like to store your
code and run the following command to bootstrap a new Django project:

```console
$ django-admin startproject mysite djangotutorial
```

*Windows*

```doscon
...\> django-admin startproject mysite djangotutorial
```

This will create a directory `djangotutorial` with a project called
`mysite` inside. The directory name doesn’t matter to Django; you can rename
it to anything you like. If it didn’t work, see
[Problem med att köra django-admin](/sv/6.1/faq/troubleshooting/#troubleshooting-django-admin).

> **Note**
>
> Du måste undvika att namnge projekt efter inbyggda Python- eller Django-komponenter. I synnerhet innebär detta att du bör undvika att använda namn som `django` (som kommer att stå i konflikt med Django själv) eller `test` (som står i konflikt med ett inbyggt Python-paket).

Låt oss titta på vad [`startproject`](/sv/6.1/ref/django-admin/#django-admin-startproject) skapade:

```text
djangotutorial/
    manage.py
    mysite/
        __init__.py
        settings.py
        urls.py
        asgi.py
        wsgi.py
```

Dessa filer är:

- `manage.py`: Ett kommandoradsverktyg som låter dig interagera med det här Django-projektet på olika sätt. Du kan läsa alla detaljer om `manage.py` i [django-admin och manage.py](/sv/6.1/ref/django-admin/).
- `mysite/`: En katalog som är det faktiska Python-paketet för ditt projekt. Dess namn är det Python-paketnamn som du måste använda för att importera något i den (t.ex. `mysite.urls`).
- `mysite/__init__.py`: En tom fil som talar om för Python att den här katalogen ska betraktas som ett Python-paket. Om du är nybörjare i Python, läs [mer om paket](https://docs.python.org/3/tutorial/modules.html#tut-packages) i de officiella Python-dokumenten.
- `mysite/settings.py`: Settings/configuration for this Django
  project. [Django-inställningar](/sv/6.1/topics/settings/) will tell you all about how settings
  work.
- `mysite/urls.py`: URL-deklarationerna för det här Django-projektet; en ”innehållsförteckning” för din Django-drivna webbplats. Du kan läsa mer om webbadresser i [URL-distributör](/sv/6.1/topics/http/urls/).
- `mysite/asgi.py`: En ingångspunkt för ASGI-kompatibla webbservrar för att betjäna ditt projekt. Se [Så här distribuerar du med ASGI](/sv/6.1/howto/deployment/asgi/) för mer information.
- `mysite/wsgi.py`: An entry-point for WSGI-compatible web servers to
  serve your project. See [Så här distribuerar du med WSGI](/sv/6.1/howto/deployment/wsgi/) for more details.

## Server för utveckling

Låt oss verifiera att ditt Django-projekt fungerar. Byt till `djangotutorial`-katalogen, om du inte redan har gjort det, och kör följande kommandon:

```console
$ python manage.py runserver
```

*Windows*

```doscon
...\> py manage.py runserver
```

Du kommer att se följande utdata på kommandoraden:

```
Performing system checks...

System check identified no issues (0 silenced).

You have unapplied migrations; your app may not work properly until they are
applied. Run 'python manage.py migrate' to apply them.

aug. 11, 2026 - 15:50:53
Django version 6.1, using settings 'mysite.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

WARNING: This is a development server. Do not use it in a production setting. Use a production WSGI or ASGI server instead.
For more information on production servers see: https://docs.djangoproject.com/en/6.1/howto/deployment/
```

> **Note**
>
> Ignorera varningen om oanvända databasmigreringar för tillfället; vi kommer att ta itu med databasen inom kort.

Nu när servern är igång kan du besöka <http://127.0.0.1:8000/> med din webbläsare. Du kommer att se en ”Grattis!”-sida med en raket som lyfter. Det fungerade!

Du har startat Djangos utvecklingsserver, en lättviktig webbserver som är skriven helt i Python. Vi har inkluderat detta med Django så att du kan utveckla saker snabbt, utan att behöva ta itu med att konfigurera en produktionsserver - till exempel Apache - tills du är redo för produktion.

Nu är det dags att påpeka: **använd** inte den här servern i något som liknar en produktionsmiljö. Den är endast avsedd för användning under utveckling. (Vi är i branschen för att göra webbramverk, inte webbservrar)

(För att servera webbplatsen på en annan port, se [`runserver`](/sv/6.1/ref/django-admin/#django-admin-runserver)-referensen)

> **Automatisk omladdning av runserver**
>
> Utvecklingsservern laddar automatiskt om Python-koden för varje begäran efter behov. Du behöver inte starta om servern för att kodändringar ska träda i kraft. Vissa åtgärder, som att lägga till filer, utlöser dock inte en omstart, så du måste starta om servern i dessa fall.

## Skapa appen Polls

Nu när din miljö - ett ”projekt” - har skapats är du redo att börja arbeta.

Varje applikation du skriver i Django består av ett Python-paket som följer en viss konvention. Django levereras med ett verktyg som automatiskt genererar den grundläggande katalogstrukturen för en app, så att du kan fokusera på att skriva kod istället för att skapa kataloger.

> **Projekt kontra appar**
>
> Vad är skillnaden mellan ett projekt och en app? En app är en webbapplikation som gör något - t.ex. ett bloggsystem, en databas med offentliga register eller en liten app för opinionsundersökningar. Ett projekt är en samling konfigurationer och appar för en viss webbplats. Ett projekt kan innehålla flera appar. En app kan finnas i flera projekt.

Dina appar kan ligga var som helst i din [Python-sökväg](https://docs.python.org/3/tutorial/modules.html#tut-searchpath). I den här handledningen skapar vi vår poll-app i mappen `djangotutorial`.

För att skapa din app, se till att du befinner dig i samma katalog som `manage.py` och skriv detta kommando:

```console
$ python manage.py startapp polls
```

*Windows*

```doscon
...\> py manage.py startapp polls
```

Det skapar en katalog `polls`, som är uppbyggd så här:

```text
polls/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    views.py
```

Denna katalogstruktur kommer att hysa pollapplikationen.

## Skriv din första vy

Låt oss skriva den första vyn. Öppna filen `polls/views.py` och lägg in följande Python-kod i den:

*`polls/views.py`*

```python
from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, world. You're at the polls index.")
```

Detta är den mest grundläggande vyn som är möjlig i Django. För att komma åt den i en webbläsare måste vi mappa den till en URL - och för detta måste vi definiera en URL-konfiguration, eller ”URLconf” för kort. Dessa URL-konfigurationer definieras i varje Django-app, och de är Python-filer med namnet `urls.py`.

För att definiera en URLconf för appen `polls` skapar du en fil `polls/urls.py` med följande innehåll:

*`polls/urls.py`*

```python
from django.urls import path

from . import views

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

Din appkatalog bör nu se ut som följer:

```text
polls/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    urls.py
    views.py
```

Nästa steg är att konfigurera rot-URLconf i projektet `mysite` så att den inkluderar URLconf som definieras i `polls.urls`. För att göra detta lägger du till en import för `django.urls.include` i `mysite/urls.py` och infogar en [`include()`](/sv/6.1/ref/urls/#django.urls.include) i listan `urlpatterns`, så att du har:

*`mysite/urls.py`*

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

urlpatterns = [
    path("polls/", include("polls.urls")),
    path("admin/", admin.site.urls),
]
```

Funktionen [`path()`](/sv/6.1/ref/urls/#django.urls.path) förväntar sig minst två argument: `route` och `view`. Funktionen [`include()`](/sv/6.1/ref/urls/#django.urls.include) tillåter referenser till andra URLconfs. När Django stöter på [`include()`](/sv/6.1/ref/urls/#django.urls.include), hugger den av den del av URL:en som matchade fram till den punkten och skickar den återstående strängen till den inkluderade URLconf för vidare bearbetning.

Tanken bakom [`include()`](/sv/6.1/ref/urls/#django.urls.include) är att göra det enkelt att plugga in och spela upp webbadresser. Eftersom omröstningar finns i sin egen URLconf (`polls/urls.py`) kan de placeras under ”/polls/”, eller under ”/fun\_polls/”, eller under ”/content/polls/”, eller någon annan sökvägsrot, och appen kommer fortfarande att fungera.

> **When to use include()**
>
> Du bör alltid använda `include()` när du inkluderar andra URL-mönster. Det enda undantaget är `admin.site.urls`, som är en förbyggd URLconf som tillhandahålls av Django för standardadministratörsplatsen.

Du har nu kopplat en `index`-vy till URLconf. Verifiera att det fungerar med följande kommando:

```console
$ python manage.py runserver
```

*Windows*

```doscon
...\> py manage.py runserver
```

Gå till <http://localhost:8000/polls/> i din webbläsare, och du bör se texten ”*Hello, world. You’re at the polls index.*”, som du definierade i vyn `index`.

> **Sidan hittades inte?**
>
> Om du får en felsida här, kontrollera att du går till <http://localhost:8000/polls/> och inte <http://localhost:8000/>.

När du känner dig bekväm med det grundläggande flödet för begäran och svar kan du läsa [del 2 av denna handledning](/sv/6.1/intro/tutorial02/) för att börja arbeta med databasen.