Comment configurer et utiliser l'interpréteur Python

L'invité interactif Python

L'invité interactif permet d'interagir avec l'interpréteur Python à partir d'une console. Une fois lancé, il est dès lors possible de taper du code Python au fur et à mesure. Une ligne de l'invité interactif commence toujours par les caractères >>> où bien ... selon l'indentation.

$ python
Python 2.6.5 (r265:79063, Apr 16 2010, 13:09:56)
[GCC 4.4.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> prompt = "invité"
>>> if prompt:
...     print prompt
...
invité
>>>

Pour sortir du mode invité interactif Python, nous allons taper Ctrl+D sous linux. Puisque le mode d'invité interactif joue un rôle important dans le développement du code Python, nous avons intérêt à le personnaliser pour une utilisation plus efficace. Ceci est expliqué dans le paragraphe suivant.

Le fichier de démarrage de l'interpréteur Python

L'invité interactif peut être configuré avec un fichier de démarrage. Quand il est lancé, l'invité interactif recherche la variable d'environnement PYTHONSTARTUP et exécute le code qui réside dans le fichier pointé par cette variable. Certaines distributions Linux fournissent un script de démarrage par défaut, qui est généralement situé dans le répertoire home; ce script est appelé .pythonstartup. Des fonctionnalités, telles que l'achèvement de mots par la touche tab, l'historique des commandes, sont souvent fournis pour améliorer l'invité interactif. Elles sont basées sur le module readline, qui est donc requis. Il est aussi possible de créer un script simple de démarrage comme en suit:

import readline
import rlcompleter
import atexit
import os
# tab completion
readline.parse_and_bind('tab: complete')
# history file
histfile = os.path.join(os.environ['HOME'], '.pythonhistory')
try:
    readline.read_history_file(histfile)
except IOError:
    pass
atexit.register(readline.write_history_file, histfile)
del os, histfile, readline, rlcompleter

Sous Linux, le moyen le plus simple est de créer ce script de démarrage dans le répertoire home en l'appelant .pythonstartup. Ensuite, ajouter une variable PYTHONSTARTUP dans l'environnement de travail pour pointer vers ce fichier .pythonstartup. Par exemple, bash utilise le fichier .profile (ou plutôt .bashrc), où nous pouvons initialiser la variable PYTHONSTARTUP par l'insertion d'une ligne telle que:

export PYTHONSTARTUP=~/.pythonstartup

Lorsque l'invité interactif est lancé, le script .pythonstartup devrait être exécuté et les nouvelles fonctionnalités disponibles. Par exemple, l'achèvement de mots par la touche tab est vraiment utile pour visualiser le contenu d'un module:

>>> import hashlib
>>> hashlib.<tab>
hashlib.__class__(                  hashlib.__loader__       hashlib.__subclasshook__(
hashlib.__delattr__(                hashlib.__name__         hashlib._hashlib
hashlib.__dict__                    hashlib.__new__(         hashlib.md5(
hashlib.__doc__                     hashlib.__package__      hashlib.new(
hashlib.__file__                    hashlib.__py_new(        hashlib.sha1(
hashlib.__format__(                 hashlib.__reduce__(      hashlib.sha224(
hashlib.__get_builtin_constructor(  hashlib.__reduce_ex__(   hashlib.sha256(
hashlib.__getattribute__(           hashlib.__repr__(        hashlib.sha384(
hashlib.__hash__(                   hashlib.__setattr__(     hashlib.sha512(
hashlib.__hash_new(                 hashlib.__sizeof__(
hashlib.__init__(

Un invité interactif avancé

On peut adapter le script de démarrage .pythonstartup pour plus d'automatisation. En outre, le module code fournit les classes de base de l'interpréteur. Par contre il existe déjà un invité interactif avancé, IPython, avec des fonctionnalités telles que l'introspection dynamique d'objets, l'accès au terminal système à partir de l'invité, des outils de débogage, etc.

Lancement de l'interpréteur Python par le terminal

Lors du lancement de l'interpréteur Python par le terminal, on a accès à un certain nombre d'options:

$ python [-dEiOQsStuvVxX3?] [-c command | -m module-name | script | - ] [args]
$ python -V
Python 2.6.5

Tout argument suivant la commande python est disponible dans sys.argv, avec comme premier élément sys.argv[0]. Le cas d'utilisation le plus courant de l'interpréteur Python est, bien sûr, une simple invocation du nom de fichier d'un script Python. Dans ce cas, l'interpréteur Python lit et exécute un script à partir de ce fichier:

$ python script.py [args]

Lorsqu'il est lancé avec -c command, il exécute les instructions Python données comme command. command peut contenir des déclarations multiples séparées par des sauts de ligne, en tenant compte des espaces nécessaires en début de ligne. Si cette option est utilisée, le premier élément de sys.argv sera -c et le répertoire courant sera ajouté au début de sys.path, permettant aux modules dans ce répertoire d'être importés.

$ python -c """
> a=2; b=3
> if a: print a+b"""
5
$

Lorsque l'interpréteur Python est appelé avec -m module-name, le module donné est localisé sur les chemins d'importation des modules Python et exécuté comme un script. Le nom du module donné ne contiendra pas la terminaison .py.

$ python -m module [args]

Avec l'option -i on peut toute à la fois lancer un script python, l'exécuter, lancer l'invité interactif Python et pouvoir accéder aux attributs du script. Considérons par exemple un fichier dans le répertoire courant, nommé interpreteur.py, contenant le script suivant:

#!/usr/local/bin/python2.7
# -*- coding: utf-8 -*-
#
# Copyright 2012 RasadaCrea. Droits réservés
un_string = 'string'
un_entier = 11
un_arg = 'un_arg_de_fonction'
def une_fonction(un_arg):
    return un_arg
class UneClasse:
    pass
une_instance = UneClasse()
print '%s - %d - %s - %s' % (un_string, un_entier, une_fonction(un_arg), une_instance)

Le lancement de ce script en console, avec l'option -i donnerait ceci:

$ python -i interpreteur.py
string - 11 - un_arg_de_fonction - <__main__.UneClasse instance at 0xb738ca0c>
>>> vars()
{'un_entier': 11, '__builtins__': <module '__builtin__' (built-in)>,
 'UneClasse': <class __main__.UneClasse at 0xb7382a7c>, '__package__': None,
 'une_instance': <__main__.UneClasse instance at 0xb738ca0c>,
 'un_arg': 'un_arg_de_fonction', '__name__': '__main__', '__doc__': None,
 'un_string': 'string', 'une_fonction': <function une_fonction at 0xb737da74>}
>>> un_entier
11
>>> une_fonction
<function une_fonction at 0xb737da74>
>>> une_fonction('un autre argument')
'un autre argument'
>>> une_instance
<__main__.UneClasse instance at 0xb738ca0c>