Démarrer un projet Django – Real Python

By | juillet 21, 2021

Python pas cher

Django est un framework Web Python de haut niveau qui encourage un développement rapide et une conception propre et pragmatique.

Dans ce tutoriel, nous répondrons à la question « Comment configurer un projet Django (1.5, 1.6, 1.7 ou 1.8) à partir de zéro ? » En d'autres termes, vous apprendrez comment installer Django et comment configurer la structure de votre projet Django.

Voici comment tirer le meilleur parti de ce tutoriel :

  1. Lisez les sections Introduction et Configuration.
  2. Ensuite, choisissez votre poison – Django 1.5, 1.6, 1.7, 1.8 – pour configurer un projet Django.
  3. Après la configuration initiale du projet, accédez à la section Créer une application pour configurer une application agréable et facile.
  4. Consultez ensuite le workflow récapitulatif pour un guide de démarrage rapide d'un projet Django.

Mettre à jour: Nous avons pointé le domaine realdjango.com vers ce message, afin que vous puissiez le retrouver facilement.

introduction

Ce tutoriel répond à la question, « Comment configurer un projet Django à partir de zéro ? » Puisque vous lisez ceci, je suppose (euh, j'espère) que vous savez que Django est un framework Web Python conçu pour un développement Web rapide. Nous allons passer en revue la configuration, en détaillant les procédures d'installation de base de Django et les dépendances requises ainsi que quelques bibliothèques/extensions supplémentaires pour vous permettre de commencer à développer dès que possible.

Nous examinerons également un flux de travail de base que vous pouvez utiliser dès que la structure de votre projet est configurée.

Enfin, n'oubliez pas de regarder les vidéos suivantes :

Bien que ces vidéos soient spécifiques à Django 1.5, elles vous aideront également à comprendre le workflow de base pour Django 1.6, 1.7 et 1.8.

Exigences du didacticiel

Vous devez avoir une certaine expérience de Python et connaître les commandes bash Unix de base. Si vous n'avez jamais utilisé la ligne de commande auparavant, veuillez vous familiariser avec les commandes suivantes : pwd, CD, ls, rm, et mkdir.

Pour plus de simplicité, tous les exemples utilisent l'invite de style Unix :

$ python manage.py runserver

(Le signe dollar ne fait pas partie de la commande.)

Équivalent Windows :

C:> python manage.py runserver

Installer

Ce dont vous avez besoin pour un environnement de développement Django de base :

  1. Python 2.7.x ou 3.4.x
  2. easy_install et Pip
  3. Git
  4. virtualenv
  5. Django
  6. Base de données (SQLite, MySQL, PostgreSQL, MongoDB, etc.)
  7. Sud (pour les versions Django antérieures à la 1.7)
  8. Éditeur de texte (Sublime, vim, Komodo, gedit)

Noter: Ce tutoriel utilise Python version 2.7.8.

Python

Les environnements Unix sont pré-installés avec Python. Pour vérifier votre version Python, exécutez la commande :

$ python -V
Python 2.7.8
$ python3 -V
Python 3.4.2

Si vous possédez déjà une version 2.7.x, passez à l'étape suivante. Sinon, téléchargez et installez la dernière version 2.7.x spécifique à votre système d'exploitation.

easy_install et pip

easy_install et pip sont tous deux des gestionnaires de packages Python, ce qui en fait beaucoup plus facile à installer et à mettre à niveau des packages Python (et des dépendances de packages).

Pour télécharger easy_install, accédez à Python Package Index (PyPI). Vous devez télécharger setuptools, qui inclut easy_install. Téléchargez le package egg (.egg), puis installez-le directement à partir du fichier.

Pip, quant à lui, est un wrapper qui repose sur easy_install, vous devez donc d'abord avoir configuré easy_install et fonctionner avant de pouvoir installer pip. Une fois easy_install configuré, exécutez la commande suivante pour installer pip :

Git

Pour le contrôle de version, nous utiliserons git. Vous pouvez vérifier votre version actuelle, si git est déjà installé, avec la commande suivante :

$ git --version
git version 2.3.0

Si vous n'avez pas installé de version supérieure à 1.7.x, veuillez télécharger la dernière version.

MySQL

SQLite est pré-installé avec Python, et la plupart des tutoriels utilisent SQLite – alors poussons-nous un peu et utilisons MySQL à la place.

Tout d'abord, installez MySQL à partir d'ici.

Ensuite, démarrez le serveur, puis configurez une nouvelle base de données et un utilisateur :

$ démarrage mysql.server
$ mysql -u racine -p
Entrer le mot de passe:
Bienvenue sur le moniteur MySQL. Les commandes se terminent par ; ou g.
Votre identifiant de connexion MySQL est 1
Tapez « aide ; » ou 'h' pour obtenir de l'aide. Tapez 'c' pour effacer le tampon.
mysql>
mysql> CRÉER LA BASE DE DONNÉES django_db;
Requête OK, 1 ligne affectée (0,01 s)
mysql>
mysql> quitter
Au revoir

virtualenv

Il est courant d'utiliser un virtualenv (environnement virtuel) pour vos projets Python afin de créer des environnements de développement autonomes (également appelés « bacs à sable »). Le but de virtualenv est d'empêcher les différentes versions de bibliothèques/paquets de se gêner les unes les autres.

Considérez virtualenv comme un conteneur complètement isolé au sein de votre ordinateur, où vous pouvez utiliser n'importe quelle version de Python et installer des bibliothèques/packages et cela n'affectera rien en dehors de ce conteneur. C'est comme une pièce isolée et insonorisée dans votre maison où vous pouvez crier aussi fort que vous le souhaitez, à propos de tout ce que vous voulez, et personne d'autre à l'extérieur de cette pièce ne peut l'entendre.

Installez virtualenv avec la commande suivante :

Django 1.5

Lancé pour la première fois le 26 février 2013, les nouvelles fonctionnalités les plus notables incluent :

  1. Modèle utilisateur configurable: Au lieu d'être obligé d'utiliser la définition d'« utilisateur » de Django, vous pouvez désormais créer votre propre modèle d'utilisateur, en créant des champs personnalisés, comme des liens vers des profils sociaux, la date de naissance, la couleur préférée, etc.
  2. Prise en charge de Python 3: Django suggère de ne pas utiliser Python 3 en production pour l'instant, car le support est encore « expérimental ». Cependant, cette fonctionnalité est énorme pour la communauté Python dans son ensemble, contribuant à mettre encore plus de pression pour mimer vers Python 3.

Vous voulez lire les notes de version complètes ? Découvrez les changements officiels de Django ici.

La dernière version est sortie le 2 janvier 2015 : v1.5.12

Regardez les vidéos qui accompagnent ce tutoriel :

Installation de Django

Configurez votre structure de développement :

$ mkdir django15_project
$ CD django15_projet
$ environnement virtuel
$ la source env/bin/activer

Tu devrais voir (env) avant votre invite, (env)$, indiquant que vous exécutez dans le virtualenv 'env'.

Pour quitter virtualenv, saisissez la commande suivante :

Ensuite, réactivez-vous lorsque vous êtes prêt à travailler à nouveau.

Installons Django :

$ pip installer django==1.5.12

Vous pouvez vérifier la version en exécutant les commandes suivantes :

>>>

$ python
>>> importer django
>>> django.obtenir_version()
'1.5.12'

Configuration du projet

Configurer le projet Django

$ django-admin.py startproject my_django15_project

Cela crée un nouveau répertoire appelé "my_django15_project" avec le répertoire et les structures de base de Django :

manage.py
my_django15_project
    __init__.py
    settings.py
    urls.py
    wsgi.py

Contrôle de version

Avant de commencer tout développement, mettez votre projet sous contrôle de version. Tout d'abord, ajoutez un nouveau fichier appelé .gitignore dans votre répertoire « django15_project », qui est utilisé pour ignorer l'ajout de fichiers inutiles au référentiel git.

Ajoutez les éléments suivants au fichier :

env
*.DS_Store
*.pyc
__pycache__

Maintenant, initialisez (ou créez) un nouveau dépôt Git et ajoutez vos modifications au transfert puis au dépôt local.

$ git init
$ git ajouter -A
$ git commit -am "commission initiale"

Si vous utilisez BitBucket ou GitHub (fortement recommandé), PUSH vos fichiers vers votre référentiel central.

Paramètres de la base de données

Tout d'abord, installez MySQL-python, qui est un connecteur de base de données pour Python :

$ pip installer MySQL-python

Modifiez votre paramètres.py dans votre répertoire "my_django15_project" pour ajouter les informations suivantes sur votre base de données que vous avez configurée précédemment :

BASES DE DONNÉES = 
    'défaut': 
        'MOTEUR': 'django.db.backends.mysql',
        'NOM': 'django_db',
        'UTILISATEUR': 'racine',
        'LE MOT DE PASSE': 'votre mot de passe',
    

Créez vos tables de base de données et configurez un superutilisateur :

$ CD mon_django15_projet
$ python manage.py syncdb

Lancez le serveur de développement :

$ python manage.py runserver

Vous devriez voir la sortie suivante si Django et la base de données sont correctement configurés :

Validation des modèles...

0 erreurs trouvées
7 septembre 2014 - 23:36:02
Django version 1.5, en utilisant les paramètres 'my_django15_project.settings'
Le serveur de développement s'exécute à l'adresse http://127.0.0.1:8000/
Quittez le serveur avec CONTROL-C.

Pointez votre navigateur sur http://127.0.0.1:8000 et vous devriez voir le Django "Cela a fonctionné!" page.

De retour dans votre terminal, tuez le serveur en appuyant sur CONTROL-C.

Sud

South est utilisé pour gérer les modifications apportées aux tables de votre base de données. Au fur et à mesure que votre application grandit et que vous devez ajouter un champ à une table spécifique, par exemple, vous pouvez simplement apporter des modifications à la base de données via des migrations avec South. ça fait la vie beaucoup Plus facile.

Installer Sud :

gel de pépins

Maintenant que toutes vos bibliothèques sont installées, utilisez la commande suivante pour créer un enregistrement des bibliothèques installées dans le répertoire "my_django15_project":

$ gel des pépins > requirements.txt

Cette commande est incroyablement utile si vous devez recréer votre projet à partir de zéro et devez connaître les bibliothèques/versions exactes que vous devez installer.

Validez vos nouvelles modifications dans Git.

Configurez votre application Django

Créez votre nouvelle application :

$ python manage.py startapp monapp

La structure de votre projet devrait maintenant ressembler à ceci :

manage.py
my_django15_project
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
monapplication
    __init__.py
    models.py
    tests.py
    vues.py

Mettez à jour les INSTALLED_APPS dans votre paramètres.py déposer:

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'django.contrib.admin',
    'monapplication',
    'Sud',
)

Ici, nous avons activé l'administrateur, 'django.contrib.admin', et ajouté les applications, 'monapplication', et 'Sud'.

Ouvert urls.py et décommentez ces trois lignes :

de django.contrib importer administrateur
administrateur.découverte automatique()
URL(r'^admin/', inclure(administrateur.placer.URL)),

Synchronisez à nouveau votre base de données :

$ python manage.py syncdb

Créez un fichier de migration de base de données avec South :

$ python manage.py schemamigration myapp --initial

Migrez les modifications apportées à la base de données :

$ python manage.py migrer myapp

Lancez le serveur (python manage.py runserver), puis accédez à http://127.0.0.1:8000/admin. Entrez le nom d'utilisateur et le mot de passe de votre superutilisateur pour vous connecter à la page d'administration.

Engagez-vous dans Git. Par example:

$ git ajouter -A
$ git commit -am "paramètres mis à jour, application créée, sud ajouté, administrateur Django activé"

Utiliser git, de la bonne manière

REMARQUE: Cette section est assez avancée et complètement facultative. Si c'est la première fois que vous configurez Django, vous pouvez ignorer cette section.

Si vous n'utilisez pas GitHub ou Bitbucket comme référentiel central, vous devez créer une branche distincte de votre référentiel local pour le développement.

Tout d'abord, créez un nouveau répertoire appelé "dev" dans votre répertoire "django15_project", naviguez dans le répertoire nouvellement créé, puis clonez (copiez) l'intégralité de votre projet Django :

$ git clone /chemin/vers/votre/projet/

Par example: /Utilisateurs/michaelherman/desktop/django15_project

Cette commande crée une copie exacte de votre dépôt, qui inclut tous vos commits et branches. Développez toujours à partir de ce répertoire en créant des branches distinctes pour chaque modification majeure de votre projet :

$ branche git 

Passez ensuite à cette branche :

$ git caisse 

Vous pouvez toujours vérifier quelles branches sont disponibles avec cette commande :

Une fois le développement terminé, validez vos modifications :

$ git ajouter -A
$ git commit -am "quelques messages"

Maintenant, vous voulez fusionner vos modifications avec la branche master :

$ maître de caisse git
$ git fusionner 

Vous pouvez PUSH vos modifications vers GitHub ou Bitbucket si vous utilisez l'un ou l'autre service. Enfin, revenez à votre dossier de production principal et tirez les modifications :

Exemple:

(env)$ CD développeur
(env)$ CD django15_projet
(env)$ branche git 06212013
(env)$ git caisse 06212013
(env)$ git ajouter -A
(env)$ git commit -am "description des modifications apportées"
(env)$ maître de caisse git
(env)$ git fusionner 06212013
(env)$ CD ..
(env)$ git pull /Utilisateurs/michaelherman/desktop/django15_project/dev/django15_project

Flux de travail

Maintenant que votre application est configurée, suivez l'un de ces flux de travail simples chaque fois que vous souhaitez apporter des modifications à votre application :

De base:

  1. Accédez à votre projet
  2. Activer virtualenv
  3. Développer
  4. Valider les modifications
  5. Déployer
  6. Désactiver virtualenv

Avancée:

  1. Accédez à votre projet
  2. Activer virtualenv
  3. Créer et extraire une nouvelle branche git
  4. Développer
  5. Valider les modifications
  6. Fusionner la nouvelle branche avec votre branche principale
  7. PULL les modifications dans le dossier de production
  8. Déployer
  9. Désactiver virtualenv

Acclamations! Des questions? Suggestions?

Créons une application de base !

Django 1.6

Sorti pour la première fois le 6 novembre 2013, les nouvelles fonctionnalités les plus notables incluent :

  1. Prise en charge de Python 3: La prise en charge de Python 3 est désormais officielle, sans aucune restriction, vous pouvez donc l'exécuter en production.
  2. Gestion améliorée des transactions de base de données: L'API est plus légère, plus propre et plus simple, ce qui facilite grandement les restaurations et la gestion des erreurs.
  3. Nouveau coureur de test
  4. Connexions de base de données persistantes

Vous voulez lire les notes de version complètes ? Découvrez les changements officiels de Django ici.

La dernière version est sortie le 18 mars 2015 : v1.6.11

Installation de Django

Configurez votre structure de développement :

$ mkdir django16_project
$ CD django16_projet
$ environnement virtuel
$ la source env/bin/activer

Tu devrais voir (env) avant votre invite, (env)$, indiquant que vous exécutez dans le virtualenv 'env'.

Pour quitter virtualenv, saisissez la commande suivante :

Ensuite, réactivez-vous lorsque vous êtes prêt à travailler à nouveau.

Avec votre virtualenv activé, installez Django avec Pip :

$ pip installer django==1.6.11

Vous pouvez vérifier la version en exécutant les commandes suivantes :

>>>

$ python
>>> importer django
>>> django.obtenir_version()
'1.6.11'

Configuration du projet

Configurer le projet Django

$ django-admin.py startproject my_django16_project

Cela crée un nouveau répertoire appelé "my_django16_project" avec le répertoire et les structures de base de Django :

manage.py
my_django16_project
    __init__.py
    settings.py
    urls.py
    wsgi.py

Contrôle de version

Avant de commencer tout développement, placez votre projet sous contrôle de version. Tout d'abord, ajoutez un .gitignore dans votre répertoire « django16_project », qui empêche l'ajout de fichiers inutiles au référentiel git.

Ajoutez les éléments suivants au fichier :

env
*.DS_Store
*.pyc
__pycache__

Maintenant, initialisez (ou créez) un nouveau référentiel Git et ajoutez vos modifications à la mise en scène, puis au référentiel.

$ git init
$ git ajouter -A
$ git commit -am "initiale"

Si vous utilisez GitHub, PUSH également vos fichiers vers votre référentiel central.

Paramètres de la base de données

Tout d'abord, installez MySQL-python pour que Python puisse communiquer avec MySQL :

$ pip installer MySQL-python

Modifiez votre paramètres.py fichier dans votre répertoire "my_django16_project":

BASES DE DONNÉES = 
    'défaut': 
        'MOTEUR': 'django.db.backends.mysql',
        'NOM': 'django_db',
        'UTILISATEUR': 'racine',
        'LE MOT DE PASSE': 'votre mot de passe',
    

Créez vos tables de base de données et configurez un superutilisateur :

$ CD ma
$ python manage.py syncdb

Lancez le serveur de développement :

$ CD mon_django16_projet
$ python manage.py runserver

Vous devriez voir la sortie suivante si tout va bien jusqu'à présent :

Validation des modèles...

0 erreurs trouvées
7 septembre 2014 - 23:36:02
Django version 1.6, en utilisant les paramètres 'my_django16_project.settings'
Le serveur de développement s'exécute à l'adresse http://127.0.0.1:8000/
Quittez le serveur avec CONTROL-C.

Accédez à http://127.0.0.1:8000 et vous devriez voir le bleu clair familier "Cela a fonctionné!" page.

Tuez le serveur en appuyant sur CONTROL-C dans le terminal.

Sud

South est utilisé pour gérer les migrations de bases de données – par exemple, apporter des modifications à votre schéma de base de données.

Installer Sud :

gel de pépins

Une fois les dépendances installées, utilisez la commande suivante pour en créer un enregistrement, ainsi que leurs versions ultérieures, dans le répertoire "my_django16_project":

$ gel des pépins > requirements.txt

Cette commande est pratique lorsque vous devez recréer votre projet à partir de zéro. Vous pouvez simplement exécuter pip install -r requirements.txt pour installer toutes les dépendances de votre projet.

Validez vos nouvelles modifications dans Git.

Configurez votre application Django

Créez votre nouvelle application :

$ python manage.py startapp monapp

La structure de votre projet devrait maintenant ressembler à ceci :

manage.py
my_django16_project
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
monapplication
    __init__.py
    admin.py
    models.py
    tests.py
    vues.py

Mettez à jour les INSTALLED_APPS dans votre paramètres.py fichier pour inclure South ainsi que votre nouvelle application :

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'django.contrib.admin',
    'monapplication',
    'Sud',
)

Maintenant dès que tu cours syncdb, Django sera conscient des deux Sud et monapplication.

Ouvert urls.py et décommentez ces trois lignes :

de django.contrib importer administrateur
administrateur.découverte automatique()
URL(r'^admin/', inclure(administrateur.placer.URL)),

Synchronisez à nouveau votre base de données :

$ python manage.py syncdb

Créez un fichier de migration de base de données avec South :

$ python manage.py schemamigration myapp --initial

Migrez les modifications apportées à la base de données :

$ python manage.py migrer myapp

Lancez le serveur (python manage.py runserver), puis accédez à http://127.0.0.1:8000/admin. Entrez le nom d'utilisateur et le mot de passe de votre superutilisateur pour vous connecter à la page d'administration. Il s'agit simplement d'un contrôle de cohérence pour s'assurer que tout fonctionne.

Engagez-vous dans Git. Par example:

$ git ajouter -A
$ git commit -am "paramètres mis à jour, application créée, sud ajouté, administrateur Django activé, boum"

Tout est prêt. Créons une application de base !

Django 1.7

Sorti pour la première fois le 2 septembre 2014, les nouvelles fonctionnalités les plus notables incluent :

  1. Migrations de bases de données: Django a maintenant un support intégré pour apporter des modifications de schéma de base de données, qui est basé sur South. C'est grand !
  2. Outils améliorés de vérification du système pour valider et vérifier vos projets
  3. Refactorisation de la façon dont Django identifie et charge les applications

Vous voulez lire les notes de version complètes ? Découvrez les changements officiels de Django ici.

La dernière version est sortie le 1er mai 2015 : v1.7.8

Installation de Django

Mettre en place une structure de développement :

$ mkdir django17_project
$ CD django17_projet
$ environnement virtuel
$ la source env/bin/activer

Tu devrais voir (env) avant votre invite, (env)$, indiquant que votre virtualenv est activé.

Pour désactiver le virtualenv :

Ensuite, réactivez-vous une fois que vous êtes prêt à recommencer à développer.

Avec votre virtualenv activé, installez Django avec Pip :

$ pip installer django==1.7.8

Vous pouvez vérifier la version en exécutant les commandes suivantes :

>>>

$ python
>>> importer django
>>> django.obtenir_version()
'1.7.8'
>>>

Configuration du projet

Configurer le projet Django

$ django-admin.py startproject my_django17_project

Cela crée un nouveau répertoire appelé "my_django17_project" avec le répertoire et les structures de base de Django :

manage.py
└── my_django17_project
    __init__.py
    settings.py
    urls.py
    wsgi.py

Contrôle de version

Avant de commencer tout développement, placez votre projet sous contrôle de version. Tout d'abord, ajoutez un .gitignore dans votre répertoire « django17_project », qui empêche l'ajout de fichiers inutiles au référentiel git.

Ajoutez les éléments suivants au fichier :

env
*.DS_Store
*.pyc
__pycache__

Maintenant, initialisez (ou créez) un nouveau référentiel Git et ajoutez vos modifications à la mise en scène, puis au référentiel.

$ git init
$ git ajouter -A
$ git commit -am "initiale"

Si vous utilisez GitHub, PUSH également vos fichiers vers votre référentiel central.

Paramètres de la base de données

Tout d'abord, installez MySQL-python pour que Python puisse parler à MySQL :

$ pip installer MySQL-python

Éditer paramètres.py dans votre répertoire « my_django17_project » :

BASES DE DONNÉES = 
    'défaut': 
        'MOTEUR': 'django.db.backends.mysql',
        'NOM': 'django_db',
        'UTILISATEUR': 'racine',
        'LE MOT DE PASSE': 'votre mot de passe',
    

Créez vos tables de base de données et configurez un superutilisateur :

$ CD mon_django17_projet
$ python manage.py migrer
$ python manage.py createsuperuser

Lancez le serveur de développement :

$ python manage.py runserver

Vous devriez voir la sortie suivante si tout va bien jusqu'à présent :

Effectuer des vérifications du système...

La vérification du système n'a identifié aucun problème (0 désactivé).
07 septembre 2014 - 19:51:01
Django version 1.7, en utilisant les paramètres 'my_django17_project.settings'
Démarrage du serveur de développement à l'adresse http://127.0.0.1:8000/
Quittez le serveur avec CONTROL-C.

Accédez à http://127.0.0.1:8000 et vous devriez voir le bleu clair familier "Cela a fonctionné!" page.

Tuez le serveur en appuyant sur CONTROL-C dans le terminal.

gel de pépins

Une fois les dépendances installées, utilisez la commande suivante pour en créer un enregistrement, ainsi que leurs versions ultérieures, dans le répertoire « my_django17_project » :

$ gel des pépins > requirements.txt

Cette commande est pratique lorsque vous devez recréer votre projet à partir de zéro. Vous pouvez simplement courir pip install -r requirements.txt pour installer toutes les dépendances de votre projet.

Validez vos nouvelles modifications dans Git.

Configurez votre application Django

Créez votre nouvelle application :

$ python manage.py startapp monapp

La structure de votre projet devrait maintenant ressembler à ceci :

manage.py
├── my_django17_project
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
monapplication
    __init__.py
    admin.py
    migrations
    │   └── __init__.py
    models.py
    tests.py
    vues.py

Mettez à jour les INSTALLED_APPS dans votre paramètres.py:

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'monapplication',
)

Lancez le serveur (python manage.py runserver), puis accédez à http://127.0.0.1:8000/admin. Entrez le nom d'utilisateur et le mot de passe de votre superutilisateur pour vous connecter à la page d'administration. Il s'agit simplement d'un contrôle de cohérence pour s'assurer que tout fonctionne.

S'engager dans Git. Par example:

$ git ajouter -A
$ git commit -am "paramètres mis à jour, application créée, boum"

Tout est prêt. Créons une application de base !

Django 1.8

Sorti pour la première fois le 1er avril 2015, les nouvelles fonctionnalités les plus notables incluent :

  1. Nouvelle fonctionnalité spécifique à PostgreSQL: Cela a ajouté de nouveaux ModelFields spécifiques à PostgreSQL – les champs ArrayField, HStoreField et Range. Consultez notre article de blog, Amusez-vous avec les nouvelles fonctionnalités Postgres de Django, pour plus d'informations.
  2. Plusieurs moteurs de modèles : vous pouvez maintenant utiliser Jinja !

Vous voulez lire les notes de version complètes ? Découvrez les changements officiels de Django ici.

La dernière version est sortie le 1er mai 2015 : v1.8.1

Installation de Django

Mettre en place une structure de développement :

$ mkdir django18_project
$ CD django18_project
$ environnement virtuel
$ la source env/bin/activer

Tu devrais voir (env) avant votre invite, (env)$, indiquant que votre virtualenv est activé.

Pour désactiver le virtualenv :

Ensuite, réactivez-vous une fois que vous êtes prêt à recommencer à développer.

Avec votre virtualenv activé, installez Django avec Pip :

$ pip installer django==1.8.1

Vous pouvez vérifier la version en exécutant les commandes suivantes :

>>>

$ python
>>> importer django
>>> django.obtenir_version()
'1.8.1'
>>>

Configuration du projet

Configurer le projet Django

$ django-admin.py startproject my_django18_project

Cela crée un nouveau répertoire appelé "my_django18_project" avec le répertoire et les structures de base de Django :

manage.py
└── my_django17_project
    __init__.py
    settings.py
    urls.py
    wsgi.py

Contrôle de version

Avant de commencer tout développement, placez votre projet sous contrôle de version. Tout d'abord, ajoutez un .gitignore dans votre répertoire « django18_project », qui empêche l'ajout de fichiers inutiles au référentiel git.

Ajoutez les éléments suivants au fichier :

env
*.DS_Store
*.pyc
__pycache__

Maintenant, initialisez (ou créez) un nouveau référentiel Git et ajoutez vos modifications à la mise en scène, puis au référentiel.

$ git init
$ git ajouter -A
$ git commit -am "initiale"

Si vous utilisez GitHub, PUSH également vos fichiers vers votre référentiel central.

Paramètres de la base de données

Tout d'abord, installez MySQL-python pour que Python puisse parler à MySQL :

$ pip installer MySQL-python

Éditer paramètres.py dans votre répertoire « my_django17_project » :

BASES DE DONNÉES = 
    'défaut': 
        'MOTEUR': 'django.db.backends.mysql',
        'NOM': 'django_db',
        'UTILISATEUR': 'racine',
        'LE MOT DE PASSE': 'votre mot de passe',
    

Créez vos tables de base de données et configurez un superutilisateur :

$ CD mon_django18_projet
$ python manage.py migrer
$ python manage.py createsuperuser

Lancez le serveur de développement :

$ python manage.py runserver

Vous devriez voir la sortie suivante si tout va bien jusqu'à présent :

Effectuer des vérifications du système...

La vérification du système n'a identifié aucun problème (0 désactivé).
19 mai 2015 - 09:52:02
Django version 1.8, en utilisant les paramètres 'my_django18_project.settings'
Démarrage du serveur de développement à l'adresse http://127.0.0.1:8000/
Quittez le serveur avec CONTROL-C.

Accédez à http://127.0.0.1:8000 et vous devriez voir le bleu clair familier "Cela a fonctionné!" page.

Tuez le serveur en appuyant sur CONTROL-C dans le terminal.

gel de pépins

Une fois les dépendances installées, utilisez la commande suivante pour en créer un enregistrement, ainsi que leurs versions ultérieures, dans le répertoire « my_django17_project » :

$ gel des pépins > requirements.txt

Cette commande est pratique lorsque vous devez recréer votre projet à partir de zéro. Vous pouvez simplement exécuter pip install -r requirements.txt pour installer toutes les dépendances de votre projet.

Validez vos nouvelles modifications dans Git.

Créer une application

Créons une application de base d'une seule page qui utilise la démarque pour afficher du texte.

Installer

Avec virtualenv activé, installez le package suivant pour rendre la démarque.

$ pip installer django-markdown-deux

Mettez à jour le fichier d'exigences pour inclure la nouvelle dépendance :

$ gel des pépins > requirements.txt

Ajoutez « markdown_deux » à paramètres.py:

INSTALLED_APPS = (

  ... couper ...

  'markdown_deux',
)

Créez un nouveau répertoire dans le « my_django1_project" répertoire appelé "templates", puis ajoutez le chemin d'accès au fichier settings.py* :

importer système d'exploitation
SETTINGS_DIR = système d'exploitation.chemin.dirname(__déposer__)
PROJECT_PATH = système d'exploitation.chemin.rejoindre(SETTINGS_DIR, système d'exploitation.pardir)
PROJECT_ROOT = système d'exploitation.chemin.abspathique(PROJECT_PATH)
TEMPLATE_DIRS = (
    système d'exploitation.chemin.rejoindre(PROJECT_ROOT, 'modèles'),
)

La structure de votre projet devrait ressembler à…

Ceci pour Django 1.5 et 1.6 :

manage.py
├── my_django1*_project
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
monapplication
│   ├── __init__.py
│   ├── migrations
│   │   ├── 0001_initial.py
│   │   └── __init__.py
│   ├── models.py
│   ├── tests.py
│   └── views.py
└── modèles

Ou ceci pour Django 1.7 :

manage.py
├── my_django17_project
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
monapplication
│   ├── __init__.py
│   ├── admin.py
│   ├── migrations
│   │   ├── __init__.py
│   ├── models.py
│   ├── tests.py
│   └── views.py
└── modèles

Vues et URL

Nous suivrons la structure de l'architecture Modèle-Vue-Contrôleur (MVC). Les projets Django s'organisent logiquement autour de cette architecture. Cependant, l'architecture de Django est légèrement différente dans la mesure où les vues agissent en tant que contrôleurs. Ainsi, les projets sont en fait organisés dans une architecture Model-Template-Views (MTV). Oui, c'est déroutant.

Vues

Ajoutez le code suivant au vues.py déposer:

de django.raccourcis importer render_to_response
de modèle.django importer Contexte de la demande


déf indice(demander):
    revenir render_to_response('index.html')

Cette fonction prend un paramètre, demander, qui est un objet contenant des informations sur l'utilisateur demandant la page au navigateur. La réponse de la fonction est de simplement rendre le index.html modèle.

URL

Ensuite, nous devons ajouter un nouveau modèle au urls.py déposer:

urlpatterns = motifs(
    '',
    URL(r'^admin/', inclure(administrateur.placer.URL)),
    URL(r'^$', 'myapp.views.index')
)

Pour plus d'informations sur la façon de générer des modèles d'URL, veuillez consulter la documentation officielle de Django.

Modèles

Enfin, nous devons créer le index.html modèle. Créez un nouveau fichier appelé index.html dans le répertoire des modèles, et ajoutez le code trouvé ici.

Allumez le serveur. A quoi ça ressemble ? Ajoutons quelques styles.

Remplacez le code précédent par le code ici.

Mieux?

Conclusion

Finissez d'ajouter des styles et du contenu comme bon vous semble. Revenez ensuite à la section Workflow pour terminer le processus de développement. Si vous avez besoin d'aide, veuillez acheter Real Python. Ou faites-le de toute façon pour aider à soutenir ce projet open source. Merci. Acclamations!.

Résumé du flux de travail

Ce qui suit est un workflow de base que vous pouvez utiliser comme référence rapide pour développer un projet Django.

Installer

  1. Dans un nouveau répertoire, créez et activez un fichier virtualenv.
  2. Installez Django.
  3. Créez votre projet : django-admin.py startproject
  4. Créez une nouvelle application : python manage.py startapp
  5. Ajoutez votre application au tuple INSTALLED_APPS.

Ajouter des URL et des vues de base

  1. Cartographiez votre projet urls.py fichier dans la nouvelle application.
  2. Dans votre répertoire App, créez un urls.py fichier pour définir les URL de votre application.
  3. Ajoutez des vues, associées aux URL, dans le vues.py; assurez-vous qu'ils retournent un Réponse HTTP objet. Depending on the situation, you may also need to query the model (database) to get the required data back requested by the end user.

Templates and Static Files

  1. Create a templates et static directory within your project root.
  2. Update settings.py to include the paths to your templates.
  3. Add a template (HTML file) to the templates directory. Within that file, you can include the static file with – % load static % et % static "filename" %. Also, you may need to pass in data requested by the user.
  4. Update the views.py file as necessary.

Models and Databases

  1. Update the database engine to settings.py (if necessary, as it defaults to SQLite).
  2. Create and apply a new migration.
  3. Create a super user.
  4. Add an admin.py file in each App that you want access to in the Admin.
  5. Create your models for each App.
  6. Create and apply a new migration. (Do this whenever you make quelconque change to a model).

Forms

  1. Create a forms.py file at the App to define form-related classes; define your ModelForm classes here.
  2. Add or update a view for handling the form logic – e.g., displaying the form, saving the form data, alerting the user about validation errors, etc.
  3. Add or update a template to display the form.
  4. Add a urlpattern in the App’s urls.py file for the new view.

User Registration

  1. Create a UserForm
  2. Add a view for creating a new user.
  3. Add a template to display the form.
  4. Add a urlpattern for the new view.

User Login

  1. Add a view for handling user credentials.
  2. Create a template to display a login form.
  3. Add a urlpattern for the new view.

Setup the template structure

  1. Find the common parts of each page (i.e., header, sidebar, footer).
  2. Add these parts to a base template
  3. Create specific. templates that inherent from the base template.

Django Learning Resources Pack

Django is an amazing web development framework that we use every day at Real Python (realpython.com is powered by Django).

Django can make you a highly productive Python web developer—if you get the basics right and avoid some of the common pitfalls.

That’s why we’ve put together this free “Django resource pack” you can use to dig deeper: