Fermer

août 28, 2020

Démystifier la magie de Django


À 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.
En savoir plus sur
Précieux

Dans cet article, nous allons examiner en profondeur ce que Django apporte à la table en comprenant ce que font les fichiers et le dossier générés, cela nous donnera une meilleure compréhension du framework Django. [19659005] 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. Il 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 apprécié pour son évolutivité dans la création d’un passe-partout avec des configurations et des fichiers définis. Ceci résume tout l'objectif de Django pour les développeurs:

«… créer une excellente application en peu de temps et moins de soucis 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 construisez. 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 central du développement de votre application pendant que Django gère les 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 en apprendre davantage sur 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 qui sortent du cadre 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 plate-forme 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 à partir de la vue de l'administrateur.

Cet article vous guidera dans la compréhension des commandes, des fichiers et des principes de base 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 bien comprendre 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éer 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 accéder à 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% . virtualenvs  djangodev  Scripts  activate.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 un peu de 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 un délai à respecter, même pour les projets personnels.

En suivant cette méthode lors de la création d'un nouveau grand projet, vous devrez créer plusieurs fichiers et dossiers et effectuer plusieurs réglages, ce qui pourrait conduire à la création de bogues évitables et beaucoup de temps perdu. Les commandes startproject et startapp dont nous disposons 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 la commande startproject .

Scaffolding An Application

Nous allons générez notre application et regardez 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. En savoir 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 nous lui passons 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, elle crée plusieurs fichiers et un dossier nommé en utilisant le nom spécifié dans le 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. Il s’agit du dossier contenant manage.py et l’autre module qui contient settings.py et d’autres fichiers. Une application est un package python qui fait une certaine fonctionnalité, inclut des fichiers comme models.py le répertoire migration 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 un excellent mappage que vous pouvez utiliser pour quelle que soit l'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 découvrez 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 opter pour celles-ci vous voulez et branchez-les. 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 y a certaines variables qu'il cherche des. 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 fichier manage.py et prend des informations ou charge d'autres fichiers vers lesquels il est conduit.

Ces configurations incluent:

  • DEBUG
    Le La fonctionnalité DEBUG est définie sur True pour permettre la lecture des erreurs et du code de débogage en cours de développement, elle doit être définie 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 de la commande startapp devra se trouver 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 Django et réponses. 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 requêtes . Vous devriez consulter les autres fonctionnalités de chaque middleware dans la documentation .
  • ROOT_URLCONF est une variable vers un chemin où Django recherche vos 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 dans la liste urlpatterns pour rechercher le chemin correspondant.
  • TEMPLATES est un paramètre à autoriser rendu de fichiers HTML pour représenter une vue. Il communique avec les applications de demande, d'authentification et de messagerie. La valeur 'BACKEND' et le 'APP_DIRS' défini sur True permettent à Django de rechercher des fichiers HTML dans le dossier / templates . Les 'context_processors' dans les OPTIONS sont callables qui prennent la requête comme argument et la fusionnent avec le contexte lorsqu'un modèle est rendu, ces Les callables fonctionnent pour faciliter le débogage, l'authentification et le traitement des requêtes en général.
  • WSGI_APPLICATION est un chemin menant à la variable application dans le fichier wsgi.py .
  • ] DATABASE est un dictionnaire qui détient l'accès à une base de données externe (ou interne comme dans le cas de la 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 = {
    'défaut': {
        'MOTEUR': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'nom_base',
        '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 transmettre l'utilisateur, mot de passe avec autorisation d'écriture à la base de données.

Note : Pour les besoins de ceci tutoriel, 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 ces fonctions 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 nécessitent une entrée point de départ des commandes. Un point d'entrée faisant office de passerelle dans l'application. Dans chaque projet Django, il s'agit généralement du fichier manage.py .

Ce fichier est nécessaire comme point de départ de 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 la fonction def main () pour gérer le module de paramètres par défaut de notre fichier settings.py . Il essaie d'importer la fonction d'exécution, et s'il rencontre une erreur, il lance l'erreur ImportError . Sinon, il prend n'importe quel argument passé par le sys.argv à partir de la ligne de commande et s'exécute.

sys.argv est une liste qui contient la commande passée via le terminal. Lorsque nous exécutons python manage.py runserver dans la ligne de commande, sys.argv est défini sur ["manage.py", "runserver"] et cela est passé à la fonction execute () .

Les arguments comme python manage.py startapp trading ou python manage.py makemigrations sont respectivement définis sur [ "manage.py", "startapp", "trading"] et ["manage.py", "makemigrations"] pour l'exécution.

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

En plus d'exécuter les fonctions django-admin 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 disposition de modélisation simple pour vous. Vous configurez vos modèles dans le fichier models.py du répertoire trading . Vos classes (ou modèles) sont des mises en page que suivront vos tables de base de données.

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 la variable DATABASE dans le settings.py .

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

 à partir de modèles d'importation django.db

Classe Produit (models.Model):
    name = models.CharField (max_length = 50)
    image = models.ImageField (upload_to = 'produits', par défaut = 'python.png')
    prix = modèles.IntegerField ()
    description = models.TextField ()

    def __str __ (soi):
        retourne self.name

Ordre des classes (models.Model):
    product = models.ForeignKey (Product, on_delete = models.CASCADE)
    quantité = modèles.IntegerField ()
    date = models.DateField (auto_now_add = True)
    user = models.CharField (max_length = 50)

    def __str __ (soi):
        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 dans un dossier products . Celui-ci est créé s'il n'existe pas). . La commande a un produit (lié au tableau products ), la quantité, la date et les colonnes utilisateur.

Avec ces informations, Django crée une base de données schéma de 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 cela, nous devons enregistrer trading comme application dans notre répertoire de projet.

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

Maintenant, dans settings.py add commercial dans INSTALLED_APP . Cela devrait ressembler à ceci:

 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 de modifications apportées dans le module de trading et crée un fichier dans le dossier migration des modifications dans models.py et python manage.py migrate puis met à jour les modifications. [19659010] Vous pouvez trouver le fichier de migration généré à partir de la commande python manage.py makemigrations trading dans le répertoire migration nommé 0001_initial.py . Vous pouvez voir les classes et les colonnes comme des commandes de création à l'intérieur du fichier. Au fur et à mesure que d'autres modifications seront apportées à models.py d'autres 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. être créé 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 liste INSTALLED_APP ; 'django.contrib.admin' .

De plus, l'URL de l'administrateur a également été enregistrée dans la liste urlpatterns notre fichier de configuration d'URL urls.py ]; chemin ('admin /', admin.site.urls), . Le fichier admin.py vous permet d'enregistrer les modèles et les actions CRUD qui doivent être effectuées sur les modèles.

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

 $ python manage.py createuperuser 

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 démarrer avec la fonctionnalité d'administration, exécutez le serveur:

 $ python manage.py runserver 

La visite http://127.0.0.1:8000/admin/ conduira à 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:

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

Les groupes et les utilisateurs sont des configurations par défaut qui permettent à admin d'accéder à la gestion et à l'autorisation des utilisateurs. Maintenant, enregistrons nos modèles.

Dans le admin.py ajoutez les lignes suivantes:

 from django.contrib import admin

# Enregistrez vos modèles ici.
à partir de .models importation de produit, commande

admin.site.register (Produit)
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 enregistré 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:

 ceci montre l'administrateur admin ajoutant un produit au site.
Admin ajoutant un produit (chaussure) au site. ( Grand aperçu )

Passer des commandes depuis le tableau de bord de l'administrateur:

 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 le fait pour vous dans le fichier urls.py .

Le urls.py est un fichier qui part de la variable ROOT_CONF 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 fichier urls.py elles doivent être configurées dans la liste urlpatterns .

Django attend une liste nommée urlpatterns dans le fichier. Vous pouvez remplacer le fichier de la variable ROOT_CONF par n'importe quel autre fichier que vous avez placé dans la liste urlpatterns .

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

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

Les instances peuvent également conduire à une 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 fichier views.py . Une vue est une classe ou une fonction qui traite une requête et renvoie une réponse à votre utilisateur.

Modifiez votre fichier views.py comme suit:

 de django.http import HttpResponse

def home (demande):
    return HttpResponse ("Ceci est un site d'achat de produits")

ordre def (demande):
    return HttpResponse ("Bonjour, bienvenue dans notre boutique, parcourez nos produits et commandez!") 

Ici, nous avons importé HTTPResponse pour l'utiliser dans la définition de deux vues (vues de fonction) pour renvoyer la phrase lorsqu'il est 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 l'attribuer à différents itinéraires (ou urlpatterns ). Cela peut être fait de plusieurs façons, nous pouvons créer une liste urlpatterns dans le même fichier, ou nous pouvons importer trading.views dans le fichier ecommerce_site.urls et créer le chemin.

La meilleure façon de le faire est de créer un fichier de configuration de sous-URL (à l'intérieur de trading ), et de l'inclure dans ecommerce_site.urls . Créez un fichier urls.py dans le répertoire trading . Votre annuaire 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 )

 à partir du chemin d'importation de django.urls

de . importer des vues

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

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

 de l'administrateur d'importation django.contrib
à partir de l'importation django.urls incluent, chemin

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

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

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

 image affichée 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/ .

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

Note: Le processus d'exécution de 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épendances

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

  1. Django recherche l'emplacement racine (chemin ) pour vos URL dans la variable ROOT_CONF .
  2. Django charge le fichier python indiqué dans le chemin fourni. Et trouve la variable urlpatterns 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 les fonctions ou basée sur les classes). Qui est ensuite transmis 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 pendant une Dans ce processus, Django invoque une vue appropriée de gestion des erreurs.
 Arbre 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 didacticiel sur GitHub .

Resources

 Smashing Editorial ( ks, ra, yk, il)




Source link