Une introduction à Python 3

Image non disponible


précédentsommairesuivant

11. Passer du problème au programme

Lorsqu'on a un problème à résoudre par un programme, la difficulté est de savoir :

  • par où commencer ?
  • comment concevoir l'algorithme ?

11-1. Prérequis

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.

11-2. Réutiliser

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 ».

11-3. Réfléchir à un algorithme

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.

11-4. Résoudre « à la main »

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 xe é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.

11-5. Formaliser

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.

11-6. Factoriser

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.

11-7. Passer de l'idée au programme

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.

précédentsommairesuivant

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2015 Kordeo. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.