Aller au contenu

TP Python – Premiers programmes

BTS SIO SISR 1re année – Mathématiques pour l'informatique – S00

Note

Comment ce TP fonctionne. Chaque exercice a un éditeur Python intégré à la page (il s'exécute dans ton navigateur, rien à installer). Avant de lancer, écris sur ta feuille ce que tu anticipes. Les lignes ... et « À compléter » sont à remplacer par ton code ; le reste est déjà écrit. Le bouton Valider exécute des tests : un test réussi ne dispense pas de comprendre pourquoi.

Exercice A – Essayer

Dans l'éditeur ci-dessous, écris des print(...) pour calculer : 7 // 2, 7 % 2, 2 ** 10, "ab" + "cd", len("réseau"). Compare avec ce que tu avais prévu.

###

# Écris tes print(...) ici, puis clique sur Lancerbksl-nlbksl-nl



Exercice B – Quotient et reste

Tip

Syntaxe utile. a // b : quotient ; a % b : reste ; x == 0 : test d'égalité (donne True ou False) ; return (q, r) : renvoyer deux valeurs.

Complète quotient_reste(a, b), est_multiple(a, b) et conversion_secondes(s) (durée en heures, minutes, secondes).

J'anticipe. Pour s = 3725, combien d'heures entières ? Quel reste en secondes ? Combien de minutes entières dans ce reste ?

###
assert quotientpy-undreste(17, 5) == (3, 2)bksl-nlassert quotientpy-undreste(20, 5) == (4, 0)bksl-nlassert quotientpy-undreste(3, 7) == (0, 3)bksl-nlassert estpy-undmultiple(15, 5) is Truebksl-nlassert estpy-undmultiple(16, 5) is Falsebksl-nlassert estpy-undmultiple(0, 7) is Truebksl-nlassert conversionpy-undsecondes(3725) == (1, 2, 5)bksl-nlassert conversionpy-undsecondes(59) == (0, 0, 59)bksl-nlassert conversionpy-undsecondes(3600) == (1, 0, 0)bksl-nlassert conversionpy-undsecondes(86399) == (23, 59, 59)bksl-nlbksl-nl ∞/∞

def quotientpy-undreste(a, b):bksl-nl """Renvoie le couple (quotient, reste) de la division euclidienne de a par b (b > 0)."""bksl-nl q = ... # à compléter : quotientbksl-nl r = ... # à compléter : restebksl-nl return (q, r)bksl-nlbksl-nldef estpy-undmultiple(a, b):bksl-nl """Renvoie True si a est un multiple de b (b > 0), False sinon."""bksl-nl return ... # à compléter : comparer le reste de a par b à 0bksl-nlbksl-nldef conversionpy-undsecondes(s):bksl-nl """Renvoie (heures, minutes, secondes) pour une durée de s secondes."""bksl-nl heures = ... # à compléterbksl-nl reste = s % 3600bksl-nl minutes = ... # à compléterbksl-nl secondes = ... # à compléterbksl-nl return (heures, minutes, secondes)bksl-nlbksl-nl



Exercice C – Texte

Tip

Syntaxe utile. t[0] : premier caractère ; t[-1] : dernier ; a + b : colle deux textes ; len(t) : nombre de caractères ; str(n) : nombre vers texte ; int(t) : texte vers nombre.

Complète premier_et_dernier(t), entoure(t, c), nb_chiffres_texte(n) et somme_de_textes(a, b).

###
assert premierpy-undetpy-unddernier("python") == "pn"bksl-nlassert premierpy-undetpy-unddernier("a") == "aa"bksl-nlassert entoure("ab", "py-str") == "py-strabpy-str"bksl-nlassert entoure("", "-") == "--"bksl-nlassert nbpy-undchiffrespy-undtexte(2026) == 4bksl-nlassert nbpy-undchiffrespy-undtexte(7) == 1bksl-nlassert nbpy-undchiffrespy-undtexte(0) == 1bksl-nlassert sommepy-unddepy-undtextes("12", "30") == 42bksl-nlassert sommepy-unddepy-undtextes("0", "0") == 0bksl-nlassert sommepy-unddepy-undtextes("255", "1") == 256bksl-nlbksl-nl ∞/∞

def premierpy-undetpy-unddernier(t):bksl-nl """Renvoie le premier et le dernier caractère de t, collés (t n'est pas vide)."""bksl-nl return ... # à compléterbksl-nlbksl-nldef entoure(t, c):bksl-nl """Renvoie t avec le caractère c ajouté au début et à la fin."""bksl-nl return ... # à compléterbksl-nlbksl-nldef nbpy-undchiffrespy-undtexte(n):bksl-nl """Nombre de chiffres décimaux de l'entier n >= 0 (indice : str et len)."""bksl-nl return ... # à compléterbksl-nlbksl-nldef sommepy-unddepy-undtextes(a, b):bksl-nl """a et b sont des textes qui écrivent des entiers : renvoie leur somme (un nombre)."""bksl-nl return ... # à compléterbksl-nlbksl-nl



Exercice D – Conditions

Tip

Syntaxe utile.

if condition:
    return ...
elif autre_condition:
    return ...
else:
    return ...
Comparaisons : <, <=, >, >=, ==, !=.

Complète signe(n), plus_grand(a, b) et resultat(note).

Je comprends. Pourquoi resultat(8) ne renvoie-t-il pas "ajourné" ?

###
assert signe(-4) == "négatif"bksl-nlassert signe(0) == "nul"bksl-nlassert signe(12) == "positif"bksl-nlassert pluspy-undgrand(3, 9) == 9bksl-nlassert pluspy-undgrand(9, 3) == 9bksl-nlassert pluspy-undgrand(5, 5) == 5bksl-nlassert resultat(7.5) == "ajourné"bksl-nlassert resultat(8) == "rattrapage"bksl-nlassert resultat(9.9) == "rattrapage"bksl-nlassert resultat(10) == "admis"bksl-nlassert resultat(18) == "admis"bksl-nlbksl-nl ∞/∞

def signe(n):bksl-nl """Renvoie "négatif", "nul" ou "positif" selon le signe de l'entier n."""bksl-nl # À compléter avec if / elif / elsebksl-nl return ""bksl-nlbksl-nldef pluspy-undgrand(a, b):bksl-nl """Renvoie le plus grand des deux nombres a et b."""bksl-nl # À compléter avec if / elsebksl-nl return 0bksl-nlbksl-nldef resultat(note):bksl-nl """Renvoie "ajourné" si note < 8, "rattrapage" si 8 <= note < 10, "admis" si note >= 10."""bksl-nl # À compléter avec if / elif / elsebksl-nl return ""bksl-nlbksl-nl



Exercice E – Boucles

Tip

Syntaxe utile.

for i in range(1, n + 1):    # i vaut 1, 2, ..., n
    total = total + i
while condition:             # répète tant que la condition est vraie
    n = n // 10              # une variable doit changer !

Complète somme_jusqua(n), nb_chiffres(n) et premiere_puissance(limite).

J'anticipe. Pour nb_chiffres(2026), écris la trace de n et de compteur (voir le cours, § VI).

###
assert sommepy-undjusqua(4) == 10bksl-nlassert sommepy-undjusqua(1) == 1bksl-nlassert sommepy-undjusqua(0) == 0bksl-nlassert sommepy-undjusqua(100) == 5050bksl-nlassert nbpy-undchiffres(7) == 1bksl-nlassert nbpy-undchiffres(10) == 2bksl-nlassert nbpy-undchiffres(2026) == 4bksl-nlassert nbpy-undchiffres(999) == 3bksl-nlassert premierepy-undpuissance(1000) == 10bksl-nlassert premierepy-undpuissance(255) == 8bksl-nlassert premierepy-undpuissance(256) == 9bksl-nlassert premierepy-undpuissance(0) == 0bksl-nlassert premierepy-undpuissance(1) == 1bksl-nlbksl-nl ∞/∞

def sommepy-undjusqua(n):bksl-nl """Renvoie 1 + 2 + ... + n (0 si n vaut 0), avec une boucle for."""bksl-nl total = 0bksl-nl for i in range(1, n + 1):bksl-nl pass # À compléter : ajouter i à totalbksl-nl return totalbksl-nlbksl-nldef nbpy-undchiffres(n):bksl-nl """Nombre de chiffres décimaux de l'entier n > 0, avec une boucle while."""bksl-nl compteur = 0bksl-nl # La condition « compteur < 100 » évite une boucle infinie si tu te trompes.bksl-nl while n > 0 and compteur < 100:bksl-nl # À compléter : diviser n par 10 (quotient) et ajouter 1 à compteurbksl-nl passbksl-nl return compteurbksl-nlbksl-nldef premierepy-undpuissance(limite):bksl-nl """Plus petit entier k >= 0 tel que 2 py-strpy-str k > limite, avec une boucle while."""bksl-nl k = 0bksl-nl while 2 py-strpy-str k <= limite and k < 100:bksl-nl pass # À compléter : augmenter k de 1bksl-nl return kbksl-nlbksl-nl



Exercice F – Listes

Tip

Syntaxe utile. adresse.split(".") : découpe un texte en liste de textes ; for x in liste: : parcourt la liste ; liste.append(v) : ajoute v à la fin ; int(morceau) : texte vers nombre.

Complète somme_octets(adresse), compte_superieurs(liste, seuil) et liste_carres(n).

###
assert sommepy-undoctets("192.168.1.10") == 371bksl-nlassert sommepy-undoctets("0.0.0.0") == 0bksl-nlassert sommepy-undoctets("255.255.255.255") == 1020bksl-nlassert comptepy-undsuperieurs([3, 9, 4, 12], 5) == 2bksl-nlassert comptepy-undsuperieurs([], 5) == 0bksl-nlassert comptepy-undsuperieurs([5, 5], 5) == 0bksl-nlassert listepy-undcarres(4) == [0, 1, 4, 9]bksl-nlassert listepy-undcarres(0) == []bksl-nlassert listepy-undcarres(1) == [0]bksl-nlbksl-nl ∞/∞

def sommepy-undoctets(adresse):bksl-nl """Somme des quatre nombres d'une adresse comme "192.168.1.10"."""bksl-nl total = 0bksl-nl for morceau in adresse.split("."):bksl-nl pass # À compléter : ajouter int(morceau) à totalbksl-nl return totalbksl-nlbksl-nldef comptepy-undsuperieurs(liste, seuil):bksl-nl """Nombre d'éléments de la liste strictement supérieurs à seuil."""bksl-nl n = 0bksl-nl for x in liste:bksl-nl pass # À compléter : si x > seuil, ajouter 1 à nbksl-nl return nbksl-nlbksl-nldef listepy-undcarres(n):bksl-nl """Renvoie la liste des carrés de 0 à n - 1 : [0, 1, 4, ...] (liste vide si n vaut 0)."""bksl-nl carres = []bksl-nl for i in range(n):bksl-nl pass # À compléter : ajouter i py-str i à la liste avec appendbksl-nl return carresbksl-nlbksl-nl



Pour aller plus loin

Dans la console, écris une fonction est_bissextile(annee) (divisible par 4, sauf les multiples de 100 qui ne sont pas multiples de 400) et teste-la sur 1900, 2000, 2024, 2026.