Dans le domaine du développement Web Python, le framework Django est comme une étoile brillante, ses fonctionnalités complètes, efficaces et sûres le rendent populaire dans le monde entier. Cet article analysera en détail les fichiers par défaut du framework Django, discutera en profondeur de la signification et de l'utilisation de chaque fichier et de sa composition, et démontrera en détail la structure des fichiers et les principes de conception de ce puissant framework.

Examinons d'abord la structure des répertoires après avoir créé un nouveau projet Django :

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

manage.py: Il s'agit d'un outil en ligne de commande pour les projets Django qui peut être utilisé pour effectuer de nombreuses tâches liées à la gestion et au développement de projets, telles que l'exécution de serveurs, l'exécution de tests, la création de schémas de base de données, etc.
myproject/__init__.py: Il s'agit d'un fichier vide utilisé pour indiquer à l'interpréteur Python que le répertoire est un package Python.
myproject/settings.py: Ce fichier contient toutes les configurations du projet. Chaque projet Django a ses propres paramètres dans lesquels vous pouvez configurer des bases de données, des applications, des intergiciels, des modèles, la mise en cache, etc.
myproject/urls.py: Ce fichier définit les routes URL du projet. En écrivant des modèles d'URL et les fonctions de vue correspondantes, Django peut acheminer les requêtes HTTP vers les vues appropriées.
myproject/asgi.pyEt myproject/wsgi.py: Ces deux fichiers sont utilisés pour configurer le serveur, WSGI est l'interface de passerelle de serveur Web de Python, et ASGI est une interface de passerelle de serveur asynchrone pour le traitement des requêtes asynchrones.

manage.py

Dans la structure du projet de Django, manage.pyil joue un rôle très important. C'est un outil en ligne de commande qui vous permet d'interagir avec les projets Django de différentes manières. Explorons ce fichier en profondeur et ses principales utilisations.

Tout d'abord, Django crée automatiquement un fichier lorsque nous créons un nouveau projet Django manage.py. Il est situé dans le répertoire racine du projet et son objectif principal est d'être un utilitaire de ligne de commande qui encapsule les django-admin.pyfonctionnalités du projet et contient également des commandes supplémentaires spécifiques au projet.

Regardons un manage.pycontenu de fichier typique :

#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys

def main():
    """Run administrative tasks."""
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')
    try:
        from django.core.management import execute_from_command_line
    except ImportError as exc:
        raise ImportError(
            "Couldn't import Django. Are you sure it's installed and "
            "available on your PYTHONPATH environment variable? Did you "
            "forget to activate a virtual environment?"
        ) from exc
    execute_from_command_line(sys.argv)

if __name__ == '__main__':
    main()

Nous pouvons voir que dans manage.pyle fichier, le module de paramètres de Django est défini comme une variable d'environnement DJANGO_SETTINGS_MODULEavec une valeur par défaut de 'myproject.settings'. Ensuite, il essaie d'importer django.core.managementà partir de celui-ci execute_from_command_line, qui est utilisé pour effectuer des tâches de gestion de ligne de commande.

Regardons quelques manage.pyusages courants :

Exécution du serveur de développement : Lors du développement local, nous avons souvent besoin d'exécuter le serveur de développement fourni avec Django. Vous pouvez runserverle faire avec la commande :

python manage.py runserver

Cela démarrera le serveur de développement, qui est activé par défaut 127.0.0.1:8000. Vous pouvez visiter cette adresse dans votre navigateur pour afficher votre site Web.

Migrations de base de données : Django dispose d'une API d'abstraction de base de données très puissante qui peut gérer de nombreuses tâches liées à la base de données. Par exemple, lorsque nous modifions le modèle (les modèles), nous devons appliquer ces modifications à la base de données, ce qui nécessite une migration de la base de données. Voici comment procéder manage.pyavec :

python manage.py makemigrations  # 创建迁移文件
python manage.py migrate  # 应用迁移至数据库

Créer un super utilisateur : Lorsque nous devons accéder à l'arrière-plan de l'administrateur de Django, nous devons créer un super utilisateur. Nous pouvons le faire avec la commande suivante :

python manage.py createsuperuser

Django Shell : manage.pyUn shell Python interactif est également fourni, mais ce shell s'exécute dans l'environnement Django. Cela signifie que vous pouvez importer vos modèles, vues, paramètres, etc. dans ce shell, ce qui est très utile pour tester et déboguer :

python manage.py shell

Dans l'utilisation quotidienne de Django, manage.pyc'est un outil très important. Il facilite l'interaction avec les projets Django et encapsule de nombreuses tâches courantes. Apprenez à l'utiliser manage.py, et votre développement Django n'en sera que plus facile.

init .py

En Python, __init__.pyle fichier a une position importante, et son existence permet à Python de reconnaître le dossier comme un package (package). Ce concept est particulièrement important dans la programmation modulaire de Python, ce qui nous permet d'organiser le code de manière plus structurée et offre une meilleure gestion des espaces de noms. Maintenant, explorons en profondeur __init__.pyce qu'il fait et comment l'utiliser.

Examinons d'abord le __init__.pyfichier le plus simple, un fichier vide. Dans un projet Python, vous pouvez voir de nombreux fichiers de ce type. Ils sont situés sous le répertoire du package et sont nommés __init__.py.

# mypackage/__init__.py

L'existence de ce fichier vide signifie que l'interpréteur Python traitera le répertoire dans lequel il se trouve comme un package (package), et ce package peut contenir d'autres modules (module) ou sous-packages (subpackage). Par exemple, si nous avons la structure de projet suivante :

mypackage/
    __init__.py
    module1.py
    module2.py

Dans ce cas, nous pouvons importer le module comme ceci :

from mypackage import module1, module2

Outre le marquage des dossiers en tant que packages, __init__.pyil existe d'autres utilisations importantes. D'une manière générale, __init__.pyil est utilisé pour stocker le code d'initialisation au niveau du package ou pour définir un alias pour une importation facile. Par exemple, nous pouvons __init__.pyimporter nos modules dans , afin qu'ils soient directement disponibles lors de l'importation du package :

# mypackage/__init__.py

from . import module1, module2

On peut alors importer directement le package sans importer le module séparément :

import mypackage

# 我们可以直接使用mypackage.module1，而不需要单独导入module1
mypackage.module1.some_function()

En outre, __init__.pyil peut être utilisé pour définir __all__des variables. __all__La variable est une liste de chaînes qui définissent quels modules seront importés lors de l'importation * depuis le package.

# mypackage/__init__.py

__all__ = ['module1', 'module2']

Maintenant, lorsque nous importons comme ceci :

from mypackage import *

Seuls module1et module2seront importés, les autres modules ne le seront pas.

En général, __init__.pyc'est un élément clé de la structure du package Python, qui nous permet de mieux organiser et gérer notre code. Comprendre comment cela fonctionne et comment l'utiliser peut nous aider à écrire un code plus modulaire et maintenable.

paramètres.py

Le framework Django est un framework web connu pour sa modularité et sa flexibilité. De nombreux aspects sont configurables, et ces configurations sont concentrées dans settings.pydes fichiers. Dans un projet Django, settings.pyle fichier est crucial, il contient toutes les informations de configuration nécessaires à l'exécution du projet. Maintenant, explorons ce fichier en profondeur et ses principales utilisations.

Le fichier d'un nouveau projet Django settings.pycontient de nombreuses configurations par défaut, qui conviennent à la plupart des situations, mais vous pouvez modifier ces configurations selon vos besoins. Voici quelques-uns des paramètres les plus importants :

DEBUG : Ce paramètre indique à Django s'il doit s'exécuter en mode débogage. Dans un environnement de développement, nous définissons généralement ceci sur True, de sorte que lorsque quelque chose ne va pas, Django affichera des messages d'erreur détaillés. Cependant, dans un environnement de production, nous devrions le définir sur False.

DEBUG = True

INSTALLED_APPS : ce paramètre définit toutes les applications du projet. Chaque application est un package Python qui contient des vues, des modèles, des modèles, etc. Lorsque nous créons une nouvelle application ou installons une application tierce, l'application doit être ajoutée à cette liste.

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    # Add your apps here
    'myapp',
]

MIDDLEWARE : ce paramètre définit un ensemble de classes middleware qui jouent un rôle important dans le traitement des requêtes et des réponses. Vous pouvez ajouter votre propre middleware, ou modifier l'ordre de cette liste pour changer l'ordre d'exécution des middleware.

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

DATABASES : Ce paramètre définit la configuration de votre base de données. Django utilise ORM (Object Relational Mapping) pour gérer les opérations de base de données, et vous pouvez utiliser n'importe quel backend de base de données pris en charge par Django, tel que SQLite, PostgreSQL, MySQL, etc.

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

MODÈLES : ce paramètre définit la configuration des modèles de Django, y compris l'emplacement des modèles, les moteurs de modèles, etc.

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        ...
    },
]

STATIC_URL et STATIC_ROOT : Ces deux paramètres sont utilisés pour configurer la gestion des fichiers statiques. STATIC_URLDéfinit le préfixe d'URL des fichiers statiques et STATIC_ROOTdéfinit l'emplacement de stockage des fichiers statiques.

STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static')

Ce qui précède ne sont que settings.pyquelques paramètres de base dans le fichier. En fait, il y a plus d'éléments de configuration dans ce fichier. Vous pouvez ajuster ces configurations en fonction de vos besoins. Comprendre settings.pycomment fonctionnent les fichiers et comment les utiliser est une étape clé dans la maîtrise de Django.

urls.py

Dans le framework Web de Django, urls.pyle fichier est une partie très critique. Il est responsable de la configuration du routage d'URL, garantissant que l'URL demandée par l'utilisateur peut être correctement mappée à la fonction ou à la classe de vue correspondante. Dans cet article, nous allons plonger dans urls.pyla structure et l'utilisation du fichier.

Dans un projet Django nouvellement créé, urls.pyles fichiers sont situés dans le répertoire racine du projet. Ce fichier contient une urlpatternsliste nommée , chaque élément de la liste est un appel de fonction path()ou re_path(), et cet appel de fonction définit la relation de mappage entre un modèle d'URL et une vue.

Voici un simple urls.pyfichier :

from django.urls import path
from . import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('hello/', views.hello_world),
]

Dans ce fichier, nous django.urlsimportons d'abord path()la fonction du module puis définissons urlpatternsla liste. Cette liste contient deux modèles d'URL. Le premier modèle est qu'il 'admin/'est mappé à la vue d'administration intégrée de Django ; le second modèle est qu'il 'hello/'est mappé à notre propre hello_worldvue définie.

path()La fonction accepte deux paramètres obligatoires, le premier est une chaîne de modèle d'URL et le second est une fonction ou une classe de vue. Il peut également accepter un troisième paramètre facultatif, qui est un dictionnaire qui peut être utilisé pour passer des paramètres supplémentaires pour la vue.

En plus des path()fonctions, django.urlsle module fournit également re_path()des fonctions qui nous permettent de définir des modèles d'URL à l'aide d'expressions régulières. Par exemple, le code suivant définit un modèle d'URL qui correspond à n'importe quel nombre :

from django.urls import re_path
from . import views

urlpatterns = [
    re_path(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
]

Dans cet exemple, la chaîne de modèle d'URL est une expression régulière qui (?P<year>[0-9]{4})indique correspondre à un nombre à quatre chiffres et le nommer year. Dans la fonction view year_archive, nous pouvons yearobtenir cette valeur via des paramètres.

urls.pyLe fichier est une partie importante du projet Django. Il mappe l'URL demandée par l'utilisateur à la vue correspondante pour gérer la requête de l'utilisateur. Comprendre son principe de fonctionnement et son utilisation peut nous aider à mieux utiliser le framework Django pour créer des applications Web.

asgi.py

ASGI, le nom complet de Asynchronous Server Gateway Interface, est une interface standard Python pour la création d'applications Web asynchrones. À partir de Django 3.0, Django a commencé à prendre en charge ASGI, ce qui nous permet d'utiliser la programmation asynchrone dans Django pour améliorer les performances des applications Web. Dans un projet Django, asgi.pyle fichier est le fichier de configuration ASGI, qui définit l'application ASGI et configure le middleware et le routage. Maintenant, examinons plus en détail asgi.pyle fichier et son utilisation principale.

Examinons d'abord les fichiers d'un projet Django nouvellement crééasgi.py :

"""
ASGI config for myproject project.

It exposes the ASGI callable as a module-level variable named ``application``.

For more information on this file, see
https://docs.djangoproject.com/en/3.1/howto/deployment/asgi/
"""

import os

from django.core.asgi import get_asgi_application

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')

application = get_asgi_application()

Dans ce fichier, nous définissons d'abord la variable d'environnement DJANGO_SETTINGS_MODULE, qui indique à Django quel fichier de paramètres il doit utiliser. Ensuite, nous appelons get_asgi_application()la fonction pour obtenir une application ASGI et l'assignons à applicationla variable. Cette applicationvariable est le point d'entrée de l'interface du serveur ASGI, et le serveur ASGI utilisera cette variable pour démarrer notre application Django.

Ce asgi.pyfichier de base est suffisant pour que notre application Django s'exécute sur un serveur ASGI tel que Daphne ou Uvicorn. Cependant, la véritable puissance d'ASGI réside dans sa nature asynchrone. Nous pouvons tirer parti de cette fonctionnalité en ajoutant un middleware et un routage asynchrones.

Par exemple, nous pouvons ajouter un middleware asynchrone pour gérer les connexions Websocket :

from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
import myapp.routing

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')

application = ProtocolTypeRouter({
    "http": get_asgi_application(),
    "websocket": AuthMiddlewareStack(
        URLRouter(
            myapp.routing.websocket_urlpatterns
        )
    ),
})

Dans cet exemple, nous créons une ProtocolTypeRouterinstance qui peut acheminer les requêtes en fonction du type de protocole. Pour les requêtes HTTP, nous avons utilisé l'application Django d'origine ; pour les requêtes Websocket, nous avons utilisé une pile middleware et un routeur d'URL. AuthMiddlewareStackIl s'agit d'un middleware qui fournit une fonction d'authentification et URLRouterest utilisé pour acheminer les requêtes Websocket.

En général, asgi.pyle fichier est le point d'entrée de la programmation asynchrone Django, qui fournit un moyen de configurer les applications ASGI, y compris l'ajout de middleware et de routage. Comprendre son principe de fonctionnement et son utilisation peut nous aider à mieux utiliser la programmation asynchrone dans Django et à améliorer les performances des applications Web.

wsgi.py

WSGI, ou Web Server Gateway Interface, est une interface commune entre les applications Python et les serveurs Web. Dans Django, wsgi.pyun fichier est un fichier de configuration de l'interface WSGI qui permet à un serveur Web d'interagir avec une application Django. Dans cet article, nous allons plonger dans wsgi.pyla structure et l'utilisation du fichier.

Dans un projet Django nouvellement créé, wsgi.pyles fichiers sont situés dans le répertoire racine du projet. Il se compose principalement de deux parties : la définition des variables d'environnement DJANGO_SETTINGS_MODULEet la définition des applications WSGI. Voici wsgi.pyun exemple type de fichier :

"""
WSGI config for mysite project.

It exposes the WSGI callable as a module-level variable named ``application``.

For more information on this file, see
https://docs.djangoproject.com/en/3.1/howto/deployment/wsgi/
"""

import os

from django.core.wsgi import get_wsgi_application

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'mysite.settings')

application = get_wsgi_application()

Dans ce fichier, os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'mysite.settings')cette ligne de code définit une variable d'environnement DJANGO_SETTINGS_MODULE, qui indique à Django quel fichier settings.py il doit utiliser.

Et application = get_wsgi_application()cette ligne de code définit une application WSGI. get_wsgi_application()La fonction renvoie une application WSGI qui peut traiter les requêtes HTTP et générer des réponses HTTP. Voici applicationune variable globale qui est le point d'entrée de l'interface du serveur WSGI.

Ensuite, vous pouvez utiliser un serveur WSGI pour exécuter votre application Django. Par exemple, avec Gunicorn, vous pouvez saisir la commande suivante sur la ligne de commande :

gunicorn mysite.wsgi

Cette commande démarre un serveur Gunicorn et charge les variables mysite.wsgidans le module applicationen tant qu'application WSGI.

Collectivement, wsgi.pyle fichier est un fichier de configuration Django important qui définit l'interface de l'application Django avec le serveur WSGI. En comprenant le fonctionnement de ce fichier, nous pouvons mieux comprendre comment les applications Django fonctionnent et comment déployer les applications Django.

Si cela vous est utile, veuillez accorder plus d'attention au compte public WeChat personnel : [Perspective complète de Python] TeahLead_KrisChang, 10+ ans d'expérience dans l'industrie de l'Internet et de l'intelligence artificielle, 10+ ans d'expérience dans la technologie et la gestion d'équipe commerciale, Tongji Software Baccalauréat en ingénierie, maîtrise en gestion de l'ingénierie Fudan, architecte principal du service cloud certifié Aliyun, responsable de l'activité de produits d'IA avec des centaines de millions de revenus.

Introduction et utilisation des fichiers par défaut du framework de Django facilement oubliés mais extrêmement importants