Correction détaillée de quelques exercices

Voyons la correction détaillée de quelques exercices accessibles sur le support.

Exercices pour débuter

Exercice 1 : Comptons...

Nous allons tout d'abord récupérer la correction de l'exercice sur les chaînes de caractères

1
texte = input('Entrez un texte : ')
2
n = 0                       # Variable de "stockage" du nombre de "e"
3
for caractere in texte:
4
    if caractere == 'e':
5
        n += 1
6
print('Il y a {} "e" dans ce texte.'.format(n))

Comment créer une fonction ? Ci-dessous un exemple en copiant collant simplement le code précédent.

Il ne faut pas oublier le mot clef def, les deux-points, et l'indentation !

1
def compter():
2
    texte = input('Entrez un texte : ')
3
    n = 0                       # Variable de "stockage" du nombre de "e"
4
    for caractere in texte:
5
        if caractere == 'e':
6
            n += 1
7
    print('Il y a {} "e" dans ce texte.'.format(n))

Ceci ne va pas fonctionner car le but d'une fonction est de faire le traitement ! Donc pas de input() !

1
def compter():
2
    n = 0                       # Variable de "stockage" du nombre de "e"
3
    for caractere in texte:
4
        if caractere == 'e':
5
            n += 1
6
    print('Il y a {} "e" dans ce texte.'.format(n))
7
8
9
texte = input('Entrez un texte : ')
10
compter()
Ici, la variable texte ligne 3 ne sait pas où trouver sa valeur ! En effet, une variable ne peut voir que dans sa fonction (les deux dernières lignes sont hors de la fonction). On doit donc passer en paramètre de la fonction le texte attendu.
1
def compter(texte):
2
    n = 0                       # Variable de "stockage" du nombre de "e"
3
    for caractere in texte:
4
        if caractere == 'e':
5
            n += 1
6
    print('Il y a {} "e" dans ce texte.'.format(n))
7
8
9
texte = input('Entrez un texte : ')
10
compter(texte)
C'est beaucoup mieux ! Le code fonctionne mais on doit demander le caractère à rechercher à l'utilisateur (ici 'e'). On peut y arriver en rajoutant un paramètre supplémentaire dans la fonction.
1
def compter(texte, lettre):
2
    n = 0                       # Variable de "stockage" du nombre de lettres
3
    for caractere in texte:
4
        if caractere == lettre:
5
            n += 1
6
    print('Il y a {} "{}" dans ce texte.'.format(n, lettre))
7
8
9
texte = input('Entrez un texte : ')
10
lettre = input('Entrez une lettre : ')
11
compter(texte, lettre)
Voilà ! Mais par contre, on aimerait plutôt que la fonction compter() renvoie le nombre d'occurences au lieu d'afficher le résultat.
Pourquoi ? Pour pouvoir faire un traitement par la suite (par exemple pour afficher la valeur ou l'utiliser dans une autre fonction).
Ici, nous voulons simplement afficher la valeur.
1
def compter(texte, lettre):
2
    n = 0                       # Variable de "stockage" du nombre de lettres
3
    for caractere in texte:
4
        if caractere == lettre:
5
            n += 1
6
    return n
7
8
texte = input('Entrez un texte : ')
9
lettre = input('Entrez une lettre : ')
10
nombre = compter(texte, lettre)
11
print('Il y a {} "{}" dans ce texte.'.format(nombre, lettre))
Simulation
C'est terminé !! Voici ci-dessous un programme plus détaillé
1
##----- Définition des Fonctions ----- ##
2
def compter(chaine, carac):
3
    """Cette fonction renvoie le nombre d'occurences du caractère carac dans chaine."""
4
    nombre = 0                  # Variable interne à la fonction qui décompte le nombre d'occurences
5
    for lettre in chaine:       # On parcourt les lettres du texte
6
        if lettre == carac:
7
            nombre += 1
8
    return nombre               # La fonction retourne le nombre d'occurences
9
10
##----- Programme principal ----- ##
11
texte = input('Entrez un phrase : ')
12
lettre = input('Entrez un caractère : ')
13
n = compter(texte, lettre)
14
print('Il y a {} "{}" dans la phrase.'.format(n, lettre))
Exercice 2 : Le plus petit...
1 - Compléter la définition de la fonction mini() qui renvoie le plus petit des deux nombres entre u et v entrés en paramètres.
  • On commence par définir les paramètres
  • Ensuite, on peut vérifier la valeur des 2 variables en les comparants
  • On renvoie ensuite le plus petit
1
##----- Importation des modules -----##
2
from random import *
3
4
##----- Définition des Fonctions -----##
5
def mini(u, v):
6
    """ Entrees : deux nombres u et v
7
        Sorties : retourne la plus petite valeur entre u et v """
8
    if u < v:
9
        return u # Car u est plus petit que v donc on renvoie u qui est le plus petit
10
    else:
11
        return v # Car u n'est pas le plus petit, donc c'est v
2 - Le module random va permettre de tester cette fonction. Dans le «Programme principal», affecter aux variables a et b des valeurs entières aléatoires comprises entre 0 et 100.
Il y a 2 façons de faire :
  • soit on affecte une valeur aux deux variables en une seule ligne en utilisant la syntaxe a, b = valeurA, valeurB
  • soit on affecte une valeur ligne par ligne
1
##----- Programme Principal -----##
2
a, b = randint(0, 100), randint(0, 100)
1
##----- Programme Principal -----##
2
a = randint(0, 100)
3
b = randint(0, 100)
3 - Afficher la valeur stockée dans a, celle stockée dans b puis, en utilisant la fonction mini(), afficher la plus petite de ces deux valeurs.
On doit donc rajouter des print, et récupérer la valeur renvoyée par la fonction.
Si on reprend tout depuis le début, ça donne :
1
##----- Importation des modules -----##
2
from random import *
3
4
##----- Définition des Fonctions -----##
5
def mini(u, v):
6
    """ Entrees : deux nombres u et v
7
        Sorties : retourne la plus petite valeur entre u et v """
8
    if u < v:
9
        return u # Car u est plus petit que v donc on renvoie u qui est le plus petit
10
    else:
11
        return v # Car u n'est pas le plus petit, donc c'est v
12
13
##----- Programme Principal -----##
14
a, b = randint(0, 100), randint(0, 100)
15
print(f"Valeur de a : {a}")
16
print(f"Valeur de b : {b}")
17
plusPetit = mini(a, b)
18
print(f"Le plus petit est {plusPetit}")
4 - Améliorer ensuite le programme principal pour que trois variables a, b et c prennent une valeur entière aléatoire entre 1 et 100 puis que la plus petite valeur soit affichée à l'aide de la fonction mini().
On souhaite donc faire pareil avec 3 variables. Attention, on va toujours utiliser mini() mais le problème est que mini prend deux valeurs (et on en a trois).
Comment faire ? En appelant deux fois la fonction ! Une fois entre a et b, et une fois entre le mini trouvé et c :
1
##----- Importation des modules -----##
2
from random import *
3
4
##----- Définition des Fonctions -----##
5
def mini(u, v):
6
    """ Entrees : deux nombres u et v
7
        Sorties : retourne la plus petite valeur entre u et v """
8
    if u < v:
9
        return u # Car u est plus petit que v donc on renvoie u qui est le plus petit
10
    else:
11
        return v # Car u n'est pas le plus petit, donc c'est v
12
13
##----- Programme Principal -----##
14
a, b, c = randint(0, 100), randint(0, 100), randint(0, 100)
15
print(f"Valeur de a : {a}")
16
print(f"Valeur de b : {b}")
17
print(f"Valeur de c : {c}")
18
plusPetitAB = mini(a, b)
19
plusPetit = mini(plusPetitAB, c)
20
print(f"Le plus petit est {plusPetit}")
Simulation
On peut aussi créer une nouvelle fonction (qu'on appellera mini3) qui reprend ce même principe
1
##----- Importation des modules -----##
2
from random import *
3
4
##----- Définition des Fonctions -----##
5
def mini(u, v):
6
    """ Entrees : deux nombres u et v
7
        Sorties : retourne la plus petite valeur entre u et v """
8
    if u < v:
9
        return u # Car u est plus petit que v donc on renvoie u qui est le plus petit
10
    else:
11
        return v # Car u n'est pas le plus petit, donc c'est v
12
13
def mini3(u, v, w):
14
    """ Entrees : trois nombres u, v et w
15
        Sorties : retourne la plus petite valeur entre u, v et w """
16
    return mini(mini(u, v), w)
17
18
##----- Programme Principal -----##
19
a, b, c = randint(0, 100), randint(0, 100), randint(0, 100)
20
print(f"Valeur de a : {a}")
21
print(f"Valeur de b : {b}")
22
print(f"Valeur de c : {c}")
23
plusPetit = mini3(a, b, c)
24
print(f"Le plus petit est {plusPetit}")
Exercice 4 : Dessiner avec des carrés
Dans l'exercice 3 nous avons codé une fonction carre() qui prend 3 paramètres dont 2 facultatifs (définis avec une valeur par défaut qui suit le =)
1
##----- Importation des Modules -----##
2
from turtle import *
3
4
##----- Définition des Fonctions -----##
5
def carre(t, cote=40, sens=True):
6
    """ Entrees : une tortue t, cote est un entier naturel, sens un booleen
7
        Sorties : trace le carre de longueur cote dans le sens direct lorsque que sens=True """
8
    for i in range(4):
9
        t.forward(cote)        # On avance
10
        if sens == True:
11
            t.left(90)         # sens direct
12
        else:
13
            t.right(90)
L'exercice 4 demande la réalisation de plusieurs dessins. Pour y arriver, il ne faut pas modifier la fonction carre() mais appeler la fonction avec des attributs spécifiques.
1 - Une suite de 10 carrés de 30 pixels de côté espacés de 10 pixels.
On doit donc appeler 10 fois la fonction carre() en précisant la taille des carrés (30 pixels) et entre chaque appel on doit déplacer le pointeur.
Pour rappel, le pointeur revient à sa position de départ une fois terminé. Donc entre chaque appel on doit déplacer le curseur de 30 + 10 = 40 pixels (la taille d'un carré + l'espace entre deux carrés.
Comme il s'agit de la même action à réaliser 10 fois, on peut utiliser une boucle for :
1
##----- Importation des Modules -----##
2
from turtle import *
3
4
##----- Définition des Fonctions -----##
5
def carre(t, cote=40, sens=True):
6
    """ Entrees : une tortue t, cote est un entier naturel, sens un booleen
7
        Sorties : trace le carre de longueur cote dans le sens direct lorsque que sens=True """
8
    for i in range(4):
9
        t.forward(cote)        # On avance
10
        if sens == True:
11
            t.left(90)         # sens direct
12
        else:
13
            t.right(90)
14
15
##----- Tracé des 10 carrés alignés -----##
16
stylo = Turtle()
17
stylo.speed(0)		# Tracé rapide !
18
cote = 30		# Côté d'un carré (30 pixels)
19
espace = 10		# Espace entre 2 carrés
20
21
for i in range(10):	# Réaliser 10 fois les actions suivantes
22
    carre(stylo, cote)		# Créer un carré
23
    stylo.up()			# Lever le stylo (ne pas écrire)
24
    stylo.forward(cote+espace)	# Déplacer le stylo
25
    stylo.down()		# Baisser le stylo (écrire)
26
27
stylo.hideturtle()	# Permet de masquer le pointeur
28
exitonclick()
2 - Le même dessin, avec une alternance.
Pour réaliser le même dessin avec une alternance, on peut utiliser la valeur de i (pair ou impair) qu'on peut vérifier avec i%2 == 0 (pair).
Ensuite, on change le sens du carré pour faire le carré à droite ou à gauche du style (en bas ou en haut dans notre sens car le stylo se déplace vers la droite)
1
##----- Importation des Modules -----##
2
from turtle import *
3
4
##----- Définition des Fonctions -----##
5
def carre(t, cote=40, sens=True):
6
    """ Entrees : une tortue t, cote est un entier naturel, sens un booleen
7
        Sorties : trace le carre de longueur cote dans le sens direct lorsque que sens=True """
8
    for i in range(4):
9
        t.forward(cote)        # On avance
10
        if sens == True:
11
            t.left(90)         # sens direct
12
        else:
13
            t.right(90)
14
15
##----- Tracé des 10 carrés alignés -----##
16
stylo = Turtle()
17
stylo.speed(0)						# Tracé rapide !
18
cote = 30
19
espace = 10
20
21
for i in range(10):
22
    if i%2 == 0:					# i est-il pair ?
23
        carre(stylo, cote, False)
24
    else:							# ...ou impair ?
25
        carre(stylo, cote, True)
26
    stylo.up()
27
    stylo.forward(cote+espace)
28
    stylo.down()
29
30
stylo.hideturtle()
31
exitonclick()
Portée des variables
Exercice 2 : Analyse de code
L'exercice consiste à analyser le déroulement d'un code source et à prévoir les différents affichages qui vont se produire.
Il est nécessaire de décomposer le déroulement de ce programme afin d'être bien certain de comprendre le détail. Une compréhension superficielle de ce cas de base ne peut être que pénalisante pour la suite.
1
def g() :
2
	a=3
3
	print("Dans la fonction g : ", a)
4
	return a
5
6
def f(a) :
7
	a+=2
8
	print("Dans la fonction f : ", a)
9
	return a
10
11
a=3
12
print(a)
13
g()
14
print(a)
15
f(a)
16
print(a)
17
f(a+5)
18
print(a)
19
a=f(a+7)
20
print(a)
Détaillons le code :
  • Tout d'abord, la définition des 2 fonctions n'affiche aucun message car il s'agit simplement d'une définition, et donc le code n'est pas (encore) exécuté.
  • Ligne 11 : a = 3
  • Ligne 12 : On affiche a qui vaut 3
  • Ligne 13 : On appelle g() :
    • Ligne 2 : a = 3 uniquement dans la fonction.
      a est une variable qui est créée dans la fonction et qui restera uniquement dans cette fonction sans impacter les autres a du code.
    • Ligne 3 : On affiche a qui vaut 3
    • Ligne 4 : On renvoie la valeur de a, c'est-à-dire qu'on renvoie 3
  • Comme la valeur de g() retournée n'est pas récupérée, la valeur est perdue
  • Ligne 14 : On affiche a qui vaut 3 (il s'agit du a de la ligne 11)
  • Ligne 15 : On appelle f(a) donc f(3) :
    • Ligne 6 : La valeur du paramètre a est 3 car 3 a été passé en paramètre de la fonction.
    • Ligne 7 : a = 3+2 = 5
    • Ligne 8 : On affiche a qui vaut 5 (il s'agit du a de la ligne 7, créé à la ligne 6)
    • Ligne 9 : On renvoie la valeur de a, c'est-à-dire qu'on renvoie 5
  • Comme la valeur de f(a) retournée n'est pas récupérée, la valeur est perdue
  • Ligne 16 : On affiche a qui vaut 3 (il s'agit du a de la ligne 11)
  • Ligne 17 : On appelle f(a+5) donc f(3+5) donc f(8) :
    • Ligne 6 : La valeur du paramètre a est 8 car 8 a été passé en paramètre de la fonction.
    • Ligne 7 : a = 8+2 = 10
    • Ligne 8 : On affiche a qui vaut 10 (il s'agit du a de la ligne 7, créé à la ligne 6)
    • Ligne 9 : On renvoie la valeur de a, c'est-à-dire qu'on renvoie 10
  • Comme la valeur de f(a+5) retournée n'est pas récupérée, la valeur est perdue
  • Ligne 18 : On affiche a qui vaut 3 (il s'agit du a de la ligne 11)
  • Ligne 19 : On appelle f(a+7) donc f(3+7) donc f(10) :
    • Ligne 6 : La valeur du paramètre a est 10 car 10 a été passé en paramètre de la fonction.
    • Ligne 7 : a = 10+2 = 12
    • Ligne 8 : On affiche a qui vaut 12 (il s'agit du a de la ligne 7, créé à la ligne 6)
    • Ligne 9 : On renvoie la valeur de a, c'est-à-dire qu'on renvoie 12
  • La ligne a=f(a+7) devient donc a=12 car f(a+7) renvoie 12, ce qui signifie que f(a+7) est remplacé par 12. Donc la valeur de a change et vaut désormais 12.
  • Ligne 20 : On affiche a qui vaut 12 (il s'agit du a de la ligne 19, créé à la ligne 11)