L'icône rouge permet de télécharger chaque page du wiki visitée au format PDF et la grise au format ODT →

Ceci est une ancienne révision du document !

Table des matières

Configurations et installation de Django avec SQLite3
Configurations et installation de Django avec PostgreSQL

Développer en Python avec Django

Objet : Installer un environnement virtuel avec python3 pour utiliser Django
essayer un mini projet avec chacune des différentes bases de données supportées par ORM de Django.
Niveau requis :
débutant

Configurations et installation de Django avec SQLite3

Activer Python3 sur Jessie

Pour tout le système avec update-alternatives :

update-alternatives --list python

update-alternatives: error: no alternatives for python

Charger les différentes versions de Python :

- Pour voir où sont les versions de python disponibles :

 ls /usr/bin/python*

/usr/bin/python            /usr/bin/python3            /usr/bin/python3-config
/usr/bin/python2           /usr/bin/python3.4          /usr/bin/python3m
/usr/bin/python2.7         /usr/bin/python3.4-config   /usr/bin/python3m-config
/usr/bin/python2.7-config  /usr/bin/python3.4m         /usr/bin/python-config
/usr/bin/python2-config    /usr/bin/python3.4m-config

- Pour ajouter à la liste de update-alternatives les deux versions de python disponibles :
(ici par exemple; “/usr/bin/python2.7” et “/usr/bin/python3.4 ”)

update-alternatives --install /usr/bin/python python /usr/bin/python2.7 1

update-alternatives --install /usr/bin/python python /usr/bin/python3.4 2

- Pour voir la nouvelle liste de update-alternatives :

update-alternatives --list python

 /usr/bin/python2.7
 /usr/bin/python3.4

- Pour basculer de l'une à l'autre version de Python :

update-alternatives --config python

Si l'on choisit d'utiliser Python3 pour tout le système, il faudra prendre garde de bien installer les outils python3 et non python2 :\

Il faudra lancer :

python3-pip python3-dev

et non :

python-pip python-dev

Il est possible de laisser la version Python 2 pour tout le système et d'utiliser la version 3 pour l'environnement de l'utilisateur courant.

Pour ce faire on choisit la version de Python2 pour tout le système :

update-alternatives --config python

Il existe 2 choix pour l'alternative python (qui fournit /usr/bin/python).
 
  Sélection   Chemin              Priorité  État
------------------------------------------------------------
* 0            /usr/bin/python3.4   2         mode automatique
  1            /usr/bin/python2.7   1         mode manuel
  2            /usr/bin/python3.4   2         mode manuel
 
Appuyez sur <Entrée> pour conserver la valeur par défaut[*] ou choisissez le numéro sélectionné :1

python --version

Python 2.7.9

On configure Python3 pour l'utilisateur courant :

- On édite le fichier “~/bashrc” :

vim ~/.bashrc

- On ajoute cet alias :

alias python='/usr/bin/python3.4'

- On enregistre puis on actualise l'environnement de l'utilisateur courant :

. ~/.bashrc

python --version

Python 3.4.2

Pourquoi conserver deux versions de python ? :

- On choisit d'activer Python3 que pour l'utilisateur courant et Python2 pour tout le système :

Ce choix est bon dans le cas où l'on veut s'exercer au code Python qui diffère entre les deux versions. On peut par exemple, se créer un utilisateur qui utilisera Python2

- On veut apprendre à coder en python directement avec le framework Django :

Il faut alors choisir une unique version de Python pour tout le système, car comme dit plus haut,
les outils python2.xx ou python3.xx servant à utiliser Django s'installent en tant que root pour tout le système. Or l'installation pour tout le système des outils python2 et des des outils python3 génère des conflits.

L'utilisation d'un environnement python virtuel (virtualen) (voir plus bas) permet l'utilisation de versions différentes au sein de la même version principale ; (python2.2 et python2.7 ou python3.1 et python3.2).

Pour la suite de ce tuto : python3 pour tout le système :

update-alternatives --config python

Il existe 2 choix pour l'alternative python (qui fournit /usr/bin/python).
 
  Sélection   Chemin              Priorité  État
------------------------------------------------------------
  0            /usr/bin/python3.4   2         mode automatique
* 1            /usr/bin/python2.7   1         mode manuel
  2            /usr/bin/python3.4   2         mode manuel
 
Appuyez sur <Entrée> pour conserver la valeur par défaut[*] ou choisissez le numéro sélectionné :0

python --version

Python 3.4.2

Pour supprimer l'un des choix de la liste :

update-alternatives --remove python /usr/bin/python2.7

Installer les outils python nécessaires à l'installation d'un projet Django :

apt-get install python3-pip python3-dev virtualenv

python3-pip est un installateur de paquets python, Pip permet d'installer aisément des modules Python, à la manière dont on installe des paquets dans une distribution linux;
python3-dev : permet d'utiliser des outils de développement pour la construction des modules Python, non pris en charge par pip, en particulier pour utiliser des bibliothèques avec des extensions en C
virtualenv : permet de créer un environnement cloisonné Python

À consulter : https://virtualenv.readthedocs.org/en/latest/

Installer Django dans un environnement python virtuel

On créer un répertoire par exemple sur son bureau :

cd ~/Bureau

virtualenv PremiersProjetsDjango

Cela a crée une dossier nommé “PremiersProjetsDjango” sur le bureau de l'utilisateur courant

on se place dans le dossier "PremiersProjetsDjango"

cd PremiersProjetsDjango/

ls

Il contient trois dossiers permettant d'utiliser python :

python     python3    python3.4

On active l'environnement virtuel python

source bin/activate

Pour sortir de l'environnement virtuel python :

deactivate

On installe Django

pip3 install django

Et pour vérifier tout en prenant connaissance de la version de django installée :

(selon la méthode proposer par la doc officielle de Django : https://docs.djangoproject.com/fr/1.8/intro/tutorial01/)

python3 -c "import django; print(django.get_version())"

1.9

Tout est bien clair ?

deactivate

python3 -c "import django; print(django.get_version())"

Traceback (most recent call last):
  File "<string>", line 1, in <module>
ImportError: No module named 'django'

source bin/activate

python3 -c "import django; print(django.get_version())"

1.9

Pour avoir la liste de tous les modules python installés dans son environnement :

pip freeze

Django==1.9
wheel==0.24.0

Manuel officiel de pip : https://pip.pypa.io/en/stable/user_guide/

Création d'un premier projet Django

Un petit rappel ?

On a crée un dossier par exemple sur son bureau pour l'environnement virtuel python “virtualenv PremiersProjetsDjango”;
Dans ce dossier on a activé python “source bin/activate” ;
On a installé Django.

À partir de là pour créer un projet Django, il faut aller dans le dossier de l'environnement virtuel python et activer python :

cd ~/Bureau/PremiersProjetsDjango/

source bin/activate

python3 -c "import django; print(django.get_version())"

Le contenu de son dossier avant création d'un nouveau projet:

pwd

/home/hypathie/Bureau/PremiersProjetsDjango

ls

bin  include  lib

Pour créer un nouveau projet nommé par exemple “premierProjet”:

django-admin.py startproject premierProjet

ls

bin  include  lib  premierProjet

Architecture du dossier premierProjet :

cd premierProjet/

manage.py  premierProjet

cd premierProjet/

__init__.py  settings.py  urls.py  wsgi.py

Avec la commande tree :

tree premierProjet/

premierProjet/
├── manage.py
└── premierProjet
    ├── __init__.py
    ├── settings.py
    ├── urls.py
    └── wsgi.py

Ces fichiers sont :

premierProjet/ c'est le répertoire racine qui est le contenant du projet nouvellement créé.

manage.py est un utilitaire en ligne de commande qui vous permet d’interagir avec ce projet Django de différentes façons. Vous trouverez toutes les informations nécessaires sur manage.py dans django-admin et manage.py.

Le sous-répertoire premierProjet/ correspond au paquet Python effectif de votre projet. C’est le nom du paquet Python que vous devrez utiliser pour importer ce qu’il contient.

premierProjet/init.py : un fichier vide qui indique à Python que ce répertoire doit être considéré comme un paquet (lisez informations sur les paquets (en) dans la documentation officielle de Python si vous êtes débutant avec ce langage).

premierProjet/settings.py : réglages et configuration de ce projet Django. Les réglages de Django vous apprendra tout sur le fonctionnement des réglages.

premierProjet/urls.py : les déclarations des URL de ce projet Django, une sorte de « table des matières » de votre site Django. Vous pouvez en lire plus sur les URL dans Distribution des URL.

premierProjet/wsgi.py : un point d’entrée pour les serveurs Web compatibles WSGI pour déployer votre projet. Voir Comment déployer avec WSGI pour plus de détails.

Pour plus de détails voir la doc officielle de Django : https://docs.djangoproject.com/fr/1.8/intro/tutorial01/

Premier test

On se place à la racine du nouveau projet :

cd ~/Bureau/PremiersProjetsDjango/premierProjet/

python3 manage.py runserver

Performing system checks...
 
System check identified no issues (0 silenced).
 
You have unapplied migrations; your app may not work properly until they are applied.
Run 'python manage.py migrate' to apply them.
 
December 03, 2015 - 12:43:53
Django version 1.9, using settings 'premierProjet.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Rien de grave dans ce retour. Django prévient qu'aucune base de données n'a été migrée. Ce n'est pas important pour ce premier test.

Depuis son navigateur on entre dans la barre url: “http://localhost:8000/”

On obtient :

Premier projet avec la base de données sqlite3

Par défaut, Django utilise la base de donnée sqlite3 :

~/Bureau/PremiersProjetsDjango/premierProjet/premierProjet

vim settings.py

...
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}
...

ENGINE – Par défaut avec sqlite3 : 'django.db.backends.sqlite3'.
D’autres moteurs sont également disponibles :
Pour utiliser PoesgreSql : 'django.db.backends.postgresql_psycopg2' ;
Pour utiliser MySql: 'django.db.backends.mysql';
Pour utiliser Oracle : 'django.db.backends.oracle'.

NAME – Le nom de votre base de données. Avec SQLite, la base de données est un fichier sur votre ordinateur.
Dans ce cas, NAME doit être le chemin absolu complet de celui-ci, y compris le nom de fichier.
La valeur par défaut, os.path.join(BASE_DIR, 'db.sqlite3'), stocke ce fichier dans le répertoire de votre projet.

Modifier le fichier settings.py et Générer le fichier de base de données SQLite

Modifier les paramètres :

LANGUAGE_CODE = 'fr-fr'

TIME_ZONE = 'Europe/Paris'

Avant migration :

tree 
.
├── manage.py
└── premierProjet
    ├── __init__.py
    ├── __pycache__
    │   ├── __init__.cpython-34.pyc
    │   ├── settings.cpython-34.pyc
    │   ├── urls.cpython-34.pyc
    │   └── wsgi.cpython-34.pyc
    ├── settings.py
    ├── urls.py
    └── wsgi.py

On lance la commande de migration :

python3 manage.py migrate

Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
  Rendering model states... DONE
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying contenttypes.0002_remove_content_type_name... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  Applying auth.0005_alter_user_last_login_null... OK
  Applying auth.0006_require_contenttypes_0002... OK
  Applying auth.0007_alter_validators_add_error_messages... OK
  Applying sessions.0001_initial... OK

Après migration :

tree 
.
├── db.sqlite3
├── manage.py
└── premierProjet
    ├── __init__.py
    ├── __pycache__
    │   ├── __init__.cpython-34.pyc
    │   ├── settings.cpython-34.pyc
    │   ├── urls.cpython-34.pyc
    │   └── wsgi.cpython-34.pyc
    ├── settings.py
    ├── urls.py
    └── wsgi.py

L'exécution de la commande “manage.py migrate” a permis :

de créer à la racine le fichier de base de données nommé par défaut “db.sqlite3”;
elle a ajouté au fichier “settings.py ” dans la section “INSTALLED_APPS” la ligne : 'polls',

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

À savoir : La commande “makemigrations” permet de mettre à jour les polls (sorte de script SQL), à partir d'un modèle s'il en existe (voir plus bas).

python3 manage.py makemigrations

No changes detected

Création de Modèle (c'est presque du code first !)

On se place dans le répertoire “~/Bureau/PremiersProjetsDjango/premierProjet” :

cd ~/Bureau/PremiersProjetsDjango/premierProjet

On utilise manage.py pour créé l'arborescence nécessaire à l'utilisation de Modèle :

python3 manage.py startapp polls

Cela a crée le répertoire polls à la racine du dossier consacré au projet django :

pwd

/home/hypathie/Bureau/PremiersProjetsDjango/premierProjet

tree

.
├── db.sqlite3
├── manage.py
├── polls
│   ├── admin.py
│   ├── apps.py
│   ├── __init__.py
│   ├── migrations
│   │   ├── 0001_initial.py
│   │   ├── __init__.py
│   │   └── __pycache__
│   │       ├── 0001_initial.cpython-34.pyc
│   │       └── __init__.cpython-34.pyc
│   ├── models.py
│   ├── __pycache__
│   │   ├── admin.cpython-34.pyc
│   │   ├── __init__.cpython-34.pyc
│   │   └── models.cpython-34.pyc
│   ├── tests.py
│   └── views.py
└── premierProjet
    ├── __init__.py
    ├── __pycache__
    │   ├── __init__.cpython-34.pyc
    │   ├── settings.cpython-34.pyc
    │   ├── urls.cpython-34.pyc
    │   └── wsgi.cpython-34.pyc
    ├── settings.py
    ├── urls.py
    └── wsgi.py

On crée des Modèles dans le fichier models.py :

vim polls/models.py

import datetime

from django.db import models
from django.utils import timezone

# Create your models here.

class Question(models.Model):
    question_text = models.CharField(max_length=200)
    pub_date = models.DateTimeField('date published')
    def __str__(self):
        return self.question_text
    def was_published_recently(self):
        return self.pub_date >= timezone.now() - datetime.timedelta(days=1)


class Choice(models.Model):
    question = models.ForeignKey(Question)
    choice_text = models.CharField(max_length=200)
    votes = models.IntegerField(default=0)
    def __str__(self):
        return self.choice_text

Cette fois la commande “makemigrations” ci-dessous, va créer un script de type SQL de creation et/ou mise à jour de la base de données associées au projet, par défaut ce script est le fichier “polls/migrations/0001_initial.py” :

python3 manage.py makemigrations polls

Migrations for 'polls':
  0001_initial.py:
    - Create model Choice
    - Create model Question
    - Add field question to choice

L'ORM de Django permet de générer un script de création de base de données avec tables, noms et types des champs, clés primaires et cardinalités…
Pour voir le script créé à partir des Modèles python (classe):

python3 manage.py sqlmigrate polls 0001

Mais c'est la commande suivante qui applique les changements apportés aux Models dans la base de données :

python3 manage.py migrate

Il est ensuite possible d'interroger la base de donnée depuis le shell en utilisant les méthodes du Modèle
Sur “migrate” : https://docs.djangoproject.com/fr/1.8/intro/tutorial01/#database-setup
Sur “manage.py” : https://docs.djangoproject.com/fr/1.8/ref/django-admin/
Explication sur ORM : http://apprendre-python.com/page-django-orm-apprendre-base-donnees-database-queryset-modeles
Explication sur API : http://sametmax.com/quest-ce-quune-api/

Pour utiliser l'API Django depuis un shell python :

python3 manage.py shell

Pour s'exercer : https://docs.djangoproject.com/fr/1.8/intro/tutorial01/#playing-with-the-api

Création d'un administrateur Django

On se place de le dossier de son projet Django :

cd ~/Bureau/PremiersProjetsDjango/premierProjet/

On crée un administrateur :

python3 manage.py createsuperuser

Username (leave blank to use 'hypathie'): Hypathie
Email address: hypathie@gmx.fr
Password: 
Password (again): 
Superuser created successfully.

Et maintenant on peut accéder à la gestion de son projet depuis son navigateur :

python3 manage.py runserver 192.168.0.26:8000

Modifier 192.168.0.26 par l'ip de la machine sur laquelle le projet est installé.

Pour le savoir :

ifconfig

remarques :

On peut aussi taper dans son navigateur :
localhost:8000 ou 0.0.0.0:8000 si l'on a lancé :
python3 manage.py runserver 0.0.0.0:8000
L'avantage de l'ip de la machine c'est de pouvoir se connecter à son application depuis son navigateur depuis une machine distante.

On tape dans son navigateur par exemple :

192.168.0.26:8000/admin

Pour apprendre à gérer son site depuis le site d'administration de Django : https://docs.djangoproject.com/fr/1.8/intro/tutorial02/

Le création des Vues : https://docs.djangoproject.com/fr/1.8/intro/tutorial03/#writing-your-first-django-app-part-3

Factoriser son code Python : https://docs.djangoproject.com/fr/1.8/intro/tutorial04/#writing-your-first-django-app-part-4

Tests automatisés : https://docs.djangoproject.com/fr/1.8/intro/tutorial05/

Utiliser du Javascript, du CSS avec Django : https://docs.djangoproject.com/fr/1.8/intro/tutorial06/#writing-your-first-django-app-part-6

Configurer Vim pour Python

On installe curl

apt-get install curl

On installe git :

apt-get install git-core

On installe pathogen

Voir : https://github.com/search?utf8=%E2%9C%93&q=pathogen

mkdir -p ~/.vim/autoload ~/.vim/bundle && \
curl -LSso ~/.vim/autoload/pathogen.vim https://tpo.pe/pathogen.vim

On crée et édite un fichier caché ~/.vimrc :

vim ~/.vimrc

execute pathogen#infect()
syntax on
filetype plugin indent on

pathogen va chercher dans le répertoire bundle les plugin qu'on lui a installé et les utiliser comme si on les avait installé dans le fichier .vimrc

On installe le module nerdtree :

Voir : https://github.com/scrooloose/nerdtree

git clone https://github.com/scrooloose/nerdtree.git ~/.vim/bundle/nerdtree

Principales commandes de NERD Tree :

  t: Ouvrir le fichier sélectionné dans un nouvel onglet
  i: Ouvrez le fichier sélectionné dans une fenêtre fissure verticale
  s: Open the selected file in a vertical split window
  I: Commutation de fichiers cachés
  m: Pour faire apparaître un menu qui vous permettra d'ajouter rapidement, déplacer(=renomer), copier et supprimer des nœuds (ou fichiers).
  R: Actualiser l'arbre, utile si les fichiers ont changés en dehors de Vim
  ?: Commutation entre l'aide rapide et l'explorateur NERD Tree 
  Ctrl +w puis w: Passer de l'explorateur NERD Tree à la fenêtre d'édition des fichiers

On installe vim-airLine améliorer le statusline.

git clone https://github.com/bling/vim-airline.git ~/.vim/bundle/vim-airline

On ajoute la ligne suivante dans ~./vimrc :

let g:airline#extensions#tabline#enabled = 1

Après avoir ouvert plusieurs fichiers, pour passer d'un fichier à l'autre, le curseur entant placé dans l'encadré d'édition d'un fichier:

On peut utiliser la commande vim :register puis on choisit son buffer ;
On peut faire :bn (pour Buffer Next) ou :bp (pour Buffer Prevous) ;

On peut se faire un racourcit :

On édite ~/.vimrc
on ajoute :

nmap <C-n> :bn<CR>
nmap <C-p> :bp<CR>

Pour utiliser la souris

set mouse=a

Utilisation de la souris pour naviger entre les fenêtres, et sélectionner dans une seule fenêtre (i.e mode visuel de vim)

On édite ~/.vimrc

On ajoute :

set mouse=a

On ajoute le plugin syntastic

Voir : https://github.com/scrooloose/syntastic

git clone https://github.com/scrooloose/syntastic.git ~/.vim/bundle/syntastic

On ajoute le plugin tagbar

git clone https://github.com/majutsushi/tagbar.git ~/.vim/bundle/tagbar

Ajout dans ~/.vimrc

"Racourci clavier pour basculer avec Tagbar
nmap <F2> :TagbarToggle<CR>

Ajout de l'autocomplétion :