Exercices – Chapitre 13

Exercice 1 — Types de variables

Indiquer le type Python le plus adapté (int, float, bool, str).

1. Le nombre de pages d'un livre.

2. Le prix en euros d'un article (par exemple 4.99).

3. La réponse à « ce nombre est-il pair ? ».

4. Un numéro de téléphone.

Exercice 2 — Trace d'exécution (affectations)

On exécute le programme suivant.

a = 10
b = 4
a = a - b
b = a * 2
print(a, b)

Que s'affiche-t-il ? Détailler chaque ligne.

Exercice 3 — Formules et priorités

Donner la valeur affichée par chaque print.

print(2 + 3 * 4)
print((2 + 3) * 4)
print(17 % 5)
print(17 // 5)
print(2 ** 3)

Exercice 4 — Instruction conditionnelle

1. Écrire une fonction parite(n) renvoyant "pair" si n est pair, "impair" sinon. (Indice : utiliser n % 2.)

2. Écrire une fonction tarif(age) renvoyant le prix d'un billet : 0 si age < 12, 5 si 12 <= age < 18, 10 sinon.

def parite(n):
    if n % 2 == 0:
        return "pair"
    else:
        return "impair"

def tarif(age):
    if age < 12:
        return 0
    elif age < 18:
        return 5
    else:
        return 10

Exercice 5 — Boucle bornée et accumulateur

1. Écrire une fonction somme(n) renvoyant \(1 + 2 + \dots + n\). Tester avec \(n = 100\) (attendu : \(5050\)).

2. Écrire une fonction compte_multiples(n) renvoyant le nombre de multiples de \(3\) parmi les entiers de \(1\) à \(n\). Tester avec \(n = 10\) (attendu : \(3\), à savoir \(3, 6, 9\)).

def somme(n):
    total = 0
    for i in range(1, n + 1):
        total = total + i
    return total

def compte_multiples(n):
    compteur = 0
    for i in range(1, n + 1):
        if i % 3 == 0:
            compteur = compteur + 1
    return compteur

print(somme(100))            # 5050
print(compte_multiples(10))  # 3

Exercice 6 — Boucle non bornée

1. Écrire une fonction premiere_puissance(seuil) renvoyant la première puissance de \(2\) qui dépasse strictement seuil. Tester avec seuil = 1000 (attendu : \(1024\)).

2. Expliquer pourquoi on utilise while et non for.

def premiere_puissance(seuil):
    p = 1
    while p <= seuil:
        p = p * 2
    return p

print(premiere_puissance(1000))   # 1024

Exercice 7 — Fonction aléatoire et répétition

Une urne contient \(2\) boules gagnantes et \(8\) perdantes.

1. Écrire une fonction tirage() renvoyant 1 (gagné) avec la bonne probabilité, 0 sinon.

2. Écrire une fonction frequence_gain(n) répétant n tirages indépendants et renvoyant la fréquence de gains.

3. Vers quelle valeur tend cette fréquence pour n grand ?

import random

def tirage():
    if random.random() < 0.2:   # probabilité 2/10 = 0,2 de gagner
        return 1
    else:
        return 0

def frequence_gain(n):
    total = 0
    for i in range(n):
        total = total + tirage()
    return total / n

print(frequence_gain(100000))   # proche de 0.2

Exercice 8 — Problème type : lire et écrire un script

On donne le script suivant, censé calculer la factorielle \(n! = 1 \times 2 \times \dots \times n\).

def factorielle(n):
    resultat = 0          # ligne A
    for k in range(1, n): # ligne B
        resultat = resultat * k
    return resultat

print(factorielle(5))

1. Ce script est erroné. Repérer les deux erreurs (lignes A et B) et les corriger.

2. Réécrire le script corrigé et donner l'affichage attendu pour factorielle(5).

3. Compléter : quel est le rôle de return ? Que se passerait-il si on écrivait print(resultat) à sa place et qu'on voulait ensuite calculer factorielle(5) + 1 ?

def factorielle(n):
    resultat = 1
    for k in range(1, n + 1):
        resultat = resultat * k
    return resultat

print(factorielle(5))   # 120