BUT SD Université d’Avignon
LE PSEUDO-CODE
TABLE DES MATIERES
1 Introduction ......................................................................................................................................... 2
2 Les fonctions ........................................................................................................................................ 2
3 Les variables ......................................................................................................................................... 3
4 Les structures de branchement ........................................................................................................... 3
5 Les boucles de répétition ..................................................................................................................... 3
6 Les opérateurs mathématiques ........................................................................................................... 4
7 Les opérateurs de comparaison ........................................................................................................... 4
8 Les listes et chaines de charactères ..................................................................................................... 5
9 …Et tout le reste ! ................................................................................................................................ 5
1/6
BUT SD Université d’Avignon
1 INTRODUCTION
La partie la plus complexe lorsque l’on doit coder, est de savoir comment articuler les différentes instructions,
structures de branchement, dans quel ordre manipuler et traiter les données… Ce que l’on appelle
l’algorithmique. Comment faire ?
La solution la plus simple est d’essayer de résoudre notre problème « manuellement », sans ordinateur. En
comprenant comment nous ferions, et en décomposant les opérations que nous réalisons (instructions), nos
prises de décisions et quelles sont les étapes que nous allons répéter (structure de branchement), nous allons
avoir une idée détaillée de ce à quoi devrait ressembler l’architecture de notre code. Il ne restera plus qu’à le
retranscrire dans le langage informatique souhaité (ici : Python).
Si le développeur aguerri arrive à réaliser cette étape de manière intuitive, ce qui lui permet de coder directement
son programme, il a souvent commencé armé d’un brouillon, à écrire du pseudo-code, à réaliser schémas et
tableaux, et n’hésite pas à revenir à ses bases lorsque cela est nécessaire.
Mais qu’est-ce que le pseudo-code ? C’est un moyen permettant d’écrire un algorithme dans le langage naturel,
mais d’une manière suffisamment élémentaire pour être retranscrit en code, dans n’importe quel langage de
programmation impératif. Si des pratiques sont usuelles, il n’y a pas réellement de norme concernant le pseudo-
code
2 LES FONCTIONS
Tout problème peut être traduit en fonction : des données en entrées, doivent permettre de renvoyer des
données en sortie. Le pseudo-code est donc majoritairement structuré sous forme de fonction :
Fonction addition(a , b) :
Entrées : a et b, réels à additionner
Sorties : réel égal à l’addition de a avec b
DEBUT
resultat ← a + b
renvoyer resultat
FIN
• On écrit donc la signature de la fonction (son nom et le nom des arguments à minima)
• On détaille éventuellement les entrées et sorties : type (important) et description si nécessaire
• Un algorithme commence toujours avec DEBUT et finit toujours avec FIN
• Un bloc de code est représenté par une barre verticale avant ce bloc
• On retourne le résultat de la fonction avec renvoyer ou retourner
2/6
BUT SD Université d’Avignon
3 LES VARIABLES
Il est habituel dans de nombreux langages de programmation, de définir les variables avant de les utiliser. Ce
n’est pas le cas de Python : le type est dit « implicite ». L’utilisation d’une variable ne nécessite donc pas de
déclarer son type en pseudo-code (même si cela peut être utile, on n’hésitera pas alors à faire un commentaire).
Les différents types de variables sont : entier, réel, liste, chaine (chaine de charactères), dictionnaire.
On affecte une valeur à une variable en utilisant une flèche pointée vers celle-ci. Exemple : a ← 4
4 LES STRUCTURES DE BRANCHEMENT
En Python, seul la structure « if – elsif – else » existe. En pseudo-code, elle sera donc écrite de la manière
suivante :
si [condition] alors :
traitement 1
sinon si [condition 2] alors :
traitement 2
sinon :
traitement 3
fin si
A noter : comme en Python, « sinon si » et « sinon » ne sont pas obligatoires. Il est possible d’utiliser autant de
« sinon si » que nécessaire. Dans tous les cas, cette structure finit par un « fin si »
5 LES BOUCLES DE REPETITION
Il est important de les identifier afin d’utiliser la bonne :
• Dans le cas où le nombre de répétitions est connu, on parle de boucle bornée. C’est une boucle « pour »
• Dans le cas où le nombre de répétitions est inconnu, on parle de boucle non bornée. C’est une boucle
« tant que »
Chaque ré-exécution du bloc d’instructions contenue dans une boucle est appelée une itération.
Il existe 2 types de boucles bornées. En utilisant une variable d’itération, ou en énumérant les éléments de la
structure de données, lorsque celle-ci le permet :
pour i allant de 0 à 10:
traitement
fin pour
pour element dans liste :
traitement
fin pour
3/6
BUT SD Université d’Avignon
Vous pouvez évidemment utiliser n’importe quel nom pour « élément », et évidemment le nom de la variable
contenant votre structure d’énumération à la place de « liste ». Pour le premier type, il est possible de donner
un pas.
Attention : dans python, un for i in range(0,10) va itérer pour i allant de 0 à 9. En pseudo-code, pour i allant de 0
à 10 va itérer avec i allant bien de 0 à 10 !
Enfin, une seule boucle bornée existe dans Python : la boucle « while » (en pseudo-code : « tant que »).
tant que [condition]
traitement
fin tant que
6 LES OPERATEURS MATHEMATIQUES
Les classiques : +, -, x, /
Les moins classiques :
• a^b (a puissance b)
• a // b (division entière ou euclidienne: le résultat est un entier)
• a % b (modulo : reste d’une division euclidienne)
7 LES OPERATEURS DE COMPARAISON
Une comparaison renvoie VRAI ou FAUX, en fonction du résultat de l’expression de comparaison. Nous utlisons
donc des opérateurs de comparaison.
Nous trouvons les classiques : < , > , ≤ , ≥ , ==
Il est possible d’utiliser les opérateurs « est vide », et « dans » (retourne VRAI si la valeur est dans les valeurs
d’une structure)
Ils peuvent être combinés avec des opérateurs logiques :
• non [condition] : inverse le résultat d’une condition
• [condition_1] et [condition_2] : renvoie VRAI seulement si les 2 conditions renvoient VRAI
• [condition_1] ou [condition_2] : renvoie VRAI si une ou les deux conditions renvoient VRAI
Afin de s’assurer que l’ordre des opérations est le bon, il est souvent nécessaire d’utiliser des parenthèses.
4/6
BUT SD Université d’Avignon
8 LES LISTES ET CHAINES DE CHARACTERES
Une liste est définie par des crochets, chaque élément étant séparé par des virgules. Exemple : valeurs ← [1,8,12].
Il est tout à fait possible de définir une liste vide : liste_vide ←[]
De manière similaire, une chaine de charactères sera définie à travers des guillements : texte ← "bonjour"
Les opérateurs sont communs :
• longueur(variable) : renvoie la taille de la liste ou de la chaine.
• variable[0] : renvoie le premier élément de la liste ou de la chaine
• variable1 + variable2 : ajoute les éléments contenus dans la variable 2 à la suite des éléments de la
variable 1
• permuter(variable[0],variable[1]) : va permuter la position des valeurs contenues à ces emplacements.
Il est possible de faire des tableaux multidimensionnels (des listes de listes). La liste supérieur contient donc des
éléments de type liste qui correspondent aux lignes, et chaque sous-liste contient donc les éléments en colonne.
Pour récupérer la valeur qui est à la 2ème ligne et 3ème colonne se fait en utilisant donc : valeur ← liste[1][2]
9 …ET TOUT LE RESTE !
Nous venons de voir que le pseudo-code a tout de même des règles à respecter. Cependant, il n’est pas
normalisé. Nous pouvons avoir besoin d’utiliser des intructions, des opérateurs, ou des fonctions qui ne sont pas
présente dans le pseudo-code de base. Il n’est donc pas interdit de les écrire, même si il est indispensable
d’utiliser les éléments de base du pseudo-code, afin d’être le plus indépendant possible du langage de
programmation utilisé par la suite.
Pour finir, le pseudo-code n’est qu’une simple retranscription d’un algorithme. Le succès pour réaliser un bon
pseudo-code, réside dans l’analyse de votre problème et le moyen de le résoudre. C’est une méthode qui
nécessite de décomposer votre réflexion, et à ce titre, il est indispensable d’utiliser tous les moyens nécessaires
(dessins, schémas, tableaux, texte) pour savoir ce que vous faites et où vous en êtes dans votre algorithme.
L’algorithmique est une question de patience. Prenez votre temps pour relire votre pseudo-code et le dérouler
(l’exécuter manuellement), ligne après ligne, opération après opération, afin de s’assurer qu’il est juste.
5/6
BUT SD Université d’Avignon
Fonctions : Structure de branchement : Listes :
Fonction addition(a , b) : si [condition] alors : valeurs ← [1,8,12]
Entrées : a et b, réels à additionner traitement 1 liste_vide ←[]
Sorties : réel égal à l’addition de a avec b sinon si [condition 2] alors :
DEBUT traitement 2 Chaines :
resultat ← a + b sinon : texte ← "bonjour"
renvoyer resultat traitement 3 texte ← ""
FIN fin si
Opérateurs :
Boucles :
longueur(variable)
Bornée et non bornées. variable[0]
variable1 + variable2
pour i allant de 0 à 10: permuter(variable[0],variable[1])
traitement
fin pour Tableaux multidimensionnels :
pour element dans liste : liste[1][2] (el. 2ème ligne, 3ème col.)
traitement
fin pour
tant que [condition]
traitement
fin tant que
Variables : Opérateurs mathématiques : Opérateurs de comparaisons :
entier, réel, liste, chaine +, -, x, / < , > , ≤ , ≥ , ==
a←4 a^b (a puissance b) non, et, ou
a//b (division entière)
a%b (modulo) résultat : VRAI ou FAUX
6/6
