Python, de zéro

L’interpréteur Python (nommé « python ») est habituellement installé dans le dossier « /usr/bin » sur les machines Unix où il est disponible (quasiment toutes). En vérifiant que le dossier « /usr/bin » est bien présent dans le PATH de votre shell Unix (généralement il y est par défaut), cela vous permettra de lancer l’interpréteur Python en tapant la commande « python ».

python

Sous les systèmes Windows, Python n’est pas nativement présent et doit alors être installé manuellement par l’utilisateur qui désire l’utiliser. Le choix du dossier d’installation est libre, mais dans les versions Python 2, le dossier habituel « C:\Program Files » était déconseillé dans la mesure où certaines bibliothèques Python 2 n'appréciaient pas la présence d’espaces dans le chemin du dossier d’installation. Les bibliothèques Python 3 semblent aujourd’hui avoir réglé ce souci.

Par défaut, les versions de Python 3 s’installent dans « C:\Program Files\Python3X » et les versions de Python 2 s’installent dans « C:\Python2X » (X étant dans à chaque fois le n° de la release).

Tout comme pour Unix, il est nécessaire que ce dossier d’installation soit inscrit dans le PATH de Windows. Néanmoins, les dernières versions Python vous proposent de le faire pour vous à l’installation.

Sous les systèmes de type MacOs, Python est pour l’instant installé par défaut, mais d’une part c’est la version 2.7 qui est installée ; et d’autre part il ne sera plus installé par défaut dans les nouvelles moutures d’Apple. Dans cet OS, ceux qui veulent Python 3 doivent donc aussi l’installer manuellement. Toutefois, ceux qui ont l’ordinateur connecté à Internet peuvent alors taper la commande python3 afin que le système aille automatiquement le chercher et l’installer. Ensuite, tout nouvel appel à la commande python3 permettra de lancer l’interpréteur Python.

Lorsque l’interpréteur est lancé, Python est dit être en mode interactif. Dans ce mode, il attend ses instructions avec un prompt primaire composé généralement de trois signes « supérieur » (>>>) ; et pour les instructions demandant plusieurs lignes, il affiche ensuite un prompt secondaire, composé de trois points (...).

À son lancement, l’interpréteur affiche un message de bienvenue indiquant son numéro de version et une notice de copyright avant d’afficher le prompt primaire permettant de taper la première instruction Python.

Python 3.4.2 (default, Oct  8 2014, 10:45:20)
[GCC 4.9.1] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Exécution d’une première instruction simple avec son résultat directement affiché…

>>> 2 + 2
4
>>>

… et d’une instruction multilignes. On notera l’obligation de protéger la fin de ligne par un backslash (\) pour éviter que cette fin de ligne soit comprise par l’interpréteur comme la fin de l’instruction ; ainsi que l’apparition du prompt secondaire (...).

>>> 2+\
... 3
5
>>>

À noter : comme on le voit dans ces exemples, les résultats des calculs et expressions sont directement affichés après exécution. C'est une caractéristique du mode interactif qui n'existe plus dans le mode script (sera vu un peu plus bas).

Une fonction est un mécanisme permettant d’encapsuler un travail spécifique dans un nom logique individuel (nom de la fonction). Offrant ainsi à l’utilisateur la possibilité de faire exécuter le travail en appelant simplement la fonction par son nom.

L'appel est activé par l'utilisation de parenthèses placées après le nom de la fonction. Et dans les parenthèses seront placés les paramètres éventuels permettant à la fonction d'adapter son action au contexte de l’appelant.

Python possède en natif toute une masse de fonctions internes directement utilisables par le programmeur. Exemple la fonction print() permettant d'afficher une valeur à l'écran…

>>> print(2 + 2)
4
>>> print(2 + 3)
5
>>> print("Hello World !!!")
Hello World !!!
>>> print("Hello\
... World !!!")
Hello World !!!
>>> print()

>>>

On verra plus tard comment créer nos propres fonctions.

Le mode interactif, utile pour tester des instructions simples, montrera vite ses limites pour produire des codes complexes. Une autre façon de faire (plus classique chez les développeurs) sera de créer un fichier texte (d’extension conventionnellement définie à « .py ») pour y inscrire l’ensemble des instructions composant un programme Python.

Ce fichier sera alors considéré comme un code source Python. Une fois écrit, il suffira d'appeler l'interpréteur en lui demandant de traiter le fichier pour que Python exécute les instructions s’y trouvant.

Exemple (depuis un shell Unix) :

PromptUnix> vi prog.py

PromptUnix> python prog.py
Hello World !!!

print("Hello World !!!")

Il est possible de demander à l’interpréteur d’activer l’optimisation interne de Python avec l’option ‑O passée lors de l’appel. À ce moment‑là, certains tests de vérification comme les assertions sont alors ignorés.

Exemple (depuis un shell Unix) : demande à l'interpréteur Python d'exécuter le script en mode optimisé

PromptUnix> python –O prog.py
Hello World !!!

Généralement, un script Python commence par la ligne #!/usr/bin/env python. Cette ligne indique au système d'exploitation d'associer le contenu du script à l'interpréteur Python de son environnement. Ce qui permet ensuite d'appeler directement le script comme si c'était un exécutable (plus besoin alors de mettre python devant le nom du script lors de l’appel).

Exemple :

PromptUnix> ./prog.py
Hello World !!!

#!/usr/bin/env python
print("Hello World !!!")

Toutefois, dans cette forme d’appel, il n’est alors plus possible d’activer l’optimiseur. De plus, quand on exécute un script contenant cette ligne #!/usr/bin/env python, l’interpréteur Python utilisé dans ce cas sera l’interpréteur défini par défaut sur la machine sur laquelle le script est exécuté. Et cet interpréteur est alors fonction des choix de l’administrateur de la machine. Si celui‑ci a choisi Python 2, alors c’est Python 2 qui sera exécuté. Et s’il a positionné Python 3, alors c’est Python 3 qui sera exécuté.

Il est quand même possible de forcer le Python de son choix (s’il est disponible) en spécifiant la version voulue de façon explicite (#!/usr/bin/env python2 ou #!/usr/bin/env python3).

Par ailleurs, un script est considéré comme écrit en ASCII. Si ce n'est pas le cas (comme avec les éditeurs modernes qui ont tous pris l'option « utf‑8 » par défaut), l’interpréteur Python s’arrêtera en échec en arrivant sur une instruction contenant une chaîne accentuée.

Pour lui préciser que le script est encodé en « utf‑8 », il faut rajouter la ligne # coding: utf‑8 ou # ‑*‑ coding: utf‑8 ‑*‑ (ancienne syntaxe) en seconde ligne.

Exemple :

#!/usr/bin/env python
# coding: utf-8
print("Hello World !!!")

#!/usr/bin/env python
# -*- coding: utf-8 -*-
print("Hello World !!!")

Cette syntaxe n'est bien entendu pas limitée au seul encodage « utf‑8 » et fonctionne avec tous les encodages disponibles de votre OS.

Un commentaire sert à améliorer la lisibilité du programme. Il est placé en le faisant précéder du caractère dièse (#). Tout ce qui suit ce dièse est ignoré jusqu'à la fin de la ligne ; ce qui permet de mettre un commentaire sur une ligne d'instructions. Dans ce cas, il convient alors d’insérer au moins un espace entre la fin de l'instruction et le début du commentaire.

#!/usr/bin/env python
# coding: utf-8
# Ce programme affiche "Hello World !!!"
print("Hello World !!!")            # Cette ligne est la ligne qui affiche "Hello World !!!"

Le dièse des deux premières lignes représente d’ailleurs lui aussi un commentaire. En effet, il peut arriver qu’un script Python soit récupéré par un autre. Dans ce cas, les deux premières lignes du script récupéré n’ont plus d’effet dans le script récupérateur (elles ne sont plus les deux premières lignes). Mais n’étant pas des instructions Python (ce sont des lignes habituellement traitées par le système d’exploitation et non par l’interpréteur Python), elles doivent donc être commentées.

La fonction print() sert à afficher une valeur, une variable, une expression à l’écran. Dans Python 2 elle existe tout aussi bien sous forme de fonction que de simple instruction (ex : print(2) ou print 2), instruction qui disparait dans Python 3 au seul profit de la fonction (print(2)) qui offre plus de souplesse concernant la syntaxe de son paramétrage. Il est alors possible de préciser le séparateur à afficher entre les éléments (séparateur qui par défaut est l’espace), ainsi que le caractère de fin de ligne ('\n' par défaut).

>>> print(2, 3)
2 3
>>> print(2, 3, sep='xxx')
2xxx3
>>> print(2, 3, end='-')
2 3->>>

D’autres possibilités existent comme remplacer l’écran par un flux de sortie différent (fichier, pipe), flusher (vider=écrire) la sortie immédiatement ou pas, etc. Il conviendra de lire la documentation pour étudier ces possibilités plus en détail.

Généralement, les instructions distinctes se placent sur des lignes distinctes (une instruction par ligne).

>>> print(2, 3, sep='+', end='=')
2+3=
>>> print(5)
5
>>>

Mais il est possible d’écrire plusieurs instructions sur la même ligne en les séparant par un point‑virgule (;). Elles seront alors exécutées séparément.

>>> print(2, 3, sep='+', end='='); print(5)
2+3=5
>>>

L’exception (qu’on confond parfois à tort avec l’erreur) est un évènement qui se produit quand Python se trouve dans l’impossibilité d’exécuter une instruction valide. L’impossibilité peut résulter d’une incohérence mathématique (exemple : diviser par 0), d’une incohérence entre l’état d’une donnée et l’état qu’on veut en obtenir (exemple : tenter de convertir une chaîne en nombre) ou de n’importe quel évènement fortuit du système qui se répercute dans Python par ricochet (exemple : disparition du fichier qu’on était en train de traiter).

Dès que Python se trouve en échec, il lève une exception et la fait remonter jusqu’à ce qu’elle soit interceptée. Cela peut se faire dans le code lui‑même (sera vu ultérieurement) sinon elle arrive jusqu’à l’OS qui l’affiche alors sur le terminal (ou la console Python si l’on est dans un environnement de développement) en indiquant la ligne ayant provoqué l’exception ainsi que toute la hiérarchie des appels (la ligne ayant appelé la ligne en question, puis la ligne ayant appelé…, etc.).

>>> 1/0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero
>>>