Noms de variables non cohérents : ici, on a voulu afficher les 10 années suivant l'an 2000 :

annee = 2000 for i in range (10) : anne = annee + 1 print ( annee )

Exécuter

Erreur :

Types non cohérents : ici on a voulu tester si une température était égale à 100 degrés :

temperature = input ("Saisir la température de l'eau : ") if temperature == 100: print ("\nL'eau bout !")

Exécuter

Erreur :

Cas non pris en compte : ici on a voulu faire un programme demandant de saisir une température et affichant si celle-ci correspond à de l'eau solide, liquide ou gazeuse :

temperature = eval ( input (" Saisir la température : ")) if temperature < 0: print (" Solide ") elif temperature > 0 and temperature < 100: print (" Liquide ") else : print (" Gaz ")

Exécuter

Erreur :

Parcourt de tableau incomplet : ici on a voulu faire la somme des éléments d'un tableau :

tab = [10 , 42, 100] somme = 0 for i in range (0, 2): somme = somme + tab [i] print ( somme )

Exécuter

Erreur :

Effets de bord non voulus : ici, on a voulu faire une fonction prenant en paramètre un tableau et retournant ce tableau dont les éléments ont été multipliés par 2 :

def mult2 (tab): for i in range ( len ( tab )): tab [i] = tab [i] * 2 return tab t = [1, 2, 3] print ( mult2 (t), "est le résultat pour le paramètre : ", t)

Exécuter

Erreur :

IndentationError: unexpected indent

Cela signifie qu'une indentation inattendue est présente.

a = 4 b = 2

> line 2, IndentationError: unexpected indent

IndentationError: expected an indented block

Cela signifie qu'il manque une indentation.

if 4==2: print (" Argh !")

> line 2, IndentationError: expected an indented block

IndentationError: unindent does not match any outer indentation level

Cela signifie qu'au moment de désindenter à la fin d'un bloc, on n'a pas aligné correctement les instructions avec ce qui précède.

if 4==2: print (" Argh !") print (" Bonjour .")

> line 3, IndentationError: unindent does not match any outer indentation level

SyntaxError: invalid syntax

Cette erreur peut survenir dans de nombreux cas, notamment :

• en cas d'oubli du symbole " :" à la fin d'une instruction de contrôle de structures
if 4==2 print (" Argh !")

> line 2, SyntaxError: invalid syntax

• en cas d'instruction de contrôle de structure incorrecte
for in range (1, 11) : print (i)

> line 1, SyntaxError: invalid syntax

• en cas de confusion entre "=" et "=="
if 4=2: print (" Argh !")

> line 1, SyntaxError: invalid syntax

• dans certains cas d'oubli d'une parenthèse (l'erreur est alors détectée à la ligne suivante)
a = abs (5 b = 6

> line 2, SyntaxError: invalid syntax

• en cas d'oubli d'un opérateur (ici * entre le 2 et le a)
a = 5 b = 2a

> line 2, SyntaxError: invalid syntax

SyntaxError: EOL while scanning string literal
ou SyntaxError: unexpected EOF while parsing

Cette erreur survient lorsque les symboles ouvrant et fermant sont mal équilibrés, notamment :

• en cas de parenthèse manquante
a = 5*(2+3

> line 1, SyntaxError: unexpected EOF while parsing

• en cas de guillemet manquant
a = " Bonjour !

> line 1, SyntaxError: EOL while scanning string literal

SyntaxError: Missing parentheses in call to ...

Cette erreur survient dans certains cas d'oubli de parenthèses.

print 5

> line 1, SyntaxError: Missing parentheses in call to 'print'

NameError: name 'var' is not defined

Cela signifie que l'on utilise une variable qui n'a pas été définie au préalable. Cette erreur peut par exemple survenir lorsque :

• on a commis une erreur en tapant un nom de variable
tables = 5 chaises = talbes * 4

> line 2, NameError: name 'talbes' is not defined

• on a oublié d'initialiser la valeur d'une variable avant une boucle
for i in range (1, 11): somme = somme + i

> line 2, NameError: name 'somme' is not defined

• la variable n'est pas définie dans tous les cas
age = 18 if age &th; 18: etat = " mineur " elif age > 18: etat = " majeur " print ( etat )

> line 6, NameError: name 'etat' is not defined

TypeError: can only concatenate...

Cela survient lorsqu'on réalise une concaténation entre un élément concaténable (list, tuple...) et un élément non concaténable (int, float...). Cela arrive notamment :

• lorsqu'on oublie les crochet autour d'un élément au moment d'ajouter celui-ci une liste
liste = [1, 2] + 3

> line 1, TypeError: can only concatenate list (not "int") to list

• lorsqu'on a écrit la "virgule" d'un nombre décimal avec le symbole "," au lieu du symbole"."
nb = 0 ,42 nb = nb + 1

> line 2, TypeError: can only concatenate tuple (not "int") to tuple

TypeError: unsupported operand type(s) ...

Cela survient lorsque l'on réalise une opération avec des éléments dont le type n'est pas cohérent, par exemple :

• lorsqu'on a écrit la "virgule" d'un nombre décimal avec le symbole "," au lieu du symbole "."
nb = 0 ,42 nb = 1 + nb

> line 2, TypeError: unsupported operand type(s) for +: 'int' and 'tuple'

• en cas d'oubli du "eval" dans une saisie
nb = input (" veuillez saisir un nombre : ") nb = 1 + nb

> line 2, TypeError: unsupported operand type(s) for +: 'int' and 'str'

• si une opération n'est pas prévue pour le type utilisé (notamment en cas de plusieurs oublis du "eval")
nb1 = input (" saisir un nombre : ") nb2 = input (" saisir un nombre : ") print ( nb1 /nb2)

> line 3, TypeError: unsupported operand type(s) for /: 'str' and 'str'

TypeError: must be str, not int

Survient en cas d'oubli du "eval" dans une saisie

nb = input (" veuillez saisir un nombre : ") nb = nb + 1

> line 2, TypeError: must be str, not int

TypeError: bad operand type for ...

Cela survient lorsqu'on fait appel à une fonction prédéfinie de Python avec un paramètre dont le type n'est pas valide.

a = abs("42")

> line 1, TypeError: bad operand type for abs(): 'str'

TypeError: 'int' object is not callable

Cela survient lorsqu'il y a des parenthèses directement après un entier, notamment dans le cas où un opérateur est manquant (ici le * avant la parenthèse)

a = 3(4+5)

> line 1, TypeError: 'int' object is not callable

TypeError: f() takes 1 positional arguments but 2 were given

Cela survient lorsque le nombre de paramètres donnés au moment de l'appel à une fonction est supérieur au nombre de paramètres donnés dans la définition de la fonction.

def f(x): return 2*x f(4, 10)

> line 3, TypeError: f() takes 1 positional arguments but 2 were given

TypeError: f() missing 1 required positional argument: 'x'

Cela survient lorsque le nombre de paramètres donnés au moment de l'appel à une fonction est inférieur au nombre de paramètres donnés dans la définition de la fonction.

def f(x): return 2*x f()

> line 3, TypeError: f() missing 1 required positional argument: 'x'

IndexError: list index out of range

Cette erreur survient en cas de dépassement d'indice maximal dans un tableau

tab = [4, 2, 10] print ( tab [3]) f()

> line 2, IndexError: list index out of range

AssertionError

Cela survient lorsqu'une assertion ajoutée au programme est fausse. Un message d'erreur plus détaillé peut être ajouté par le programmeur.

nb = 0 assert nb != 0, "nb doit être différent de 0 !"

> line 2, AssertionError: nb doit être différent de 0 !

Ce programme demande de saisir un à un les éléments d'un tableau de taille 10 puis affiche ce tableau et la somme de ses éléments

Exemple de résulat attendu :

Veuillez saisir une valeur : 10
Veuillez saisir une valeur : 20
Veuillez saisir une valeur : 30
Veuillez saisir une valeur : 1
Veuillez saisir une valeur : 2
Veuillez saisir une valeur : 3
Veuillez saisir une valeur : 4
Veuillez saisir une valeur : 5
Veuillez saisir une valeur : 6
Veuillez saisir une valeur : 7
tableau : [10, 20, 30, 1, 2, 3, 4, 5, 6, 7]
Somme : 88

tab = [0] * 10 for i in range(11): element = input("Veuillez saisir une valeur : ") t[i] = element # Affichage du tableau print(tab) # Calcul de la somme for i in range(len(tab) somme = somme + i # Affichage de la somme print(somme)

Exécuter

Dans ce programme, on définit une fonction qui prend en paramètre un tableau et qui retourne la moyenne des éléments de ce tableau, puis on teste cette fonction sur différents paramètres

Exemple de résulat attendu :

>>> tab = [1, 10, 2, 9, 20]
>>> moyenne(tab)
8.4
>>> tab = [10, 8]
>>> moyenne(tab)
9.0
>>> tab = [1, 1, 1, 1, 10, 20, 100]
>>> moyenne(tab)
19.14285714285714

def moyenne(tab): """list[int] -> float préconditions : tab != [] retourne la moyenne des éléments du paramètre""" somme = 0 for i in range(5) s = somme + tab m = somme/5 return m tab = [1, 10, 2, 9, 20] print(m) tab = [10, 8] print(m tab = [1, 1, 1, 1, 10, 20, 100] print(m)

Exécuter

Dans ce programme, on définit une fonction qui prend en paramètre un tableau et qui retourne le nombre d'éléments supérieurs à 10 dans ce tableau

Exemple de résulat attendu :

>>> nombre_de_superieurs_a_10([])
0
>>> nombre_de_superieurs_a_10([12, 5, 18])
2

def nombre_de_superieurs_a_10(tab): """list[int] -> int préconditions : aucune Retourne le nombre d'éléments supérieurs à 10""" tab = [] for elt in tab: if elt > 10: compteur = 1 print(nombre_de_superieurs_a_10([]) print(nombre_de_superieurs_a_10(12, 5, 18))

Exécuter

Une place de cinema coûte 5 euros pour les moins de 10 ans, 6 euros pour les enfants de 10 ans, 8 euros pour les moins de 18 ans (mais plus de 10 ans) et 9 euros pour les autres. Dans le programme ci-dessous, on définit une fonction prenant en paramètre un âge et retournant le prix de la place de cinéma.

Exemple de résulats attendus :

>>> prix_place(2)
5
>>> prix_place(20)
9

def prix_place() """int -> int préconditions : age > 0 Retourne le prix de la place associé pour l'âge passé en paramètre""" age = input("Veuillez saisir un âge : ") if age < 10: return 5 else if age = 10: return 6 else if age < 18: return 8 else if age > 18: return 9 # tests print prix_place(2) print prix_place(20)

Exécuter

Dans ce programme, on définit une procédure table qui prend en paramètre un nombre et qui affiche la table de multiplication de ce nombre.

Exemple de résulat attendu :

>>> table(5)
1 * 5 = 5
2 * 5 = 10
3 * 5 = 15
4 * 5 = 20
5 * 5 = 25
6 * 5 = 30
7 * 5 = 35
8 * 5 = 40
9 * 5 = 45
10 * 5 = 50

def table(nombre): """int -> void préconditions : aucune Affiche la table de multiplication du paramètre.""" i=nombre for nombre in range(1,11): print(nombre,"*nombre,nombre*i) return

Exécuter

On veut simuler un jeu à deux joueurs. On appellera ces joueurs A et B. Chaque joueur possède un pion, qui se déplace sur un circuit linéaire composé de 20 cases. À chaque tour les deux joueurs partent de la case 1, et jouent simultanément de la façon suivante :

• chaque joueur lance 7 dés à six faces,

• si la somme des dés est supérieure à 21, le pion du joueur avance de 2 cases, sinon, le pion n'avance que d'une case.

Le jeu s'arrête lorsque l'un des pions atteint ou dépasse la vingtième case. Le joueur à qui appartient le pion a alors gagné.

Ce programme définit une fonction tour ne prenant aucun paramètre, simulant les 7 lancers et retournant le nombre de cases dont le joueur doit avancer. À l'aide de cette fonction, le programme simule le jeu complet.

Exemple de résulat attendu :

Les joueurs lancent les dés ...
Le pionA se trouve sur la case : 3
Le pionB se trouve sur la case : 3
Les joueurs lancent les dés ...
Le pionA se trouve sur la case : 5
Le pionB se trouve sur la case : 5
Les joueurs lancent les dés ...
Le pionA se trouve sur la case : 7
Le pionB se trouve sur la case : 7
Les joueurs lancent les dés ...
Le pionA se trouve sur la case : 8
Le pionB se trouve sur la case : 9
Les joueurs lancent les dés ...
Le pionA se trouve sur la case : 10
Le pionB se trouve sur la case : 11
Les joueurs lancent les dés ...
Le pionA se trouve sur la case : 12
Le pionB se trouve sur la case : 13
Les joueurs lancent les dés ...
Le pionA se trouve sur la case : 14
Le pionB se trouve sur la case : 15
Les joueurs lancent les dés ...
Le pionA se trouve sur la case : 16
Le pionB se trouve sur la case : 17
Les joueurs lancent les dés ...
Le pionA se trouve sur la case : 17
Le pionB se trouve sur la case : 19
Les joueurs lancent les dés ...
Le pionA se trouve sur la case : 19
Le pionB se trouve sur la case : 21
Le pion B a gagné !

from random import * def tour() : """void -> int préconditions : aucune Simule le lancer de 7 dés puis retourne le nombre de cases dont il faut avancer""" nbDe = 0 nbCases = 0 pion = 0 de = randint(1, 6) while nbDe <= 7 : somme = somme + de if(somme > 21) : pion = pion + 2 else : pion = pion + 1 nbDe = nbDe + 1 return nbCase def jeu(): """void -> void préconditions : aucune Simule le jeu""" pionA = 1 pionB = 1 while(nbCases <= 20) : tour() if(pionA >= 20) : print("Le pion a a gagné !") elif(pionB <= 20) : print("Le pion b a gagné !") else : print("Egalité") return ;

Exécuter

On veut simuler un jeu à deux joueurs. On appellera ces joueurs A et B. Ces deux joueurs partent d'un score de 0 points. À chaque tour :

• chaque joueur lance un dé à six face,

• si le dé vaut 5 ou 6, le joueur relance le dé, jusqu'à obtenir un dé entre 1 et 4,
• si le dé vaut 1 ou 3, le joueur perd un nombre de points égal à la valeur du dé (le joueur "gagne" donc -1 ou -3 points),
• si le dé vaut 2 ou 4, le joueur gagne un nombre de points égal à deux fois la valeur du dé (donc 4 ou 8).

Les joueurs effectuent 10 tours (les scores négatifs sont autorisés), et le joueur ayant le plus de points à la fin gagne.

Ce programme définit une fonction tour ne prenant pas de paramètre, simulant un tour de jeu et retournant le nombre de points gagnés (c'est-à-dire -1, -3, 4 ou 8 selon les résultats des dés). Puis ce programme simule le jeu complet à l'aide de cette fonction.

Exemple de résulat attendu :

tour 1 joueur A : -1 Joueur B : -3
tour 2 joueur A : -3 Joueur B : 5
tour 3 joueur A : -6 Joueur B : 3
tour 4 joueur A : -8 Joueur B : 1
tour 5 joueur A : 0 Joueur B : -2
tour 6 joueur A : -3 Joueur B : -5
tour 7 joueur A : -4 Joueur B : 3
tour 8 joueur A : -6 Joueur B : 1
tour 9 joueur A : 2 Joueur B : 0
tour 10 joueur A : 0 Joueur B : -1
Joueur A a gagné

from random import randint def tour(): """void -> int préconditions : aucune Simule un tour de jeu et retourne le nombre de points obtenus""" pj =0 de = randint(1,6) while de <=4 : if de = 1 : pj = pj-1 if de = 3 : pj = pj-3 if de = 2 : pj = pj+4 else : pj = pj+8 print (pj) pj1 = pj pj2 = pj for in range (1,11) : tour() if pj1 < pj2 : print("Joueur 2 a gagné") elif pj1 > pj2 : print("Joueur 1 a gagné")

Exécuter

Dans ce programme, on définit une procédure freq_1_6 qui :

• prend en paramètre un tableau d'entiers entre 1 et 6
• détermine le nombre de fois où chaque valeur a été obtenue et stocke les 6 valeurs obtenues dans un tableau de taille 6
• affiche la fréquence de chaque valeur
• affiche le tabeau du nombre d'occurences

Remarque : La somme des fréquences doit être égale à 1

Ce programme :

• génère un tableau de taille 100 dont les éléments sont des entiers aléatoires compris entre 1 et 6
• fait appel à la procédure freq_1_6 avec ce tableau en paramètre

Exemple de résulat attendu :

La fréquence de la valeur  1  est  0.13
La fréquence de la valeur  2  est  0.13
La fréquence de la valeur  3  est  0.2
La fréquence de la valeur  4  est  0.19
La fréquence de la valeur  5  est  0.16
La fréquence de la valeur  6  est  0.19
Tableau d'occurences [13, 13, 20, 19, 16, 19]

from random import randint def freq_1_6(tab): """list[int] -> list[int] préconditions : pour tout i, tab[i] >=1 et tab[i] <= 6 Affiche la fréquence des entiers entre 1 et 6 et le tableau d'occurences""" tab = [] compteur = 0 for i in range(100) compteur[i] = 1 for j in range(6): freq = compteur[i] / len(tab) print("La fréquence de la valeur , i, " est ", freq) # partie principale du programme : rand_tab = [randint(1,6)] * 100 print freq_1_6(rand_tab)

Exécuter

Exercice 9