Django Beginnershandleiding: Snel je eerste webapplicatie bouwen
2/19/2026
6 min read
# Django Beginnershandleiding: Snel je eerste webapplicatie bouwen
Django is een geavanceerd Python Web framework, gericht op snelle ontwikkeling en een strak ontwerp. Het volgt de Model-Template-View (MTV) architectuur, en moedigt code hergebruik en modulariteit aan. Deze handleiding leidt je stap voor stap door het maken van een simpele Django applicatie, zodat je snel aan de slag kunt.
## 1. Omgeving instellen
Allereerst moet je ervoor zorgen dat Python op je systeem is geïnstalleerd. Django raadt aan om Python 3.6 of hoger te gebruiken.
### 1.1 Python installeren
Als Python niet op je systeem is geïnstalleerd, kun je het downloaden en installeren van de [Python website](https://www.python.org/downloads/).
### 1.2 Een virtuele omgeving (Virtual Environment) maken
Om de afhankelijkheden tussen verschillende projecten te isoleren, wordt het sterk aangeraden om een virtuele omgeving te gebruiken.
1. Open een terminal of opdrachtprompt.
2. Maak een projectmap, bijvoorbeeld `myproject`:
```bash
mkdir myproject
cd myproject
```
3. Maak en activeer de virtuele omgeving:
```bash
python3 -m venv venv # Of python -m venv venv
source venv/bin/activate # Linux/macOS
venv\Scripts\activate # Windows
```
Nadat de virtuele omgeving is geactiveerd, toont je terminalprompt `(venv)`, wat aangeeft dat je de virtuele omgeving gebruikt.
### 1.3 Django installeren
Installeer Django met pip in de geactiveerde virtuele omgeving:
```bash
pip install Django
```
Controleer of de installatie succesvol is:
```bash
python -m django --version
```
Je zou het Django versienummer moeten zien.
## 2. Een Django project maken
Nadat Django is geïnstalleerd, kun je een nieuw Django project maken.
1. Voer, nog steeds in je projectmap (`myproject`), het volgende commando uit:
```bash
django-admin startproject mysite
```
Dit maakt een map genaamd `mysite` in de map `myproject`, met de basisbestanden voor het Django project.
2. Ga naar de `mysite` map:
```bash
cd mysite
```
3. De Django projectmapstructuur is als volgt:
```
mysite/
manage.py
mysite/
__init__.py
settings.py
urls.py
asgi.py
wsgi.py
```
* `manage.py`: Een command-line tool voor het beheren van het Django project.
* `mysite/`: Een Python pakket dat de projectconfiguratie bevat.
* `__init__.py`: Een leeg bestand dat Python vertelt dat de map als een Python pakket moet worden beschouwd.
* `settings.py`: Het configuratiebestand van het project, bijvoorbeeld database instellingen, debug modus, etc.
* `urls.py`: URL routing configuratie, die URLs aan view functies koppelt.
* `asgi.py`: ASGI (Asynchronous Server Gateway Interface) configuratiebestand, voor het deployen van asynchrone applicaties.
* `wsgi.py`: WSGI (Web Server Gateway Interface) configuratiebestand, voor het deployen van traditionele synchrone applicaties.## 3. Een ontwikkelserver starten
Django wordt geleverd met een lichtgewicht ontwikkelserver, handig voor lokale ontwikkeling en testen.
1. Voer in de map `mysite` de volgende opdracht uit:
```bash
python manage.py runserver
```
2. Open uw browser en ga naar `http://127.0.0.1:8000/`. U zou de pagina "It worked! Congratulations on your first Django-powered page." moeten zien.
## 4. Een Django-applicatie maken
Een Django-project kan meerdere applicaties bevatten. Laten we een applicatie maken met de naam `myapp`.
1. Open een nieuw terminalvenster (laat de ontwikkelserver draaien).
2. Voer in de map `mysite` de volgende opdracht uit:
```bash
python manage.py startapp myapp
```
Dit maakt een map met de naam `myapp` in de map `mysite`, die de skeletbestanden van de Django-applicatie bevat.
3. De Django-applicatiemapstructuur is als volgt:
```
myapp/
__init__.py
admin.py
apps.py
migrations/
__init__.py
models.py
tests.py
views.py
```
* `__init__.py`: Een leeg bestand dat Python vertelt dat de map als een Python-pakket moet worden beschouwd.
* `admin.py`: Wordt gebruikt om de Django-beheerinterface te configureren.
* `apps.py`: Applicatieconfiguratie.
* `migrations/`: Wordt gebruikt om databasemigraties te beheren.
* `models.py`: Definieert datamodellen (databasetabellen).
* `tests.py`: Schrijf testgevallen.
* `views.py`: Definieert view-functies, verwerkt verzoeken en retourneert antwoorden.
4. Voeg in `mysite/settings.py` `myapp` toe aan de lijst `INSTALLED_APPS`:
```python
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'myapp', # 添加 myapp (myapp toevoegen)
]
```
## 5. Een eenvoudige view maken
Nu maken we een eenvoudige view die "Hello, Django!" in de browser weergeeft.
1. Bewerk het bestand `myapp/views.py` en voeg de volgende code toe:
```python
from django.http import HttpResponse
def index(request):
return HttpResponse("Hello, Django!")
```
2. Maak een bestand `myapp/urls.py` en wijs de URL toe aan de view-functie:
```python
from django.urls import path
from . import views
urlpatterns = [
path('', views.index, name='index'),
]
```
3. Neem `myapp/urls.py` op in `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')), # Voeg de URL-configuratie van myapp toe
]
```
4. Bezoek `http://127.0.0.1:8000/myapp/`. Je zou de pagina "Hello, Django!" moeten zien.
## 6. Een model maken
Laten we een eenvoudig model maken om wat gegevens op te slaan.
1. Bewerk het bestand `myapp/models.py` en voeg de volgende code toe:
```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
```
Dit definieert een model genaamd `Question` met twee velden: `question_text` (CharField) en `pub_date` (DateTimeField).
2. Maak en pas databasemigraties toe:
```bash
python manage.py makemigrations myapp
python manage.py migrate
```
De opdracht `makemigrations` maakt migratiebestanden op basis van uw model, de opdracht `migrate` past de migraties toe op de database.
## 7. De Django-beheerinterface gebruiken
Django biedt een krachtige beheerinterface waarmee u eenvoudig uw gegevens kunt beheren.
1. Maak een superuser:
```bash
python manage.py createsuperuser
```
Volg de aanwijzingen om een gebruikersnaam, e-mailadres en wachtwoord in te voeren.
2. Bewerk het bestand `myapp/admin.py` en registreer het `Question`-model:
```python
from django.contrib import admin
from .models import Question
admin.site.register(Question)
```
3. Bezoek `http://127.0.0.1:8000/admin/` en log in met de superuser die u hebt gemaakt. U zou de module "Questions" moeten zien, waar u vragen kunt toevoegen, bewerken en verwijderen.
## 8. Sjablonen gebruiken
Het gebruik van sjablonen maakt het flexibeler om HTML-pagina's te genereren.
1. Maak in de map `myapp` een map met de naam `templates`, en maak in de map `templates` een map met de naam `myapp` ( `myapp/templates/myapp` ).\n\n2. Maak in de map `myapp/templates/myapp` een bestand met de naam `index.html` en voeg de volgende code toe:\n\n ```html\n \n\n \n
Hallo, Django!
\n De huidige tijd is: {{ current_time }} \n \n ```\n\n3. Bewerk het bestand `myapp/views.py` en gebruik de template:\n\n ```python\n from django.shortcuts import render\n import datetime\n\n def index(request):\n now = datetime.datetime.now()\n return render(request, 'myapp/index.html', {'current_time': now})\n ```\n\n De functie `render` laadt de template en geeft de data door aan de template om te renderen.\n\n4. Bezoek opnieuw `http://127.0.0.1:8000/myapp/`. Je zou een pagina moeten zien met de huidige tijd.\n\n## 9. Conclusie\n\nMet deze handleiding heb je de basisconcepten en het gebruik van Django geleerd, waaronder het opzetten van de omgeving, het maken van projecten en applicaties, het definiëren van modellen, het maken van views en het gebruik van templates. Dit is nog maar het begin, Django biedt een schat aan functies, je kunt blijven leren en ontdekken om complexere webapplicaties te bouwen.Published in Technology





