Ga naar hoofdinhoud

Django-webontwikkeling in Python

Leer de basis van webontwikkeling met Django door blogapplicaties te bouwen met (CRUD) Create, Read, Update, Delete-functionaliteit.
· 12 min lezen

Verken met AI

Django is een veelgebruikt, gratis, open-source en high-level webframework. Het levert ontwikkelaars veel functies "out of the box", waardoor je snel kunt ontwikkelen. Tegelijkertijd zijn websites die ermee zijn gebouwd veilig, schaalbaar en goed te onderhouden.

Doel

Het doel van deze tutorial is om een blogapplicatie te bouwen waarbij de bloginhoud kan worden aangemaakt en bijgewerkt via een beheerpaneel. Blogberichten worden op de pagina getoond en kunnen indien nodig worden verwijderd. De applicatie biedt al met al CRUD-functionaliteit (Create, Read, Update, Delete).

In deze tutorial gebruiken we geen Frontend-technologieën zoals JavaScript, CSS, enz., maar focussen we op basis- en kernconcepten die in elke Django-webontwikkeling nodig zijn.

Benodigdheden

  1. Git Bash: Gebruikers van alle besturingssystemen kunnen dit gebruiken. Alle Django-gerelateerde commando's en Unix-commando's voer je hiermee uit. Om Git Bash te downloaden: Klik hier.
  2. Texteditor: Elke texteditor zoals Sublime Text of Visual Studio Code volstaat. Voor dit project is Sublime Text gebruikt.
  3. Python 3: De nieuwste versie van Python is te downloaden via Download Python.

Let op: Je kunt deze tutorial gemakkelijk volgen als je de basis van Python begrijpt en weet wat lussen, functies, classes, enz. zijn, en enige kennis hebt van bash of de command line.

Virtuele omgeving

Een virtuele omgeving beheert de afhankelijkheden van Python-projecten. Het is een zelf-contained container of geïsoleerde omgeving waarin alle Python-pakketten en vereiste versies voor een specifiek project worden geïnstalleerd. Omdat er steeds nieuwere versies van Python, Django of pakketten uitkomen, kun je met een virtuele omgeving met oudere, projectspecifieke versies blijven werken. Samengevat: je kunt op dezelfde computer een onafhankelijk project starten met Django versie 2.0, terwijl je ook een ander project met Django versie 3.0 draait.

Let op: Er zijn veel manieren om een virtuele omgeving te maken, hieronder laten we er één zien.

Stappen om een virtuele omgeving te maken

  1. Maak een nieuwe map met de naam 'project-blog' via het commando 'mkdir' op je bureaublad.
  2. Navigeer naar de map 'project-blog' met het commando 'cd'.
    Steps to Create a Virtual Environment

  3. Maak de virtuele omgeving met 'python -m venv env', waarbij env de naam van je virtuele omgeving is; controleer met 'ls'.
    Steps to Create a Virtual Environment

  4. Activeren van je virtuele omgeving: Activeer de virtuele omgeving met het 'source'-commando, waarbij je de map 'Scripts' activeert.
    Steps to Create a Virtual Environment
    Als je virtuele omgeving succesvol is geactiveerd, zie je 'env' tussen haakjes.

  5. Django installeren: Gebruik 'pip install django' om Django te installeren in je specifieke virtuele omgeving.
    Steps to Create a Virtual Environment

Let op: Linux- en Mac-gebruikers moeten specifiek 'python3' gebruiken in het commando, omdat Python versie 2 vaak al vooraf is geïnstalleerd op hun computer. Bovendien is het aan te raden versie 3 te gebruiken, aangezien Python versie 2 na 2020 niet meer wordt ondersteund.

Een Django-project aanmaken

  1. De eerste stap is je project aanmaken met het commando 'django-admin startproject project_name', waarbij 'project_name' in jouw geval 'django_blog' is. Dit genereert veel bestanden binnen het nieuwe project; je kunt hier desgewenst meer over lezen in de Django-documentatie.
    Creating a Django Project
  2. Navigeer naar het nieuw aangemaakte project met 'cd' en bekijk de aangemaakte bestanden met 'ls'.
    Creating a Django Project
  3. Je kunt je project draaien met 'python manage.py runserver'.
    Creating a Django Project
  4. Bekijk het project in je favoriete browser (Google Chrome, Mozilla Firefox, enz.). Ga naar 'localhost:8000' of '127.0.0.1:8000' in de URL, zoals hieronder getoond.
    Creating a Django Project
    Let op: Om dezelfde pagina als hierboven te zien, moet de server in de bash op de achtergrond draaien. Je kunt de server handmatig stoppen met 'Ctr+C' in Windows/Linux en 'Cmd+C' op Mac.

Het nieuwe Django-project starten

Een nieuw project in Django opzetten is altijd een proces in twee stappen, zoals hieronder weergegeven.

  1. De eerste stap is het aanmaken van een app met het commando 'python manage.py startapp app_name', waarbij app_name in jouw geval 'blog' is. In Django kunnen meerdere apps in één project bestaan, waarbij elke app één specifieke functionaliteit voor het project levert.
    Starting the New Project
  2. De tweede stap is je project laten weten dat de nieuwe app bestaat door een wijziging te maken in de sectie INSTALLED_APP van 'django_blog/settings.py'.
    Starting the New Project

Wijzigingen in onze Models

Django gebruikt 'SQLite' als standaarddatabase. Die is lichtgewicht en geschikt voor kleine projecten, wat prima is voor dit project. Het gebruikt een 'Object Relational Mapper (ORM)', wat werken met de database erg eenvoudig maakt. Je schrijft geen ruwe databasecode; de databasetabellen worden aangemaakt via het trefwoord 'class' in 'models.py'.

In 'blog/models.py' maak je een nieuw model genaamd 'Post'. Dit is een class die later een databasetabel wordt en nu erft van 'models.Model'. Zoals in een standaardblog bevat een 'Post' een titel, die een veld CharField zal zijn. Dit is een tekstkolom en vereist het argument 'max_length', dat in jouw geval 50 is. Daarnaast is er nog een veld 'content', een TextField met de inhoudelijke tekst van de 'Post', zoals in een standaardblog. De dubbele underscore-methode ('str') is gedefinieerd, waarmee het veld 'title' wordt teruggegeven zodat de daadwerkelijke titelnaam wordt getoond in plaats van een objectrepresentatie.
Changing in our Models

Migrations aanmaken

'python manage.py makemigrations' is de eerste stap: deze leest 'models.py' nadat je het model hebt gemaakt. Er wordt een nieuwe map 'migrations' aangemaakt met daarin een bestand '0001_initial.py', dat overdraagbaar is tussen databases.
Changing in our Models

Migreren naar de database

Dit is de tweede stap, waarbij 'python manage.py migrate' de nieuw aangemaakte map 'migrations' leest en de database aanmaakt, en de database bijwerkt wanneer het model verandert.
Changing in our Models

Registreren in de admin

Ga naar 'blog/admin.py' en importeer het model 'Post' met 'from .models import Post'. Om modellen in de admin te registreren, gebruik je 'admin.site.register(Post)'.


Changing in our Models

Superuser aanmaken en bekijken in het beheerpaneel

Je moet een SuperUser aanmaken voordat je het 'admin'-paneel kunt openen. Gebruik hiervoor 'winpty python manage.py createsuperuser'.
Changing in our Models
Let op: winpty is een bash-specifiek commando voor communicatie met Windows-consoleprogramma's.

Draai je server op de achtergrond in bash met het commando python manage.py runserver. Ga in de browser naar de volgende URL.

Vul vervolgens je gegevens in, oftewel de gebruikersnaam en het wachtwoord die je eerder hebt aangemaakt:
Changing in our Models
Bekijk daarna je adminpaneel met ons nieuw aangemaakte model 'Post'.
Changing in our Models
Wijzig de inhoud van de 'Post' door op de knop 'Add' te klikken. Vul de informatie in en klik op 'Save'.
Changing in our Models

Wijzigingen in views en urls

Ga naar 'blog/views.py' en breng de onderstaande wijzigingen aan. Voeg de functie 'blog_list' toe, die de request aanneemt. Er wordt een query uitgevoerd die alle aangemaakte objecten ophaalt met 'Post.objects.all()' en deze opslaat in post. Er is een nieuw aangemaakt woordenboek 'context' waarin het object als key kan worden doorgegeven en via de template 'blog-list.html' kan worden opgehaald; dit gebeurt door de response te retourneren met behulp van render.
Changing in views and urls
Maak een nieuw bestand 'urls.py' in 'django_blog/blog' en voeg de volgende wijzigingen toe. Er is een relatieve import van de view 'blog_list' en een 'urlpatterns', een lijst met paden naar specifieke pagina's op de website. Momenteel bevat de path de lege string en de naam van de view.
Changing in views and urls
Ga naar 'django_blog/urls.py', importeer include en wijzig 'urlpatterns'. Voeg vervolgens het pad naar de URLs van je app toe via include. Wanneer gebruikers naar 'posts/' gaan, worden ze doorgestuurd naar onze 'blog.urls'.

Templates maken en aanpassen

Maak een templates-map aan die doorgaans de 'HTML' bevat en de eigen templatingtaal 'Jinja2' gebruikt. Noem de map/het bestand volgens de conventie 'templates/blog/blog_list.html'.
Making and Changing the Templates
Hieronder zie je syntax gerelateerd aan 'HyperText Markup Language (HTML)' met 'h1' voor een grote kop en een ongeordende lijst (ul) met listelementen li. Ook is de 'for'-lus van 'Jinja2' gebruikt, waarbij over het object 'blog_list' wordt geïtereerd dat als key vanuit 'blog/views.py' is doorgegeven, met elk element 'list'.
Making and Changing the Templates
Bekijk de 'title' met de naam 'First Post' op de webpagina.
Making and Changing the Templates
Voeg op dezelfde manier nog een item toe via het adminpaneel en noem je tweede post-title 'Second Post'.
Making and Changing the Templates
Na het toevoegen en verversen van de homepage wordt de informatie bijgewerkt.
Making and Changing the Templates

Details voor elke individuele post

Je maakt een aparte pagina voor elke post met de titel en de inhoud. De 'url' wordt "localhost:8000/posts/'id'", waarbij id het unieke nummer of de primaire sleutel is die Django aan elke 'Post' toekent.
Maak een functie 'blog_detail' in 'blog/view.py', die id als parameter accepteert. Er wordt een query uitgevoerd om specifiek die id op te halen en op te slaan in 'each_post'. Net als hierboven wordt de benodigde informatie als context doorgegeven aan 'blog_detail.html'.
Details for Each Individual post
De url in 'blog/urls.py' wordt aangepast, waarbij het pad '<id>' bevat dat de unieke id als integer accepteert. Stel dat de gebruiker naar 'posts/' gaat: dan ziet die alle posts. Gaat die naar 'posts/1', dan ziet die alleen de informatie over de eerste aangemaakte post.
Details for Each Individual post
Maak een nieuw bestand 'blog/blog_detail.html' en breng de volgende wijzigingen aan. Omdat blog_detail als context is doorgegeven, kun je 'title' en 'content' benaderen met dotnotatie.
Details for Each Individual post
Ga in je browser naar dezelfde URL-structuur om individuele posts te bekijken. Aangenomen dat de 'id' voor de eerste aangemaakte informatie '1' is, de tweede '2', enzovoort voor nieuw aangemaakte informatie.
Details for Each Individual post

De post verwijderen

Definieer blog_delete, die de request en de id aanneemt. Er wordt ook een query uitgevoerd waarbij 'Post.objects.get(id=id)' het object met een unieke id ophaalt en opslaat in each_post. Daarna wordt 'each_post.delete()' aangeroepen om de 'Post' te verwijderen. Tot slot importeer je HttpResponseRedirect uit de module 'django.http', waarmee je de pagina kunt doorsturen naar '/posts/'.
Deleting the Post
. Importeer in 'urls.py' 'blog_delete' en stel het pad in op '<id>/delete', waarbij de id met 'delete' erachter dat specifieke object of die specifieke informatie verwijdert.
Deleting the Post
Verwijder onze post door het volgende in de 'urls.py' te typen.
Deleting the Post
Uiteindelijk wordt de pagina doorgestuurd naar '/posts' wanneer 'posts/1/delete/' wordt aangeroepen en er slechts één post op de homepage bestaat.
Deleting the Post

Conclusie

Gefeliciteerd met het afronden van de tutorial! Je hebt de basis van Django-webontwikkeling geleerd en weet nu hoe de CRUD-functionaliteit werkt. Voor meer details over een specifiek onderwerp kun je terecht in de Django-documentatie.

Referenties:

Django-webontwikkeling in Python: veelgestelde vragen

Wat is Django?

Django is een gratis en open-source webframework, geschreven in Python, dat het model-template-view-architectuurpatroon volgt. Het is ontworpen om ontwikkelaars te helpen om applicaties zo snel mogelijk van concept tot oplevering te brengen.

Wat zijn enkele functies van Django?

Enkele functies van Django zijn een lichtgewicht en modulaire opzet, een krachtige ORM (Object-Relational Mapper) die het werken met databases vereenvoudigt, en ingebouwde ondersteuning voor veelvoorkomende taken in webontwikkeling, zoals gebruikersauthenticatie en -beheer, formulierenafhandeling en contentbeheer.

Hoe begin ik met Django?

Om met Django te beginnen, installeer je Python en de Django-bibliotheek op je machine. Vervolgens kun je een nieuw Django-project aanmaken met het commando django-admin startproject en je applicatie bouwen met de ingebouwde features en tools van Django.

Hoe maak ik een database in Django?

Django gebruikt standaard de SQLite-database-engine, die bij Python is inbegrepen. Je kunt een nieuwe database aanmaken door modellen te definiëren in je Django-app en het commando migrate uit te voeren. Dit maakt de benodigde tabellen in de database aan om de data voor je modellen op te slaan.

Hoe maak ik views en templates in Django?

In Django zijn views functies die HTTP-verzoeken afhandelen en HTTP-responses retourneren. Je kunt views maken door functies te definiëren in je Django-app die een request aannemen en een response teruggeven. Templates zijn HTML-bestanden met placeholders voor dynamische content. Met de templatingtaal van Django kun je dynamische content in templates invoegen en ze in je views renderen.

Hoe deploy ik een Django-applicatie?

Er zijn verschillende manieren om een Django-applicatie te deployen, afhankelijk van je hostingbehoeften en voorkeuren. Veelvoorkomende opties zijn deployment naar een cloudplatform zoals Heroku of AWS, een webserver zoals Apache of Nginx, of een hostingdienst zoals PythonAnywhere of DigitalOcean.

Onderwerpen

Gerelateerd