Plongée dans Python

Les conventions usuelles voudraient que je démarre ce tutoriel en vous ennuyant avec les éléments fondamentaux de la programmation afin que nous puissions travailler doucement pour construire quelque chose d’utile. Passons outre. Voici un exemple de programme Python complet et qui fonctionne. Il n’a probablement aucun sens pour vous. Ne vous inquiétez pas : on va le disséquer ligne par ligne. Mais commencez par le lire et voyez ce que vous pouvez en comprendre.

SUFFIXES = {1000: ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],
            1024: ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']}

def approximate_size(size, a_kilobyte_is_1024_bytes=True):
    '''Convert a file size to human-readable form.

    Keyword arguments:
    size -- file size in bytes
    a_kilobyte_is_1024_bytes -- if True (default), use multiples of 1024
                                if False, use multiples of 1000

    Returns: string

    '''
    if size < 0:
        raise ValueError('number must be non-negative')

    multiple = 1024 if a_kilobyte_is_1024_bytes else 1000
    for suffix in SUFFIXES[multiple]:
        size /= multiple
        if size < multiple:
            return '{0:.1f} {1}'.format(size, suffix)

    raise ValueError('number too large')

if __name__ == '__main__':
    print(approximate_size(1000000000000, False))
    print(approximate_size(1000000000000))

Le moment est venu d’exécuter ce programme depuis la ligne de commande. Sur Windows, vous devriez avoir quelque chose qui ressemble à ceci :

c:\home\diveintopython3\examples> c:\python31\python.exe humansize.py
1.0 TB
931.3 GiB

Sur Max OSX ou Linux, ça ressemblera plutôt à ceci :

you@localhost:~/diveintopython3/examples$ python3 humansize.py
1.0 TB
931.3 GiB

Que vient-il de se passer ? Vous avez exécuté votre premier programme Python. Vous avez appelé l’interpréteur Python depuis la ligne de commande et lui avez donné le nom du script que vous vouliez exécuter. Ce script définit une seule fonction, la fonction approximate_size(), qui à partir d’une taille exacte de fichier en octets (bytes) renvoie cette même taille sous une forme plus jolie (mais approximative). Vous avez déjà probablement vu cela avec Windows Explorer, ou avec Mac OS X Finder, ou encore avec Nautilus, Dolphin ou Thunar sous Linux. Si vous faites afficher un dossier de documents sous la forme de listes à plusieurs colonnes, alors apparaît une table avec l’icône du document, la taille, le type, la date de dernière modification, etc. Si le dossier contient un fichier de 1093 octets, votre gestionnaire de fichiers n’affichera pas 1093 octets, mais plutôt quelque chose comme 1Ko à la place. C’est ce que calcule la fonction approximate_size().

Regardez à la fin du script les deux appels à print(approximate_size(arguments)). Ce sont des appels de fonction. approximate_size() est d’abord appelée en lui passant un certain nombre d’arguments, puis la valeur de retour de cette fonction est elle-même directement passée en argument de la fonction print(). La fonction print() est une fonction intégrée à Python. Vous n’en verrez pas de déclaration explicite. Vous pouvez simplement l’utiliser n’importe quand, n’importe où. Il y a beaucoup d’autres fonctions intégrées (et beaucoup plus encore dans des modules séparés), mais patience…

Pourquoi lancer le script en ligne de commande vous renvoie toujours le même résultat ? On va voir cela. Mais d’abord, regardons de plus près la fonction approximate_size().

Python a des fonctions comme la plupart des autres langages, mais on n’a pas besoin d’avoir de fichier de prototypes (ou fichiers de déclarations, communément appelés entêtes ou headers) comme en C++ ou avec un sectionnement interface/implémentation comme en Pascal. Quand vous avez besoin d’une fonction, déclarez la simplement comme ceci :

def approximate_size(size, a_kilobyte_is_1024_bytes=True):

La déclaration de la fonction débute par le mot-clef def suivi du nom de la fonction et suivi d’arguments entre parenthèses. Les arguments sont séparés par des virgules.

Notez que la fonction ne définit pas le type de la valeur qu’elle renvoie. Les fonctions Python ne sont pas typées ; elles ne spécifient d’ailleurs même pas si elles retournent une valeur ou non. (En fait, toutes les fonctions Python retournent une valeur : si la fonction exécute une instruction return, la fonction renvoie cette valeur ; sinon, la fonction va retourner None qui est la valeur nulle ou vide de Python).

La fonction approximate_size() prend deux arguments – size et a_kilobyte_is_1024_bytes– mais aucun type n’est spécifié pour ceux-ci. En Python, les variables ne sont jamais explicitement typées. Python devine de quel type est une variable, et en garde la trace en interne.

II-B-1. Arguments nommés et optionnels▲

def approximate_size(size, a_kilobyte_is_1024_bytes=True):

if __name__ == '__main__':
    print(approximate_size(1000000000000, False))   ### (1)
    print(approximate_size(1000000000000))          ### (2)

>>> from humansize import approximate_size
>>> approximate_size(4000, a_kilobyte_is_1024_bytes=False)       ### (1)
'4.0 KB'
>>> approximate_size(size=4000, a_kilobyte_is_1024_bytes=False)  ### (2)
'4.0 KB'
>>> approximate_size(a_kilobyte_is_1024_bytes=False, size=4000)  ### (3)
'4.0 KB'
>>> approximate_size(a_kilobyte_is_1024_bytes=False, 4000)       ### (4)
  File "<stdin>", line 1
SyntaxError: non-keyword arg after keyword arg
>>> approximate_size(size=4000, False)                           ### (5)
  File "<stdin>", line 1
SyntaxError: non-keyword arg after keyword arg

Je ne veux pas vous ennuyer avec un long sermon moralisateur sur l’importance de la documentation du code. Sachez juste qu’un script est écrit une seule fois, mais lu de nombreuses fois et l’audience la plus importante pour votre code est vous-même, 6 mois après l’avoir écrit (c’est-à-dire après avoir tout oublié de lui, mais quand vous avez besoin de vous remettre dedans pour corriger un bogue). Avec Python, c’est facile d’écrire du code lisible, donc tirez-en parti. Vous me remercierez dans 6 mois.

Vous pouvez documenter une fonction Python en lui attribuant une docstring (raccourci de l’anglais documentation string, le mot string signifiant chaîne de caractères). Dans ce programme, la fonction approximate_size() a une docstring :

def approximate_size(size, a_kilobyte_is_1024_bytes=True):
    '''Convert a file size to human-readable form.

    Keyword arguments:
    size -- file size in bytes
    a_kilobyte_is_1024_bytes -- if True (default), use multiples of 1024
                                if False, use multiples of 1000

    Returns: string

    '''

Les triples apostrophes indiquent une chaîne de caractères sur plusieurs lignes. Tout ce qui se trouve entre le début et la fin des apostrophes triples constitue une seule et unique chaîne de caractères, y compris les retours à la ligne, les espaces et aussi les éventuels guillemets et apostrophes. Vous pouvez l’utiliser n’importe où, mais vous verrez cela le plus souvent pour définir une docstring.

Tout ce qui est entre les triples apostrophes constitue la docstring de la fonction qui renseigne sur ce que la fonction fait. Une docstring, si elle existe, doit être la première chose définie dans une fonction (c’est-à-dire, sur la ligne qui suit la déclaration de la fonction). Techniquement, vous n’avez pas besoin de fournir une docstring à votre fonction, mais vous devriez toujours le faire. Je sais que vous avez entendu cela dans tous les cours de programmation que vous avez suivis, mais Python vous donne une motivation supplémentaire : la docstring est disponible lors de l’exécution comme un attribut de la fonction.

Avant d’aller plus loin, faisons brièvement mention de la recherche des bibliothèques. Python regarde à plusieurs endroits lorsque vous essayez d’importer un module. En particulier, il regarde dans tous les répertoires définis dans sys.path. Ce n’est qu’une liste et vous pouvez facilement l'afficher ou la modifier avec les méthodes habituelles sur les listes. (Vous en apprendrez plus dans le prochain chapitre.)

>>> import sys                                                 (1)
>>> sys.path                                                   (2)
['', 
 '/usr/lib/python31.zip', 
 '/usr/lib/python3.1',
 '/usr/lib/python3.1/plat-linux2@EXTRAMACHDEPPATH@', 
 '/usr/lib/python3.1/lib-dynload', 
 '/usr/lib/python3.1/dist-packages', 
 '/usr/local/lib/python3.1/dist-packages']
>>> sys                                                        (3)
<module 'sys' (built-in)>
>>> sys.path.insert(0, '/home/mark/diveintopython3/examples')  (4)
>>> sys.path                                                   (5)
['/home/mark/diveintopython3/examples', 
 '', 
 '/usr/lib/python31.zip', 
 '/usr/lib/python3.1', 
 '/usr/lib/python3.1/plat-linux2@EXTRAMACHDEPPATH@', 
 '/usr/lib/python3.1/lib-dynload', 
 '/usr/lib/python3.1/dist-packages', 
 '/usr/local/lib/python3.1/dist-packages']

(1) On importe le module sys pour avoir accès à toutes ses fonctions et attributs.

(2) sys.path est une liste de noms de répertoires dans laquelle Python recherche les bibliothèques. (Vous avez probablement quelque chose de différent ; cela dépend de votre système d’exploitation, de votre version de Python et de son installation d’origine). Python recherche dans ces répertoires (dans l’ordre) un fichier .py dont le nom correspond à ce que vous essayez d’importer.

(3) En fait, j'ai un peu simplifié : c’est un peu plus compliqué que cela car tous les modules ne sont pas des fichiers .py. Certains sont des modules intégrés (built-in modules) ; ils font partie de Python lui-même. Les modules intégrés se comportent comme les autres modules, mais leur code source n’est pas disponible car il n’est pas écrit en Python ! (Comme Python lui-même, ces modules intégrés sont écrits en C).

(4) Vous pouvez ajouter un nouveau répertoire au sys.path et ainsi, Python regardera aussi dans ce répertoire lorsque vous tenterez d’importer un module. L’effet perdure aussi longtemps que Python continue à tourner.

(5) En utilisant sys.path.insert(0, new_path), vous insérez un nouveau répertoire en tête de la liste sys.path, c'est-à-dire au début de la liste des chemins où Python va rechercher des modules. La plupart du temps c’est ce que vous voudrez faire. En cas de conflit de nommage (par exemple, si Python est livré avec la version 2 d’une bibliothèque particulière mais que vous souhaitez utiliser la version 3), ceci assure que vos modules seront trouvés et utilisés au lieu des modules qui ont été installés en même temps que Python.

Au cas où vous auriez oublié, je rappelle que les fonctions Python ont des attributs et que ces attributs sont disponibles au moment de l’exécution. Une fonction, comme n’importe quoi d’autre en Python, est un objet.

>>> import humansize                               ##  (1)
>>> print(humansize.approximate_size(4096, True))  ##  (2)
4.0 KiB
>>> print(humansize.approximate_size.__doc__)      ##  (3)
Convert a file size to human-readable form.

    Keyword arguments:
    size -- file size in bytes
    a_kilobyte_is_1024_bytes -- if True (default), use multiples of 1024
                                if False, use multiples of 1000

    Returns: string

(1) La première ligne importe le programme humansizecomme un module — un bout de code que vous pouvez utiliser interactivement, ou dans un programme Python plus gros. Une fois que vous avez importé ce module, vous pouvez faire référence à toutes ses fonctions, classes ou attributs publics et vous pouvez aussi le faire en interactif dans le terminal Python. C’est un concept important et vous en verrez beaucoup dans ce livre.

(2) Quand vous voulez utiliser une fonction définie dans un module importé, vous devez inclure le nom du module. Donc vous ne pouvez pas simplement écrire approximate_size, mais vous devez écrire humansize.approximate_size. Si vous utilisez des classes en Java, ceci devrait vous être vaguement familier.

(3) Au lieu d’appeler la fonction comme vous vous y seriez attendu, vous demandez l’attribut __doc__ de la fonction. 

Absolument tout dans Python est objet et tout objet peut avoir des attributs et des méthodes. Toute fonction a un attribut __doc__ qui retourne sa docstring définie dans le code source de la fonction. Le module sys est un objet qui a (entre autres choses) un attribut nommé path. Et ainsi de suite.

Cependant, ceci ne répond pas à la question la plus fondamentale : qu’est-ce qu’un objet ? Les langages de programmation définissent l’ « objet » de différentes manières. Dans certains langages, tout objet doit avoir des attributs et des méthodes. Dans d’autres, tout objet est dérivable (c'est-à-dire que l’on peut créer une sous-classe de l’objet). En Python la définition est plus vague. Certains objets n’ont ni attribut ni méthode, mais ils pourraient en avoir. Tous les objets ne sont pas dérivables. Cependant tout est un objet dans le sens où l’on peut l’assigner à une variable ou le passer comme argument à une fonction.

Vous avez peut-être entendu le terme « objet de première classe » (first-class object) dans d’autres contextes de programmation. En Python, les fonctions sont des objets de première classe. Vous pouvez passer une fonction en argument à une autre fonction. Les modules sont également des objets de première classe. Vous pouvez passer un module entier en argument à une fonction. Les classes sont des objets de première classe et les instances individuelles d’une classe sont aussi des objets de première classe.

Ceci est important, donc je vais le répéter au cas où vous l’oublieriez : en Python, tout est objet. Les chaînes de caractères sont des objets. Les listes sont des objets. Les fonctions sont des objets. Les classes sont des objets. Les instances de classe sont des objets. Tout module est un objet.

Les fonctions Python n’ont pas de mot-clef begin ou end explicite et pas non plus d’accolades pour marquer où démarre la fonction et où elle s’arrête. Le seul délimiteur est un caractère deux-points ( : ) et l’indentation du code lui-même.

def approximate_size(size, a_kilobyte_is_1024_bytes=True):  ## (1)
    if size < 0:                                            ## (2)
        raise ValueError('number must be non-negative')     ## (3)
                                                            ## (4)
    multiple = 1024 if a_kilobyte_is_1024_bytes else 1000
    for suffix in SUFFIXES[multiple]:                       ## (5) 
        size /= multiple
        if size < multiple:
            return '{0:.1f} {1}'.format(size, suffix)

    raise ValueError('number too large')

(1) Les blocs de code sont définis via leur indentation. Par « bloc de code », j’entends les fonctions, les conditions if, les boucles for et while, etc. Une indentation marque le début d’un bloc, la fin de cette indentation marque la fin du bloc. Il n’y a pas d’accolades explicites, de parenthèses ou de mots-clefs. Ceci signifie que les espaces sont importants et doivent être cohérents. Dans cet exemple, le code de la fonction est indenté avec quatre espaces. Ce n’est pas obligatoirement 4 espaces, il faut juste que les espaces soient cohérents. La première ligne qui n’est pas indentée marque la fin du bloc ou de la fonction.

(2) En Python, une instruction ifest suivie d’un bloc de code. Si l’expression du if est évaluée à True, le bloc indenté est exécuté, sinon on passe directement au bloc else (s’il y en a un). Notez qu’il n’y a pas de parenthèses autour de l’expression.

(3) La ligne est à l’intérieur du bloc if. L’instruction raise va lancer une exception (du type ValueError) si size < 0.

(4) Ce n’est pas la fin de la fonction. Les lignes entièrement blanches ne comptent pas. Elles peuvent simplement rendre le code plus lisible et elles ne sont pas considérées comme un délimiteur de bloc de code. La fonction continue sur la ligne suivante.

(5) La boucle for marque également le début d’un bloc de code. Les blocs de code peuvent contenir de multiples lignes tant qu’elles sont indentées de la même manière. Cette boucle for contient trois lignes dans son bloc. Il n’y a pas d’autre syntaxe spécifique pour les blocs de codes sur plusieurs lignes. Vous n’avez qu’à indenter et c’est tout.

Après quelques protestations et analogies méprisantes avec le Fortran, vous ferez la paix avec cela et commencerez à voir l'intérêt de l'indentation. L’un des principaux avantages est que tous les programmes Python se ressemblent, car l’indentation est nécessaire au langage et n’est pas juste une question de style. Ceci rend plus facile la lecture et la compréhension de code Python écrit par d’autres personnes.

Les exceptions sont partout en Python. Pratiquement tous les modules de la bibliothèque standard de Python les utilisent et Python lui-même en lance dans beaucoup de circonstances. Nous le verrons à de nombreuses reprises dans ce livre.

Qu’est-ce qu’une exception ? Souvent, c’est une erreur, une indication que quelque chose se passe mal. (Toutes les exceptions ne sont pas des erreurs, mais laissons ceci de côté pour l’instant.) Certains langages de programmation encouragent l’utilisation des codes d’erreur de sortie, que vous pouvez vérifier. Python encourage l’utilisation des exceptions que vous pouvez traiter.

Quand une erreur survient dans le shell Python, il affiche certains détails sur l’exception et comment elle est arrivée. Ceci s'appelle une exception non-gérée. Quand une exception est lancée, il n’y a pas de code pour explicitement l’identifier et la traiter, donc elle remonte jusqu’au haut niveau du shell Python, qui vous affiche des informations de débogage et s'arrête. Une erreur dans le shell ce n’est pas très grave, mais si cela arrive lorsque votre programme Python actuel tourne, le programme entier s’arrêtera abruptement si rien ne traite l’exception. Peut-être que c’est ce que vous voulez, ou peut-être pas.

Une exception n’a cependant pas besoin de provoquer un arrêt complet du programme. Les exceptions peuvent être traitées. Parfois une exception est réelle car vous avez un bogue dans votre code (comme accéder à une variable qui n’existe pas), mais parfois une exception est juste quelque chose que vous pouvez anticiper. Si vous ouvrez un fichier, il peut ne pas exister. Si vous importez un module, il peut ne pas être installé. Si vous vous connectez à une base de données, elle peut être indisponible ou vous pouvez ne pas avoir les droits suffisants pour y accéder. Si vous connaissez une ligne de code qui peut lancer une exception, vous pouvez traiter l’exception en utilisant le bloc try…except.

La fonction approximate_size() lance une exception dans deux cas de figure différents : si la taille (size) donnée est plus grande que ce que la fonction est capable de traiter ou bien si elle est inférieure à zéro.

if size < 0:
    raise ValueError('number must be non-negative')

La syntaxe pour lancer une exception est assez simple. On utilise le mot-clef raise, suivi du nom de l’exception et optionnellement d’une chaîne de caractères lisible pour un humain (une phrase) pour faciliter le débogage. La syntaxe est évocatrice d’un appel de fonction. (En réalité, les exceptions sont implémentées comme des classes et le mot-clef raise crée ici une instance de la classe ValueError et passe la chaîne de caractères « number must be non-negative » à sa méthode d’initialisation. Mais nous verrons cela plus tard !)

II-G-1. Intercepter les erreurs d'importation de module▲

try:
  import chardet
except ImportError:
  chardet = None

if chardet:
  # faire quelque chose
else:
  # continuer tout de même

try:
    from lxml import etree
except ImportError:
    import xml.etree.ElementTree as etree

Regardons de plus près la ligne de code suivante de la fonction approximate_size() :

multiple = 1024 if a_kilobyte_is_1024_bytes else 1000

Notez que nous n’avons jamais déclaré la variable multiple, nous lui avons simplement affecté une valeur. Cela suffit, car Python vous le permet. Ce que Python ne vous permettra pas, c’est une référence à une variable qui n’a pas été affectée à une valeur auparavant. Si vous le faites, cela lancera une exception NameError.

>>> x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined
>>> x = 1
>>> x
1

Vous remercierez Python un jour pour cela.

Tous les noms dans Python sont sensibles à la casse (c'est-à-dire à la distinction entre lettres minuscules et lettres capitales) : les noms des variables, les noms des fonctions, les noms des classes, les noms des modules, les noms des exceptions. Si c'est quelque chose que vous pouvez obtenir, définir, appeler, construire, importer ou lancer, c’est sensible à la casse.

>>> an_integer = 1
>>> an_integer
1
>>> AN_INTEGER
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'AN_INTEGER' is not defined
>>> An_Integer
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'An_Integer' is not defined
>>> an_inteGer
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'an_inteGer' is not defined

Les modules Python sont des objets et ils ont des attributs bien pratiques. Vous pouvez les utiliser pour tester facilement vos modules au fur et à mesure que vous les écrivez, en incluant un bloc spécial de code qui s’exécute lorsque vous lancez le fichier Python en ligne de commande. Prenons les dernières lignes de humansize.py :

if __name__ == '__main__':
    print(approximate_size(1000000000000, False))
    print(approximate_size(1000000000000))

Qu'y a-t-il de spécial dans cette condition if ? Et bien, les modules sont des objets et les modules ont un attribut intégré, __name__. Le __name__ d’un module dépend de la manière dont vous utilisez le module. Si vous importez le module, alors __name__ est le nom du fichier du module sans le chemin ni l’extension.

>>> import humansize
>>> humansize.__name__
'humansize'

Mais vous pouvez aussi exécuter votre module directement en tant que programme autonome. Dans ce cas __name__ aura la valeur spéciale __main__. Ici, Python évaluera alors la condition if, identifiera un test renvoyant vrai et exécutera le code du bloc if, qui dans notre cas, imprime deux valeurs à l’écran.

c:\home\diveintopython3> c:\python31\python.exe humansize.py
1.0 TB
931.3 GiB

Mais si vous appelez ce script comme un module, la partie contrôlée par la condition if __name__ == '__main:_ ne s'exécutera pas et la fonction renverra l'approximation de la taille qui lui est passée en paramètre.

Et voici votre premier programme Python !

• PEP 257: Docstring Conventions explique ce qui différencie une bonne docstring d’une excellente docstring.
• Python Tutorial: Documentation Strings traite également du même sujet.
• PEP 8: Style Guide for Python Code aborde les bonnes pratiques sur les styles d’indentation.
• Python Reference Manual explique ce que veut dire “En Python, tout est objet”, car certaines personnes pédantes aiment discuter longuement de ce genre de choses.