Django débloqué : point d'apparition pour débutants

Présentation

Django est un framework Web puissant qui vous permet de créer des applications Web robustes et évolutives rapidement et efficacement. Il est écrit en Python et suit la philosophie "batteries incluses", ce qui signifie qu'il est livré avec de nombreuses fonctionnalités intégrées qui rendent le développement plus rapide et plus facile, le rendant ainsi adapté au prototypage. Que vous créiez un petit projet personnel ou une grande application d'entreprise, Django dispose des outils dont vous avez besoin.

Dans ce guide, je vais vous présenter le modèle de conception MVT de Django (Modèles, vues et modèles), fournissant une base solide pour créer vos propres applications Web. À la fin, vous comprendrez clairement comment fonctionne Django et comment utiliser efficacement ses composants.

Configurer un projet Django avec un environnement virtuel

Référez-vous à la documentation officielle de Django : Django Documentation

Avant de plonger dans les composants de base, mettons en place un environnement virtuel pour gérer les dépendances de votre projet. Cela permet de garder votre projet isolé et d'éviter les conflits avec d'autres projets Python.

Remarque : J'encourage fortement l'utilisation de Linux. Si vous utilisez Windows, installez WSL pour accéder à l'environnement Linux.

1. Installez le module venv :

sudo apt install python3-venv

2. Créez un environnement virtuel :

python -m venv .venv

3. Activez l'environnement virtuel :

source .venv/bin/activate

4. Installez Django :

Avec l'environnement virtuel activé, installez Django :

python -m pip install django

5. Créez un projet Django :

django-admin startproject myproj

Remplacez myproj par le nom de votre projet souhaité.

6. Créez une application :

Dans le répertoire de votre projet, créez une application.

python manage.py startapp myapp

7. Ajoutez votre application nouvellement créée au settings.py situé dans :

votre-nom-de-projet/votre-nom-de-projet/settings.py

INSTALLED_APPS = [
    'myapp',
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

Votre projet est maintenant configuré avec une structure de base, comprenant un fichier manage.py, les paramètres du projet et votre première application

Modèles

Les

Modèles définissent la structure de vos tables de base de données et les relations entre elles à l'aide de classes Python. Chaque classe de modèle correspond à une seule table de base de données et chaque attribut du modèle correspond à un champ de base de données. Django simplifie ce processus en vous permettant de définir votre schéma de base de données à l'aide de classes qui héritent de django.db.models.Model.

ORM signifie Object-Relational Mapping. Dans Django, l'ORM est une fonctionnalité puissante qui permet aux développeurs d'interagir avec la base de données en utilisant du code Python au lieu d'écrire des requêtes SQL. Cette couche d'abstraction mappe les classes Python (modèles) aux tables de base de données et les instances de ces classes aux lignes de la table.

Présentation de SQLite

Django utilise SQLite comme base de données par défaut car elle est très simple à configurer. SQLite est une base de données légère qui conserve toutes vos données dans un seul fichier simple, vous n'avez donc rien à installer de plus pour commencer à enregistrer et à gérer les données de votre site Web. Cela en fait un excellent choix pour le développement et les tests, car il vous permet de vous concentrer sur la création de votre application sans vous soucier des configurations de bases de données complexes.

Dans Django, une table nommée Airport avec des attributs tels que « code » et « city » est représentée comme une classe Python, où chaque attribut est défini comme une variable de classe.

class Airport(models.Model):
    code = models.CharField(max_length=3)
    city = models.CharField(max_length=64)

1. Définir des modèles :

Dans models.py de votre application, définissez vos modèles à l'aide de l'ORM de Django.

from django.db import models

class Flight(models.Model):
    # Diri, kada flight naa tay origin kung asa gikan, destination, ug duration
    # Nakabutang sa parameters ilang properties, such as length of the characters

    origin = models.ForeignKey(Airport, on_delete=models.CASCADE, related_name='departures')
    destination = models.ForeignKey(Airport, on_delete=models.CASCADE, related_name='arrivals')
    duration = models.IntegerField()

    def __str__(self):
        return f'{self.id}: {self.origin} to {self.destination} | {self.duration} minutes.'

2. Migrations :

Après avoir défini vos modèles, créez et appliquez des migrations pour mettre à jour le schéma de votre base de données.

En termes simples :

• makemigrations revient à planifier les modifications que vous souhaitez apporter à votre base de données.
• migrate effectue en fait ces modifications sur la base de données. Ainsi, après la planification avec makemigrations, la migration consiste à exécuter et appliquer les modifications.

python manage.py makemigrations
python manage.py migrate

3. Interagir avec les modèles :

Utilisez le shell de Django pour interagir avec vos modèles : python manage.py shell

Exemple :

>> from flights.models import Flight

>> flight1 = Flight(origin="Davao", destination="Manila", duration=569)
>> fligh1.save()

J'ai créé une instance du modèle Flights. Cette instance Flight1 représente une seule ligne dans la table Flight de ma base de données. Le modèle de vol contient des champs origine, destination et durée définis.
Lorsque vous créez l'instance. vous définissez ces champs sur des valeurs spécifiques :

• origin : "Davao"
• destination : "Manila"
• duration : 569 (representing the flight duration in minutes)

Views

Views are a crucial part of the framework that handles the logic behind what a user sees and interacts with in a web application. Views are responsible for processing user requests, retrieving necessary data from the database, and returning the appropriate response (typically an HTML page, JSON data, or a redirect).

In simple terms, Views in Django act as the middleman between the web pages and the data. They take requests from users, process any necessary data, and then send back the appropriate response, like a webpage or a file. Essentially, views decide what content should be shown to the user and how it should be presented.

In this read, we will only be using Function-Based Views

1. Function-Based Views:

These are Python functions that take a web request and return a web response. The most basic view in Django is a function that receives a request object and returns a response object.

from django.http import HttpResponse

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

2. Class-Based Views:

These are Python classes that provide more structure and allow for more complex functionality compared to Function-Based Views.

from django.views import View
from django.http import HttpResponse

class MyView(View):
    def get(self, request):
        return HttpResponse("Hello, World!")

Templates

Templates are used to render HTML and display data to users. They allow you to separate your HTML from Python code. Django templates are a powerful tool for generating dynamic HTML content in your web application. By separating the presentation (HTML) from the backend logic (Python code), templates help keep your code clean, maintainable, and reusable.

In simple terms, Templates in Django are like blueprints that define how data should be displayed on a webpage. They allow you to combine static content (like HTML) with dynamic content (like data from a database) to create a fully rendered page. Instead of hardcoding every detail, you use templates to keep the design and data separate, making it easier to update and manage your website.

1. Creating a Template

Start with creating a directory for your templates inside your app and name the directory as templates. Create another directory inside the templates named myapp.

django-proj/myapp/templates/myapp

Now, you can finally place all your templates inside the inner directory you created:

django-proj/myapp/templates/myapp/base.html

Creating the base.html allows you to define a base template or layout with common structure (headers, navbar, and footer) that other templates can inherit. This feature is useful for maintaining consistency across different pages.

Example:

<!DOCTYPE html>
<html>
<head>
    <title> {% block title %} myApp {% endblock %} </title>
</head>
<body>
    <header>
        <h1>My Site</h1>
    </header>
    <div class="content">
        {% block content %}{% endblock %}
    </div>
    <footer>
        <p>Footer content here</p>
    </footer>
</body>
</html>

Let's create another template called index.html and place it in the same directory of base.html.

Example of extending template index.html:

{% extends "myapp/base.html" %}
{% block content %}
    <h1>Flights</h1>
    <ul>
        {% for flight in flights %}
            <li>Flight: {{ flight.id }} {{ flight.origin }} to {{ flight.destination }}</li>
        {% endfor %}
    </ul>
{% endblock %}

The {% extends "myapp/base.html" %} tells Django to use the base.html as the base layout template. The {% block content %} defines a block of content that will be filled with content from index.html. The content block in base.html will be replaced with the content provided in index.html.

2. Rendering Templates

In a Django view, you typically render a template using the render() function, which combines the template with the context data to produce the final HTML output.

from django.shortcuts import render

def index(request):
    return render(request, 'myapp/index.html')

When Django renders index.html, it will include the structure from base.html, replacing the content block with the content specified in index.html. This allows for consistent design across pages and makes it easy to update the overall layout without changing every individual template.

URLs and Routing

Django uses URL patterns to map URLs to views. These patterns are defined in a file called urls.py within each Django app.

URL patterns are defined with the path() function, mapping specific URL paths to view functions or classes. Dynamic URL segments, such as , allow for capturing variables from the URL to be used in views. The include() function enables modular URL management by including patterns from other apps.

In simple terms, URLs are like street addresses for different pages on your website. Routing is the system that makes sure when someone types in a specific address (URL), they get directed to the right page. You set up these "addresses" in a special file so Django knows where to send people when they visit your site.

1. Configuring URLs:
Define URL patterns in urls.py of your app:

from django.urls import path
from . import views

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

Inlcude your app's URLs in the project's urls.py:

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

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('myapp.urls'))
]

Wrapping up

Congratulations! You've taken the first steps in learning Django. I’ve covered the basics of Models, Views, Templates, and URL routing. With these fundamentals, you’re on your way to building your own Django applications. Keep experimenting, keep coding, and don't hesitate to dive deeper into the Django documentation and community resources.

I hope this guide has made these concepts clearer and that you’ve learned something valuable along the way.

• 0xshr00msz

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!