Le Livre d'Argent

Par rapport aux langages les plus courants

Parmi tous les langages de programmation existants, Python présente une caractéristique à la fois très intéressante et très peu commune(4) : celle de donner une fonction sémantique à l'indentation (là encore, si ce concept ne vous est pas familier, jetez un œil à cet article).

Là où, dans les autres langages, on utilise des accolades ou des mots-clefs spécialisés pour fermer les différents blocs (« fi », « endif »…), et où l'indentation ne sert donc qu'à faciliter la lecture aux personnes qui regardent le code, python se distingue donc en utilisant cette indentation pour délimiter les différents blocs : en cas d'erreur, la machine et le lecteur se trompent donc de la même façon, ce qui aide à comprendre le soucis.

Un exemple rapide (qui n'a pas vraiment de sens, c'est uniquement pour montrer la différence de syntaxe) entre ce qui pourrait fonctionner, par exemple, en C ou en Java(5), et la façon dont on l'écrit en Python :

if (a == b) {
    a += 2;
    b += 4;
}
c = a + b;

if a == b:
    a += 2
    b += 4
c = a + b

Autre remarque, le code à accolade présenté ci-dessus ne pourrait pas fonctionner tel quel en C ou en Java : d'une part, il faudrait encapsuler ça proprement (dans une fonction main en C, dans la méthode main d'une classe en Java) ; d'autre part, il faudrait commencer par déclarer les variables a, b et c en précisant de quel type elles sont.

En Python, pas besoin : d'une part, on peut écrire du code directement en vrac dans un fichier simple(6) ; d'autre part, il n'y a pas de typage précis obligeant à déclarer ses variables plus ou moins à l'avance : la variable est créée la première fois qu'on l'affecte, et c'est tout (bon, en l'occurrence, il faudrait quand même initialiser a et b avant).

Python propose également un mécanisme d'initialisation à partir d'éléments multiples assez intéressant : si, comme on en a l'habitude par ailleurs, on peut affecter un tuple de cette manière :

t = a,b,c,d

On peut également procéder à l'opération inverse assez simplement :

a,b,c,d = t

Et affecter, donc, les quatre variables à partir du contenu du tuple. Ce qui permet d'échanger le contenu de deux variables en une seule opération, plutôt que de devoir passer par une variable intermédiaire comme ailleurs :

a,b = b,a

Voilà pour les quelques éléments qui pourront surprendre les habitués à d'autres langages. Passons maintenant à ce que l'on croisera le plus souvent dans ce langage :

Types de base et conversions

Disposant d'une bibliothèque standard, Python propose évidemment un certain nombre de types et de fonctions utiles que l'on peut aller chercher en cas de besoin. Mais certains d'entre eux sont beaucoup plus fréquents que d'autres.

En premier lieu, évidemment, les nombres, pour lesquels on croise surtout les types int et float, et les chaînes de caractères. En Python 2, il y avait deux sortes de chaînes : d'un côté, str, qui représentait un flux brut venu de l'extérieur, et de l'autre unicode, qui représentait une suite de chaînes de caractères interne au programme, correctement décodée. Cela a été simplifié dans Python 3, où le type str est désormais le principal.

Attention : quoique le typage soit dynamique, il n'y a pas de conversions implicites. Si vous écrivez « 1 + "1" », ça n'essayera pas de convertir la chaîne en entier ou l'entier en chaîne, ça générera une exception.

Il faut donc utiliser les fonctions de conversions de base. C'est assez simple : str(variable) renverra une chaîne de caractère automatiquement constituée à partir de la variable passée, quelle que soit son type. De même, int(variable) (pour lequel on peut éventuellement préciser une base en second paramètre, par exemple) et float(variable) tenteront de convertir la variable en entier ou en nombre à virgule.

Notez que cela ne marchera pas uniquement pour les types de base : on peut définir, dans les objets, des fonctions adéquates pour effectuer des conversions de la même manière, j'y reviendrai en vous parlant d'objets.

Il y a également, bien sûr, des booléens et une valeur nulle, qui s'écrivent ici avec une majuscule : True, False et None.

Les autres types courants sont les collections : un tuple représente un tableau immutable (son contenu ne pourra pas être modifié après sa première affectation), et une list représente une liste d'éléments, que l'on va pouvoir modifier. Par ailleurs, le dict représente un dictionnaire, c'est-à-dire un tableau associatif, pour lequel on peut associer des valeurs à des clefs de toutes sortes de types. Enfin, les set sont des ensembles, c'est-à-dire des collections d'éléments sans doublons, mais dont l'ordre n'est pas déterminé (on ne peut pas demander à accéder au énième élément).

Ces quatre types sont tellement courants qu'ils peuvent être initialisés très simplement :

t = ("ceci", "est", "un", "tuple")
l = ["ceci", "est", "une", "liste"]
d = {"ceci": "est", "un": "dictionnaire"}
s = {"ceci", "est", "un", "ensemble"}

Attention, puisque ensembles et dictionnaires se déclarent de deux façons assez proches : si vous demandez juste {}, cela crée un dictionnaire vide. Pour obtenir un ensemble vide, il faut passer par une fonction plus explicite : set().

Tant qu'on est dans les pièges : (valeur) ne crée pas un tuple contenant la valeur. Il faut pour cela écrire ceci : (valeur,) car les parenthèses seules sont également utilisées comme délimiteur (elles permettent, par exemple, de placer une seule expression sur plusieurs lignes, pour les cas où l'indentation sémantique serait problématique).

Un autre objet relativement courant, quoique rarement explicitement, est le generator : il s'agit d'une sorte de liste dont les éléments ne sont pas connus à l'avance, mais calculés au fur et à mesure, ce qui est utilisé pour les parcours, par exemple. D'ailleurs, à ce sujet :

Structures de contrôle

Python se veut lisible : les structures de contrôle s'efforcent donc d'utiliser moins de caractères sibyllins que d'autres langages. En particulier, les opérations booléennes sont appelées par leur nom : or pour le ou logique et and pour le et logique. On écrit donc « if condition1 and condition2 ».

L'opérateur de test mono-ligne, permettant de donner plusieurs valeurs en fonction d'une condition, s'utilise également très simplement :

nb = 1 if condition else 2

Les deux boucles habituelles for et while sont bien sûr disponibles : le second sert à répéter une suite d'opérations tant qu'une condition est validée ; tandis que le premier sert à effectuer une suite d'opérations pour chaque élément d'une liste ou d'un générateur(7). On écrit donc :

while condition:
    instructions

for variable in liste:
    instructions

Ce second opérateur peut d'ailleurs être lui aussi utilisé en mono-ligne, pour constituer un générateur à partir d'une liste (ou d'un autre générateur) :

doubles = (i*2 for i in simples)

Notez que les parenthèses sont ici requises.

Le mot-clef in peut cependant être utilisé également pour les conditions classiques : en dehors de la syntaxe particulière d'une boucle for, « variable in liste » est évalué à vrai quand la variable est l'un des éléments de la liste, et à faux sinon.

Par ailleurs, quelques fonctions de base pouvant vous être utile : range, appelée avec un seul paramètre entier, renvoie une liste d'entiers allant de zéro jusqu'à cet entier, zéro inclus, et la valeur maximale exclue(8) ; et len vous renvoie la longueur d'une collection (ou d'une chaîne de caractère). Pour un parcours classique des indices d'une liste, on utilisera donc classiquement :

for i in range(len(liste)):
    instructions

Par ailleurs, la gestion des exceptions se fait classiquement avec le mot-clef try(9) :

try:
    instructions à risque
except Exception as e:
    traitement

Définition de fonctions

Python propose deux manières de définir une fonction. En premier lieu, vous avez la version classique, en plusieurs lignes, qui va s'écrire ainsi :

def fonction(param1, param2="default", *args, **kwargs):
    instructions

Détaillons un peu : dans cet exemple particulier, la fonction prendra nécessairement un paramètre param1 (une exception sera déclenchée s'il n'est pas présent). Un paramètre param2 peut également être indiqué, mais il sera optionnel : s'il n'est pas précisée, la valeur par défaut fournie sera utilisée. Les deux trucs bizarre, juste derrière, indique que vous pouvez fournir autant de paramètre supplémentaires que vous voulez.

Si vous appelez votre fonction avec, par exemple, « fonction(1, 2, 3, 4, 5) », les deux premiers paramètres auront, respectivement, les valeurs 1 et 2, et le tuple args contiendra les valeurs supplémentaires (3, 4 et 5). Vous pouvez également préciser un nom spécifique à chaque paramètre : « fonction(1, 2, a=3, b=4, c=5) » fera en sorte que le dictionnaire kwargs contiendra les clefs a, b et c, avec les valeurs indiquées.

Bien sûr, vous pouvez tout à fait définir une fonction n'utilisant qu'un nombre fixe de paramètres, sans cas bizarres de ce genre, en retirant simplement la fin.

À l'intérieur de la fonction, vous pouvez définir une valeur de retour à l'aide du classique mot-clef return. Si celui-ci n'est pas mentionné, la fonction sera considérée comme renvoyant None… à moins que vous n'utilisiez un autre mot-clef, yield. Dans ce cas, la fonction renverra un générateur, et la valeur suivant ce mot-clef sera celle renvoyée au énième appel.

L'autre manière de définir une fonction est quelque chose de plus condensé, utilisée par exemple pour préciser une fonction de comparaison pour les tris : elle permet de définir et de renvoyer une fonction en une seule ligne. Cela fonctionne ainsi :

fonction = lambda argument: valeur

Et c'est rigoureusement identique à ceci :

def fonction(argument):
    return valeur

À la différence près, bien sûr, que vous pouvez utiliser la fonction directement plutôt que de la stocker dans une variable.

Création d'objets

Python vous permet de définir des objets assez simplement, et supporte quelques aspects intéressants, comme l'héritage multiple. Basiquement, déclarer une nouvelle classe se fera ainsi :

class MaClasse(parent1, parent2):
    def __init__(self, *args):
        instructions

Les parents indiqués entre parenthèses sur la première ligne sont les classes-mères. Il est conseillé, si vous n'héritez de rien en particulier, de tout de même préciser la classe de base object à cet endroit.

La deuxième ligne définit la première méthode de notre classe, qui sera son constructeur, appelé automatiquement lorsque l'on crée une nouvelle instance. Placez-y donc les instructions d'initialisation de l'objet.

On remarque, dans les paramètres de cette classe, un self. Il sert à désigner l'objet courant. En effet, en Python, les deux appels suivants sont rigoureusement équivalents (le premier étant en fait un alias du second) :

monObjet.methode()

MaClasse.methode(monObjet)

En d'autres termes, la référence vers l'objet courant sera le premier paramètre passé à votre méthode, avant les éventuels autres paramètres. Vous pouvez donc, d'ailleurs, lui donner le nom que vous désirez, même si self est le nom conventionnel, généralement mis en valeur par la coloration syntaxique.

Vous pouvez ensuite définir autant d'autres méthodes que vous le désirez, certaines étant utilisées par le langage pour accomplir quelques fonctions usuelles. Par exemple, si vous tentez de convertir votre objet en chaîne de caractère (« str(monObjet) », appelé automatiquement lors d'un print par exemple), le système cherchera et appellera la méthode __str__ si celle-ci est présente. Vous pouvez ainsi redéfinir pas mal d'opérations de base à votre convenance.

Une fois la classe définie, vous voudrez sans doute l'utiliser. Il suffit dans ce cas d'utiliser le nom de la classe comme une méthode d'initialisation. Dans l'exemple ci-dessus, par exemple, l'objet sera créé ainsi :

monObjet = MaClasse()

Oh, pour les méthodes des objets comme pour les fonctions indépendantes, n'oubliez pas de décrire leur fonctionnement en commentaire (avec un caractère « # » au début), juste avant ou juste après la ligne contenant le « def » : ces commentaires seront utilisés automatiquement par Python pour générer la documentation de votre code (ça marchera pour la fonction help dont je vous parlais au début, notamment).

Alternativement, cela peut également être obtenu avec une chaîne de caractère multilignes (obtenue délimitée par trois guillemets doubles d'affilée) en lieu et place des commentaires.

Erratum (merci à Gordon pour la relecture) : le commentaire avant la déclaration de la fonction est reconnu par help, mais pas par d'autres fonctions. Après la déclaration, il ne l'est dans aucun cas. Utilisez plutôt ces chaînes de caractères multilignes, qui sont la bonne manière de documenter.

Remarques personnelles : quelques défauts

J'aime beaucoup le Python. C'est très agréable à coder, et les quelques éléments sus-mentionnés permettent de faire plein de choses de manière plus simple que dans d'autres langages. Néanmoins, il y a quelques petits détails qui me chiffonnent, et dont je préfère quand même vous faire part.

D'une part, j'ai tendance à considérer que l'interprété est très bien pour faire des tests et des scripts, mais, quand il s'agit de quelque chose de sérieux, j'ai tendance à préférer compiler(10). De même, la démarche de séparer compilation et exécution, la première pour vérifier que la syntaxe et les usages généraux sont corrects, et la seconde pour tester réellement le code, me semble importante pour l'apprentissage.

Ceci dit, sur ce point-là, on peut s'arranger : il existe un outil, Cython, qui est initialement conçu pour créer facilement des modules python compilés en C, mais qui peut également être utilisé pour compiler le code principal.

D'autre part, il manque la notion de visibilité sur les objets : quand on veut écrire un attribut ou une méthode qui ne soit qu'interne, on lui donne par convention un nom commençant par le caractère « _ », histoire de prévenir les autres gens qu'il vaut mieux éviter de l'utiliser directement ; mais il n'existe aucun mécanisme du langage permettant réellement d'empêcher que le truc soit utilisé à l'extérieur.

Cette fois encore, cela me semble important pour un usage réel, mais également dans un cadre pédagogique : d'après mon expérience, apprendre à distinguer clairement ce qui est uniquement interne à l'objet et ce qui est ouvert sur l'extérieur est une étape importante pour bien comprendre la notion d'objet.

De tierce part, le typage dynamique est très pratique pour, par exemple, des collections contenant plusieurs sortes d'éléments ; mais la rigueur du typage statique est préférable dans certains autres cas. Notamment, il serait préférable de pouvoir spécifier, dès la définition d'une fonction, quels types d'arguments elle attend. Ou bien qu'une éventuelle exception se déclenche au moment où on affecte une valeur incorrecte à une variable, et non pas au moment, quelques lignes plus bas, où on tente de l'utiliser.

Dans un cadre pédagogique, une fois encore, la démarche de commencer par réfléchir aux variables dont on va avoir besoin, et des types qu'elles recevront ; et l'impossibilité d'utiliser une même variable pour mettre successivement deux trucs radicalement différents, est assez importante(11).

Si quelqu'un connaissait donc un langage extrêmement proche de Python, mais qui serait compilé, avec du typage statique (quoique pas forcément obligatoire) et des visibilités sur les objets, je vous saurais gré de bien vouloir me le présenter : ce serait vraisemblablement, à mes yeux, le langage pédagogique idéal (enfin, je me fais confiance pour trouver quelques raisons de râler contre quand même ^^").