Une introduction à Python 3

Au fur et à mesure que l'on acquière de l'expérience, on découvre et on apprend à utiliser les bibliothèques de modules et paquets qui fournissent des types de données et des services avancés, évitant d'avoir à recréer, coder et déboguer une partie de la solution.

La première chose à faire est de vérifier qu'il n'existe pas déjà une solution (même partielle) au problème que l'on pourrait reprendre in extenso ou dont on pourrait s'inspirer. On peut chercher dans les nombreux modules standard installés avec le langage, dans les dépôts institutionnels de modules tiers (le Python Package Index(45) par exemple), ou encore utiliser les moteurs de recherche sur l'Internet. Si on ne trouve pas de solution existante dans notre langage préféré, on peut trouver une solution dans un autre langage, qu'il n'y aura plus qu'à adapter.

L'analyse qui permet de créer un algorithme et la programmation ensuite, sont deux phases qui nécessitent de la pratique avant de devenir « évidentes » ou « faciles ».

Pour démarrer, il faut partir d'éléments réels, mais sur un échantillon du problème comportant peu de données, un cas que l'on est capable de traiter « à la main ».

Il est fortement conseillé de démarrer sur papier ou sur un tableau (le papier ayant l'avantage de laisser plus facilement des traces des différentes étapes).

On identifie tout d'abord quelles sont les données que l'on a à traiter en entrée et quelles sont les données que l'on s'attend à trouver en sortie. Pour chaque donnée, on essaie de préciser quel est son domaine, quelles sont ses limites, quelles contraintes la lient aux autres données.

On commence par une résolution du problème, en réalisant les transformations et calculs sur notre échantillon de problème, en fonctionnant par étapes.

À chaque étape, on note :

• quelles sont les étapes pertinentes, sur quels critères elles ont été choisies ;
• quelles sont les séquences d'opérations que l'on a répétées.

Lorsque l'on tombe sur des étapes complexes, on découpe en sous-étapes, éventuellement en les traitant séparément comme un algorithme de résolution d'un sous-problème. Le but est d'arriver à un niveau de détails suffisamment simple ; soit qu'il s'agisse d'opérations très basiques (opération sur un texte, expression de calcul numérique…), soit que l'on pense/sache qu'il existe déjà un outil pour traiter ce sous-problème (calcul de sinus pour un angle, opération de tri sur une séquence de données…).

Lors de ce découpage, il faut éviter de considérer des opérations comme « implicites » ou « évidentes », il faut préciser d'où proviennent les informations et ce que l'on fait des résultats. Par exemple on ne considère pas « un élément », mais « le nom traité est l'élément suivant de la séquence de noms » ou encore « le nom traité est le x^e élément de la séquence de noms ».

Normalement, au cours de ces opérations, on a commencé à nommer les données et les étapes au fur et à mesure qu'on en a eu besoin.

Une fois qu'on a un brouillon des étapes, il faut commencer à mettre en forme et à identifier les constructions algorithmiques connues et les données manipulées :

• boucles (sur quelles informations, condition d'arrêt) ;
• tests (quelle condition) ;

• informations en entrée, quel est leur type, quelles sont les contraintes pour qu'elles soient valides et utilisables, d'où viennent-elles :

  • demandées à l'utilisateur,
  • déjà présentes en mémoire,
  • lues dans des fichiers ou récupérées ailleurs (sur l'Internet par exemple) ;

• calculs et expressions :

  • quel genre de données sont nécessaires, y a-t-il des éléments constants à connaître, des résultats intermédiaires à réutiliser,
  • on peut identifier ici les contrôles intermédiaires possibles sur les valeurs qui puissent permettre de vérifier que l'algorithme se déroule bien ;
• stockage des résultats intermédiaires ;

• résultat final — à quel moment l'a-t-on, qu'en fait-on :

  • retourné dans le cadre d'une fonction,
  • affiché à l'utilisateur,
  • sauvegardé dans un fichier.

Le but est d'identifier les séquences d'étapes qui se répètent en différents endroits, séquences qui seront de bons candidats pour devenir des fonctions ou des classes. Ceci peut être fait en même temps que l'on formalise.

Le passage de l'idée puis de l'algorithme au code dans un programme, est relativement facile en Python, car celui-ci est très proche d'un langage d'algorithmique.

• Les noms des choses que l'on a manipulées vont nous donner des variables.
• Les tests vont se transformer en if condition:.
• Les boucles sur des séquences d'informations vont se transformer en for variable in séquence:.
• Les boucles avec expression de condition vont se transformer en while conditions:.
• Les séquences d'instructions qui se répètent en différents endroits vont se transformer en fonctions.
• Le retour de résultat d'une séquence (fonction) va se traduire en return variable.
• Les conditions sur les données nécessaires pour un traitement vont identifier des tests d'erreurs et des levées d'exception.