2 Ti

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 :
L’ordinateur choisi Table de Tester la réponse et afficher
au hasard 2 entiers multiplication (Bravo ou c’est faux)
a et b entre 0 et 10
Poser à l’utilisateur la Saisi de la réponse
question a*b= ? de l’utilisateur
Algorithme Programme python :

Début calculatrice from random import*
1) aAléa (0 ,10) a=randint(0,10)
2) bAléa (0 ,10) b=randint(0,10)
print(a,"*",b,"=", end=" ")
3) Afficher (a,’’*’’,b,’’= ’’)
p=int(input())
Lire(p) test=(a*b==p)
4) test(a*b=p) if (test==True):
5) Si (test=vrai) alors print(test,"Bravo!")
Afficher (test,‘’Bravo !‘’) else:
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éen tester de la réponse de l’utilisateur
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.
 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”)

Activité1: Différents types des variables
1) Compléter le
Affectation Résultat affiché Type
tableau suivant en v=5 #<class 'int'> Entier
indiquant le résultat v=12.25 #<class 'float'> Réel
affiché et le type de la v='2 eme
Ti' #<class 'str'> Chaine de caractère
variable v en exécutant la
v=8<10 #<class 'bool'> Booléen
commande
v=[1,5,3] #<class 'list'> Tableau
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.
No te :
 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
1)Afficher et
interpréter les
Résultat Opération arithmétique
résultats des affiché En Algorithme En Python
opérateurs 20 + 3 = 23 Addition (+) +
arithmétiques (=, -, 20 -3 = 17 Soustraction (-) -
*, /, **, // et %) 20 * 3 = 60 Multiplication (*) *
utilisés pour les 20 / 3 = 6.667 Division décimale (/) /
variables : a=20 b=3 20 ** 3 = 8000 Puissance (^) **
20 // 3 = 6 Division entière (DIV) //
20 % 3 = 2 Reste de la division entière (MOD) %
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 :
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
Objet Type/nature Rôle
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 6") Afficher ("Saisir un age supérieur ou égal 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

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 :
Saisie de Chercher l’indice/position du caractère espace (séparateur) dans
Nom&Prénom la chaine Ch  pos_espace  pos(" ", Ch)
Chercher l’indice du dernier caractère de Ch Llong(Ch)
Avec indice du dernier caractère= L-1
Extraire la sous_chaine (prénom) commençant du caractère situé

après l’espace jusqu'à la fin de la chaine.
prenomSous-chaine (Ch, (pos_espace)+1, L) avec L exclus
automatiquement et la sous chaine se termine à L-1

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!")
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 (" ")
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 Retourne une partie de la chaîne ch à partir de la position d

(ch,d,f) Ch[d:f] jusqu’à la position f (f exclue).

Activité4: L’accès par indice à une chaine [début:fin]
Soit la chaine de caractère V
V= " 2 è m e I n f o"
suivante :
Indice (positif) 0 1 2 3 4 5 6 7 8
1) Donnez les instructions Indice (négatif) -9 -8 -7 -6 -5 -4 -3 -2 -1
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 :
InstructionsRésultats Interprétations
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
Instruction
s
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 s2 True Vérifie le non inclusion du caractère ‘E‘ dans
la chaine s2.
"la" in s1 False Vérifie l’inclusion de la chaine ‘la‘ dans la
chaine s1.
"belle "== s3 True Compare l’égalité entre les 2 chaines.
s2<=s3 True Compare l’infériorité de s2 par rapport à s3.

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
Initialiser le score à 0 pour débuter le jeu
Tirer deux entiers aléatoires entre 0 et 10
Répéter
Demander et saisir le produit p de l’utilisateur
5 fois
p = a*b
Vrai Faux
Algorithme1
Score+=1 Programme
Score-=1 python1 :
Afficher bravo ! Afficher c’est import*
from random faux !
Début calculatrice score=0
[score=0] pour i de 0 à 4 faire for i in range(5):
Fin de jeu : Afficher le nombre d’essais et le score final
a=randint(0,10)
aAléa (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):

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
score=score-1
Afficher (‘’c’est faux ! score=’’, score)
Fin si
Fin pour
Fin calculatrice
Améliorons l’affichage :
Algorithme2 Programme python2 :

from random import*
1) [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("Essai"+str(i+1)+":"+ str(a)
Afficher (’’Essai’’, i+1, ’’ :’’, a,’’*’’, b,’’= ’’) +"*"+str(b)+"="))
Lire(p) if (a*b==p):
Si (a*b=p) alors score=score+1
Score=score+1 print("Bravo! score=", score)
else:
Afficher (‘’Bravo ! score=’’, score)
score=score-1
Sinon print("c'est faux! score=", score)
Score=score-1 print("*********************************")
Afficher (‘’c’est faux ! score=’’, score) print(" Résultat final : ")
Fin si print(i+1," essais et votre score=", score)
Fin pour
2) Afficher (‘’Résultat final : ‘’, i+1,
‘’essais et votre score=", score)
Fin calculatrice

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] faire for compteur in séquence :
Traitement Traitement
Fin pour Les éléments de la séquence sont issus
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.
Activité1: Fonction range() :

Exécutez et interpréter les scripts suivantes :
Scripts 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)
maliste =
range(2,10,2)
print(maliste[2]) 5 Accéder au 3ème élément a l'indice 2

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.
Test de la condition d’entrée
Fausse réponse :
p≠a*b
Objectifs :
 La boucle à condition d’arrêt (Tantque)
Demander le produit de l’utilisateur Répéter

Répéter
p = a*b tant que
5 fois Faux
Vrai réponse
erronée
Algorithme
Score+=1 Programme python :
Score-=1
Afficher c’est faux ! réessayer!
Afficher bravo ! from random import*
Fin de jeu : Afficher le nombre d’essais et le score final
a=randint(0,10)
aAléa (0 ,10)
b=randint(0,10)
bAléa (0 ,10) p=int(input("Essai"+str(i+1)+":"+ str(a)
Afficher (’’Essai’’, i+1, ’’ :’’, a,’’*’’, b,’’= ’’) +"*"+str(b)+"="))

Lire(p) while (p!= a*b):
Tantque (p ≠ a*b) faire score=score-1
print("c'est Faux! Réessayez encore!
Score=score-1
score=", score)
Afficher (‘’c'est Faux! Réessayez p=int(input(str(a)+"*"+str(b)+"="))
encore! score=", score)
Afficher (a,’’*’’, b,’’= ’’) score=score+1
print("Bravo! score=", score)
Lire(p)
print("*********************************")
Fin Tantque print(" Résultat final : ")
Score=score+1 print(i+1," essais et votre score=", score)
Afficher (‘’Bravo! score=’’, score)
Fin pour
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
[] Tantque condition_Vrai faire While condition_True:
Traitement Traitement
Fin tant que

Partie 5
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.
Sortir
Objectifs :
 La boucle à condition d’arrêt (Répéter.. jusqu’a)
 Fonctions prédéfinies sur les chaines de caractères.
Saisir le produit p Répéter

p entier ?
Vrai Faux jusqu'à
Sortir saisie
Algorithme
Continuer le jeu Programme
Afficher un message python :correcte
d’erreur
from de saisie
random import*

aAléa (0 ,10) a=randint(0,10)
b=randint(0,10)
bAléa (0 ,10)
while True:
Répéter p=input("Essai "+str(i+1)+": "+ str(a)
Afficher (’’Essai’’, i+1, ’’ :’’, a,’’*’’, b,’’= ’’) +"*"+str(b)+"=")
Lire(p) if (p.isdigit()): break
Jusqu'à estnum(p) else:
print("erreur! saisir un entier.")
Tantque (p ≠ a*b) faire while (int(p)!= a*b):

Score=score-1 score=score-1
Afficher (‘’c'est Faux! Réessayez print("c'est Faux! Réessayez encore!
encore! score=", score) score=", score)
p=int(input(str(a)+"*"+str(b)+"="))
Afficher (a,’’*’’, b,’’= ’’)
Lire(p) score=score+1
Fin Tantque print("Bravo! score=", score)
Score=score+1 print("*********************************")
print(" Résultat final : ")
print(i+1," essais et votre score=", score)
Fin pour
Fin calculatrice
Break de savoir : Différence. Entre Tant que et Répéter :

Tant que 1- test condition 2-traitement.
Note : Répétér : 1-traitement 2-test condition.
 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.
[] 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:

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

Partie 6
 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 :
[Initialiser Réponse à oui]
Faux Quitter le jeu Vrai  Déclencher le jeu

Réponse= oui ?
Un même traitement de Saisir p contrôlé (entier)

saisie est écrit 2 fois
Vrai Faux
p≠ a*b
Score-=1 Score+=1
Afficher c’est faux ! réessayer! Afficher bravo !
Saisir p contrôlé (entier)
Faux Quitter le jeu Vrai  Rejouer

Demander au joueur s’il veut rejouer

Algorithme
Un même traitement de
Début calculatrice
[reponse" oui"] Tantque (reponse="oui") faire saisie est écrit 2 fois
[score0] pour i de 0 à 4 faire Il faut le simplifier par un
aAléa (0 ,10) seul module (sous
bAléa (0 ,10) programme)
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
Lire(p)
Jusqu'à estnum(p)
Fin Tantque
Score=score+1
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.
Programme
Principal

 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.
Fonction ma_fonction (paramètres formels :type) :type_résultat Def ma_fonction (param) :
Début Traitement
Traitement return résultat
Retourner Résultat (facultatif)
Fin def, mot-clé qui est l'abréviation de
Appel : var ma_fonction (param effectifs) (au niveau « define » (définir, en anglais)
du prog. principal)
Exemple :
def cube(x): print(cube(3))  affiche 27
return (x * x * x) print(cube(5))  affiche 125
 Un sous-programme qui retourne 0 ou plusieurs valeurs est appelé une procédure.
Procedure ma_procedure(paramètres formels :type) Def ma_procedure(param) :
Début Traitement
Traitement
Fin
Appel : ma_procedure (param effectifs) (au niveau du
prog. Princip.)
Exemple :
def message ():
message() affiche Fonction
print ("Fonction sans retour de valeur !")
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 : Variable locale

def cube(x): print(x)
return (x * x * x)  Affiche NameError: name 'x' is not defined

Activité: Les sous-programmes
Compléter les sous-programmes suivants:
Scripts Résultat
 Afficher la table de multiplication par 7: 1*7=7
2 * 7 = 14
def tableMult_par_7(): 3 * 7 = 21
i = 1 4 * 7 = 28
while i <= 10: 5 * 7 = 35
print(i, "*", 7, "=", i * 7) 6 * 7 = 42
i += 1 # On incrémente i de 1 à chaque tour de boucle. 7 * 7 = 49
8 * 7 = 56
# appelle de la procédure
9 * 7 = 63
tableMult_par_7()
10 * 7 = 70
 Afficher le min suivi du max de 2 entiers:
def calculMiniMaxi(x,y):
if x<y: print (x,y)
else: print (y,x) 2, 10
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):
print("périmètre :",2*(x+y),"aire :",x*y) périmètre : 24
aire : 35
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):
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):
s = a + b
13 42
p = a * b
print(s, p)
somme_produit(6,7)
a et b sont passées par valeurs (pas de changement)

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
aAléa (0 ,10) return(X)
bAléa (0 ,10)
saisie_produit (p) #appel de la procédure #----------Programme principal-----------
from random import*
Tant que (p ≠ a*b) faire
score=0
Score=score-1 for i in range(5):
Afficher (‘’c'est Faux! Réessayez encore! a=randint(0,10)
score=", score) b=randint(0,10)
saisie_produit (p) #appel de la procédure p=saisie_produit() #------appel------
while (int(p)!= a*b):

Fin Tant que score=score-1
Score=score+1 print("c'est Faux! Réessayez
Afficher (‘’Bravo! score=’’, score) encore! score=", score)
Fin pour p=saisie_produit() #----
appel------
Afficher (‘’Résultat final : ‘’, i+1, ‘’essais et votre
score=", score) score=score+1
Afficher ("voulez-vous rejouez? (oui/non): ") print("Bravo! score=", score)
Lire (reponse) print("********************************")
@ : Variable change de valeur print(i+1,"essais et votre score=", score)
Fin calculatrice
Algorithme procédure
saisie_produit :
Procédure saisie_produit (@X: entier)
Début
Répéter
Lire(X)
Jusqu'à estnum(X)
Fin
 Objets globaux du programme principal TDO :

Objet Type/nature
i, a, b, p, score Entier
reponse Chaine de caractère
saisie_produit() procédure
Objets Locaux de la procédure saisie_produit
Objet Type/nature
x Entier
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:

Partie 6
 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 :
[Initialiser Réponse à oui]
Faux Quitter le jeu Vrai  Déclencher le jeu

Réponse= oui ?
Un même traitement de Saisir p contrôlé (entier)

saisie est écrit 2 fois
Vrai Faux
p≠ a*b
Score-=1 Score+=1
Afficher c’est faux ! réessayer! Afficher bravo !
Saisir p contrôlé (entier)
Faux Quitter le jeu Vrai  Rejouer

Demander au joueur s’il veut rejouer

Algorithme
Un même traitement de
Début calculatrice
[reponse" oui"] Tantque (reponse="oui") faire saisie est écrit 2 fois
[score0] pour i de 0 à 4 faire Il faut le simplifier par un
aAléa (0 ,10) seul module (sous
bAléa (0 ,10) programme)
Répéter
Lire(p)
Jusqu'à estnum(p)
Tantque (valeur(p) ≠ a*b) faire
Score=score-1
Répéter
Lire(p)
Jusqu'à estnum(p)
Fin Tantque
Score=score+1
Fin pour
Afficher (‘’Résultat final : ‘’, i+1, ‘’essais et votre score=", score)
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.
Programme
Principal

 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.
Fonction ma_fonction (paramètres formels :type) :type_résultat Def ma_fonction (param) :
Début Traitement
Traitement return résultat
Retourner Résultat (facultatif)
Fin def, mot-clé qui est l'abréviation de
Appel : var ma_fonction (param effectifs) (au niveau « define » (définir, en anglais)
du prog. principal)
Exemple :
def cube(x): print(cube(3))  affiche 27
return (x * x * x) print(cube(5))  affiche 125
 Un sous-programme qui retourne 0 ou plusieurs valeurs est appelé une procédure.
Procedure ma_procedure(paramètres formels :type) Def ma_procedure(param) :
Début Traitement
Traitement
Fin
Appel : ma_procedure (param effectifs) (au niveau du
prog. Princip.)
Exemple :
def message ():
message() affiche Fonction
print ("Fonction sans retour de valeur !")
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 : Variable locale

def cube(x): print(x)
return (x * x * x)  Affiche NameError: name 'x' is not defined

Activité: Les sous-programmes
Compléter les sous-programmes suivants:
Scripts Résultat
 Afficher la table de multiplication par 7: 1*7=7
2 * 7 = 14
def tableMult_par_7(): 3 * 7 = 21
i = 1 4 * 7 = 28
while i <= 10: 5 * 7 = 35
print(i, "*", 7, "=", i * 7) 6 * 7 = 42
i += 1 # On incrémente i de 1 à chaque tour de boucle. 7 * 7 = 49
8 * 7 = 56
9 * 7 = 63
tableMult_par_7()
10 * 7 = 70
 Afficher le min suivi du max de 2 entiers:
def calculMiniMaxi(x,y):
if x<y: print (x,y)
else: print (y,x) 2, 10
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):
print("périmètre :",2*(x+y),"aire :",x*y) périmètre : 24
aire : 35
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):
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):
s = a + b
13 42
p = a * b
print(s, p)
somme_produit(6,7)
a et b sont passées par valeurs (pas de changement)

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)+": "+
str(a)+"*"+str(b)+"=")
[score0] pour i de 0 à 4 faire if X.isdigit()==True:break
aAléa (0 ,10) return(X)
bAléa (0 ,10)
saisie_produit (p) #appel de la procédure #----------Programme principal-----------
from random import*
score=0
Score=score-1 for i in range(5):
Afficher (‘’c'est Faux! Réessayez encore! a=randint(0,10)
score=", score) b=randint(0,10)
saisie_produit (p) #appel de la procédure p=saisie_produit() #------appel------

Fin Tant que score=score-1
Score=score+1 print("c'est Faux! Réessayez
Afficher (‘’Bravo! score=’’, score) encore! score=", score)
Fin pour p=saisie_produit() #----
appel------
Afficher (‘’Résultat final : ‘’, i+1, ‘’essais et votre
score=", score) score=score+1
Afficher ("voulez-vous rejouez? (oui/non): ") print("Bravo! score=", score)
Lire (reponse) print("********************************")
@ : Variable change de valeur print(i+1,"essais et votre score=", score)
Fin calculatrice
Algorithme procédure
saisie_produit :
Début
Répéter
Lire(X)
Jusqu'à estnum(X)
Fin

Objet Type/nature
i, a, b, p, score Entier
reponse Chaine de caractère
saisie_produit() procédure
Objets Locaux de la procédure saisie_produit
Objet Type/nature
x Entier
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:

Partie 7
Améliorons encore notre jeu en affichant à la fin les scores correspondant aux parties
jouées.
Objectif :
 Les tableaux à une dimension (vecteurs)
Algorithme principal
Début calculatrice
[reponse" oui" j=0] #---j contient le numéro de partie---

score0 jj+1
Afficher (‘’Partie ‘’, j)
Pour i de 0 à 4 faire
aAléa (0 ,10)
bAléa (0 ,10)
saisie_produit (p) #---appel de la procédure---
Score=score-1
saisie_produit (p) #---appel de la procédure---
Fin Tant que
score=score+1 Saisie score partie1,
partie2, … avec boucle
pour
Fin pour
T_parties[j-1]=j #---remplir un tableau des parties et un tableau des scores---
T_scores[j-1]=score
Lire (reponse)
Fin Tantque
Afficher (‘’fin de jeu et résultat : ‘’)
Pour c de 0 à j-1 faire #---Afficher les deux tableaux---
Afficher ("Partie",T_parties[c]," Score=", T_scores[c])
Fin pour
Fin calculatrice
Algorithme procédure saisie_produit :

Début
Répéter
Lire(X)
Jusqu'à estnum(X)
Fin

Objets Locaux de la procédure
Objet Type/nature saisie_produit
i, a, b, p, score Entier Objet Type/nature
reponse Chaine de caractère x Entier
saisie_produit() Procédure
T_scores, T_parties Tableaux de 100
entiers

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.

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()
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("************************************")

2 Ti

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

2 Ti

Transféré par

Droits d'auteur :

Formats disponibles

Pensée Computationnelle et programmation

Programmer mon 1er jeu! (calcul mental)

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

Algorithme Programme python :

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

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

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

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

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

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

Le type booléen :

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

Le type chaine de caractère:

Extraire la sous_chaine (prénom) commençant du caractère situé

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

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

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

Sous_chaine Retourne une partie de la chaîne ch à partir de la position d

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

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

 Premier caractère  V[0]= V[-9] vaut '2'

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

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

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

Tirer deux entiers aléatoires entre 0 et 10

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

Algorithme2 Programme python2 :

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

Activité1: Fonction range() :

Scripts Résultat Interprétation

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

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

Tirer deux entiers aléatoires entre 0 et 10

Demander le produit de l’utilisateur Répéter

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

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

Tirer deux entiers aléatoires entre 0 et 10

Saisir le produit p Répéter

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

Tantque (p ≠ a*b) faire while (int(p)!= a*b):

Break de savoir : Différence. Entre Tant que et Répéter :

 break : permet de quitter la boucle.

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

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

Faux Quitter le jeu Vrai  Déclencher le jeu

Tirer deux entiers aléatoires entre 0 et 10

Un même traitement de Saisir p contrôlé (entier)

Faux Quitter le jeu Vrai  Rejouer

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

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

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

Exemple : Variable locale

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

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

Algorithme principal Programme python:

while (int(p)!= a*b):

 Objets globaux du programme principal TDO :

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

Faux Quitter le jeu Vrai  Déclencher le jeu

Tirer deux entiers aléatoires entre 0 et 10

Un même traitement de Saisir p contrôlé (entier)

Faux Quitter le jeu Vrai  Rejouer

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

Tantque (p ≠ ab) faire while (int(p)!= ab):