Pensée Computationnelle et programmation

ème
Niveau : 2 TI

Programmer mon 1er jeu! (calcul mental)

Révisez la table de multiplication (X):

Partie1
Jouez contre l’ordinateur :
L’ordinateur commence par tirer au hasard deux
entiers (entre 0 et 10) puis vous demande de
donner leur produit et affiche par la suite «Bravo!»
en cas de bonne réponse et «C’est faux» sinon.

Partie2

On interrogera 5 fois l’utilisateur ! Améliorer le jeu

en ajoutant un score (1 par bonne réponse et -1
sinon)

Partie3

Prof : Mme A.Hanen & Mr S.Akrem Page 1

Améliorer l’affichage comme suit en ajoutant à
chaque interrogation le numéro d’essai ainsi que le
résultat final comportant le nombre d’essais et le
score final.

Partie1
☞Objectifs :
▪ Les différents types des variables.

▪ Les nombre aléatoire (Aléa() / random())

▪ Structure conditionnelle.

🖎Décomposition de problème :

Prof : Mme A.Hanen & Mr S.Akrem Page 2

☞Algorithme ☞Programme python :
Début calculatrice
from random import*
1) a🡨Aléa (0 ,10) a=randint(0,10)
b=randint(0,10)
2) b🡨Aléa (0 ,10) print(a,"*",b,"=", end=" ")
3) Afficher (a,’’*’’,b,’’= ’’) p=int(input())
Lire(p) test=(a*b==p)
if (test==True):
4) test🡨(a*b=p) print(test,"Bravo!")
5) Si (test=vrai) alors else:
Afficher (test,‘’Bravo !‘’) print(test,"C'est faux!")
Sinon
Afficher (test,‘’c’est faux !’’)
Fin si
Fin calculatrice

☞TDO
Objet Type/nature Rôle
a, b Variable/Entier Deux variables tirés au hasard par l’ordinateur
p Variable/Entier Produit des deux entiers
test Variable/Boolée tester de la réponse de l’utilisateur
n

Break de savoir :
🖎Note :
☞Une variable est une zone de la mémoire centrale de l'ordinateur dans
laquelle une valeur est stockée.
☞Une variable possède un identificateur (nom) et un type (numérique, booléen,..)

☞La bibliothèque random permet de générer des nombres aléatoires.

Prof : Mme A.Hanen & Mr S.Akrem Page 3

 ☞ random(): tirer un réel aléatoire entre 0 et 1

☞ randint(a,b): tirer un entier aléatoire entre a et b.

☞ uniform(a,b): tirer un réel aléatoire entre a et b.

🖎Note :
🖎 Structures conditionnelle (test) : permet d’exécuter un bloc de code selon qu’une
condition (test booléen) soit vérifié ou pas.
On distingue les formes suivantes :
☞Forme simple: if (“si”)
☞Forme complète: if…else (“si…sinon”)
☞Forme imbriqués (avec alternatives): if…elif…else (“si…sinon si… sinon”)

Prof : Mme A.Hanen & Mr S.Akrem Page 4

 Activité1: Différents types des variables
Affectatio Résultat affich Type
v=5 #<class 'int'> Entier
v=12.25 #<class 'float'> Réel
v='2eme Ti' #<class 'str'> Chaine de caractère
v=8<10 #<class 'bool'> Booléen
v=[1,5,3] #<class 'list'> Tableau
1) Compléter le tableau suivant en indiquant le résultat affiché et le type de la variable v
en exécutant la commande print(type(v))
2) Que constatez-vous ? Python est un langage typé dynamiquement, c’est-à-dire
qu’une variable peut changer de type suite à l’affectation d’une valeur d’un autre type.

🖎Note :
☞ Les types des variables sont classés généralement en quatre catégories: les types
numériques (entiers & réels), les types alphanumériques (les chaines de caractères),
types booléens (Vrai/faux) et les tableaux (listes).

🖉Les types numériques (entier&réel) :

Activité2: Opérateurs sur les données numériques
Résul Opération arithméti
affi En Algorith En Pyt
20 + 3 = 23 Addition (+)
20 -3 = Soustraction (-)
20 * 3 = Multiplication (*) *
20 / 3 = 6 Division décimale (/)
20 ** 3 = 8 Puissance (^)
20 // 3 Division entière (DIV)
20 % 3 Reste de la division entière (MOD)
1)Afficher et interpréter les résultats des opérateurs arithmétiques (=, -, *, /, **,
// et %) utilisés pour les variables : a=20 b=3

Prof : Mme A.Hanen & Mr S.Akrem Page 5

 2) Refaire le même travail pour c=4.5 d=8.0, que remarquez-vous ? ☞ Les flottants
supportent les même opérations que les entiers.

3) A part les opérateurs arithmétiques usuels, citer d’autres qu’on peut les appliquer
avec des opérandes numériques ?

🖎Note :
☞ On peut appliquer plusieurs opérateurs avec des opérandes (variables) numériques.

❶ Opérateurs arithmétiques (=, -, *, /, **, // et %)

❷ Opérateurs de comparaison (<, >, <=, >=, ==, !=)

❸ Opérateurs d’assignation (+=, -=, *=, /=, %=)

Exercice d’application:
Aider votre professeur de math à trouver une solution informatique pour résoudre
l’équation suivante : F(x,y)= √|2x+1|/y3
Sachant que x et y sont deux réels aléatoires (x €
[0,1] et y € [0,40])

☹Remarque : Si y=0, le message d’erreur suivant sera affiché sur écran :

Prof : Mme A.Hanen & Mr S.Akrem Page 6

 ☞Algorithme
Début EQUATION
1) x🡨Aléa () x est un réel aléatoire entre 0 et 1

2) y🡨Aléa (0,40) y est un réel aléatoire entre 1 et 40

3) Si y#0 alors
f🡨 RacineCarrée(Absolu(2*x+1)/exposant(y,3))
Afficher (‘’X=’’, arrondi(x,3), ‘’Y=’’, arrondi(y,3),, ‘’F=’’, arrondi(f,3),)
Fin

☞Programme python :
from random import *
from math import *
x=random()
y=uniform(1,40)
if (y!=0) :
f=sqrt(abs(2*x+1)/pow(y,3))
print("X=", round(x,3), "Y=", round(y,3), "F=",round(f,3))

☞TDO
Obje Type/nature Rôle
t

Prof : Mme A.Hanen & Mr S.Akrem Page 7

 x Variable/ réel un réel tiré aléatoirement entre 0 et 1
y Variable/ réel un réel tiré aléatoirement entre 1 et 40
f Variable/ réel une fonction

🖎Note :
☞Le module math contient des fonctions mathématiques de base (sqrt, abs, pow..)

☞ round(x,nb) : fixer nb chiffres après la virgule.

🖉Le type booléen :

Activité3: Opérateurs sur les booléens
Compléter l’algorithme ci-dessous qui demande l’âge d’un enfant de l’utilisateur. Ensuite, il
l’informe de sa catégorie :
✔ "Poussin ": de 6 à 7 ans

✔ "Pupille": de 8 à 9 ans

✔ "Minime": de 10 à 11 ans

✔ "Cadet ": après 12 ans

Solution1 : Solution2 :
Algorithme categorie_enfant Algorithme categorie_enfant
Début Début
1) Afficher ("Saisir l'âge: ") 1) Afficher ("Saisir l'âge: ")
Lire (age) Lire (age)
2) SI age < 6 ALORS 2) SI age < 6 ALORS
Afficher ("Saisir un âge supérieur ou égal Afficher ("Saisir un age supérieur ou égal
6") 6")
SINON SI age <=7 ALORS SINON SI age …………. ET age ………… ALORS
Afficher ("Poussin") Afficher ("Poussin")
SINON SI age <=9 ALORS SINON SI age ………… ET age ………… ALORS
Afficher ("Pupille") Afficher ("Pupille")
SINON SI age <=11 ALORS SINON SI age ………… ET age ………… ALORS
Afficher ("Minime") Afficher ("Minime")
SINON SINON
Afficher ("Cadet") Afficher ("Cadet")
FIN SI FIN SI
Fin Fin

Prof : Mme A.Hanen & Mr S.Akrem Page 8

 🖎Note :
🖎 Un booléen ne peut prendre que les valeurs True et False.

🖎 Python définit 3 opérateurs logiques Not (NON), And (ET) et Or (OU).

🖎 Table de vérité des opérateurs logiques:

🖉Le type chaine de caractère:

Revenons à notre partie1 du jeu calculatrice :

Suite Partie1
l’utilisateur doit
s’identifier au début du
jeu à travers la saisie de
son nom et prénom
séparés par espace.
Affichons par la suite un
message de bienvenu à
l’utilisateur (en affichant
uniquement son prénom).

🖎Décomposition de l’identification de l’utilisateur :

Prof : Mme A.Hanen & Mr S.Akrem Page 9

Prof : Mme A.Hanen & Mr S.Akrem Page 10
 ☞Algorithme
Début calculatrice
1) Afficher ("Nom&Prénom du joueur (séparés par espace!) :")
Lire (ch)
2) p_espace🡨pos(" ", ch)

3) L🡨long( ch)

4) prenom🡨 sous-chaine(ch,(pos_espace)+1,L) avec L exclus

5) Afficher ("Bienvenu", prenom, "dans notre jeu !")
6) a🡨Aléa (0 ,10)

7) b🡨Aléa (0 ,10)
8) Afficher (a,’’*’’,b,’’= ’’)
Lire(p)
9) test🡨(a*b=p)
10)Si (test=vrai) alors Afficher (test, ‘’Bravo !‘’)
Sinon Afficher (test, ‘’c’est faux !’’)
Fin si
Fin calculatrice

☞Programme python :
from random import randint
#----------------Ajout de l'identification de l'utilisateur----------------
ch=input("Nom&Prénom du joueur (séparés par espace!):")
p_espace=(ch.find(" "))
L= len(ch)
prenom=ch[(p_espace)+1 :L] #--- avec L exclus---
print("Bienvenu", prenom, "dans notre jeu !")
#---------------Commençant le jeu -----------------------------------------
a=randint(0,10)
b=randint(0,10)
print(a,"*",b,"=", end=" ")
p=int(input())
test=(a*b==p)
if (test==True): print(test, "Bravo!")
else: print(test, "C'est faux!")

Prof : Mme A.Hanen & Mr S.Akrem Page 11

 ☞TDO
Objet Type/nature
a, b, p_espace, p, L Variable/Entier
test Variable/Booléen
ch, Prenom Variable/Chaine de caractère

Break de savoir :
🖎Note :
🖎 Une chaîne de caractères est une suite ordonnée de caractères (un mot, une phrase..),
délimitée par des quottes.
🖎 Une chaîne peut ne contenir aucun caractère : on l’appelle chaîne vide (‘‘’’)

🖎 Un chaine est immuable, càd que son contenu ne peut plus être modifié.

🖎 L’accès aux caractères d’une chaine se fait par indice : ch[début:fin]

🖎 Un et un seul caractère peut être (lettre/chiffre/symbole) et est de longueur 1.

🖎 Chaque caractère est définit par un code appelé code ASCII.

🖎 Voici la table des codes ASCII des premiers caractères. Les numéros 0 à 32 ne sont pas
des caractères imprimables. Cependant le numéro 32 est le caractère espace (" ")

Prof : Mme A.Hanen & Mr S.Akrem Page 12

 🖎Note :
En En python Description
algorith
me
Ord (c) Ord (c) Retourne le code ASCII du caractère c.

Chr (code) Chr (code) Retourne le caractère correspondant au code ASCII

donné.

Long (ch) len (ch) Retourne le nombre de caractères/longueur de la chaîne

ch.

Pos (ch1, ch2) Ch2.find(ch1) Retourne la première position de la chaîne ch1 dans ch2

Sous_chaine Ch[d:f] Retourne une partie de la chaîne ch à partir de la position

(ch,d,f) d jusqu’à la position f (f exclue).

Prof : Mme A.Hanen & Mr S.Akrem Page 13

 Activité4: L’accès par indice à une chaine [début:fin]
V= " è m e I n f o
2 "
Indice 0 1 2 3 4 5 6 7 8
(positif)
Indice -9 - - - - -4 - - -1
8 7 6 5 3 2
(négatif)
Soit la chaine de caractère V suivante :
1) Donnez les instructions nécessaires pour accéder au :

● Premier caractère ☞ V[0]= V[-9] vaut '2'

● Dernier caractère ☞ V[-1] = V[8] vaut 'o'

● Caractère d’indice 4☞ V[4]= V[-5] vaut ' ' (espace)

2) Exécutez et interprétez les instructions de découpage de la chaine V suivantes :

Instructio Résulta Interprétation

print(V[1:3]) 'èm' Caractère d'indice 1 au caractère d'indice 3 (exclu)
print(V[1:-7]
)
print(V[1:9:3 'è f' Caractère d'indice 1 au caractère d'indice 9 (exclu)
]) par pas = 3
print(V[:3]) '2èm' Premier caractère jusqu’au d'indice 3 (exclu)
print(V[5:]) 'Info' Caractère d'indice 5 au dernier
print(V[::3]) '2en' Caractère d'indice 0 au dernier caractère par pas
=3
print(V[::-2] 'on m2' En commençant de droite à gauche par pas = -2
)
V[0]='C' Erreur On ne peut pas changer les caractères d’une chaine

Activité5: Opérateurs sur les chaines (+, *,<, >..)

1) Exécutez et interprétez les résultats d’affichage des instructions ci-dessous pour les
variables suivantes :
s1="La vie "
s2=" est "
s3="belle."

Affichage Interprétation
Instructions
Prof : Mme A.Hanen & Mr S.Akrem Page 14
 s1+s2+s3 'La vie est belle.' Concaténation des 3 chaines.
s3*3 'belle.belle.belle. Répéter 3 fois la chaine s3.
'
"E" not in True Vérifie le non inclusion du caractère ‘E‘
s2 dans la chaine s2.
"la" in s1 False Vérifie l’inclusion de la chaine ‘la‘ dans la
chaine s1.
"belle "== True Compare l’égalité entre les 2 chaines.
s3
s2<=s3 True Compare l’infériorité de s2 par rapport à
s3.

Prof : Mme A.Hanen & Mr S.Akrem Page 15

 Revenons à notre jeu « calculatrice » :

Partie 2 et 3
▪ Interroger 5 fois l’utilisateur et ajouter un score (1 par bonne réponse et -1 sinon)

▪ Améliorer par la suite l’affichage en ajoutant à chaque interrogation le numéro d’essai

et à la fin du jeu le résultat final comportant le nombre d’essais et le score final.

☞Objectifs :
▪ La structure de contrôle itératives complète (boucle Pour)

▪ Les listes

🖎Décomposition de problème :

Prof : Mme A.Hanen & Mr S.Akrem Page 16

☞Algorithme1 ☞Programme python1 :
from random import*
Début calculatrice
score=0
[score=0] pour i de 0 à 4 faire for i in range(5):
a🡨Aléa (0 ,10) a=randint(0,10)
b=randint(0,10)
b🡨Aléa (0 ,10) p=int(input(str(a)+"*"+str(b)+"="))
Afficher (a,’’*’’, b,’’= ’’) if (a*b==p):
score=score+1
Lire(p)
print("Bravo! score=", score)
Si (a*b=p) alors else:
score=score+1 score=score-1
Afficher (‘’Bravo ! score=’’, score) print("c'est faux! score=",
Sinon score)
score=score-1
Afficher (‘’c’est faux ! score=’’,
score)
Fin si
Fin pour
Fin calculatrice

Améliorons l’affichage :

Prof : Mme A.Hanen & Mr S.Akrem Page 17

☞Algorithme2 ☞Programme python2 :
from random import*
Début calculatrice
score=0
1) [score🡨0] pour i de 0 à 4 faire for i in range(5):
a=randint(0,10)
a🡨Aléa (0 ,10) b=randint(0,10)
p=int(input("Essai"+str(i+1)+":"+
b🡨Aléa (0 ,10)
str(a)+"*"+str(b)+"="))
Afficher (’’Essai’’, i+1, ’’ :’’, a,’’*’’, b,’’= ’’) if (a*b==p):
Lire(p) score=score+1
Si (a*b=p) alors print("Bravo! score=", score)
else:
Score=score+1
score=score-1
Afficher (‘’Bravo ! score=’’, score) print("c'est faux! score=", score)
Sinon print("*********************************")
Score=score-1 print(" Résultat final : ")
Afficher (‘’c’est faux ! score=’’, print(i+1," essais et votre score=",
score)
score)
Fin si
Fin pour
2) Afficher (‘’Résultat final : ‘’, i+1,
‘’essais et votre score=", score)
Fin calculatrice

Prof : Mme A.Hanen & Mr S.Akrem Page 18

 Break de savoir :
🖎Note :
🖎 Les boucles s’utilisent pour répéter plusieurs fois un traitement.

🖎 La boucle (Pour) : utilisée quand on sait d’avance le nombre de fois de la répétition.

En algo En python
[ ] Pour compteur de Vi à Vf [Pas = valeur] for compteur in séquence :
faire Traitement
Traitement ☞Les éléments de la séquence sont issus
Fin pour d'une chaîne ou d'une liste.

🖎 Une liste est une structure de données contenant plusieurs éléments de même type
ou de types différents, délimités entre 2 crochets.

Prof : Mme A.Hanen & Mr S.Akrem Page 19

 Activité1: Fonction range() :
Exécutez et interpréter les scripts suivantes :

Scrip Résultat Interprétation

maliste = range(10) range(n) ou range(0,n) : liste par
print(maliste) range(0, 10) défaut ça commence par 0 à n-1, avec
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] pas=1
print(list(maliste))
List() : permet d’afficher les
éléments de notre liste
print(type(maliste)) <class 'range'> Type liste
maliste =
range(1,10,2) [1, 3, 5, 7, 9] range(début,fin exclu,pas)
print(list(maliste))
maliste =
range(2,10,2)
print(list(maliste))

print(maliste[2]) 5 Accéder au 3ème élément a l'indice 2

Prof : Mme A.Hanen & Mr S.Akrem Page 20

 Revenons à notre jeu « calculatrice » :

Partie 4
Améliorons encore notre jeu :
En cas de réponse erronée, le programme
reposera la même question, tant que la bonne
réponse n'aura pas été donnée.

☞Objectifs :
▪ La boucle à condition d’arrêt (Tantque)

🖎Décomposition de problème :

Prof : Mme A.Hanen & Mr S.Akrem Page 21

☞Algorithme ☞Programme python :
from random import*
Début calculatrice
score=0
1) [score🡨0] pour i de 0 à 4 faire for i in range(5):
a=randint(0,10)
a🡨Aléa (0 ,10) b=randint(0,10)
p=int(input("Essai"+str(i+1)+":"+
b🡨Aléa (0 ,10)
str(a)+"*"+str(b)+"="))
Afficher (’’Essai’’, i+1, ’’ :’’, a,’’*’’, b,’’= ’’) while (p!= a*b):
Lire(p) score=score-1
Tantque (p ≠ a*b) faire print("c'est Faux! Réessayez
encore! score=", score)
Score=score-1
Afficher (‘’c'est Faux! Réessayez p=int(input(str(a)+"*"+str(b)+"="))
encore! score=", score)
Afficher (a,’’*’’, b,’’= ’’) score=score+1
Lire(p) print("Bravo! score=", score)
print("*********************************")
Fin Tantque
print(" Résultat final : ")
Score=score+1 print(i+1," essais et votre score=",
Afficher (‘’Bravo! score=’’, score) score)
Fin pour
2) Afficher (‘’Résultat final : ‘’, i+1,
‘’essais et votre score=", score)
Fin calculatrice

Break de savoir :
🖎Note :
🖎 La boucle non bornée sans limite (Tantque/while) : permet de répéter un traitement
tant que la condition d’entrée est Vraie (valide/vérifiée).
🖎 Elle est utilisée si on ne connait pas à l’avance le nombre de répétitions.

En algorithme En python

Prof : Mme A.Hanen & Mr S.Akrem Page 22

 [] Tantque condition_Vrai While
faire condition_True:
Traitement
Traitement
Fin tant que

Prof : Mme A.Hanen & Mr S.Akrem Page 23

 Revenons à notre jeu « calculatrice » :

Partie 5
Améliorons encore notre jeu :
Le programme fait un contrôle de saisie du produit p donné par le joueur et n’accepte
que une valeur numérique (entier) pour déclencher par la suite le jeu.

☞Objectifs :
▪ La boucle à condition d’arrêt (Répéter.. jusqu’a)

▪ Fonctions prédéfinies sur les chaines de caractères.

🖎Décomposition de problème :

Prof : Mme A.Hanen & Mr S.Akrem Page 24

☞Algorithme ☞Programme python :
from random import*
Début calculatrice
score=0
3) [score🡨0] pour i de 0 à 4 faire for i in range(5):
a=randint(0,10)
a🡨Aléa (0 ,10) b=randint(0,10)
while True:
b🡨Aléa (0 ,10)
p=input("Essai "+str(i+1)+": "+
Répéter str(a)+"*"+str(b)+"=")
Afficher (’’Essai’’, i+1, ’’ :’’, a,’’*’’, if (p.isdigit()): break
b,’’= ’’) else:
print("erreur! saisir un entier.")
Lire(p)
Jusqu'à estnum(p) while (int(p)!= a*b):
score=score-1
Tantque (p ≠ a*b) faire print("c'est Faux! Réessayez
Score=score-1 encore! score=", score)
Afficher (‘’c'est Faux! Réessayez
p=int(input(str(a)+"*"+str(b)+"="))
encore! score=", score)
Afficher (a,’’*’’, b,’’= ’’) score=score+1
Lire(p) print("Bravo! score=", score)
Fin Tantque print("*********************************")
print(" Résultat final : ")
Score=score+1
print(i+1," essais et votre score=",
Afficher (‘’Bravo! score=’’, score) score)
Fin pour
4) Afficher (‘’Résultat final : ‘’, i+1,
‘’essais et votre score=", score)
Fin calculatrice

Break de savoir :
🖎Note :

Prof : Mme A.Hanen & Mr S.Akrem Page 25

 🖎 La boucle non bornée (c.-à-d. non limitée par de born inf et born sup) (Répéter.. jusqu’à/while
True) : permet la répétition d’un Traitement jusqu'à ce qu’une condition de sortie soit Vraie.
🖎 Dans cette boucle, le traitement est exécuté au moins une fois (1 ou +eurs) avant l'évaluation
de la condition d'arrêt.
🖎 Elle est utilisée si on ne connait pas à l’avance le nombre de répétitions.

🖎 Elle est fréquemment utilisée pour les contrôles de saisie.

En algorithme En python
[] Répéter while True:
Traitement Traitements
if condition_True:
Jusqu'à condition_Vrai
break

🖎 break : permet de quitter la boucle.

🖎 Fonctions sur les chaînes de caractères:

Prof : Mme A.Hanen & Mr S.Akrem Page 26

 Activité1:
Quelle est la valeur affichée suite aux séquences d'instructions suivantes :
[N🡨7520 Répéter [i = 0]
Afficher("x=") Tantque i <= 9 faire
S🡨0] Lire(x) Afficher (i)
Ch 🡨convch(N) Jusqu'à (x mod 2 =0 ) i=i+1
Pour i de 1 à long(Ch) faire
S🡨S + valeur(ch[i+1])
Fin Pour
Afficher(S)

Prof : Mme A.Hanen & Mr S.Akrem Page 27

Revenons à notre jeu « calculatrice » :

Partie 6
Améliorons encore notre jeu :
✔ Contrôler toute saisie du produit p donné par le joueur (doit être de type entier)

✔ Donner la possibilité de rejouer (lancement du jeu à la demande).

☞Objectifs :
▪ Les sous programmes (procédures et fonctions)

☞Décomposition de problème :

Prof : Mme A.Hanen & Mr S.Akrem Page 28

Prof : Mme A.Hanen & Mr S.Akrem Page 29
☞Algorithme
Début calculatrice
[reponse🡨" oui"] Tantque (reponse="oui") faire

[score🡨0] pour i de 0 à 4 faire

a🡨Aléa (0 ,10)

b🡨Aléa (0 ,10)
Répéter
Afficher (’’Essai’’, i+1, ’’ :’’, a,’’*’’, b,’’= ’’)
Lire(p)
Jusqu'à estnum(p)
Tantque (valeur(p) ≠ a*b) faire
Score=score-1
Afficher (‘’c'est Faux! Réessayez encore! score=", score)
Répéter
Afficher (’’Essai’’, i+1, ’’ :’’, a,’’*’’, b,’’= ’’)
Lire(p)
Jusqu'à estnum(p)
Fin Tantque
Score=score+1
Afficher (‘’Bravo! score=’’, score)
Fin pour
Afficher (‘’Résultat final : ‘’, i+1, ‘’essais et votre score=", score)
Afficher ("voulez-vous rejouez? (oui/non): ")
Lire (reponse)
Fin Tantque
Fin calculatrice

Break de savoir :

🖎Note :
🖎 Un sous programme (module) permet l’utilisation redondante d’un même traitement en
différents points du programme juste par un simple appel.
🖎 Il s’agit de découper un programme complexe en petits modules traités séparément.

Prof : Mme A.Hanen & Mr S.Akrem Page 30

🖎 Un module peut être une procédure ou une fonction.

🖎 Une fonction retourne une seule valeur (numérique, chaine, liste..) suite à un traitement
bien précis.

En algorithme En python
Fonction ma_fonction (paramètres Def ma_fonction
formels :type) :type_résultat (param) :
Début Traitement
Traitement return résultat
Retourner Résultat (facultatif)
Fin def, mot-clé qui est l'abréviation
de « define » (définir, en anglais)
☞Appel : var🡨 ma_fonction (param effectifs) (au
niveau du prog. principal)

Exemple :
def cube(x):
return (x * x * x)

🖎 Un sous-programme qui retourne 0 ou plusieurs valeurs est appelé une procédure.

En algorithme En python

Prof : Mme A.Hanen & Mr S.Akrem Page 31

 Procedure ma_procedure(paramètres formels :type) Def
Début ma_procedure(param) :
Traitement
Traitement
Fin

☞Appel : ma_procedure (param effectifs) (au niveau

du prog. Princip.)

Exemple :
def message ():
print ("Fonction sans retour de valeur !")

🖎 Une variable déclarée dans un sous-programme est dite locale est elle n’est accessible
que depuis ce sous-programme (indéterminée dehors)

Exemple :
def cube(x):
return (x * x * x)

Prof : Mme A.Hanen & Mr S.Akrem Page 32

 Activité: Les sous-programmes
Compléter les sous-programmes suivants:

Scripts Résultat
1*7=7
🖳 Afficher la table de multiplication par 7: 2 * 7 = 14
3 * 7 = 21
def tableMult_par_7(): 4 * 7 = 28
i = 1 5 * 7 = 35
while i <= 10: 6 * 7 = 42
print(i, "*", 7, "=", i * 7) 7 * 7 = 49
i += 1 # On incrémente i de 1 à chaque tour de boucle. 8 * 7 = 56
9 * 7 = 63
# appelle de la procédure
10 * 7 = 70
tableMult_par_7()

🖳 Afficher le min suivi du max de 2 entiers:

def calculMiniMaxi(x,y):
if x<y: print (x,y) 2, 10
else: print (y,x)
# appelle de la procédure
calculMiniMaxi(2,10)
x et y sont passées par valeurs fixes (pas de changement)

🖳 Afficher le périmètre et l’aire d’un rectangle:

def rectangle(x,y): périmètre : 24
print("périmètre :",2*(x+y),"aire :",x*y) aire : 35

# appelle de la procédure
rectangle(7,5)
x et y sont passées par valeurs (pas de changement)

🖳 Afficher la somme de la suite de n entiers:

def sommeEntiers(n):
somme = 0
for i in range(n+1):

Prof : Mme A.Hanen & Mr S.Akrem Page 33

 somme += i 21
return somme

# appelle de la fonction
s=sommeEntiers(6)
print(s)

🖳 Afficher la somme et le produit de deux entiers:

def somme_produit(a,b): 13 42
s = a + b
p = a * b
print(s, p)

# appelle de la procédure
somme_produit(6,7)
a et b sont passées par valeurs (pas de changement)

Prof : Mme A.Hanen & Mr S.Akrem Page 34

Revenons à notre jeu..

☞Algorithme principal ☞Programme python:

#-----procédure saisie_produit------------
Début calculatrice
def saisie_produit():
[reponse🡨" oui"] while True:
X=input("Essai "+str(i+1)+": "+
Tantque (reponse="oui") faire
str(a)+"*"+str(b)+"=")
[score🡨0] pour i de 0 à 4 faire if X.isdigit()==True:break
return(X)
a🡨Aléa (0 ,10)
#----------Programme principal-----------
b🡨Aléa (0 ,10)
from random import*
saisie_produit (p) #appel de la procédure score=0
Tant que (p ≠ a*b) faire for i in range(5):
a=randint(0,10)
Score=score-1
b=randint(0,10)
Afficher (‘’c'est Faux! Réessayez encore! p=saisie_produit() #------appel------
score=", score)
saisie_produit (p) #appel de la procédure while (int(p)!= a*b):
score=score-1
print("c'est Faux! Réessayez
Fin Tant que
encore! score=", score)
Score=score+1 p=saisie_produit()
Afficher (‘’Bravo! score=’’, score) #----appel------
Fin pour
Afficher (‘’Résultat final : ‘’, i+1, ‘’essais et votre score=score+1
score=", score) print("Bravo! score=", score)
Afficher ("voulez-vous rejouez? (oui/non): ") print("********************************")
Lire (reponse) print(" Résultat final : ")
Fin Tantque print(i+1,"essais et votre score=",
Fin calculatrice score)

☞Algorithme procédure
saisie_produit :
Procédure saisie_produit (@X: entier)
Début
Répéter
Afficher (’’Essai’’, i+1, ’’ :’’, a,’’*’’, b,’’= ’’)
Lire(X)
Jusqu'à estnum(X)
Fin

Prof : Mme A.Hanen & Mr S.Akrem Page 35

 Objets globaux du programme principal
Objet Type/nature
i, a, b, p, score Entier
reponse Chaine de caractère
saisie_produit() procédure

☞ TDO :

Objets Locaux de la procédure saisie_produit

Objet Type/nature
x Entier

Prof : Mme A.Hanen & Mr S.Akrem Page 36

 🖎Note :
🖎 On distingue les paramètres effectifs et les paramètres formels.

❶ Un paramètre formel (local) est un paramètre utilisé dans la définition d'un sous
programme.

❷ Un paramètre effectif (global) ou réel est un paramètre utilisé lors de l'appel d'un
sous-programme.
🖎 Une règle à respecter :
Eliminer tous les paramètres dont le mode de passage est par référence @
et les retourner en résultat.
def Nom_procédure (paramètres):
Traitement
[return resultat]

☞L’appel en Python
- Si la procédure retourne un ou plusieurs résultats, il faut les stocker dans des
variables :
Variable(s)= Nom_procédure (paramètres)
- Si la procédure ne retourne rien :
Nom_procédure (paramètres)

❸ Passage des paramètres par valeur et passage par référence:

Prof : Mme A.Hanen & Mr S.Akrem Page 37

Prof : Mme A.Hanen & Mr S.Akrem Page 38
Revenons à notre jeu « calculatrice » :

Partie 6
Améliorons encore notre jeu :
✔ Contrôler toute saisie du produit p donné par le joueur (doit être de type entier)

✔ Donner la possibilité de rejouer (lancement du jeu à la demande).

☞Objectifs :
▪ Les sous programmes (procédures et fonctions)

☞Décomposition de problème :

Prof : Mme A.Hanen & Mr S.Akrem Page 39

Prof : Mme A.Hanen & Mr S.Akrem Page 40
☞Algorithme
Début calculatrice
[reponse🡨" oui"] Tantque (reponse="oui") faire

[score🡨0] pour i de 0 à 4 faire

a🡨Aléa (0 ,10)

b🡨Aléa (0 ,10)
Répéter
Afficher (’’Essai’’, i+1, ’’ :’’, a,’’*’’, b,’’= ’’)
Lire(p)
Jusqu'à estnum(p)
Tantque (valeur(p) ≠ a*b) faire
Score=score-1
Afficher (‘’c'est Faux! Réessayez encore! score=", score)
Répéter
Afficher (’’Essai’’, i+1, ’’ :’’, a,’’*’’, b,’’= ’’)
Lire(p)
Jusqu'à estnum(p)
Fin Tantque
Score=score+1
Afficher (‘’Bravo! score=’’, score)
Fin pour
Afficher (‘’Résultat final : ‘’, i+1, ‘’essais et votre score=", score)
Afficher ("voulez-vous rejouez? (oui/non): ")
Lire (reponse)
Fin Tantque
Fin calculatrice

Break de savoir :

🖎Note :
🖎 Un sous programme (module) permet l’utilisation redondante d’un même traitement en
différents points du programme juste par un simple appel.
🖎 Il s’agit de découper un programme complexe en petits modules traités séparément.

Prof : Mme A.Hanen & Mr S.Akrem Page 41

🖎 Un module peut être une procédure ou une fonction.

🖎 Une fonction retourne une seule valeur (numérique, chaine, liste..) suite à un traitement
bien précis.

En algorithme En python
Fonction ma_fonction (paramètres Def ma_fonction
formels :type) :type_résultat (param) :
Début Traitement
Traitement return résultat
Retourner Résultat (facultatif)
Fin def, mot-clé qui est l'abréviation
de « define » (définir, en anglais)
☞Appel : var🡨 ma_fonction (param effectifs) (au
niveau du prog. principal)

Exemple :
def cube(x):
return (x * x * x)

🖎 Un sous-programme qui retourne 0 ou plusieurs valeurs est appelé une procédure.

En algorithme En python

Prof : Mme A.Hanen & Mr S.Akrem Page 42

 Procedure ma_procedure(paramètres formels :type) Def
Début ma_procedure(param) :
Traitement
Traitement
Fin

☞Appel : ma_procedure (param effectifs) (au niveau

du prog. Princip.)

Exemple :
def message ():
print ("Fonction sans retour de valeur !")

🖎 Une variable déclarée dans un sous-programme est dite locale est elle n’est accessible
que depuis ce sous-programme (indéterminée dehors)

Exemple :
def cube(x):
return (x * x * x)

Prof : Mme A.Hanen & Mr S.Akrem Page 43

 Activité: Les sous-programmes
Compléter les sous-programmes suivants:

Scripts Résultat
1*7=7
🖳 Afficher la table de multiplication par 7: 2 * 7 = 14
3 * 7 = 21
def tableMult_par_7(): 4 * 7 = 28
i = 1 5 * 7 = 35
while i <= 10: 6 * 7 = 42
print(i, "*", 7, "=", i * 7) 7 * 7 = 49
i += 1 # On incrémente i de 1 à chaque tour de boucle. 8 * 7 = 56
9 * 7 = 63
# appelle de la procédure
10 * 7 = 70
tableMult_par_7()

🖳 Afficher le min suivi du max de 2 entiers:

def calculMiniMaxi(x,y):
if x<y: print (x,y) 2, 10
else: print (y,x)
# appelle de la procédure
calculMiniMaxi(2,10)
x et y sont passées par valeurs fixes (pas de changement)

🖳 Afficher le périmètre et l’aire d’un rectangle:

def rectangle(x,y): périmètre : 24
print("périmètre :",2*(x+y),"aire :",x*y) aire : 35

# appelle de la procédure
rectangle(7,5)
x et y sont passées par valeurs (pas de changement)

🖳 Afficher la somme de la suite de n entiers:

def sommeEntiers(n):
somme = 0
for i in range(n+1):

Prof : Mme A.Hanen & Mr S.Akrem Page 44

 somme += i 21
return somme

# appelle de la fonction
s=sommeEntiers(6)
print(s)

🖳 Afficher la somme et le produit de deux entiers:

def somme_produit(a,b): 13 42
s = a + b
p = a * b
print(s, p)

# appelle de la procédure
somme_produit(6,7)
a et b sont passées par valeurs (pas de changement)

Prof : Mme A.Hanen & Mr S.Akrem Page 45

Revenons à notre jeu..

☞Algorithme principal ☞Programme python:

#-----procédure saisie_produit------------
Début calculatrice
def saisie_produit():
[reponse🡨" oui"] while True:
X=input("Essai "+str(i+1)+": "+
Tantque (reponse="oui") faire
str(a)+"*"+str(b)+"=")
[score🡨0] pour i de 0 à 4 faire if X.isdigit()==True:break
return(X)
a🡨Aléa (0 ,10)
#----------Programme principal-----------
b🡨Aléa (0 ,10)
from random import*
saisie_produit (p) #appel de la procédure score=0
Tant que (p ≠ a*b) faire for i in range(5):
a=randint(0,10)
Score=score-1
b=randint(0,10)
Afficher (‘’c'est Faux! Réessayez encore! p=saisie_produit() #------appel------
score=", score)
saisie_produit (p) #appel de la procédure while (int(p)!= a*b):
score=score-1
print("c'est Faux! Réessayez
Fin Tant que
encore! score=", score)
Score=score+1 p=saisie_produit()
Afficher (‘’Bravo! score=’’, score) #----appel------
Fin pour
Afficher (‘’Résultat final : ‘’, i+1, ‘’essais et votre score=score+1
score=", score) print("Bravo! score=", score)
Afficher ("voulez-vous rejouez? (oui/non): ") print("********************************")
Lire (reponse) print(" Résultat final : ")
Fin Tantque print(i+1,"essais et votre score=",
Fin calculatrice score)

☞Algorithme procédure
saisie_produit :
Procédure saisie_produit (@X: entier)
Début
Répéter
Afficher (’’Essai’’, i+1, ’’ :’’, a,’’*’’, b,’’= ’’)
Lire(X)
Jusqu'à estnum(X)
Fin

Prof : Mme A.Hanen & Mr S.Akrem Page 46

 Objets globaux du programme principal
Objet Type/nature
i, a, b, p, score Entier
reponse Chaine de caractère
saisie_produit() procédure

☞ TDO :

Objets Locaux de la procédure saisie_produit

Objet Type/nature
x Entier

Prof : Mme A.Hanen & Mr S.Akrem Page 47

 🖎Note :
🖎 On distingue les paramètres effectifs et les paramètres formels.

❶ Un paramètre formel (local) est un paramètre utilisé dans la définition d'un sous
programme.

❷ Un paramètre effectif (global) ou réel est un paramètre utilisé lors de l'appel d'un
sous-programme.
🖎 Une règle à respecter :
Eliminer tous les paramètres dont le mode de passage est par référence @
et les retourner en résultat.
def Nom_procédure (paramètres):
Traitement
[return resultat]

☞L’appel en Python
- Si la procédure retourne un ou plusieurs résultats, il faut les stocker dans des
variables :
Variable(s)= Nom_procédure (paramètres)
- Si la procédure ne retourne rien :
Nom_procédure (paramètres)

❸ Passage des paramètres par valeur et passage par référence:

Prof : Mme A.Hanen & Mr S.Akrem Page 48

Prof : Mme A.Hanen & Mr S.Akrem Page 49
Revenons à notre jeu « calculatrice » :

Partie 7
Améliorons encore notre jeu en affichant à la fin les scores correspondant aux parties
jouées.

☞Objectif :
▪ Les tableaux à une dimension (vecteurs)

Prof : Mme A.Hanen & Mr S.Akrem Page 50

☞Algorithme
principal
Début calculatrice
[reponse🡨" oui" j=0]
Tantque (reponse="o
score🡨0 j🡨j+1
Afficher (‘’Partie
Pour i de 0 à 4
a🡨Aléa (0 ,10

b🡨Aléa (0 ,10
saisie_produ
Tant que (p
Score=sc
Afficher
saisie_pr
Fin Tant que
score=score+1
Afficher (‘’Bra
Fin pour
T_parties[j-1]=j #
T_scores[j-1]=sco
Afficher ("voulez-
Lire (reponse)
Fin Tantque
Afficher (‘’fin de jeu
Pour c de 0 à j-1 faire
Afficher ("Partie",
Fin pour
Fin calculatrice

☞Algorithme
Procédure saisie_prod
Début
Répéter
Afficher (’’Essai’’,
Lire(X)
Jusqu'à estnum(X)
Fin

Prof : Mme A.Hanen & Mr S.Akrem Page 51

 Objets globaux du programme principal
Objet Type/nature
i, a, b, p, score Entier
reponse Chaine de caractère
saisie_produit() Procédure
T_scores, Tableaux de 100
T_parties entiers

Objets Locaux de la procédure

saisie_produit
Objet Type/nature
x Entier

☞ TDO :

Prof : Mme A.Hanen & Mr S.Akrem Page 52

 Break de savoir :

🖎Note :
🖎 Un tableau à une dimension (vecteur) est une structure de données permettant de
ranger un nombre fini d'éléments tous de même type.
🖎 L'accès à un élément du tableau est un accès direct, il suffit de donner l'identificateur
(nom) du tableau et l'indice de cet élément.
🖎tab[i] désigne l’élément numéro i du tableau tab

Exemple: tab[0] désigne le 1er élément du tableau tab 🡪 tab[0]=12

🖎 La bibliothèque "numpy" de python est destinée à manipuler des matrices ou tableaux

multidimensionnels ainsi que des fonctions mathématiques opérant sur ces tableaux.

Revenons à notre jeu.. traduire l’algorithme principale en pyhton.

Prof : Mme A.Hanen & Mr S.Akrem Page 53

☞Programme python:
from numpy import array
from random import*
def saisie(): #-----ma procedure saisie()
while True:
x=input("Essai "+str(i+1)+": "+ str(a)+"*"+str(b)+"=")
if x.isdigit()==True:break
else: print("erreur de saisie!")
return(x)
#---------------------Fin procédure -----------------------------------------------
#---------------Commençant le jeu
--------------------------------------------------
reponse="oui"
j=0
T_parties=array([int( )] * 100)
T_scores=array([int( )] * 100)
while reponse =="oui":
j=j+1
score=0
print("************** Partie",j,"**************")
for i in range(5):
a=randint(0,10)
b=randint(0,10)
p=saisie() #-----appel de la procedure saisie()
while (int(p)!= a*b):
score=score-1
print("c'est Faux! Réessayez encore! score=", score)
p=saisie() #-----appel de la procedure saisie()
print("Bravo! score=", score)
#--- fin de
partie----------------------------------------------------------
#-----remplir un tableau des parties et un tableau des
scores--------------------
T_parties[j-1]=j
T_scores[j-1]=score

reponse= input("voulez-vous rejouez? (oui/non): ")

print("************************************")
print("Fin de jeu et résultat: ")

#-----Afficher les éléments des tableaux

-------------------------------------------
for c in range(j):
print("Partie",T_parties[c]," Score=", T_scores[c])
print("************************************")

Prof : Mme A.Hanen & Mr S.Akrem Page 54