Lycée de Cachan BTS SIO

Algorithmique

1 Introduction
1.1 Algorithmes
Le mot  algorithme vient du nom du mathématicien et astronome Al Khuwarizmi (latinisé
au Moyen Âge en Algoritmi), qui, au IXe siècle écrivit le premier ouvrage systématique sur
la solution des équations linéaires et quadratiques.

Dénition
Un algorithme est une suite nie d'opérations ou d'instructions à appliquer dans un
ordre déterminé à un nombre ni de données pour résoudre un problème en un nombre
ni d'étapes.

Exemples. On peut trouver des exemples d'algorithmes dans la vie courante :

• recette de cuisine,

• notice de montage de meuble.

Remarque. Les premiers algorithmes mathématiques sont apparus bien avant les premiers
ordinateurs et étaient exécutés à la main. Dans ce cours nous allons apprendre à écrire les
algorithmes en langage de programmation de manière à ce que l'ordinateur les exécute.

Dénition
Un algorithme écrit en langage de programmation s'appelle un programme.

1.2 Langages informatiques

Le langage de l'ordinateur est le langage binaire, qui est composé uniquement de 0 et de 1.

Exemple. On peut par exemple traduire le mot  Bonjour (codage UTF-8) par le code
binaire  01000010011011110110111001101010011011110111010101110010 .

Pour éviter de devoir écrire nos algorithmes en binaire, on a recours à ce que l'on appelle
un langage de programmation (comme par exemple Python, C, C++, etc). Un programme,
appelé interpréteur ou compilateur selon les cas, se charge ensuite de traduire ces algorithmes
en langage binaire compréhensible par la machine.

Durant l'année, nous allons utiliser deux langages pour nos algorithmes :

• Le pseudo-code : un langage naturel, exprimé en français, que nous utiliserons pour

élaborer nos algorithmes sur papier.

• Python : un langage informatique multi-plateforme placé sous licence libre, créé en 1989
par le programmateur Guido van Rossum.

1
1.3 Environnement de développement
Durant l'année, nous allons utiliser la version 3 de Python. Pour faciliter l'écriture d'algo-
rithmes, nous allons travailler dans un environnement de développement intégré (en anglais
IDE, pour Integrated Development Environment).

Au cours de l'année, nous allons utiliser le logiciel Thonny.

Thonny est un environnement de développement léger, muni d'un débogueur permet-

tant de visualiser le contenu de chaque variable. Il est portable et peut s'installer sans
droits d'administration. Il est disponible à l'adresse : https://thonny.org/

Autres possibilités :
• Parmi les autre environnements de développement il y a :
 Idle, un IDE installé avec toute distribution Python (attention à choisir Python 3) :
https://www.python.org/downloads/
 Spyder, un peu lourd et lent mais assez convivial. Sous Windows et MacOs s'installe avec le
pack Anaconda : http://continuum.io/downloads
ou avec le pack Miniconda (version allégée) : https://conda.io/miniconda.html
puis taper dans la console conda : conda install spyder
• Il existe certains environnements de développement en ligne, notamment :
 http://www.pythontutor.com/visualize.html#mode=edit
qui permet de visualiser le contenu de la mémoire au fur et à mesure.
1.4 Présentation de Thonny
Les environnements de développement sont essentiellement constitués de deux blocs : l'éditeur
de texte et la console de l'interpréteur.

L'éditeur de texte
L'éditeur de texte est la zone du programmeur. En
eet, les programmes sont tapés dans des chiers Exécution
textes, que l'on peut sauvegarder, modier et dis-
tribuer à loisir.
Dans Thonny, on peut exécuter le programme
contenu dans le chier texte à l'aide du bouton
d'exécution.

La console de l'interpréteur : Éditeur

La console est la zone de l'utilisateur. Elle se repère
aux trois chevrons (>>>) qu'elle contient.
En général, on se sert de cette zone essentiellement
pour visualiser le résultat de l'exécution de nos pro- Console de
grammes, et pour interagir avec le programme (sai-
sie). Cependant, on peut aussi se servir de la console
l'interpréteur
pour tester l'eet d'une commande.

Remarque.
Tous les exemples de ce document sont à taper dans l'éditeur de texte, sauf si il est explici-
tement écrit de tester les exemples dans la console.

2
Remarques.
• Le symbole >>> dans la console s'appelle une invite de commande. Il signie que l'inter-
préteur est prêt à recevoir une instruction.

• Les chiers créés par l'éditeur de texte portent l'extension ".py". Il est important de
sauvegarder son travail régulièrement.

• Pour ajouter des commentaires, on utilise le symbole #. Le texte suivant le symbole # (sur
une seule ligne) n'est pas pris en compte par l'interpréteur.
Dans Thonny, on peut mettre en commentaire une portion du texte en sélectionnant celle-
ci, en allant dans le menu "Edit" et en cliquant sur "Comment out". On peut réaliser
l'opération inverse en cliquant sur "Uncomment".

• En Python, les espaces en début de ligne (on parle d'indentation) ont un sens. Sauf pré-
cision contraire, toutes les instructions doivent donc être alignées complètement à gauche.

Important : les résultats des instructions tapées dans la console sont achés automatique-
ment. Pour acher le résultat d'une instruction tapée dans l'éditeur de texte, il faut utiliser
print, qui est la procédure permettant d'acher.
Par exemple :
dans la console, on tape : 1+2 dans l'éditeur de texte, on tape : print(1+2)

1.5 Règles de nommage des chiers et de sauvegarde

Attention, les ordinateurs du lycée peuvent être réinitialisés à tout moment, toute donnée
stockée sur l'un d'eux étant alors perdue. Il est recommandé de sauvegarder son travail :

• sur l'espace documentaire de l'ENT,

• sur une clé USB (attention toutefois : il y a régulièrement des virus),

• sur un espace de stockage en ligne (drive, dropbox, etc...).

Dans tous les cas, tout travail eectué en classe doit être sauvegardé. Par ailleurs, tout
chier rendu doit être nommé de la façon suivante : nom_devoir_date.py
Par exemple, un élève dont le nom est Azerty, qui rend un chier pour le DS1 le
15/09/2042 devra nommer son chier : azerty_ds1_15_09_2042.py

Remarque.
Pour une meilleure organisation, il est par ailleurs recommandé de créer un dossier dédié.

1.6 Exercice
Exercice 1 (Pour se tester).
1) Quelles sont les deux zones principales d'un environnement de développement intégré ?

2) Dans quelle zone écrit-on ses programmes ?

3) Dans quelle zone teste-on ses commande et interagit-on avec l'ordinateur ?

3
2 Variables
2.1 Ce qu'est une variable
Dénition
Une variable correspond à un emplacement dans la mémoire de l'ordinateur auquel on
donne :

• un nom : qui doit commencer par une lettre et ne contenir que des lettres non
accentuées, des caractères _ et des chires,

• une valeur : qui est modiable,

• un type : entier, réel, etc..., que l'on peut obtenir en Python avec la fonction type.

Remarques.
• Python est sensible à la casse : la variable nom_de_variable et la variable Nom_De_Variable
ne sont pas les mêmes.

• Il est très important de donner des noms de variable qui permettent de retrouver ce que
la variable contient. Par exemple si je veux créer une variable qui contient un âge, je ne
l'appelle pas toto, ou x, mais age. Les évaluations pourront tenir compte des choix de noms
de variables.

2.2 Achage
Pour acher la valeur d'une variable, une valeur ou du texte dans la console, on utilise :

• en pseudo-code :

1 Afficher : expression à afficher

• en Python :

1 print ( expression à afficher )

Exemple.
en pseudo-code : en Python :
1 a ← 10 1 a = 10
2 Afficher : a , 5 , " Bonjour " 2 print (a , 5 , " Bonjour " )

Remarques (importantes).
• Attention à bien distinguer une variable d'une chaîne de caractères :
 La chaîne de caractères est un texte écrit entre guillemets et qui sera aché tel quel.
 Lorsqu'on met un nom de variable (sans guillemets), c'est la valeur de cette variable qui
sera achée.

• En Python, les diérents éléments à acher sont mis entre parenthèses et séparés par
des virgules. Par exemple :
print(42, "Bob", "1+1 =", 1+1)

4
2.3 Aectation d'une valeur à une variable
Dénition
L'aectation est une opération permettant de dénir la valeur initiale d'une variable
(on parle alors d'initialisation), puis de modier la valeur de cette variable.

• En pseudo code, on note :

1 nom_variable ← valeur

• En Python, on note :

1 nom_variable = valeur

Exemple.
en pseudo-code : en Python :
1 annee ← 2021 1 annee = 2021
2 Afficher : annee 2 print ( annee )
3 annee_prochaine ← annee + 1 3 annee_prochaine = annee + 1
4 Afficher : annee_prochaine 4 print ( annee_prochaine )

Remarques.
• On peut aecter à une variable la valeur d'une autre variable au moment de l'aectation.
Tester :

1 a = 42
2 b = a
3 a = 10
4 print (a , b )

• Une même variable peut apparaître à droite et à gauche de l'aectation. Tester :

1 a = 10
2 a = a * 4
3 print ( a )

• On fera toujours très attention à mettre la variable dont on veut changer la valeur à
gauche, et la valeur que l'on veut donner à cette variable à droite.
Par exemple le code ci-dessous génère une erreur :

1 10 = a

Dénition
On appelle incrémentation l'opération (très courante) consistant à ajouter 1 ou une
valeur entière xe à une variable.
Exemple : a ←a + 1 (pseudo-code) ou a = a + 1 (Python).

5
2.4 Saisie
À savoir
Pour rendre un programme interactif, on peut, pendant l'exécution de celui-ci, demander
à l'utilisateur de saisir un texte ou une valeur grâce à une instruction de saisie.
Lorsqu'arrive une instruction de saisie, le programme se met en pause. L'utilisateur doit
alors saisir quelque chose dans la console et appuyer sur la touche "entrée" pour valider.
Pour expliciter ce qu'il faut saisir, une instruction de saisie est en général accompagnée
par l'achage d'un message explicatif. La valeur saisie doit par ailleurs être stockée
dans une variable de manière à pouvoir être réutilisée dans la suite du programme.

Pour demander de saisir une valeur et la stocker dans une variable nommée a, on utilise
les instructions suivantes :
en Python :
en pseudo-code :  pour saisir un texte :

1 Afficher : " message " 1 a = input ( " message " )

2 Saisir a
 pour saisir un nombre :

1 a = eval ( input (" message " ) )

Remarques.
• Dans les instruction précédentes, le nom de variable a doit bien sûr être remplacé par un
nom de variable bien choisi.

• Dans les instruction précédentes, le "message" doit être remplacé par un message expli-
quant à l'utilisateur ce qu'il doit saisir.

Exemple.
• En pseudo-code :

1 Afficher : " Veuillez saisir votre prénom : "

2 Saisir : nom
3 Afficher : " Veuillez saisir votre âge : "
4 Saisir : age
5 Afficher : " Bonjour " , nom , " , vous avez " , age , " ans . "

• En Python :
1 nom = input ( " Veuillez saisir votre prénom : " )
2 age = eval ( input ( " Veuillez saisir votre âge : " ) )
3 print ( " Bonjour " , nom , " , vous avez " , age , " ans . " )

6
Remarque (important !).
La valeur retournée par la fonction input est toujours un texte (du type chaîne de caractère,
str en Python) et non un nombre. Or Python ne gère pas les chaînes de caractères et les
nombres de la même façon. Testez :

1 age = input ( " Veuillez saisir votre âge : ")

2 print ( type ( age ) )
3 print ( age *2)

Il faut donc bien penser au eval lorsqu'on veut saisir un nombre. Testez :

1 age = eval ( input ( " Veuillez saisir votre âge : " ) )

2 print ( type ( age ) )
3 print ( age *2)

2.5 Opérations sur les nombres et variables numériques

Les deux types numériques en Python sont :

• le type int pour les entiers (1, 2, −1, etc...)

• le type float pour les réels, notés avec un point en Python (1.2 etc...)

Python permet d'eectuer les opérations classiques sur les nombres. En plus de celles-ci,
deux opérations importantes sont à connaître :

• la division entière, qui donne la partie entière de la division (ou le quotient de la

division euclidienne pour des entiers). Elle s'obtient par le symbole //.
• le modulo, qui est le reste de la division entière. il s'obtient par le symbole %.
Le tableau ci-dessous récapitule les symboles permettant d'eectuer les diérentes opé-
rations en Python :

division
addition soustraction multiplication division puissance modulo
entière
+ - * / ** // %

Exemple (à tester dans la console).

1+1
10-3
6*7
12/4
10**3
13//3 # retourne 4 car 13/3 vaut environ 4,33 dont la partie entière est 4
13%3 # retourne 1 car 13 - 3 * 13//3 = 1
Remarque.
Attention, les calculs avec des nombres réels (ottants) donnent parfois des résultats approxi-
matifs à cause de la façon dont sont stockés ces nombres (essayez par exemple de calculer
0.1 + 0.2). Il faut toujours privilégier les calculs entiers, et manier les réels avec une extrême
prudence (et ce quelque soit le langage).

7
2.6 Exercices
Exercice 2 (Pour se tester).
1) À quoi sert une variable ?

2) Comment aecter une valeur à une variable a?

3) Comment acher la valeur d'une variable a?
4) Comment demander de saisir un nombre et stocker ce nombre dans une variable a?
5) Quel est le symbole pour l'exposant (puissance) en Python ?

6) À quoi correspondent les opérations // et % en Python ?

Exercice 3 (Sur feuille).

On considère l'algorithme suivant :

1 A ← 5
2 B ← 2
3 C ← A
4 A ← A + 1
5 B ← B + C

Compléter le tableau ci-dessous avec les valeurs des variables A, B, et C après chacune des
lignes (on notera NI si la variable n'a pas été initialisée) :

Numéro de ligne A B C
1
2
3
4
5

Exercice 4.
Traduire en Python puis tester l'algorithme suivant :

1 # Algorithme : Affichage de l ' âge

2 annee ← 2021
3 Afficher : " Veuillez saisir votre année de naissance : "
4 Saisir : annee_naissance
5 Afficher : " Veuillez saisir 1 si votre anniversaire est déjà
passé cette année et 0 sinon "
6 Saisir : anniversaire_deja_passe
7 age ← annee - annee_naissance - 1 + anniversaire_deja_passe
8 Afficher : " Vous avez : " , age , " ans ! "

8
Exercice 5.
Le programme Python ci-dessous contient deux erreurs. Le reproduire puis corriger les erreurs
en testant autant que nécessaire.

1 # Algo : présentation
2 nom = input ( " Veuillez saisir votre nom " )
3 age = input ( " Veuillez saisir votre age " )
4 print ( " Bonjour " , nom , " . Dans 2 ans , vous aurez : " , age +5 , "
ans . " )

Exercice 6.
Une épicerie vend de la farine à 2 euros le kilo, et des tablettes de chocolat à 2,5 euros.
Écrire en pseudo-code puis en Python un algorithme qui :

• demande de saisir un nombre de kilos de farine,

• demande de saisir un nombre de tablettes de chocolat,

• ache le prix à payer au total pour la farine et le chocolat.

Exercice 7.
Bob possède un certain nombre de billes. Il veut grouper ses billes dans des sacs, en mettant
17 billes par sac.
Écrire en pseudo-code puis en Python un algorithme qui :

• demande de saisir un nombre de billes,

• ache le nombre de sacs qui seront pleins,

• ache le nombre de billes restantes.

Exercice 8.
Bob part en voyage aux États-Unis.

a) Écrire en pseudo-code puis en Python un algorithme qui demande de saisir une somme en
euros, qui convertit cette somme en dollars (1 euro vaut environ 1,17dollars), et qui ache
le résultat.

b) Bob veut ramener des chapeaux de cowboy de son voyage. Il trouve des chapeaux à 3,99
dollars pièce. Compléter l'algorithme précédent en achant combien de chapeaux pourront
être achetés au maximum avec la somme saisie à la question a et combien il restera alors
de dollars.

Exercice 9.
a) Écrire en pseudo-code un algorithme qui demande de saisir une somme en centimes, puis
qui donne le nombre de pièces minimal de 2 centimes et 1 centime nécessaires pour payer
cette somme.
Par exemple si l'utilisateur saisit 17 centimes, l'ordinateur achera : 8 pièces de 2 centimes
et 1 pièce de 1 centime.
b) Implémenter en Python l'algorithme précédent, puis le modier pour qu'il donne la dé-
composition de la somme en pièces de 1, 2, 5, 10, 20 et 50 centimes.

9
3 Fonctions et procédures
3.1 Introduction
Nous avons déjà manipulé des fonctions et procédures. Par exemple eval, import, ou print.

Remarques.
• Les fonctions permettent notamment de décomposer un programme complexe en sous-
programmes plus simples et d'améliorer ainsi la lisibilité d'un algorithme. Ces sous-programmes
peuvent en outre être utilisés plusieurs fois au sein d'un même programme, évitant ainsi
des répétitions de code.

• Un autre intérêt des fonctions est qu'elle sont réutilisables dans d'autres programmes et
par d'autres programmeurs.

Exemple.
L'image ci-dessous montre une petite partie de ce que contient la fonction randint qui sert à
générer un entier aléatoire (en fait pseudo-aléatoire) :

Au lieu de devoir réécrire toutes ces instructions à chaque fois que l'on désire obtenir un
entier pseudo-aléatoire par exemple entre 1 et 6, il sut d'écrire randint(1, 6), c'est-à-dire
de faire appel à la fonction randint avec en paramètres 1 et 6.

À savoir
Tout comme les variables, les fonctions portent un nom. Les règles de nommage d'une
fonction sont les mêmes que les règles de nommage d'une variable.

10
3.2 Dénitions et premier exemple
Dénition
• Une fonction est un morceau de code pouvant recevoir en entrée une ou plusieurs
valeurs à partir desquelles elle retourne une ou plusieurs valeurs en sortie.

• Les valeurs que la fonction reçoit en entrée s'appellent les paramètres ou les
arguments de la fonction.

• Les valeurs retournées par la fonction sont les résultats de celle-ci.

Paramètres Résultats
ou Fonction retournés
Arguments par la
fonction

Exemple.
La fonction Python ci-dessous prend en paramètre un nombre à trois chires et retourne les
trois chires de ce nombre dans l'ordre.

1 def decompose ( nombre ) :

2 chiffre1 = nombre // 100
3 reste = nombre % 100
4 chiffre2 = reste // 10
5 chiffre3 = reste % 10
6 return chiffre1 , chiffre2 , chiffre3

La fonction ci-dessus, nommée decompose, a les caractéristiques suivantes :

• elle a un unique paramètre nommé nombre,

• elle retourne trois résultats qui sont nommés chiffre1, chiffre2 et chiffre3.

3.3 Création de fonctions et procédures

Pour dénir une fonction, on utilise la syntaxe suivante :

• En pseudo-code :
1 Fonction nom_fonction ( parametre_1 , parametre_2 , ...) :
2 Variables locales : ....
3 Debut Fonction
4 instructions
5 Retourner : valeur_1 , valeur_2 ,...
6 Fin Fonction

• En Python :
1 def nom_fonction ( parametre_1 , parametre_2 , ...) :
2 instructions
3 return valeur_1 , valeur_2 ,...

11
Exemple.
En pseudo-code : En Python :
1 Fonction cube ( x ) : 1 def cube ( x ) :
2 Variables locales : x , res 2 res = x * x * x
3 Debut Fonction : 3 return res
4 res ← x * x * x
5 Retourner res
6 Fin Fonction

Utilisation (suite de l'algo) : Utilisation (suite de l'algo) :

7 a ← cube (3) 4 a = cube (3)

8 Afficher : a 5 print ( a )
9 Afficher : cube (4) 6 print ( cube (4) )
10 Afficher : cube (5) 7 print ( cube (5) )

Remarques.
• Les parenthèses après le nom de la fonction sont obligatoires. Si une fonction n'a pas de
paramètre, on ne met rien entre les parenthèses.

• Le symbole " :" après les parenthèse est également obligatoire.

• L'instruction Retourner ou return précède la liste des valeurs retournées par la fonction.
Attention, les instructions après le return ne sont pas eectuées.

Dénition
En Python, les instructions qui sont dans la dénition de la fonction (ou dans n'importe
quelle autre structure de programmation) commencent par un espace horizontal appelé
indentation.
L'indentation s'obtient grâce à la touche tabulation (on peut également l'obtenir en
appuyant quatre fois sur la touche espace). Elle est obligatoire en Python.

Remarque.
L'indentation fait partie du code, elle sert à indiquer le début et la n d'une structure : les
instructions indentées sont dans la structure, celles qui ne sont pas indentées sont hors de la
structure.
Les règles d'indentation sont donc à respecter scrupuleusement sous peine d'erreurs.

Dénition
Il existe des structures en tout point similaires à des fonctions, mais ne retournant
aucun résultat. Dans ce cas, on parle de procédure.
Les procédures se construisent de la même façon que les fonctions en Python (et en
pseudo-code). La seule diérence est qu'elles ne contiennent pas l'instruction return.

12
3.4 Appel d'une fonction ou d'une procédure
Remarque.
Dénir une fonction est un peu comme écrire une recette de cuisine : on fait la liste des
ingrédients (paramètre d'entrée), puis on note les instructions à eectuer avec ces ingrédients
pour arriver à un résultat nal. Mais une fois qu'on a ni d'écrire la recette de cuisine, on n'a
toujours rien cuisiné : il faut que quelqu'un réunisse les ingrédients et eectue les instructions
de la recette avec ceux-ci pour obtenir le plat.

Dénitions
• Dénir une fonction veut dire écrire les instructions constituant cette fonction (c'est-
à-dire, en Python, le def et tout ce qui est indenté ensuite).

• Pour exécuter les instructions constituant une fonction, il faut avoir recours à une
instruction qui porte le nom d'appel à la fonction.

Remarque.
Attention : sans appel, aucune instruction n'est exécutée !
3.4.1 Appel d'une fonction

Il existe deux cas de gure pour l'appel d'une fonction :

• Premier cas : on veut utiliser le résultat de la fonction dans des instructions ulté-
rieures. Dans ce cas, il est nécessaire de stocker le résultat de la fonction dans une
variable.
En pseudo-code : En Python :
1 variable ← nom_fonction ( 1 variable = nom_fonction (
paramètres ) paramètres )

• Deuxième cas : on veut juste acher le résultat de la fonction (pour tester celle-ci
par exemple).
En pseudo-code : En Python :
1 Afficher : nom_fonction ( 1 print ( nom_fonction (
paramètres ) paramètres ) )

Exemple.
1 # appel de la fonction min ( premier cas ) :
2 a = min (5 , 42)
3 print ( a )
4 # appel de la fonction min ( deuxième cas ) :
5 print ( min (5 , 42) )

13
3.4.2 Appel d'une procédure

Pour appeler une procédure, on utilise la syntaxe suivante :

En pseudo-code : En Python :
1 nom_procédure ( paramètres ) 1 nom_procédure ( paramètres )

Exemple.
Dénition et appel d'une procédure affiche_somme en Python :

1 # Définition :
2 def affiche_somme (x , y ) :
3 print (x , " + " , y , " vaut : " , x + y )
4 # Appel :
5 affiche_somme (3 ,2) # L ' appel ne contient pas de print !

Remarque.
En Python, si on ne met pas de return, la procédure ainsi obtenue retournera en fait l'objet
None. Tester (à la suite de l'exemple précédent) :

1 a = affiche_somme (3 , 2)
2 print ( a )
3 print ( affiche_somme (40 ,2) )

En cas d'achage non voulu de None, vériez que vous n'avez pas fait appel à une procédure
avec la méthode d'appel d'une fonction.

3.5 Variables locales et variables globales

Dénition
• Lorsque des variables sont dénies à l'intérieur d'une procédure ou d'une fonc-
tion, elles ne sont accessibles que dans cette dernière. On dit que ce sont des
variables locales. Les paramètres d'une fonction sont également des variables locales.

• Les variables dénies à l'extérieur d'une procédure ou d'une fonction sont appelées
variables globales. Elles sont accessibles à l'intérieur d'une fonction si une variable
locale de même nom n'existe pas.

Remarque. Les variables locales dénies dans une fonction (ou une procédure), y compris
les paramètres, sont supprimées de la mémoire après exécution de la fonction.

Exemple.
1 def somme (x , y ) :
2 s = x + y # s est une variable locale ( dans le def )
3 return s
4 print ( somme (20 , 22) )
5 print ( s ) # génère une erreur : s ( locale ) n ' existe pas ici

14
3.6 Fonctions prédénies
3.6.1 Dénitions
En Python, il existe un très grand nombre de fonctions prédénies. Il n'est pas pra-
tique de charger toutes ces fonctions en mémoire. Une grosse partie d'entre elles sont
donc stockées dans des chiers appelés modules qu'il faut importer en mémoire avant
utilisation.

3.6.2 Modules
Pour charger un module en mémoire, on utilise l'instruction import.

Exemple.
Pour utiliser la fonction randint du module random, on peut utiliser l'instruction import de
plusieurs façons diérentes :

• Méthode 1 : en important uniquement la fonction voulue depuis (from en anglais) le module

dans l'espace de noms principal :

1 from random import randint

2 # utilisation :
3 print ( randint (0 ,10) )

• Méthode 2 : en important toutes les fonctions du module dans l'espace de noms principal :

1 from random import *

2 # utilisation :
3 print ( randint (0 ,10) )

• Méthode 3 : en important toutes les fonctions du module dans un sous-espace de l'espace

de noms principal. Pour utiliser les fonctions du module, il faut alors spécier l'espace de
noms dans lequel elles ont été chargées. Par défaut, ce nom est le nom du module :

1 import random
2 # utilisation :
3 print ( random . randint (0 ,10) )

Remarque.
Pour obtenir la liste des fonctions contenues dans un module, on utilise la commande help
suivi du nom du module entre guillemets. Par exemple :

1 help ( " random " )

Le module random et sa fonction randint seront régulièrement utilisés et sont à connaître

pour l'examen.

15
3.7 Exercices
Exercice 10 (Pour se tester).
1) Qu'est une fonction ?

2) Comment dénit-on une fonction ?

3) Comment fait-on appel à une fonction ?

4) Quelle est la diérence entre procédure et fonction ?

5) Comment fait-on appel à une procédure ?

6) Qu'est une variable locale ? Qu'est ce qui la caractérise ?

7) Comment importe-t-on un module ?

Exercice 11.
1) Traduire en Python la fonction donnée ci-dessous en pseudo-code :

1 Fonction double ( nombre ) :

2 Variables locales : nombre , double_du_nombre
3 Debut Fonction
4 double_du_nombre ← 2 * nombre
5 retourner double_du_nombre
6 Fin Fonction

2) Tester la fonction Python en ajoutant au programme deux appels à la fonction.

Exercice 12.
Le programme Python ci-dessous tente de dénir une fonction prenant en paramètre trois
nombres et retournant la moyenne de ces nombres, puis de faire appel à cette fonction.
Ce programme contient plusieurs erreurs.

1 def moyenne ( nb1 , nb2 , nb3 ) :

2 nb1 = 1
3 nb2 = 2
4 nb3 = 3
5 moy = 1 + 2 + 3 / 3
6 moyenne (10 , 9 , 11)
7 print ( moy )

Reproduire le programme, puis corriger les erreurs en testant autant que nécessaire.

Exercice 13.
Écrire en pseudo-code et en Python une fonction produit prenant en paramètres d'entrée
deux nombres entiers et retournant leur produit.
Par exemple produit(6, 7) devra retourner 42.

Exercice 14.
Écrire en pseudo-code et en Python une fonction echange prenant en paramètres d'entrée
deux nombres entiers et retournant ces entiers dans l'ordre inverse.
Par exemple echange(12, 98) devra retourner 98, 12.

16
Exercice 15.
Écrire en pseudo-code et en Python une fonction deux_des qui ne prend pas de paramètre et
retourne deux entiers aléatoires entre 1 et 6.
Par exemple la fonction pourra retourner 4, 2.

Exercice 16.
Écrire en pseudo-code et en Python une procédure conv_duree prenant en paramètre une
durée en secondes puis achant cette même durée en heures, minutes et secondes.
Par exemple conv_duree(7422) achera "2 heures, 3 minutes et 42 secondes".

Exercice 17.
Jusqu'en 1971, une livre (monnaie anglaise) était divisée en 20 shillings, et chaque shilling
était lui-même divisé en 12 pences.

Dans la suite, on s'intéresse à un libraire londonien de 1970, vendant des journaux à 7 pences
chacun.

1) Écrire en pseudo-code et en Python une fonctions prix qui :

• prend en paramètre un nombre de journaux,

• retourne le prix de ces journaux.

Par exemple prix(6) devra retourner 42.

2) Écrire en pseudo-code et en Python une fonctions conversion qui :

• prend en paramètre une somme en pences,

• retourne les nombres de livres, de shillings et de pences qui constituent cette somme.

Par exemple conversion(267) devra retourner 1, 2, 3 car 267 pences correspondent à 1

livre, 2 shillings et 3 pences.

3) Écrire en pseudo code et en Python un algorithme qui :

• demande de saisir un nombre de journaux,

• calcule et ache la somme à payer pour ces journaux, d'abord en pences, puis en livres,
shillings et pences.

Par exemple si le nombre de journaux saisi est 38, l'algorithme achera que le prix total
est de 266 pences, soit 1 livre, 2 shillings et 2 pences.

L'algorithme utilisera sans les redénir les deux fonctions précédentes.

17
4 Les structures conditionnelles
4.1 La structure
Les structures conditionnelles permettent de faire varier le comportement de l'algo-
rithme en fonction d'une ou plusieurs conditions. Une structure conditionnelle est
construite de la façon suivante :

En pseudo-code : En Python :
1 Si condition 1 : 1 if condition 1 :
2 instructions 1 2 instructions 1
3 Sinon Si condition 2 : 3 elif condition 2 :
4 instructions 2 4 instructions 2
5 Sinon Si condition 3: 5 elif condition 3 :
6 instructions 3 6 instructions 3
7 # etc ... 7 # etc ...
8 Sinon : 8 else :
9 autres instructions 9 autres instructions
10 Fin Si

Dans cette structure, les conditions sont examinées dans l'ordre :

 Si la condition examinée est satisfaite, on eectue les instructions correspon-
dantes puis on sort de la structure conditionnelle. Sinon, on passe à la condition
suivante.
 Si aucune condition n'est satisfaite, on suit les instructions écrites après le Si-
non/else si il y en a un. Sinon, on sort de la structure.

Exemple.
En pseudo-code : En Python :
1 Algo : conditions et dé 1 # Algo : conditions et dé
2 Variable numérique : de 2 from random import *
3 DEBUT 3
4 de ← randint (1 ,6) 4 de = randint (1 ,6)
5 Afficher : " de = " , de 5 print ( " de = " , de )
6 Si de <= 2 : 6 if de <= 2 :
7 Afficher : " on a 1 ou 2 " 7 print ( " on a 1 ou 2 " )
8 Sinon Si de < 6 : 8 elif de < 6 :
9 Afficher : " on a 3 , 4 ou 5 " 9 print ( " on a 3 , 4 ou 5 " )
10 Sinon : 10 else :
11 Afficher " on a 6 " 11 print ( " on a 6 " )
12 Fin Si
13 FIN

Remarques.
• Un oubli du symbole  :  provoque une erreur de syntaxe.

• L'indentation est obligatoire. On peut imbriquer plusieurs structures (conditionnelles, fonc-

tions, boucles), à condition d'indenter autant de fois que nécessaire.

• Le else/Sinon est optionnel et on peut mettre autant de elif/Sinon Si que l'on veut, y
compris aucun.

18
4.2 Formuler les conditions
4.2.1 Opérateurs de comparaison

Les conditions qui apparaissent dans les structures conditionnelles sont exprimées à
l'aide d'opérateurs de comparaison. Il y a six opérateurs de comparaison :

En pseudo-code = 6= < ≤ > ≥

En Python == != < <= > >=

Exemples. Tester dans la console :

1==2
1!=2
1<2
40<=40
15>3
1>=2

Les conditions qui apparaissent dans les structures conditionnelles peuvent prendre
deux valeurs :
 vrai (True en Python) (Attention aux majuscules !)
 faux (False en Python)
Ce sont des booléens (type bool en Python).

Exemple.
1 variable_booleenne = (1 >1)
2 print ( variable_booleenne )
3 print ( type ( variable_booleenne ) )

4.2.2 Opérateurs booléens

On peut combiner des conditions à l'aide d' opérateurs booléens :

• L'opérateur ET se traduit en python par and :

(A ET B) est vrai si et seulement si A et B sont tous deux vrais.

• L'opérateur OU (ou inclusif ) se traduit en python par or :

(A OU B) est vrai si au moins une des deux conditions A ou B est vraie.

• L'opérateur NON se traduit en Python par not et exprime la négation.

Remarque.
Le OU logique est un OU inclusif alors que dans le langage courant, le OU est souvent exclusif
(par exemple, dans  fromage ou dessert , il faut choisir l'un ou bien l'autre).

Exemples. Tester dans la console :

(1<2) or (2<3)
(1==1) and (1>150)
not (24>=37)
not (True and (40==12))

19
4.3 Exercices
Exercice 18 (Pour se tester).
1) À quoi sert une structure conditionnelle ?

2) Comment faire une structure conditionnelle ?

3) Quels sont les opérateurs de comparaison en Python ?

4) Quels sont les opérateurs booléens en Python ?

Exercice 19.
Traduire en Python l'algorithme ci-dessous, puis le tester plusieurs fois en saisissant diérentes
valeurs.

1 Algorithme : Indicateur de majorité

2 Variable numérique : age
3 DEBUT
4 Afficher : " Veuillez saisir votre age : "
5 Saisir : age
6 Si age < 18 :
7 Afficher : " Vous êtes mineur ! "
8 Sinon :
9 Afficher : " Vous êtes majeur ! "
10 Fin Si
11 FIN

Exercice 20.
Le programme Python ci-dessous demande de saisir un température, et ache l'état de l'eau à
cette température. Ce programme contient des erreurs. Le reproduire, et le corriger en testant
autant que nécessaire.

1 temperature = input ( " Veuillez saisir une température : " )

2 if temperature <= 0
3 print "L ' eau est à l ' état solide . "
4 if temperature < 100
5 print "L ' eau est à l ' état liquide . "
6 else
7 print "L ' eau est à l ' état gazeux . "

Exercice 21.
Le mot de passe d'un ordinateur est "James-Bob". Écrire en pseudo-code et en Python un
algorithme qui demande à l'utilisateur de saisir un mot de passe, et qui ache un bip d'alarme
si le mot de passe saisi est incorrect.

Exercice 22.
Une place dans un cinéma coûte 5 euros pour les moins de 10 ans, 6 euros pour les moins de
18 ans et 8 euros pour les autres. Écrire en pseudo-code et en Python une procédure prix
qui prend en paramètre un âge et ache le prix correspondant.

20
Exercice 23.
Écrire une fonction maximum prenant en paramètres 2 nombres entiers et retournant le plus
grand des deux.

Exercice 24.
On veut réaliser un programme de calcul mental. Écrire en pseudo-code et en Python un
algorithme qui :

• tire aléatoirement deux entiers entre 1 et 10,

• demande de saisir le produit de ces deux entiers,

• ache "Gagné !" si le produit saisi est correct, et ache "Perdu !" ainsi que le vrai résultat
si le produit saisi est incorrect.

Exercice 25.
Bob ne va à la plage que si l'une des deux conditions suivantes au moins est satisfaite :
 la température de l'air est supérieure à 25 degrés,
 la température de l'eau est supérieure à 20 degrés.
Écrire en Python un algorithme demandant la température de l'eau et de l'air, et achant
un message si Bob peut aller à la plage.

Exercice 26.
Au baccalauréat, l'admission et la mention dépendent de la note :
 si la note est inférieure à 10, on est refusé,
 si la note est entre 10 (inclus) et 12 (exclu), on est admis sans mention,
 si la note est entre 12 (inclus) et 14 (exclu), on est admis avec la mention "Assez bien",
 si la note est entre 14 (inclus) et 16 (exclu), on est admis avec la mention "Bien",
 sinon, on est admis avec la mention "Très bien".

Écrire en pseudo-code et en Python une fonction mention qui prend en paramètre une note
et retourne une chaîne de caractères indiquant si la note permet d'être admis, et la mention
associée.
Par exemple mention(14.5) devra retourner "Admis avec la mention bien".

Exercice 27.
Un sac contient 10 balles numérotées de 1 à 10 et telles que : les balles 1 et 2 sont vertes, les
balles 3, 4 et 5 sont bleues et les autres balles sont rouges. Bob vous propose un jeu : vous
devez parier sur une couleur, puis, il tire une balle au hasard, et si cette balle est de la couleur
que vous avez choisie, vous avez gagné.

1) Écrire en pseudo-code et en Python une fonction tirage qui :

• ne prend pas de paramètre,

• simule le tirage d'une balle et ache son numéro,

• retourne une chaîne de caractères donnant le numéro de la balle.

2) Écrire en pseudo-code et en Python un algorithme qui :

• demande de saisir une couleur,

• réalise un tirage de balle grâce à la fonction tirage,

• ache la couleur de la balle tirée,

• ache un message indiquant si l'on a gagné ou non.

21
5 Les boucles
5.1 Introduction et dénition
On veut acher la table de multiplication de 7, de 7×1 à 7×4 :

1 Algorithme : affichage de la table de 7

2 Variables : -
3 DEBUT
4 Afficher : " 7 fois 1 = " , 7*1
5 Afficher : " 7 fois 2 = " , 7*2
6 Afficher : " 7 fois 3 = " , 7*3
7 Afficher : " 7 fois 4 = " , 7*4
8 FIN

Imaginons maintenant qu'on veuille aller jusqu'à 7 × 100. Pour éviter de devoir écrire 100
instructions, on a recours à une boucle

Dénition
Une boucle (ou structure itérative), est une structure permettant de répéter plusieurs
fois l'exécution d'un bloc d'instructions. Il en existe deux en Python : la boucle "Tant
que" et la boucle "Pour".

5.2 Boucle  Tant que 

La boucle  tant que  permet de répéter un bloc d'instructions tant qu'une condition
est vériée. Lorsque la condition n'est plus vériée, on sort de la boucle. Une telle
structure se formalise de la façon suivante :

En pseudo-code : En Python :
1 Tant Que condition : 1 while condition :
2 instructions 2 instructions
3 Fin Tant Que

Exemple (1).
En pseudo-code : En Python :
1 Algo : affichage de 1 à 10 1 # Algo : affichage de 1 à 10
2 Variable numérique : i 2
3 DEBUT 3
4 i ← 1 4 i = 1
5 Tant Que i ≤ 10 5 while i <= 10 :
6 Afficher : i 6 print ( i )
7 i ← i + 1 7 i = i + 1
8 Fin Tant Que 8
9 Afficher : " Fin de la boucle " 9 print ( " Fin de la boucle " )
10 FIN

22
Exemple (2).
En pseudo-code : En Python :
1 Algorithme : lancer de dé 1 # Algorithme : lancer de dé
2 Variables num : de , compteur 2 from random import *
3 DEBUT 3
4 de ← 0 4 de = 0
5 compteur ← 0 5 compteur = 0
6 Tant Que de 6= 6 : 6 while de != 6 :
7 de ← randint (1 ,6) 7 de = randint (1 ,6)
8 Afficher : " score " , de 8 print ( " score : " , de )
9 compteur ← compteur + 1 9 compteur = compteur + 1
10 Fin Tant Que 10
11 Afficher : " nb de lancers : " , 11 print ( " nb de lancers : " ,
compteur compteur )
12 FIN

Remarques.
• Attention, si la boucle  Tant que  est mal utilisée, elle peut donner lieu à une exécution
innie. Pour que l'exécution de la boucle  Tant que  se termine, il faut qu'à un moment
la condition devienne fausse. En particulier, les instructions dans la boucle doivent modier
la variable utilisée dans le test.

• Une fois encore, il ne faut pas oublier le " :", ni d'indenter le bloc d'instructions.

• La boucle  Tant que  est une boucle non déterministe : on ne sait pas forcément à
l'avance combien d'itérations seront eectuées. Il arrive qu'elle ne soit pas exécutée du tout
lorsque la condition est fausse dès le départ.

5.3 Boucle  Pour 

La boucle  Pour  utilise une variable, que l'on appelle compteur, qui sert à repérer
le nombre d'itérations déjà eectuées. Le compteur part d'une valeur de départ et
augmente à chaque itération d'un nombre xe, appelé pas, jusqu'à atteindre une valeur
d'arrivée. Pour chaque valeur du compteur, le bloc d'instructions est exécuté une fois.

La boucle  Pour  se formalise de la façon suivante :

En pseudo-code :
1 Pour compteur Allant De depart À arrivee ( exclue ) Par Pas
De pas :
2 instructions
3 Fin Pour

En Python :
1 for compteur in range ( depart , arrivee , pas ) :
2 instructions

23
Exemple.
• En pseudo-code :

1 Algorithme : affichage des nombres pairs de 0 à 100

2 Variable numérique : compteur
3 DÉBUT
4 Pour compteur Allant De 0 À 101 ( exclu ) Par Pas DE 2 :
5 Afficher : compteur
6 Fin Pour
7 FIN

• En Python :
1 # Algorithme : affichage des nombres pairs de 0 à 100
2 for compteur in range (0 ,101 ,2) :
3 print ( compteur )

Remarques.
• La boucle "Pour" n'est utilisée que lorsque le nombre d'itérations est connu dès le départ.

• Attention, en python, la valeur de départ est toujours incluse, mais la valeur d'arrivée
est toujours exclue.
Ainsi, si l'on écrit for compteur in range(a,b), le compteur ira de a à b-1.
En pseudo-code, il faut préciser (systématiquement) si b est exclu ou inclus.

• Dans la boucle "Pour" la valeur du compteur est modiée automatiquement.

On peut ne pas préciser de valeur pour le pas. La valeur par défaut du pas est de 1.
En pseudo-code, cela donne :

1 Pour compteur Allant De depart À arrivee ( exclue ) :

et en Python :

1 for compteur in range ( depart , arrivee ) :

En Python, on peut ne pas donner de valeur de départ, la valeur de départ par défaut
étant 0. Par exemple si on écrit :

1 for compteur in range (7) :

le compteur ira de 0 à 6 par pas de 1.

Remarque.
On peut imbriquer plusieurs structures (itératives ou autres), toujours en faisant très attention
à indenter correctement.

24
5.4 Exercices
Exercice 28 (Pour se tester).
1) À quoi sert une boucle ?

2) Quels sont les deux types de boucle en Python ?

3) Quelle est la diérence entre les deux types de boucle en Python ?

4) Comment faire chacun des deux types de boucle ?

Exercice 29.
Traduire en Python l'algorithme donné ci-dessous en pseudo-code, puis le tester :

1 Algorithme : calcul mental

2 Variables numériques : nb1 , nb2 , resultat_saisi
3 DEBUT
4 nb1 = randint (1 , 10)
5 nb2 = randint (1 , 10)
6 Afficher : nb1 , " * " , nb2 , " = ? "
7 Saisir : resultat_saisi
8 Tant Que resultat_saisi 6= nb1 * nb2 :
9 Afficher : " Le résultat est incorrect , essayez encore : "
10 Saisir : resultat_saisi
11 Fin Tant Que
12 Afficher : " Bravo ! "
13 FIN

Exercice 30.
Les deux algorithmes ci-dessous sont censés acher la table de multiplication de 3 (de 3×1
à 3 × 10). Les reproduire puis les corriger en testant autant que nécessaire.

1)

1 # Algo : table de 3 avec for

2 for i in range (10)
3 print ( " 3* i = " , 3*1)
4 endfor

2)

1 # Algo : table de 3 avec while

2 while i < 10
3 print ( " 3* i = " , 3*1)

Exercice 31.
a) Écrire en pseudo-code puis en Python une procédure prenant en paramètre une valeur
val et achant les carrés des nombres entre 1 et val (inclus). Cette procédure devra
inclure une boucle Tant Que.

b) Même exercice avec une boucle Pour.

25
Exercice 32.
Un compte informatique de Bob est protégé par le mot de passe "James-Bob". Écrire en
pseudo-code puis en Python un algorithme qui demande de saisir un mot de passe jusqu'à ce
que le bon mot de passe soit saisi.

Exercice 33.
Écrire en pseudo-code puis en Python un algorithme qui :

• simule les tirages successifs d'un dé jusqu'à ce qu'un 2 apparaisse,

• ache le nombre de lancers eectués pour obtenir le 2.

Exercice 34.
Dans la mare qui est dans son jardin, Bob a mis un nénuphar. Au début, la surface du
2
nénuphar est de 9 cm . Tous les mois, la surface du nénuphar augmente de 20%.

a) Écrire une fonction seuil prenant en paramètre une surface de mare, et retournant le
nombre de mois mis par le nénuphar pour dépasser cette surface.

b) Tester la fonction seuil sachant que la surface de la mare est de 6 m

2
(c'est-à-dire 60 000
2
cm ).

Exercice 35.
Bob se lance dans la vente de plants de nénuphars. Il en vend 3 le premier jours. Le nombre
de plants vendus double ensuite chaque jour.

a) Écrire en pseudo-code puis en Python un algorithme achant le nombre de plants vendus

chaque jour jusqu'au trentième jour.

b) Modier l'algorithme précédent pour calculer le nombre total de plants vendus en 30 jours.

Exercice 36.
a) Écrire en pseudo-code puis en Python une procédure prenant en paramètre un entier, et
achant la liste des diviseurs de cet entier.

b) Modier la procédure précédente en une fonction retournant le nombre de diviseurs de

l'entier choisi comme paramètre.

Exercice 37 (Le jeu du nombre à deviner).

Le but du jeu est de deviner un nombre entier entre 0 et 50 choisi aléatoirement par l'ordina-
teur. Écrire en pseudo-code puis en Python un algorithme qui :

• tire au hasard un entier entre 0 et 50 qui sera le nombre cible,

• répète les étapes suivantes jusqu'à ce que le nombre cible soit deviné :
 demander de saisir un entier entre 0 et 50
 acher un message disant si l'entier saisi est égal plus petit ou plus grand que le nombre
cible

• ache un message de victoire.

26
Exercice 38 (Jeu du 1 fatal).
On veut jouer à un jeu à deux joueurs dont les règles sont les suivantes :

• Le joueur 1 commence.

• Lorsque c'est son tour, chaque joueur lance un dé. Il peut relancer son dé autant qu'il veut
jusqu'à 9 fois (10 lancers en tout), mais si il tombe sur un 1, il doit s'arrêter.
Le joueur gagne alors :
 0 points si il est tombé sur un 1,
 la somme de ses dés sinon.

• Le premier joueur à avoir 100 points ou plus gagne.

1) Écrire en Python une fonction tour qui :

• ne prend pas de paramètre,

• simule un tour de jeu, en respectant les spécications suivantes :

 À chaque lancer de dé, la valeur du dé doit être achée,
 Si le dé tombe sur 1 ou si 10 lancers ont été eectués, le tour prend n.
 Sinon, après le lancer, le programme doit demander au joueur si il veut relancer.
 Le joueur devra alors saisir 0 pour arrêter et 1 pour relancer.

• Ache puis retourne le nombre de points gagnés au cours du tour.

Indice : on pourra utiliser une variable booléenne continuer pour le test de boucle.

2) Écrire en Python l'algorithme du jeu. Cet algorithme devra :

• initialiser les scores des deux joueurs à 0,

• répéter jusqu'à ce que l'un des joueurs ait atteint ou dépassé 100 points :
 acher le score des deux joueurs,
 acher un message indiquant que c'est au joueur 1 de jouer,
 faire jouer le joueur 1 grâce à la fonction tour
 si le joueur 1 n'a pas atteint 100 points, recommencer les trois étapes précédentes
pour le joueur 2

• Acher les scores naux et le gagnant.

Pour rendre le programme plus lisible, on pourra acher des lignes vides autant que
nécessaire.

27
6 Tableaux
6.1 Que sont les tableaux ?
À savoir
• Un tableau permet de stocker plusieurs valeurs dans une seule variable.

• Ces valeurs sont appelées éléments.

• Chaque élément est associé à un entier appelé indice ou rang qui repère sa position
dans le tableau.

Tableau : Élément 0 Élément 1 Élément 2 ...

Indices

Remarque.
Il existe plusieurs structures de données permettant de regrouper plusieurs éléments dans une
seule variable. Parmi elles :

• les tableaux, qui consistent à réserver un espace mémoire de taille xe, et à stocker les
éléments les uns après les autres dans cette espace.

• les listes chaînées, pour lesquelles on peut stocker les éléments n'importe où dans la mé-
moire. Cette structure de données a l'avantage d'avoir une taille extensible, mais pour s'y
retrouver, chaque élément doit être accompagné de l'adresse mémoire de l'élément suivant,
et accéder à un élément nécessite donc de suivre les adresses successives, ce qui est coûteux.

À savoir
En Python, les tableaux sont représentés par le type list.

Remarque.
L'appellation list est malheureuse, car les éléments de type list sont bien des tableaux et
non des listes chaînées. Ce sont toutefois des tableaux dynamiques, c'est-à-dire un genre de
tableaux améliorés, et qui présentent quelques avantages des listes.
Nous utiliserons par la suite quelques opérations qui sont interdites aux tableaux dans les
autres langages.

6.2 Création, accès aux éléments, modications

• En Python comme en pseudo-code, on représente un tableau en mettant entre cro-
chets les éléments séparés par des virgules.

• Le tableau qui ne contient aucun élément s'appelle le tableau vide et se note sim-
plement [].

Exemple.
En pseudo-code : En Python :
1 tab ← [5 , 1 , 42] 1 tab = [5 , 1 , 42]
2 Afficher : tab 2 print ( tab )
3 tab_vide ← [] 3 tab_vide = []

28
 • Pour accéder à l'élément d'indice i du tableau tab, on utilise, en pseudo-code comme
en Python, l'expression :

1 tab [ i ]

• On peut modier les éléments d'un tableau (les tableaux sont un type dit "mutable")
comme on modie une variable (avec une aectation).

• Attention, les indices commencent à 0 en Python.

Exemple.
En pseudo-code : En Python :
1 tab ← [5 , 1 , 42 , 8 , 34] 1 tab = [5 , 1 , 42 , 8 , 34]
2 Afficher : tab [2] 2 print ( tab [2])
3 tab [3] ← 100 3 tab [3] = 100
4 Afficher : tab 4 print ( tab )

Remarques.
• En Python, un tableau est non-typé : il peut contenir des variables de types diérents.

• En Python, on peut aussi accéder aux éléments à partir de la n du tableau en utilisant

des indices négatifs.

• tab[a:b] est une tranche du tableau contenant les éléments d'indices allant de a (inclus)
à b (exclu).

6.3 Longueur et parcours d'un tableau

• La longueur d'un tableau est le nombre d'éléments de celui-ci. En Python, elle est
donnée par la fonction len.
• Pour parcourir l'un après l'autre les éléments d'un tableau, on utilise une boucle. Il
y a deux façon de faire. Par exemple pour acher les éléments :

Méthode 1 :
En pseudo-code : En Python :
1 Pour i Allant De 0 À 1 for i in range (0 , len ( tab ) ) :
longueur ( tab ) ( exclu ): 2
2 Afficher : tab [i ] 3 print ( tab [ i ])
3 Fin Pour

Méthode 2 :
En pseudo-code : En Python :
1 Pour elt Dans tab : 1 for elt in tab :
2 Afficher : elt 2 print ( elt )
3 Fin Pour

29
Exemple.
Ajout de 1 à tous les éléments d'un tableau d'entiers :
En pseudo-code : En Python :
1 Algorithme : ajout de 1 1 # Algorithme : ajout de 1
2 Variables : tab ( tableau d ' 2
entiers ) , i ( entier ) 3
3 DEBUT 4
4 tab ← [30 , 18 , 4 , 2 , 9] 5 tab = [30 , 18 , 4 , 2 , 9]
5 Pour i Allant De 0 À 6 for i in range (0 , len ( tab ) ) :
longueur ( tab ) ( exclu ): 7
6 tab [ i ] ← tab [ i ] + 1 8 tab [ i ] = tab [ i ] + 1
7 Fin Pour 9
8 Afficher : tab 10 print ( tab )
9 FIN

6.4 Opérations sur les tableaux en Python

6.4.1 Concaténation
Si l'on dispose de deux tableaux, on peut vouloir les coller l'un à l'autre pour n'avoir
plus qu'un tableau. Cette opération s'appelle la concaténation.
Pour faire une concaténation, on utilise l'opérateur +.

Exemple.
En pseudo-code : En Python :
1 tab ← [1 , 2 , 3] + [4 , 5] 1 tab = [1 , 2 , 3] + [4 , 5]
2 Afficher : tab 2 print ( tab )
3 tab2 ← tab + [6 , 7] 3 tab2 = tab + [6 , 7]
4 Afficher : tab2 4 print ( tab2 )

Remarques.
• L'opérateur + ne modie pas directement un tableau. Il crée un nouveau tableau qu'il
faut aecter à une variable.

• On peut également concaténer plusieurs fois un tableau à lui-même avec le symbole : ∗.

1 tab = [1 , 2] * 3
2 print ( tab )

30
6.4.2 Ajout d'un élément à la n d'un tableau

Pour ajouter l'élément elt à la n du tableau tab, on peut :

• utiliser la concaténation :
En pseudo-code : En Python :
1 tab ← tab + [ elt ] 1 tab = tab + [ elt ]

• utiliser la méthode append :

En pseudo-code : En Python :
1 Ajouter elt à la fin de tab 1 tab . append ( elt )

Exemple.
En pseudo-code : En Python :
1 tab ← [1 , 2 , 3] 1 tab = [1 , 2 , 3]
2 tab ← tab + [4] 2 tab = tab + [4]
3 Ajouter 5 à la fin de tab 3 tab . append (5)
4 Afficher : tab 4 print ( tab )

6.4.3 Copie d'un tableau

Un tableau en Python est stocké sous la forme d'une adresse mémoire. Lorsqu'on veut copier
un tableau, c'est l'adresse du tableau qui est copiée. On obtient alors deux variables qui
pointent vers le même tableau, et toute modication de l'une modiera aussi l'autre.

Exemple.
Dans l'exemple ci-dessous, a est modié en même temps que b :

1 a = [1 ,2 ,3 ,4 ,5]
2 b = a
3 b [1] = 10
4 print ( a )

Pour copier un tableau tab1 dans un tableau tab2 stocké dans un emplacement mémoire
diérent, il faut utiliser l'instruction :

1 tab2 = tab1 [:]

Exemple.
1 a = [1 ,2 ,3 ,4 ,5]
2 b = a [:]
3 b [1] = 10
4 print ( a )

31
6.4.4 Création d'un tableau de taille donnée
Il arrive souvent que l'on ne connaisse pas dès le départ tous les éléments d'un tableau.
Pour construire un tableau petit à petit, il y a deux façons de procéder :

• La méthode 1 : consiste à créer un tableau de la taille voulue dont tous les éléments
sont identiques (par exemple 0), puis à modier les éléments un par un. (Cela nécessite
de connaître la taille à l'avance).

Exemple. Remplissons par exemple un tableau avec dix nombres aléatoires.

1 tab = [0]*10 # On crée un tableau contenant 10 zéros

2 for i in range (0 ,10) :
3 tab [ i ] = randint (1 ,100) # On modifie les éléments
4 print ( tab )

• La méthode 2 : consiste à créer un taleau vide auquel on ajoute des éléments petit
à petit.

Exemple. Remplissons par exemple un tableau avec dix nombres aléatoires.

1 tab = [] # On part du tableau vide

2 for i in range (0 ,10) :
3 tab = tab + [ randint (1 ,100) ] # Ajout d ' un élément
4 print ( tab )

6.4.5 Autres opérations

Si on dispose d'un tableau appelé tab, on peut utiliser diérentes fonctions :

• Faire la somme des éléments du tableau : somme = sum(tab)

• Trouver le maximum du tableau : maximum = max(tab)

• Trouver le minimum du tableau : minimum = min(tab)

Il existe aussi diérentes méthodes de tableaux :

• Trier un tableau : tab.sort()

• Trouver l'indice d'un élément : tab.index(2)
• Inverser un tableau : tab.reverse()
• Enlever un élément : tab.remove(2)
• La liste complète des méthodes de tableaux s'obtient en tapant dans l'interpréteur :
help(list)
Remarque.
On s'interdira d'utiliser les fonctions et méthodes toutes faites pour tous les exercices de ce
document.

32
6.5 Exercices
Exercice 39 (Pour se tester).
1) Qu'est un tableau ?

2) Comment est représenté un tableau en Python

3) Comment accéder à l'élément d'indice i d'un tableau tab ?

4) Comment parcourir un tableau ?

5) Comment concaténer deux tableaux ?

6) Comment ajouter un élément à la n d'un tableau ?

7) Comment construire un tableau de taille n contenant par exemple des entiers aléatoires ?

Exercice 40.
Traduire en Python l'algorithme donné ci-dessous en pseudo-code et le tester.

1 Algorithme : remplacement des 3 par des 8

2 Variables :
3 DEBUT
4 tab ← [3 , 1 , 2 , 3 , 8 , 9 , 3]
5 Pour i Allant De 0 À longueur ( tab ) ( exclu ) :
6 Si tab [ i ] = 3:
7 tab [ i ] ← 8
8 Fin Si
9 Fin Pour
10 FIN

Exercice 41.
On veut écrire en Python une procédure afficheL prenant en paramètre un tableau et a-
chant l'un après l'autre tous les éléments de ce tableau. Reproduire puis corriger la fonction
ci-dessous en testant autant que nécessaire :

1 function affiche_tab ( tab ) :

2 tab = []
3 for i in range (1 , 10) :
4 print [ i]

Exercice 42 (Les algo de référence).

1) Écrire en pseudo-code et en Python une fonction somme qui prend en paramètre un tableau
et retourne la somme des éléments du tableau.
Par exemple somme([2, 4, 10]) devra retourner 16.
2) Écrire en pseudo-code et en Python une fonction compte qui prend en paramètre une
valeur val tab et qui retourne le nombre d'apparitions de val dans tab.
et un tableau
Par exemple compte(8, [8, 4, 1, 8, 10, 8]) devra retourner 3.

3) Écrire en pseudo-code et en Python une fonction maximum qui prend en paramètre un

tableau et retourne la plus grande valeur de ce tableau.
Par exemple maximum([1, 42, 8, 5]) devra retourner 42.
4) Écrire en pseudo-code et en Python un algorithme qui :

• demande de saisir un entier n,

• crée un tableau de taille n composée d'entiers aléatoires entre 1 et 10,

• teste les fonctions précédentes sur ce tableau (pour le paramètre val, on choisira 8).

33
Exercice 43.
Écrire en pseudo-code puis en Python une fonction triple qui :

• prend en paramètre un tableau de réels noté tab

• réalise une copie de tab
• multiplie tous les éléments de la copie par 3

• retourne la copie ainsi modié.

Exercice 44.
Écrire en pseudo-code puis en Python une fonction miroir prenant en paramètre un tableau
et retournant le tableau inversé.
Par exemple miroir([1,2,3]) retourne [3,2,1].
Exercice 45.
Écrire en pseudo code et en Python un algorithme qui construit un tableau fibo de taille 20
et dont :
 l'élément d'indice 0 vaut 5,
 l'élément d'indice 1 vaut 2,
 les autres éléments sont égaux à la somme des deux éléments qui les précèdent.
Le tableau sera aché à la n de l'algorithme.

Exercice 46 (Tri à bulles).

Considérons un tableau de taille n constitué de nombres entiers. Nous allons trier ces entiers
dans l'ordre croissant selon la méthode appelée tri à bulles. Le tri à bulles consiste à répéter
n−1 fois l'étape suivante : parcourir le tableau en comparant les éléments consécutifs et les
échanger s'ils ne sont pas dans l'ordre croissant.

Par exemple si le tableau est [7;1;5;4;3] :

 Au cours du premier parcours, 7 est échangé avec 1, puis avec 5, puis avec 4 puis avec
3. Le tableau devient [1;5;4;3;7]
 Au cours du second parcours, 1 et 5 ne sont pas échangés car ils sont dans le bon
ordre. En revanche, 5 et 4 sont échangés (le tableau devient [1;4;5;3;7]), puis 5 et
3 ([1;4;3;5;7]). Enn 5 et 7 ne sont pas échangés.
 Au cours du troisième parcours, 4 et 3 sont échangés, et le tableau obtenu est trié.

1) Écrire en pseudo-code puis en Python une fonction tribulles qui prend en paramètre un
tableau et trie ce tableau selon le tri à bulles. On pourra s'aider de la fonction précédente.

2) En réalité, le tableau peut être trié avant que les n−1 parcours aient été eectués. On peut
en eet s'arrêter dès lors qu'aucun n'échange n'est fait pendant un parcours. En s'aidant
de cela, modier la fonction précédente pour limiter le nombre de parcours.

34
Exercice 47 (Bogo tri).
On désire trier un tableau en utilisant la méthode appelée "bogo-tri" (ou tri stupide). Pour
eectuer ce tri, on répète, jusqu'à ce que le tableau soit trié, les deux étapes suivantes :

• On vérie si les éléments sont classés par ordre croissant.

• Si ils ne le sont pas, on mélange aléatoirement les éléments du tableau.

1) Écrire en pseudo-code et en Python une fonction ordre qui prend en argument un tableau
et retourne Vrai si les éléments du tableau sont triés dans l'ordre croissant, et Faux sinon.

2) On considère la fonction F suivante :

1 Fonction F( tab )
2 Variables locales : ...
3 DEBUT FONCTION
4 bogotab ← []
5 Tant Que longueur ( tab ) >0:
6 i ← randint (0 , longueur ( tab ) -1)
7 bogotab ← bogotab + [ tab [ i ]]
8 tab ← tab [0:( i -1) ] + tab [( i +1) :( longueur ( tab ) -1) ]
9 Fin Tant Que
10 Retourner : bogotab
11 FIN FONCTION

a) Lister les variables utilisées dans la fonction F, ainsi que leur type.

b) À quoi sert la ligne 8 de la fonction ? Que se passe-t-il sans cette ligne ?

c) Que fait la fonction F ?

d) Traduire cette fonction en Python.

3) Écrire en pseudo-code et en Python une fonction tri qui prend en paramètre un tableau
et retourne le tableau trié grâce au bogo-tri.
Cette fonction pourra utiliser les fonctions F et ordre.
Attention à ne tester que sur de petits tableaux.

4) Pour que le temps de tri soit raisonnable, on décide de limiter le nombre d'itérations du
bogo-tri à 100 000. Si au bout de 100 000 itérations, le tableau n'est toujours pas trié, on
achera un message d'échec.
Écrire en Python une fonction tri2 reprenant la fonction tri mais avec la limite d'itéra-
tions.

35
7 Chaînes de caractères
7.1 Dénition et premiers exemples
Dénition
Une chaîne de caractères est une suite nie quelconque de caractères. En pseudo-code
comme en Python, une chaîne de caractères peut être délimitée soit par des guillemets,
soit par des apostrophes.
Les chaînes de caractères sont représentées en Python par le type str (abréviation du
mot anglais string).

Comme nous l'avons déjà vu à plusieurs reprises, on peut acher une (ou plusieurs) chaîne
de caractères à l'aide de la fonction print.
Exemple.
En pseudo-code : En Python :
1 phrase1 ← " Bonjour !" 1 phrase1 = " Bonjour ! "
2 phrase2 ← ' Comment ça va ? ' 2 phrase2 = ' Comment ça va ? '
3 Afficher : phrase1 , phrase2 3 print ( phrase1 , phrase2 )

Dénition
Le nombre de caractères d'une chaîne de caractère s'appelle longueur de la chaîne.
Pour connaître la longueur d'une chaîne en Python, on utilise la fonction len.

Exemple.
En pseudo-code : En Python :
1 chaine ← " blablabla " 1 chaine = " blablabla "
2 Afficher : longueur ( chaine ) 2 print ( len ( chaine ) )

Remarque. En Python, on peut également comparer deux chaînes de caractères à l'aide des
opérateurs <, >, ! = et ==. L'ordre utilisé est l'ordre lexicographique.

7.2 Caractères, sous-chaînes

• Comme pour les listes, les caractères d'une chaîne de caractères sont numérotés par
des indices. On rappelle qu'en Python, et par convention en pseudo-code (pour ce
cours), les indices commencent à 0.

• Pour accéder au caractère d'indice i d'une chaîne ch, on utilise l'expression :

1 ch [ i]

• On peut également obtenir des tranches de chaînes, de la même manière que les
tranches de tableaux :

1 ch [ indice_debut : indice_fin_exclu ]

36
Exemple.
1 chaine = " Les crocodiles peuvent rester 45 minutes sous l ' eau "
2 print ( chaine [0])
3 print ( chaine [4:13]) # caractères d ' indices 4 à 12 de la chaîne
.

Remarque. Attention, contrairement aux listes, il n'est pas possible de modier directement
les caractères d'une chaîne un par un. Il existe néanmoins une solution consistant à créer une
nouvelle chaine à l'aide de sous-chaines de la première.

1 chaine = " blabla "

2 chaine [3] = " u " # cette instruction génère une erreur
3 chaine = chaine [0:3] + " u " + chaine [4: len ( chaine ) ] # solution

7.3 Opérations sur les chaînes de caractères

7.3.1 Concaténation
Comme les tableaux, les chaînes de caractères peuvent être concaténées. Pour conca-
téner deux chaînes de caractères, on utilise l'opérateur +, en pseudo-code comme en
Python.

Exemple.
1 chaine1 = " Bonjour , je m ' appelle ... "
2 chaine2 = " Bob ! "
3 chaine = chaine1 + chaine2
4 print ( chaine )

7.3.2 Transtypage
Il existe plusieurs opérations de transtypage applicables aux chaînes de caractères :

• Entre chaîne et variable numérique :

 Une chaîne de caractères contenant un nombre peut être transtypée en une variable de
type int ou de type float. Par exemple :

1 chaine = " 42 "

2 nombre = eval ( chaine )
3 print ( nombre , type ( nombre ) )

 Et réciproquement, une variable numérique peut être transtypée en une chaîne de ca-
ractères à l'aide de la fonction str. Par exemple :

1 nombre = 42
2 chaine = str ( nombre )
3 print ( chaine , type ( chaine ) )

37
 • Entre chaîne et tableau :
 Une chaîne peut être transtypée en un tableau. Les éléments du tableau obtenu sont
alors les caractères de la chaîne. Par exemple :

1 chaine = " Bonjour ! "

2 tab = list ( chaine )
3 print ( tab )

 Et réciproquement, un tableau contenant des caractères ou des chaînes de caractères

peut être assemblé en une seule chaîne de caractères à l'aide de la méthode join, appli-
quée à la chaîne que l'on veut utiliser comme séparateur entre les éléments du tableau.
Exemple :

1 tab = [" Et " , " ... " , " " ," Hop ! " ]
2 chaine = " ? " . join ( tab )
3 print ( chaine )

7.3.3 Parcours
Comme pour les tableaux, on peut parcourir les uns après les autres tous les caractères d'une
chaîne grâce à une boucle.

7.3.4 Conversion en entiers

Les caractères sont codés par des entiers. En Python, on peut passer d'un caractère à
l'entier qui le code (en ascii) à l'aide de la fonction ord. Et réciproquement, on peut
passer d'un entier au caractère qu'il représente à l'aide de la fonction chr.

Exemple.
1 print ( ord ( " a ") )
2 print ( chr (97) )

7.3.5 Méthodes de chaînes

Comme pour les listes, il existe en Python un certain nombre de méthodes pour les chaînes
de caractères, dont certaines peuvent s'avérer utiles.

Exemples. Supposons que l'on ait une variable de type string nommée chaine, par exemple :
chaine = "Bob dit : Blablabla"
Alors :

• chaine = chaine.upper() : met la chaîne en majuscules,

• chaine = chaine.lower() : met la chaîne en minuscules,
• chaine.index("bla") : donne l'indice de la première occurrence de la sous-chaîne bla
(erreur si la chaîne de contient pas bla),

• chaine.count("bla") : compte le nombre d'occurrences de la sous-chaîne bla.

38
7.4 Exercices
Exercice 48 (Pour se tester).
1) Qu'est une chaîne de caractères ?

2) Comment accède-t-on au caractère d'indice i de la chaîne c?

3) Comment parcourt-on une chaîne de caractères ?

4) Comment réalise-t-on une concaténation sur des chaînes de caractères ?

5) Quelle est la fonction retournant le code ascii d'un caractère ? Quelle est la fonction réci-
proque ?

Exercice 49.
Traduire en Python l'algorithme donné ci-dessous en pseudo-code, puis le tester :

1 Algorithme : affichage des caractères

2 Variables : c ( chaine ) , i ( entier )
3 DEBUT
4 c ← " Hello world ! "
5 Pour i Allant De 0 À longueur ( c ) ( exclu ):
6 Afficher : c [ i ]
7 Fin Pour

Exercice 50.
Écrie en pseudo-code puis en Python une fonction compte_b prenant en paramètre une chaine
de caractères et retournant le nombre d'occurrences du caractère "b" dans celle-ci.

Exercice 51.
Écrire en pseudo-code puis en Python une fonction chaine_vers_tab prenant en paramètre
une chaîne de caractères et retournant un tableau donc chaque élément est un caractère de la
chaîne. (On s'interdira l'utilisation de la fonction list.)

Exercice 52.
a) Écrire une fonction bin2dec prenant en paramètre une chaine de caractères représentant
un nombre en base 2 et retournant ce nombre en base 10.

b) Écrire en pseudo-code et en Python une fonction dec2bin prenant en paramètre un entier

en décimal et retournant une chaîne de caractères contenant l'équivalent binaire de cet
entier.

Exercice 53.
a) Écrire en pseudo-code et en Python un algorithme demandant de saisir une phrase et
achant une version modiée de cette phrase dans laquelle tous les caractères e sont
remplacés par des caractères z.

b) Écrire un algorithme demandant de saisir une phrase et achant une version modiée de
cette phrase dans laquelle toutes les occurrences de la sous-chaînes Bob sont remplacées
par la sous-chaîne Roger. Appliquer cet algorithme à la phrase : Bob dit : je m'appelle
Bob !.

39
Exercice 54.
Dans cet exercice, on considère des chaînes de caractères dans lesquelles tous les mots sont
séparés par des espaces.

Écrire en pseudo-code et en Python une fonction tab_mots prenant en paramètre une chaîne
de caractères et retournant un tableau contenant les mots t symboles de ponctuation de cette
chaîne.
Par exempletab_mots("La réponse est 42 !") devra retourner :
["La", "réponse", "est", "42", "!"].

Exercice 55.
1) On considère la fonction F suivante :

1 Fonction F( caractere )
2 Variables locales : ...
3 Debut Fonction
4 n ← ord ( caractere ) - ord ( 'a ')
5 r ← ( n *9) % 26
6 c ← chr ( r + ord ( 'a ') )
7 Retourner c
8 Fin Fonction

a) Lister les variables utilisées dans la fonction F, ainsi que leur type.

b) Que retourne F('e') ? Justier.

c) Traduire la fonction F en Python.

2) Dans cette question, on veut chirer un texte. Pour cela, on commence par choisir une
clé de chirement. Dans tout ce sujet, la clé de chirement vaut 9. Pour chirer chaque
caractère du message, on procède comme suit :
 Si le caractère n'est pas une lettre minuscule, on le laisse inchangé,
 Si le caractère est une lettre minuscule, on note n le numéro correspondant à cette
lettre (0 pour "a", 1 pour "b", . . ., 25 pour "z"). On calcule alors le reste r de la
division euclidienne de n×9 par 26. La lettre chirée est alors la lettre correspondant
au numéro r.
Par exemple pour chirer la lettre d, on remarque que le numéro correspondant à d est 3.
Le reste de la division euclidienne de 3×9 par 26 est 1, qui correspond à la lettre b.

a) Écrire en pseudo code et en Python une fonction chiffre qui prend en paramètre une
chaîne de caractères et retourne la version chirée de cette chaîne.
Par exemple chiffre("de!") devra retourner "bk!".
La fonction chiffre pourra utiliser la fonction F.
b) Écrire en pseudo-code et en Python un algorithme A1 qui :
 demande de saisir un entier noté t,
 génère aléatoirement une chaîne de caractères, notée rand_str, de taille t et dont
tous les caractères sont des lettres minuscules. On pourra pour cela choisir aléatoi-
rement un entier entre 97 et 122 et utiliser la fonction chr,
 chire cette chaîne selon la méthode décrite ci-dessus,
 et ache la version originale de rand_str et sa version chirée.

c) Le déchirement se fait comme le chirement, mais avec la clé 3.

Écrire la fonction dechiffre qui réalise le déchirement.
Déchirer : "jwndwyx !".

40
8 Matrices
8.1 Généralités
Une matrice est un tableau à deux dimensions et peut se représenter en programmation
par un tableau dont les éléments sont eux-mêmes des tableaux.
Dans ce qui suit, chaque sous-tableau représentera une ligne de la matrice.

Exemple.
Soit M la matrice :
1 2 3 4
5 6 7 8
9 10 11 12

M sera représenté en Python par :

1 m = [[1 , 2 , 3 , 4] , [5 , 6 , 7 , 8] , [9 , 10 , 11 , 12]]

La case située sur la ième ligne et sur la j ème colonne de M correspond à l'élément
d'indice j−1 de l'élément d'indice i−1 de ce tableau de tableaux. On y accède par
l'expression :

1 m [i -1][ j -1]

Exemple.
1 m = [[1 , 2 , 3 , 4] , [5 , 6 , 7 , 8] , [9 , 10 , 11 , 12]]
2 print ( m [1][2]) # affiche 7

8.2 Création d'une matrice

Pour créer une matrice de taille donnée (ici 6 colonnes et 4 lignes), et ne contenant que des
0, on utilise les instructions suivantes :

1 nb_colonnes = 6
2 nb_lignes = 4
3 matrice = []
4 for i in range ( nb_lignes ) :
5 matrice . append ([0] * nb_colonnes ) # ajout d ' une ligne
6 print ( matrice )

Remarque.
Les tableaux étant représentés par leur adresse mémoire, on ne peut pas remplacer les lignes
matrice = [[0] * nb_colonnes] * nb_lignes
3 à 5 par l'instruction :
nb_lignes fois l'adresse mémoire du tableau créé par l'ex-
En eet, dans ce cas, on copie
pression [0] * nb_colonnes. Autrement dit, toutes les lignes pointent vers la même adresse
mémoire, et modier une ligne les modie toutes.

41
8.3 Exercices
Exercice 56.
1) Écrire en Python une procédure affiche_lignes qui :

• prend en paramètre une matrice sous la forme d'un tableau de tableaux,

• ache successivement chaque ligne de cette matrice.

2) Écrire en Python une fonction somme qui :

• prend en paramètre une matrice sous la forme d'un tableau de tableaux,

• retourne la somme de tous les éléments de cette matrice.

Exercice 57 (Opérations matricielles).

1) Écrire une fonction somme_matrices qui prend en paramètres deux matrices de même
taille et retourne la somme de ces deux matrices.

2) Écrire une fonction produit_matrices qui prend en paramètres deux matrices et retourne
le produit de ces deux matrices. Un message sera aché si la taille des deux matrices ne
permet pas leur produit matriciel.

Exercice 58 (Bataille navale).

On veut programmer un jeu de bataille navale. On joue sur un plateau de 5 cases sur 5. Un
bateau (de taille 1 × 1) est placé aléatoirement sur l'une des cases.

On représente le plateau par un tableau contenant lui-même 5 tableaux de taille 5, chaque

sous-tableau représentant une ligne du plateau. Les éléments des sous-tableaux valent tous 0
sauf celui correspondant à la case sur laquelle est le bateau, qui vaut 1.

1) Écrire une fonction genere_plateau qui :

• ne prend pas de paramètre,

• génère une matrice de la bonne taille ne contenant que des 0,

• place aléatoirement un 1 dans cette matrice,

• retourne cette matrice.

2) Écrire un algorithme qui :

• génère aléatoirement un plateau de jeu grâce à la fonction précédente,

• répète jusqu'à ce que le bateau soit coulé :

 demander à l'utilisateur de saisir un indice de ligne et un indice de colonne,
 acher un message indiquant si ces coordonnées correspondent à l'emplacement du
bateau ou non.

3) (Bonus) Pour aller plus loin, on pourra acher au fur et à mesure de l'algorithme le plateau
de jeu, en marquant par une croix les cases déjà cochées.

42
Annexe 1 : Formalisme
Pour plus de clarté, on construit nos algorithmes en suivant le plan ci-dessous :

1) L'en-tête, qui se décompose en :

a) (en Python, en toute première ligne) une indication d'encodage, par exemple si l'enco-
dage est utf-8 :
# -*- coding: utf-8 -*-
b) un titre qui doit être choisi intelligemment,
c) éventuellement une brève description du rôle de l'algorithme (en particulier si l'algo-
rithme est long),

d) (en pseudo-code :) une déclaration des variables, qui consiste à préciser le nom des
variables utilisées ainsi que leur type.

2) Le corps de l'algorithme, qui se décompose en :

a) (en Python :) les importations des bibliothèques nécessaires,

b) les dénitions de fonctions,

c) la partie principale de l'algorithme, où sont appelées les fonctions.

Remarques.
• La déclaration des variables est indispensable dans certains langages (par exemple en C),
et le faire en pseudo-code est une bonne habitude.

• En revanche en Python, on ne déclare pas les variables. Si l'algorithme est long, on peut
néanmoins mettre en commentaire des informations sur les variables.

Remarques supplémentaires (à compléter) :

43
Exemple.
Lors d'un jeu, on lance trois fois un dé à 6 faces, le score vaut la racine carrée de la somme
des trois lancers.
Un algorithme simulant ce jeu et achant le score est donné ci-dessous :

• En Python :
1. # -*- coding: utf-8 -*-
2. # Algorithme : afficheur de score
3.
4. # -------- Importations -------- #
5. from random import *
6. from math import *
7.
8. # -------- Fonctions -------- #
9. def lancer(n) :
10. """Simule un lancer de dé à n faces"""
11. de = randint(1, n)
12. print("Vous obtenez : ", de)
13. return de
14.
15. # -------- Partie principale -------- #
16. score = sqrt(lancer(6) + lancer(6) + lancer(6))
17. print("Votre score : ", score)
• En pseudo-code :
1. Algorithme : afficheur de score
2. Variables : de (entier), score (réel)
3. DEBUT
4. - Fonctions -
5. Fonction lancer(n) :
6. Variables locales : de (entier)
7. Début fonction
8. de ← randint(1,n)
9. Afficher : "Vous obtenez : ", de
10. Retourner : de
11. Fin fonction
12.
13. - Partie
√ principale -
14. score ← lancer(6) + lancer(6) + lancer(6)
15. Afficher : "Votre score : ", score
16. FIN

44
Annexe 2 : Débogage
Il est indispensable d'acquérir un maximum d' autonomie. À ce titre, il est nécessaire de
savoir interpréter les diérents messages d'erreur achés par l'interpréteur.
Ci-dessous sont donnés quelques exemples d'algorithmes erronés et de messages d'erreur cor-
respondants (avec spyder). Cette liste est à compléter au l de l'année.

• Variable non dénie :

1. Var = 0
2. Var = var +1
L'interpréteur ache alors : NameError: name 'var' is not defined
Ce message d'erreur veut dire que l'on utilise pour un calcul une variable qui n'a pas été
dénie au préalable. Cela arrive en particulier lorsqu'on a commis une erreur en tapant
un nom de variable, comme ici où il manque une majuscule à var. Cela arrive également
lorsqu'on utilise une fonction d'une bibliothèque que l'on n'a pas importée.

• Erreur d'indentation (indentation en trop) :

1. var = 0
2. var = var + 1 # Notez qu'il y a un espace en début de ligne.
L'interpréteur ache alors : IndentationError: unexpected indent
Cela veut dire qu'il y a un problème d'indentation, plus précisément qu'il y a des espaces
en début de ligne alors qu'il n'en faut pas.

• Erreur d'indentation (indentation manquante) :

Nous verrons plus tard que certaines structures nécessitent l'utilisation d'indentations. Si
une indentation est manquante, l'erreur achée est :
IndentationError: expected an indented block
• Erreur sur la virgule :
1. nb = 0,42
2. nb = nb + 1
L'interpréteur ache : TypeError: can only concatenate tuple (not "int") to tuple
Rappelons qu'en Python, la virgule des nombre décimaux s'écrit avec un point (.). La vir-
gule est le symbole permettant de dénir un uplet (couple, triplet, etc). Ici 0,42 est un
couple d'entiers, et 1 est un entier. Python ne sait pas additionner ces deux éléments de
types diérents.

• Oubli de parenthèses (fonction et procédure) :

1. print 5
L'interpréteur ache : SyntaxError: Missing parentheses in call to 'print'
Nous verrons ci-dessous que print (instruction servant à acher) nécessite toujours des
parenthèses. Ici les parenthèses sont manquantes.

• Oubli d'un symbole (parenthèse ou deux points) :

1. nb = ((5+6)+7
L'interpréteur ache : SyntaxError: unexpected EOF while parsing
Cela indique une erreur de syntaxe. Souvent, les erreurs de syntaxe sont dues à un caractère
manquant. Ici, il manque une parenthèse.
Les structures étudiées plus tard dans ce cours nécessitent les symbole deux points (:). En
cas d'oubli, l'interpréteur achera également une erreur de syntaxe :
SyntaxError: invalid syntax

45
Autres erreurs (à compléter) :

46