Catégories
Astuces et Design

Démystifier la magie de Django – Smashing Magazine

A propos de l'auteur

Precious Ndubueze est un développeur de logiciels qui passe la moitié de son temps dans sa tête sans se perdre dans la résolution de problèmes ou l'écriture.
Plus à propos
Précieux

Dans cet article, nous examinerons en profondeur ce que Django apporte à la table en comprenant ce que font les fichiers et les dossiers générés, cela nous donnera une meilleure compréhension du framework Django.

Selon la documentation officielle,

Django est un framework Web Python de haut niveau qui encourage un développement rapide et une conception propre et pragmatique. Conçu par des développeurs expérimentés, il prend en charge une grande partie des tracas du développement Web, vous pouvez donc vous concentrer sur l'écriture de votre application sans avoir à réinventer la roue. C'est gratuit et open source.

– DjangoProject.com

C'est l'un des frameworks populaires de Python pour la création d'applications Web et il est le plus préféré pour son évolutivité dans la création d'un passe-partout avec des configurations et des fichiers définis. Cela résume tout l'objectif de Django pour les développeurs;

"… créer une application géniale en peu de temps et moins de souci pour les paramètres de base."

Il existe des configurations de base, des fichiers et des styles qui s'appliquent à toutes les applications Web, peu importe ce que vous créez. Lorsque vous utilisez Django, ceux-ci sont générés automatiquement pour vous lorsque vous exécutez certaines commandes à différents moments du cycle de développement de votre application. Avec cela, vous aurez suffisamment de temps pour vous concentrer sur l'aspect principal du développement de votre application pendant que Django s'occupe des autres pour vous.

Cela signifie qu'il se passe beaucoup de choses sous le capot. Pour quelqu'un qui ne maîtrise pas parfaitement les pièces mobiles, cela peut être accablant. Dans cet article, nous allons découvrir les éléments suivants:

Nous allons découvrir comment ces éléments s’intègrent tous et le rôle qu’ils jouent. Il est important de savoir qu’il ne sera pas possible de regarder tout ce qui se passe à l’intérieur de Django. Pour les cas en dehors de la portée de ce didacticiel, il y aura des liens pour vous diriger vers des ressources qui vous aideront.

À des fins d'apprentissage, nous allons créer une plateforme de commerce électronique. Ce n'est pas un site e-commerce à part entière, notre application n'aura que deux fonctionnalités de base; créer des produits et passer des commandes depuis la vue de l'administrateur.

Cet article vous guidera tout au long de la compréhension des commandes, des fichiers et des bases de Django. Il s'adresse aux développeurs qui ont utilisé Django ou qui ont l'intention de l'utiliser et qui veulent savoir ce qui se passe sous le capot. Bien qu'il ne soit pas obligatoire d'avoir utilisé Django, avoir de l'expérience avec les bases de Django avant de continuer avec cet article vous donnera un avantage. Vous devez avoir une connaissance pratique de Python pour comprendre pleinement ce qui sera couvert dans cet article.

Installer Django

Si Django n'est pas déjà installé, voici les étapes à suivre.

Tout d'abord, créez un environnement virtuel, nommé djangodev. Vous en avez besoin pour isoler votre espace de travail Django et ses packages dépendants.

python3 -m venv ~/.virtualenvs/djangodev

Maintenant, pour entrer dans votre environnement virtuel, vous devez l'activer;

source ~/.virtualenvs/djangodev/bin/activate

Si vous rencontrez une erreur lors de l'exécution avec source vous pouvez utiliser cette commande alternative,

. ~/.virtualenvs/djangodev/bin/activate

Pour les utilisateurs de Windows, utilisez plutôt ceci,

...> %HOMEPATH%.virtualenvsdjangodevScriptsactivate.bat

Remarque: Vous devez activer l'environnement virtuel à chaque fois que vous souhaitez utiliser Django.

Maintenant que vous êtes dans votre environnement virtuel, installez Django:

python -m pip install Django

Pour vérifier si Django a été correctement installé, exécutez;

python -m django --version

Shakaboom! Maintenant que vous êtes prêt pour la magie, préparez vos baguettes!

La méthode de création de fichiers et de dossiers à la volée peut être simple et directe. Cependant, ce n'est pas l'idéal lorsque vous devez créer un projet de taille moyenne ou grande et un délai à battre. Nous avons toujours une échéance à battre, même pour des projets personnels.

En suivant cette méthode lors de la création d'un nouveau projet de grande envergure, vous devrez créer plusieurs fichiers et dossiers et définir plusieurs paramètres, ce qui pourrait entraîner la création de bogues évitables et beaucoup de temps perdu. startproject et startapp les commandes disponibles via Django visent à résoudre ce problème. Ces deux commandes créent des fichiers, des dossiers et effectuent de nombreuses configurations pour vous.

Commençons par générer une nouvelle application à l'aide de startproject commander.

Échafaudage une application

Nous allons générer notre application et examiner les fichiers générés, ainsi que quelques commandes que nous utiliserons. Exécutez cette commande dans votre terminal pour commencer;

django-admin startproject ecommerce_site

Lors de l'installation de Django, django-admin est ajouté à votre chemin pour lui donner accès pour effectuer ses actions. C’est l’utilitaire de ligne de commande de Django pour les responsabilités administratives. Apprendre encore plus django-admin utilise ici; cela sort un peu du cadre de cet article.

startproject est une commande Django qui aide générer le projet. Ici on lui passe le nom de notre projet site_ecommerce. Il crée ensuite le projet dans un répertoire appelé site_ecommerce. Le répertoire devrait ressembler à ceci,

affiche le répertoire après startproject.
Affichage du dossier après l'exécution de startproject. (Grand aperçu)

Nous devrons naviguer dans le répertoire nouvellement créé et exécuter la commande pour générer l'application.

cd ecommerce_site
python manage.py startapp trading

startapp est une commande exécutée par manage.py dans le répertoire du projet, il crée plusieurs fichiers et un dossier nommé en utilisant le nom spécifié dans la commande, dans ce cas, ce qui est spécifié est trading. Le dossier de l'application se compose de fichiers simples qui devraient être nécessaires pour créer des fonctionnalités d'une application. Maintenant, votre répertoire devrait ressembler à ceci:

affiche le répertoire après startapp.
Affichage du dossier après l'exécution de startapp. (Grand aperçu)

Si vous vous demandez la différence entre un projet et une application. Un projet est une application web Django, il peut être constitué d'une ou plusieurs applications. C’est le dossier contenant manage.py et l'autre module qui inclut le settings.py et autres fichiers. Une application est un package python qui fait une certaine fonctionnalité, comprend des fichiers comme models.py, les migration répertoire et plus encore. Vous pouvez consulter cette réponse sur Stack Overflow pour en savoir plus.

le startproject créera le répertoire principal du projet, tandis que le startapp créera le répertoire de l'application. Les deux reçoivent également un nom à utiliser dans la génération. le startproject est la première commande exécutée lors de la création d'un nouveau projet, tandis que le startapp est exécuté dans le nouveau répertoire du projet.

La mise en page actuelle est une excellente cartographie que vous pouvez utiliser pour n'importe quelle application que vous créez. Il est évolutif et se compose de fichiers dont vous aurez besoin. Il est possible de créer, renommer, modifier et déplacer des fichiers dans le projet.

Configuration de Django

Django fournit différents paramètres et configurations pour vous, après avoir exécuté les deux commandes dans des fichiers différents, parcourons les fichiers générés pour savoir ce que chacun fait.

settings.py

La plupart des applications Web nécessitent des configurations telles que; authentification pour vérifier les utilisateurs, autorisations pour autoriser certains utilisateurs avec certaines capacités et définir des normes de sécurité. Tous ces éléments sont nécessaires pour offrir à vos utilisateurs la meilleure expérience dont ils ont besoin. En tant que développeur, il vous faudra beaucoup de temps pour commencer à exécuter chacun de ces éléments par vous-même, pour chaque application sur laquelle vous travaillez.

Django vous fournit ces configurations nécessaires et plus encore – de sorte que vous pouvez choisir celles que vous voulez et les brancher. Cela se fait dans settings.py, il existe déjà des paramètres créés pour vous fournir des fonctionnalités de base.

Lorsque Django essaie d'exécuter un projet, il recherche certaines variables. le settings.py est le fichier contenant les variables qui mènent à d'autres fichiers ou informations. Django est dirigé vers ce fichier à partir du manage.py fichier et prend des informations ou charge d'autres fichiers vers lesquels il est conduit à partir d'ici.

Ces configurations incluent:

  • DEBUG
    le DEBUG la fonctionnalité est définie sur True pour permettre la lecture des erreurs et du code de débogage en développement, il doit être défini sur False pendant la production (c'est-à-dire lorsque vous déployez). Ce paramètre vous permet de mieux déboguer votre code avec l'aide de Django lorsqu'il essaie d'exécuter votre code.
  • INSTALLED_APPS
    Ceci est une liste de toutes les applications exécutant une certaine fonctionnalité dans Django. Il est livré avec des applications par défaut comme le 'django.contrib.auth' qui est utilisé pour l'authentification des utilisateurs, django.contrib.admin' pour la fonctionnalité d'administration, et 'django.contrib.messages' nécessaire pour envoyer une notification ou des informations aux utilisateurs. Toute autre application que vous créez à l'aide du startapp La commande devra être ici avant de pouvoir être exécutée par Django.
  • MIDDLEWARE est un framework léger pour le traitement des entrées et sorties passant par les requêtes et réponses Django. Chaque middleware remplit une fonction spécifique avec une application, comme le 'django.contrib.auth.middleware.AuthenticationMiddleware' fonctionne avec le 'django.contrib.sessions' pour associer les utilisateurs aux demandes. Vous devriez vérifier les autres fonctionnalités de chaque middleware sur la documentation.
  • ROOT_URLCONF est une variable vers un chemin où Django recherche votre urlpatterns lorsqu'une requête est transmise à votre application Django. Chaque fois qu'une requête est faite dans une application Django, Django recherche cette variable et charge le fichier principal et effectue une boucle à travers le urlpatterns list à la recherche du chemin correspondant.
  • TEMPLATES est un paramètre permettant le rendu des fichiers HTML pour représenter une vue. Il communique avec les applications de demande, d'authentification et de messagerie. le 'BACKEND' valeur et le 'APP_DIRS' mis à True permet à Django de rechercher des fichiers HTML dans / modèles dossier. le 'context_processors' dans le OPTIONS sont appelables, qui prennent la requête en tant qu'argument et la fusionnent avec le contexte lorsqu'un modèle est rendu, ces callables fonctionnent pour aider au débogage, à l'authentification et à la gestion des requêtes en général.
  • WSGI_APPLICATION est un chemin menant au application variable dans wsgi.py fichier.
  • DATABASE est un dictionnaire qui permet d'accéder à une base de données externe (ou interne comme dans le cas du sqlite par défaut) comme PostgresSQL, MySQL et MongoDB. Voici un exemple de base de données Postgres que j'utiliserai pour notre exemple:
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'db_name',
        'USER': 'db_user',
        'PASSWORD': 'db_password',
        'HOST': 'localhost',
        'PORT': '',
    }
}

Vous pouvez décider d'utiliser la base de données sqlite par défaut, cela ne fonctionne pas très bien pour la production. Vous pouvez configurer une base de données Postgres comme ci-dessus, vous devrez d'abord créer la base de données et passer l'utilisateur, mot de passe avec autorisation d'écriture à la base de données.

Remarque: Pour les besoins de ce didacticiel, vous pouvez déjà utiliser le jeu de bases de données sqlite par défaut. Ce qui précède est une démonstration sur la façon dont vous pouvez définir la connexion de base de données SQL et NO-SQL dans Django.

  • AUTH_PASSWORD_VALIDATORS ce sont des fonctions qui sont appelées pour les validations de mot de passe. Ils sont appelés lors de la création d'enregistrements d'utilisateurs (et d'administrateurs), de réinitialisation et de modification des mots de passe. Vous pouvez en apprendre plus à leur sujet dans la documentation officielle.

Plus de documentation sur les paramètres peut être trouvée ici.

manage.py

La plupart des projets Web ont besoin d'un point d'entrée d'où partent les commandes. Un point d'entrée faisant office de passerelle dans l'application. Dans chaque projet Django, c'est généralement le manage.py fichier.

Ce fichier est nécessaire comme point de départ dans votre application. De là, toutes les commandes sont exécutées et tout démarre ici.

manage.py fait la même fonction que django-admin. Il indique également à Django l'emplacement des configurations que vous avez dans votre application. Ceci est défini par défaut et n'a pas besoin d'être modifié.

Il utilise def main() fonction pour gérer le module de paramètres par défaut de notre settings.py fichier. Il essaie d'importer la fonction d'exécution, et s'il rencontre une erreur, il lance le ImportError. Sinon, il prend tout argument passé par le sys.argv à partir de la ligne de commande et s'exécute.

sys.argv est une liste qui reprend la commande passée via le terminal. Quand nous courons python manage.py runserver dans la ligne de commande, sys.argv se met à ("manage.py", "runserver") et ceci est passé au execute() fonction.

Des arguments comme python manage.py startapp trading ou python manage.py makemigrations sont réglés sur ( "manage.py", "startapp", "trading") et ("manage.py", "makemigrations") respectivement pour l'exécution.

L'instruction if est définie pour s'exécuter si la commande donnée est définie sur manage.py.

En plus de courir django-admin fonctions, vous l'utiliserez pour exécuter le serveur, gérer les migrations et d'autres commandes que votre projet utilisera. Vous en aurez également besoin lors du déploiement, du test et du débogage de vos projets.

Disposition du modèle

Django fournit une mise en page de modélisation simple pour vous. Vous configurez vos modèles dans le models.py fichier dans le trading annuaire. Vos classes (ou modèles) sont des mises en page que vos tables de base de données suivront.

Vous définissez vos classes en fonction des types de données que vous souhaitez obtenir de l'utilisateur (ou de l'administrateur) pour chaque table. Nos modèles créent un fichier de migration qui fonctionne avec le DATABASE variable dans le settings.py.

Créons deux modèles dont nous aurons besoin, pour les produits et les commandes:

from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=50)
    image = models.ImageField(upload_to='products', default='python.png')
    price = models.IntegerField()
    description = models.TextField()

    def __str__(self):
        return self.name

class Order(models.Model):
    product =  models.ForeignKey(Product, on_delete=models.CASCADE)
    quantity = models.IntegerField()
    date = models.DateField(auto_now_add=True)
    user = models.CharField(max_length=50)

    def __str__(self):
        return self.user

Le modèle de produit a un nom, un prix, une description et une image (qui, une fois enregistrée, sera téléchargée sur un products dossier. Cela est créé si le dossier n'existe pas) colonnes. le order a un product (lié au products table), les colonnes quantité, date et utilisateur.

Avec ces informations, Django crée un schéma de base de données pour l'application. Crée également une API d'accès à la base de données Python pour accéder aux objets Product et Order. Django a un outil de migration intégré pour que vous n'ayez pas à utiliser de packages externes pour les migrations.

L'étape suivante consiste à exécuter la commande de migration et à migrer vers la base de données. Mais avant de faire ça, nous devons nous enregistrer trading en tant qu'application dans notre répertoire de projets.

Tout d'abord, nous devons configurer le répertoire de trading en tant qu'application dans Django. Django a fait cela pour vous dans le app.py fichier. Ce fichier enregistre trading en tant qu'application et sera ensuite utilisé dans le settings.py fichier.

Maintenant en settings.py ajouter trading dans INSTALLED_APP. Ça devrait ressembler à ça:

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'trading.apps.TradingConf',
)

Sur le terminal, exécutez:

$ python manage.py makemigrations trading
$ python manage.py migrate

Remarque: Votre environnement virtuel doit être activé et vous devez être dans le répertoire du projet.

python manage.py makemigrations trading prend note des modifications apportées au module de trading et crée un fichier dans le migration dossier de modifications dans models.py et python manage.py migrate puis met à jour les modifications.

Vous pouvez trouver le fichier de migration généré à partir du python manage.py makemigrations trading commande dans le migration répertoire nommé 0001_initial.py. Vous pouvez voir les classes et les colonnes comme des commandes de création à l'intérieur du fichier. Comme plus de changements dans models.py sont créés, plus de fichiers seront générés ici.

Fonctionnalités d'administration

Dans notre application actuelle, nous aurons besoin de fonctionnalités d'administration pour gérer les produits et les commandes qui seront créés dans l'application. Django nous fournit une fonctionnalité d'administration intégrée déjà à notre disposition. L'application d'administration (fonctionnalité) a également été enregistrée dans notre INSTALLED_APP liste; 'django.contrib.admin'.

En outre, l'URL de l'administrateur a également été enregistrée dans le urlpatterns lister notre fichier de configuration d'URL urls.py; path('admin/', admin.site.urls),. le admin.py fichier vous permet d'enregistrer les modèles et les actions CRUD à effectuer sur les modèles.

Pour configurer l'administrateur, exécutez ceci sur le terminal:

$ python manage.py createsuperuser

Vous serez invité à entrer un nom d'utilisateur, une adresse e-mail et un mot de passe. Après cela, vous avez réussi à créer un administrateur. Pour commencer avec la fonctionnalité d'administration, exécutez le serveur:

$ python manage.py runserver

Visiter http://127.0.0.1:8000/admin/ mènera à une session de connexion, lorsque vous vous connectez (avec le nom d'utilisateur et le mot de passe que vous avez créés), vous êtes dirigé vers le tableau de bord d'administration:

cela montre le tableau de bord de l'administrateur.
Tableau de bord d'administration fourni par Django. (Grand aperçu)

Les groupes et les utilisateurs sont des configurations par défaut qui permettent à l'administrateur d'accéder à la gestion et à l'autorisation des utilisateurs. Enregistrons maintenant nos modèles.

dans le admin.py, ajoutez les lignes suivantes:

from django.contrib import admin

# Register your models here.
from .models import Product, Order

admin.site.register(Product)
admin.site.register(Order)

from django.contrib import admin importe la fonctionnalité d'administration de Django, puis nous avons importé les deux classes de notre models.py et les a enregistrés afin qu'un administrateur puisse effectuer des actions CRUD sur les produits et commander à partir du tableau de bord.

Après avoir enregistré les modèles, votre tableau de bord devrait ressembler à ceci:

montrant le tableau de bord d'administration avec les produits et le modèle de commande.
Modèle de produit et de commande sur le tableau de bord d'administration. (Grand aperçu)

Ajout de produits:

cela montre que l'administrateur a ajouté un produit au site.
Administrateur ajoutant un produit (chaussure) au site. (Grand aperçu)

Passer des commandes à partir du tableau de bord d'administration:

Image montrant l'administrateur passant des commandes.
Admin ajoutant / passant des commandes. (Grand aperçu)

Routage facile

Chaque site a besoin d'un itinéraire ou d'URL menant à des pages spécifiques contenant certaines informations pour l'utilisateur final. Des collections d'informations ou d'applications similaires sont accessibles dans un itinéraire particulier. Il est nécessaire de regrouper les itinéraires pour l'accessibilité et la communication dans les fichiers. Django a fait cela pour vous dans le urls.py fichier.

le urls.py est un fichier menant du ROOT_CONF variable dans le settings.py. C'est là que notre configuration URL principale est effectuée. Lorsque nous créons des vues dans différents fichiers ou dossiers, ou même dans le urls.py fichier, ils doivent être configurés dans le urlpatterns liste.

Django attend une liste nommée urlpatterns dans le fichier. Vous pouvez modifier le fichier dans le ROOT_CONF variable dans tout autre fichier dans lequel vous avez placé le urlpatterns liste.

urlpatterns = (
    path('admin/', admin.site.urls),
)

La liste se compose d'objets qui sont des instances de path ou re-path. Chaque instance a deux paramètres obligatoires, le pattern 'admin/', et une vue ou un fichier URL, admin.site.urls.

Les instances peuvent également conduire à un autre fichier avec plus de configurations d'URL. Ceci est fait pour la lisibilité.

views.py

Un besoin important pour une application backend est les vues auxquelles chaque route correspond. Dans Django, vous écrivez vos vues basées sur une fonction ou une classe pour une application dans le views.py fichier. Une vue est une classe ou une fonction qui traite une demande et renvoie une réponse à votre utilisateur.

Modifiez votre views.py fichier à ceci:

from django.http import HttpResponse

def home(request):
    return HttpResponse("This is a shopping site for products")

def order(request):
    return HttpResponse("Hello, welcome to our store, browse to our products and order!")

Ici nous avons importé HTTPResponse pour l'utiliser pour définir deux vues (vues de fonction) pour renvoyer une phrase lors de l'appel. def home doit être appelé lorsque vous visitez l'adresse principale et def order lorsque vous accédez à l'URL de la commande.

Après avoir créé nos vues, nous devons les affecter à différents itinéraires (ou urlpatterns). Cela peut être fait de plusieurs manières, nous pouvons créer un urlpatterns list dans le même fichier, ou nous pourrions importer trading.views dans ecommerce_site.urls fichier et créez le chemin.

La meilleure façon de le faire est de créer un fichier de configuration de sous-URL (à l'intérieur trading), et l'inclure dans ecommerce_site.urls. Créer un urls.py fichier dans le trading annuaire. Votre répertoire devrait ressembler à:

trading/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
        0001_initial.py
    models.py
    tests.py
    urls.py
    views.py

Ajoutez le code suivant à votre nouveau fichier (urls.py)

from django.urls import path

from . import views

urlpatterns = (
    path('', views.home, name='home'),
    path('order/', views.order, name='order'),
)

Enregistrons le trading Fichier de configuration d'URL (urls.py) dans le fichier de configuration des URL du projet,

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

urlpatterns = (
    path('admin/', admin.site.urls),
    path('', include('trading.urls'))
)

Pour pouvoir accéder au urlpatterns nous utiliserons le include classe de django.urls à la ligne 2. Ensuite, choisissez un motif et attachez le urls.py fichier dans le répertoire commercial.

Ce que nous avons fait ici, c'est d'importer le path classe de django, et le views.py fichier. Ensuite, notre liste se compose de deux instances de chemin pour chaque vue. Alors def home est appelé sur http://127.0.0.1:8000/.

image montrant lorsque vous visitez la page d'accueil du site.
Site lorsque vous visitez la page d'accueil. (Grand aperçu)

Et def order est appelé sur http://127.0.0.1:8000/order/.

affiche le site lorsque vous visitez l'URL de la commande.
URL de la commande visitée. (Grand aperçu)

Remarque: Le processus de course startproject et startapp n'est pas obligatoire mais fortement encouragé par Django. Et vous pouvez créer / déplacer des fichiers et des dossiers après avoir exécuté chaque commande à votre convenance de travail.

Arbre de dépendance

Voici le processus dans lequel Django traite les requêtes des URL provenant:

  1. Django recherche l'emplacement racine (chemin) de vos URL dans le ROOT_CONF variable.
  2. Django charge le fichier python indiqué dans le chemin fourni. Et localise le urlpatterns variable, il s'agit d'une liste contenant toutes les instances de django.urls.path() et / ou django.urls.re_path().
  3. Dans la liste, Django va dans l'ordre et recherche une URL correspondante.
  4. Python importe et appelle la vue (vue basée sur une fonction ou basée sur une classe). Qui est ensuite passé avec la requête HTTP.
  5. La vue traite la demande et les informations transmises et renvoie un message / modèle ou redirige vers une autre vue.
  6. Si aucun modèle d'URL ne correspond, ou si une exception est déclenchée à un moment quelconque de ce processus, Django appelle une vue de gestion des erreurs appropriée.
Arborescence montrant comment Django gère les requêtes.
Gestion des requêtes Django. (Grand aperçu)

Conclusion

Nous avons appris la possibilité de créer des fichiers pour Django sans la ligne de commande. Nous avons également appris les avantages et les éléments constitutifs d'un projet Django. Django est un outil incroyable pour créer des projets backend dans le but de créer de la simplicité.

Vous pouvez consulter le code de ce tutoriel sur GitHub.

Ressources

Éditorial fracassant(ks, ra, yk, il)

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *