Créer des applications web avec Python et Django : un guide pratique

Python est un langage de programmation populaire qui présente les avantages d'être facile à apprendre, hautement lisible et largement utilisé. Python est largement utilisé dans le développement Web, la science des données, l'apprentissage automatique et d'autres domaines. Parmi eux, Django est un framework Web avancé développé sur la base du langage Python et constitue un outil important pour le développement d'applications Web.

Django est populaire parmi les développeurs car il est facile à apprendre, facile à maintenir, suit le modèle MVC et est livré avec son propre ORM. Cet article fournira un guide pratique pour créer des applications Web à l'aide de Python et Django.

1. Installer Python et Django

Tout d'abord, nous devons installer Python et Django. Vous pouvez télécharger le dernier package d'installation de Python sur le site Web officiel de Python (www.python.org). Après l'installation, vous pouvez saisir python dans la ligne de commande pour vérifier si Python est correctement installé.

L'installation de Django peut être installée via le gestionnaire de packages pip. Ouvrez la fenêtre de ligne de commande et entrez la commande suivante :

pip install django

Une fois l'installation terminée, vous pouvez utiliser ce qui suit. commande pour vérifier si Django est une installation correcte :

django-admin --version

Si le numéro de version de Django est renvoyé, l'installation est réussie.

2. Créer un projet Django

Entrez le répertoire dans lequel vous souhaitez stocker le projet Django sur la ligne de commande, et saisissez la commande suivante :

django-admin startproject myproject

# 🎜🎜#Cette commande créera un projet Django nommé "myproject". La structure des répertoires du projet est la suivante :

myproject/
    manage.py
    myproject/
        __init__.py
        settings.py
        urls.py
        wsgi.py

Parmi eux, manage.py est un fichier script utilisé pour exécutez les tâches Django sur la ligne de commande ; settings.py contient les paramètres du projet ; urls.py contient le modèle d'URL du projet ; wsgi.py spécifie à quelle application Python le serveur Web transmet les requêtes.

Créer une application Django

Dans un projet Django, une application fait référence à un composant qui combine une application web avec une logique métier spécifique. Nous pouvons utiliser la commande suivante pour créer une application dans le projet Django créé :

python manage.py startapp myapp

Cette commande créera une application nommée "myapp" dans le répertoire "myproject" du projet Django Application Le répertoire du programme. la structure est la suivante :

myapp/
    __init__.py
    admin.py
    apps.py
    models.py
    tests.py
    views.py

Parmi eux, models.py contient la définition du modèle de base de données de l'application ; py contient le test de l'application.

Écrire des modèles Django

L'ORM de Django est un outil qui mappe les classes Python aux tables de base de données Nous pouvons éditer le fichier models.py pour définir. le modèle de candidature.

Par exemple, nous créons un modèle nommé "Livre" qui contient les attributs suivants :

title (titre du livre) : type de chaîne, la longueur maximale est 200 caractères
• author (auteur) : Type de chaîne, la longueur maximale est de 50 caractères
• pub_date (date de publication) : Type de date
price ( price) : type décimal, la valeur maximale est 9999,99, la décimale est de 2 chiffres tables de base de données

Dans Django, les tables de base de données sont automatiquement créées via des modèles. Nous pouvons créer le modèle dans la base de données à l'aide de la commande suivante :

from django.db import models


class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=50)
    pub_date = models.DateField()
    price = models.DecimalField(max_digits=5, decimal_places=2, max_value=9999.99)

Cette commande créera un fichier de migration de base de données décrivant comment mapper le modèle dans une table de base de données. Nous pouvons utiliser la commande suivante pour appliquer la migration à la base de données :

python manage.py makemigrations myapp

5. Cette commande créera la table dans la base de données selon les instructions du fichier de migration.

Écriture de vues

Dans Django, les vues sont des fonctions de traitement de requêtes qui sont responsables du traitement des requêtes initiées par les utilisateurs et de la génération du contenu des réponses. Avant d'écrire la vue, nous devons configurer le modèle d'URL pour associer la requête à la vue. Nous pouvons éditer le fichier urls.py et ajouter le code suivant :

python manage.py migrate

Cet extrait de code définit 4 modèles d'URL, qui sont associés à 4 vues. Parmi eux, le premier paramètre de la fonction path spécifie l'URL, le deuxième paramètre spécifie la fonction d'affichage et le troisième paramètre est le nom lorsque le moteur de modèle restitue la vue au format HTML.

6. Dans le fichier views.py, on peut définir la fonction de traitement des requêtes, par exemple :

from django.urls import path
from . import views

urlpatterns = [
    path('books/', views.book_list, name='book_list'),
    path('books/new', views.book_new, name='book_new'),
    path('books/<int:pk>/edit/', views.book_edit, name='book_edit'),
    path('books/<int:pk>/delete/', views.book_delete, name='book_delete'),
]

Parmi eux, la fonction book_list est utilisée pour renvoyer une liste de tous les livres ; la fonction book_new est utilisée pour créer de nouveaux livres ; la fonction book_edit est utilisée pour éditer des livres existants ; la fonction book_delete est utilisée pour supprimer des livres.

Rédaction de modèles HTML

Dans Django, nous pouvons utiliser le moteur de modèles pour restituer les fonctions d'affichage dans des pages HTML afin de présenter des visualisations à l'interface Web des utilisateurs. . Nous pouvons créer un fichier modèle HTML dans le répertoire des modèles, tel que book_list.html.

Le code est le suivant :

from django.shortcuts import render, get_object_or_404
from .models import Book
from .forms import BookForm

def book_list(request):
    books = Book.objects.all()
    return render(request, 'book_list.html', {'books': books})

def book_new(request):
    if request.method == "POST":
        form = BookForm(request.POST)
        if form.is_valid():
            book = form.save(commit=False)
            book.save()
            return redirect('book_list')
    else:
        form = BookForm()
    return render(request, 'book_edit.html', {'form': form})

def book_edit(request, pk):
    book = get_object_or_404(Book, pk=pk)
    if request.method == "POST":
        form = BookForm(request.POST, instance=book)
        if form.is_valid():
            book = form.save(commit=False)
            book.save()
            return redirect('book_list')
    else:
        form = BookForm(instance=book)
    return render(request, 'book_edit.html', {'form': form})

def book_delete(request, pk):
    book = get_object_or_404(Book, pk=pk)
    book.delete()
    return redirect('book_list')

7. Parmi eux, {% extends 'base.html' %} précise que ce template hérite du template base.html ; block content %} à { % endblock %} spécifie que le contenu principal de ce modèle est le contenu qu'il contient.

Nous exécutons le serveur Django et ouvrons localhost:8000/books/ dans le navigateur pour afficher la liste de tous les livres.

Grâce à cet exemple simple, nous avons appris à utiliser Python et Django pour créer des applications Web et avons impliqué des opérations de base, notamment l'installation de Python et Django, la création de projets et d'applications Django et l'écriture de modèles, de vues et d'applications Django. modèles. J'espère que ce guide vous aidera à créer votre propre application Web.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!