TD: Fonctions et boucles en python

Introduction

Ce TD présente des exercices de difficultés progressives.
Pour chaque exercice, lire l'énoncé, puis copier/coller le programme (le contenu du cadre) dans un éditeur python, par exemple spyder, thonny, ou un éditeur en ligne comme repl.it.

Certains exercices demandent simplement de "lire et exécuter" le programme, il n'y a donc rien à programmer vous-même (il faut juste comprendre les explications, en général c'est une aide pour les questions suivantes). Les autres exercices vous demandent d'"écrire" une fonction ou un programme, il faut alors modifier ce que vous avez collé dans l'éditeur pour répondre à la question. (Attention, il ne faut pas coller le programme dans la partie "console" de l'éditeur, sinon vous ne pourrez pas facilement le modifier.)

Lorsqu'un exercice est fini, passer au suivant. Vous pouvez effacer l'ancien programme pour coller le nouveau, ou alors mettre le nouveau à la suite du précédent (dans ce cas bien sûr l'ancien programme continuera d'afficher du texte lorsque vous exécutez le fichier). C'est surtout utile lorsque les questions s'enchaînent et que la nouvelle solution est basée sur l'ancienne. Vous pouvez aussi ouvrir un deuxième fichier dans l'éditeur (ou avoir un fichier pour conserver toutes vos anciennes solutions).

Beaucoup d'exercices ont des "indications", c'est à dire de l'aide. Essayer toujours d'abord de faire l'exercice sans les lire.

Conseils généraux pour tous les exercices:

Exercice 1 : double

Lire puis exécuter ce programme. (Il n'y a donc rien à écrire vous-même, le but est juste de vous aider pour les exercices suivants et de vérifier que vous arrivez bien à faire fonctionner Python.)

Il fonctionne en deux étapes:

1) D'abord, une fonction 'double' est définie (avec l'instruction 'def'). Elle reçoit un argument, x, puis crée une variable a contenant deux fois la valeur de x, puis elle 'retourne' comme résultat la valeur de a (avec l'instruction 'return'). Cette fonction correspond donc en maths à la fonction 'f(x)= 2x'. On remarque que les 'print' ne font pas partie de la définition de la fonction, puisque l'indentation (le nombre d'espaces entre la marge à gauche et le code) est revenu à la marge. La définition de la fonction contient donc 2 lignes seulement. Remarque: la définition contient une chaîne de caractères en triples guillemets 'Retourne le double de x', qui décrit ce que fait la fonction.

2) Après la fin de la définition de double, le programme exécute 5 instructions 'print'. Ceci permet de voir le résultat de la fonction. Lorsque Python voit 'print(double(3))', il lance la fonction double en utilisant la valeur 3 pour x; il calcule alors la valeur de a (donc 6), puis retourne cette valeur ('return a'). Donc 'double(3)' est égal à 6. Donc 'print(double(3))' affiche la valeur de double(3), donc affiche 6. Python fait ensuite la même chose pour les autres 'print' (avec les valeurs 0, puis -2, puis 4000 pour x), puis affiche 'Exercice réussi: double'.
def double(x):
    """Retourne le double de x"""
    a= 2*x
    return a

print(double(3))
print(double(0))
print(double(-2))
print(double(4000))
print("Exercice réussi: double")

Exercice 2 : double avec assert

Lire puis exécuter ce programme.

Ce programme est presque identique au précédent, mais au lieu d'afficher le résultat de la fonction 'double', Python teste que les réponses donnés sont les bonnes. L'instruction 'assert' est très simple: si la condition après le mot 'assert' est vrai, le programme continue (sans rien afficher). Si la condition est fausse (donc ici par exemple si double(3) n'est pas égal à 6), le programme s'arrête et produit une erreur. Si le texte 'Exercice réussi' s'affiche, c'est donc que tous les tests (tous les 'assert') étaient corrects.
def double(x):
    """Retourne le double de x"""
    a= 2*x
    return a

assert double(3) == 6
assert double(0) == 0
assert double(-2) == -4
assert double(4000) == 8000

print("Exercice réussi: double avec assert")

Exercice 3 : triple

Ce programme est à nouveau presque identique au précédent, mais la fonction cette fois n'est pas correcte: elle retourne le double au lieu du triple.

1) Lancer d'abord le programme sans le modifier, et regarder l'erreur. On remarque qu'il s'agit d'une AssertionError (donc une erreur venant d'un assert), qui nous indique la ligne à laquelle était l'erreur, et nous donne même le contenu de la ligne: 'assert triple(3) == 9'. C'est logique, puisque cette condition est fausse: la fonction retourne 2*3 == 6, au lieu de 9.

2) Corriger maintenant la fonction triple. ATTENTION: Il ne faut pas modifier les lignes avec "assert". Ces lignes servent à vérifier que ce que vous avez écrit dans la fonction triple est correct. Il faut faut donc uniquement modifier les lignes à l'interieur de la fonction "triple" (donc la ligne "a= 2*x" ou la ligne "return a"). Relancer ensuite le programme et vérifier que les tests fonctionnent et que le programme affiche bien 'Exercice réussi'. Le principe sera le même pour tous les exercices suivants.

Indication (aide): La fonction s'appelle 'triple', mais définit quand même a= 2*x. Est-ce correct? Que faut-il changer? (On rappelle qu'il ne faut PAS changer les lignes avec 'assert'.)
def triple(x):
    """Retourne le triple de x"""
    a= 2*x 
    return a

assert triple(3) == 9
assert triple(0) == 0
assert triple(-2) == -6
assert triple(4000) == 12000

print("Exercice réussi: triple")

Exercice 4 : somme

Écrire la fonction somme(a, b). Il faut compléter le code déjà écrit, donc il suffit donc d'écrire la bonne formule Python après le "return" (sur la même ligne).

Remarque: Une fonction peut avoir plusieurs argument; dans ce cas, ils sont séparés par des virgules.

Remarque: Il n'est pas nécessaire de créer une troisième variable ici. La formule du résultat peut être directement écrite après le 'return'.

Indication: Votre clavier a des touches pour presque toutes les opérations de base d'une calculatrice (plus, moins, fois, diviser...) . Laquelle pouvez-vous utiliser?
def somme(a, b):
    """Retourne la somme de a et b"""
    return 

assert somme(1, 1) == 2
assert somme(50, 6) == 56
assert somme(17, 28) == 45
assert somme(50, -6) == 44

print("Exercice réussi: somme")

Exercice 5 : hypoténuse_au_carré

Écrire la fonction hypoténuse_au_carré(a, b)

Remarque: La fonction précédente montre qu'on peut utiliser des formules mathématiques directement après le 'return'. Ici il faut bien sûr utiliser le théorème de Pythagore pour trouver la bonne formule.

Remarque: La touche "²" de votre clavier n'est malheureusement pas reconnue par Python. Mais vous pouvez tout de même obtenir le carré d'un nombre, en utilisant les touches des opérations de base.

Indication: Le théorème de Pythagore donne une formule du type "c² = ...". Ici c'est justement le contenu des "..." qu'il faut mettre après le return. Attention, il ne faut pas mettre d'égalité dans le return, il faut mettre une valeur (donc le contenu des "...").
def hypoténuse_au_carré(a, b):
    """Retourne le carré de la longueur de l'hypoténuse d'un triangle rectangle dont les petits côtés sont de longueurs a et b"""
    return 

assert hypoténuse_au_carré(3, 4) == 25
assert hypoténuse_au_carré(1, 1) == 2
assert hypoténuse_au_carré(6, 8) == 100
assert hypoténuse_au_carré(5, 12) == 169
assert hypoténuse_au_carré(30, 40) == 2500
assert hypoténuse_au_carré(19, 65) == 4586

print("Exercice réussi: hypoténuse_au_carré")

Exercice 6 : table_de_2

Lire et exécuter le programme.

La fonction table_de_2 affiche 12 nombres avec 'print'.

Remarquer que cette fonction n'a pas d'argument (pas de paramètres), les parenthèses sont donc vides. Il faut quand même les écrire (pour faire comprendre à Python qu'il s'agit d'une définition ou d'un appel de fonction).

Remarquer aussi que cette fonction n'a pas de 'return': en effet, elle affiche du texte mais n'a pas de résultat.
def table_de_2():
    """Affiche la table de multiplication de 2 (de 1*2 à 12*2)"""
    a= 1
    for i in range(12):
        print(2*a)
        a= a+1

table_de_2()

print("Exercice réussi: table_de_2")

Exercice 7 : table_de_2_bis

Lire et exécuter ce programme.

Ce programme est identique au précédent, mais la fonction 'print' a été remplacée par la fonction 'printbis', qui est définie au début du programme. La fonction 'printbis' affiche son argument, puis ajoute le texte à la variable 'affichage' en revenant à la ligne. Ceci permet de tester l'affichage du programme avec un assert (vous n'avez pas besoin de comprendre la la fonction printbis pour faire les exercices). Remarquer que le 'assert' tient sur plusieurs lignes, car il compare la variable 'affichage' à une chaîne de caractères sur plusieurs lignes (en utilisant des triples guillemets).
affichage=""
def printbis(x):
    global affichage
    print(x)
    affichage= affichage + "\n" + str(x)

def table_de_2_bis():
    """Affiche la table de multiplication de 2 (de 1*2 à 12*2)"""
    a= 1
    for i in range(12):
        printbis(2*a)
        a= a+1

table_de_2_bis()
assert affichage == """
2
4
6
8
10
12
14
16
18
20
22
24"""

print("Exercice réussi: table_de_2_bis")

Exercice 8 : table_de_3

Écrire maintenant la fonction table_de_3, en utilisant la fonction printbis. Il faut à nouveau compléter la fonction, en gardant les lignes déjà écrites.

(Une fois la fonction écrite, il faut bien sûr lancer le programme pour vérifier que le 'assert' fonctionne, et que le texte 'Exercice 6 réussi' s'affiche bien.)

Indication: Regarder la fonction table_de_2 de la question précédente. Quelles doivent-être les différences entre table_de_2 et table_de_3?

Indication: Il y a une ligne vide dans la fonction (au dessus du "a= a+1"). C'est ici qu'il faut écrire quelque chose.
affichage=""
def printbis(x):
    global affichage
    print(x)
    affichage= affichage + "\n" + str(x)

def table_de_3():
    """Affiche la table de multiplication de 3"""
    a= 1
    for i in range(12):
        
        a= a+1

table_de_3()
assert affichage == """
3
6
9
12
15
18
21
24
27
30
33
36"""

print("Exercice réussi: table_de_3")

Exercice 9 : table_de

Écrire maintenant la fonction table_de, en utilisant la fonction printbis. Cette fonction reçoit un argument n (au lieu de toujours donner la table de 2 ou de 3 comme dans les précédentes). Il faut à nouveau compléter le code existant.

Remarque: Lorsque vous aurez terminé cet exercice, n'effacez pas votre programme. Il pourra servir pour la question suivante.

Indication: Pour passer de la table de 2 à la table de 3, il fallait remplacer 2 par 3 dans la fonction. Maintenant, par quoi faut-il remplacer 3?

Remarquer que table_de(3) affiche la même chose que table_de_3().

Remarquer que, après avoir testé table_de(5), et avant table_de(3), la variable affichage est remise à "" (une chaîne vide). Sinon la fonction printbis va continuer à ajouter du texte à la suite de la table de 5, ce qui n'est pas ce que l'on veut.

Remarquer que, pour tester table_de(7), au lieu d'utiliser une chaîne de caractères avec des retours à la lignes, on utilise le caractère spécial '\n', qui est interprété comme un retour à la ligne. Les triples guillemets ne sont donc plus nécessaires.
affichage=""
def printbis(x):
    global affichage
    print(x)
    affichage= affichage + "\n" + str(x)

def table_de(n):
    """Affiche la table de multiplication de n"""
    a= 1
    for i in range(12):
        
        a= a+1

table_de(5)
assert affichage == """
5
10
15
20
25
30
35
40
45
50
55
60"""
affichage= ""
table_de(3)
assert affichage == """
3
6
9
12
15
18
21
24
27
30
33
36"""
affichage= ""
table_de(7)
assert affichage == "\n7\n14\n21\n28\n35\n42\n49\n56\n63\n70\n77\n84"

print("Exercice réussi: table_de")

Exercice 10 : tables_jusqu_a_10

Cette question est plus difficile que les précédentes.

Écrire maintenant la fonction tables_jusqu_a_10 (en utilisant printbis), pour qu'elle corresponde à son texte de description (au début de la fonction pour avoir plus ). Cette fonction ne reçoit aucun argument. Vous devez bien sûr utiliser une ou des boucles, et pas simplement écrire des dizaines de print (ou un print très long).

Remarque: Vous avez le droit d'utiliser la fonction table_de écrite à la question précédente, mais ce n'est pas obligatoire.

Indication (aide): La première question à se poser est: combien de tables de multiplication doit-on afficher? (C'est à dire, combien d'entiers a-t-on entre 2 et 10 inclus.)

Indication: Il faut ensuite faire la même chose que dans l'exercice précédant, mais en le répétant pour chaque nombre entre 2 et 10 (donc avec une nouvelle boucle). Attention, si votre programme a deux boucles 'for', il faut utiliser deux variable de boucle différentes (i et j par exemple).

Indication: Dans la question précédente, la variable n contenait le nombre dont on affichait la table. Ici, il n'y a pas d'argument n. Mais vous pouvez définir vous-même une variable n.

Indication: L'idée est de reprendre le code de la fonction table_de, et de le mettre dans une boucle for. Il y aura donc deux boucles l'une dans l'autre: une qui augmente a pour afficher la table de n, et une qui augmente n lui-même, pour afficher toutes les tables dans l'ordre.
affichage=""
def printbis(x):
    global affichage
    print(x)
    affichage= affichage + "\n" + str(x)

def tables_jusqu_a_10():
    """Affiche toutes les tables de multiplication, de la table de 2 à celle de 10"""

        
tables_jusqu_a_10()
assert affichage == """
2\n4\n6\n8\n10\n12\n14\n16\n18\n20\n22\n24
3\n6\n9\n12\n15\n18\n21\n24\n27\n30\n33\n36
4\n8\n12\n16\n20\n24\n28\n32\n36\n40\n44\n48
5\n10\n15\n20\n25\n30\n35\n40\n45\n50\n55\n60
6\n12\n18\n24\n30\n36\n42\n48\n54\n60\n66\n72
7\n14\n21\n28\n35\n42\n49\n56\n63\n70\n77\n84
8\n16\n24\n32\n40\n48\n56\n64\n72\n80\n88\n96
9\n18\n27\n36\n45\n54\n63\n72\n81\n90\n99\n108
10\n20\n30\n40\n50\n60\n70\n80\n90\n100\n110\n120"""

print("Exercice réussi: tables_jusqu_a_10")

Exercice 11 : tables_jusqu_a

Écrire maintenant la fonction tables_jusqu_a(n), comme la précédente, mais en allant de 2 jusqu'à n (en utilisant printbis).

Remarque: Attention, vous ne pouvez avoir qu'une seule variable qui s'appelle n!
affichage=""
def printbis(x):
    global affichage
    print(x)
    affichage= affichage + "\n" + str(x)

def tables_jusqu_a(n):
    """Affiche toutes les tables de multiplication, de la table de 2 à celle de n"""
    
        
tables_jusqu_a(10)
assert affichage == """
2\n4\n6\n8\n10\n12\n14\n16\n18\n20\n22\n24
3\n6\n9\n12\n15\n18\n21\n24\n27\n30\n33\n36
4\n8\n12\n16\n20\n24\n28\n32\n36\n40\n44\n48
5\n10\n15\n20\n25\n30\n35\n40\n45\n50\n55\n60
6\n12\n18\n24\n30\n36\n42\n48\n54\n60\n66\n72
7\n14\n21\n28\n35\n42\n49\n56\n63\n70\n77\n84
8\n16\n24\n32\n40\n48\n56\n64\n72\n80\n88\n96
9\n18\n27\n36\n45\n54\n63\n72\n81\n90\n99\n108
10\n20\n30\n40\n50\n60\n70\n80\n90\n100\n110\n120"""
affichage= ""
tables_jusqu_a(5)
assert affichage == """
2\n4\n6\n8\n10\n12\n14\n16\n18\n20\n22\n24
3\n6\n9\n12\n15\n18\n21\n24\n27\n30\n33\n36
4\n8\n12\n16\n20\n24\n28\n32\n36\n40\n44\n48
5\n10\n15\n20\n25\n30\n35\n40\n45\n50\n55\n60"""

print("Exercice réussi: tables_jusqu_a")

Exercice 12 : nombres_entre

Écrire une fonction nombres_entre(a,b), qui reçoit deux arguments entiers a et b (on suppose que a < b) et qui affiche tous les nombres entre a et b, inclus (en utilisant printbis).

Remarque: Il y a plusieurs méthodes pour résoudre cet exercice. Essayer de le résoudre avec une boucle 'for' puis avec une boucle 'while'.

Remarque: Les variables a et b sont déjà utilisées, ce n'est donc pas une bonne idée d'avoir "a=..." ou "b=..." dans votre fonction.

Indication: Prendre un exemple (par exemple le cas du premier assert, a=4 et b=10), puis trouver une formule pour le nombre de lignes à afficher dans ce cas. Si ça ne marche pas, bien regarder l'affichage pour voir quel est la différence entre l'affichage et ce qui est dans le 'assert'.
affichage=""
def printbis(x):
    global affichage
    print(x)
    affichage= affichage + "\n" + str(x)

def nombres_entre(a, b):
    """Affiche tous les entiers entre a et b, inclus."""
    
        
nombres_entre(4, 10)
assert affichage == "\n4\n5\n6\n7\n8\n9\n10"
affichage=""
nombres_entre(22, 30)
assert affichage == "\n22\n23\n24\n25\n26\n27\n28\n29\n30"
affichage=""
nombres_entre(2000, 2006)
assert affichage == "\n2000\n2001\n2002\n2003\n2004\n2005\n2006"

print("Exercice réussi: nombres_entre")

Exercice 13 : nombres_entre_inverse

Écrire une fonction nombres_entre_inverse(a,b), comme la précédente mais en sens inverse (on suppose toujours a < b) (en utilisant printbis).

Indication: Si l'énoncé n'est pas suffisamment clair, regarder les 'assert'.
affichage=""
def printbis(x):
    global affichage
    print(x)
    affichage= affichage + "\n" + str(x)

def nombres_entre_inverse(a,b):
    """Affiche tous les entiers entre a et b, inclus, en sens inverse."""
    
        
nombres_entre_inverse(4, 10)
assert affichage == "\n10\n9\n8\n7\n6\n5\n4"
affichage=""
nombres_entre_inverse(22, 30)
assert affichage == "\n30\n29\n28\n27\n26\n25\n24\n23\n22"
affichage=""
nombres_entre_inverse(2000, 2006)
assert affichage == "\n2006\n2005\n2004\n2003\n2002\n2001\n2000"

print("Exercice réussi: nombres_entre_inverse")

Exercice 14 : multiples_de_2_entre

Écrire une fonction multiples_de_2_entre(a,b), qui reçoit deux arguments entiers a et b (on suppose que a < b, et que a et b sont des multiples de 2) et qui affiche tous les multiples de 2 entre a et b, inclus (en utilisant printbis).

Remarque: Il y a plusieurs méthodes pour résoudre cet exercice. Essayer d'abord de le résoudre avec une boucle 'for' sans utiliser le modulo (symbole pourcentage), puis utiliser une autre méthode si vous le voulez.

Indication: Voir les indications de la question précédente.
affichage=""
def printbis(x):
    global affichage
    print(x)
    affichage= affichage + "\n" + str(x)

def multiples_de_2_entre(a,b):
    """Affiche tous les multiples de 2 entre a et b, inclus."""
    
        
multiples_de_2_entre(4, 10)
assert affichage == "\n4\n6\n8\n10"
affichage=""
multiples_de_2_entre(22, 30)
assert affichage == "\n22\n24\n26\n28\n30"
affichage=""
multiples_de_2_entre(2000, 2006)
assert affichage == "\n2000\n2002\n2004\n2006"

print("Exercice réussi: multiples_de_2_entre")

Exercice 15 : compare_intervalle

Écrire une fonction compare_intervalle, qui reçoit trois arguments entiers a, b et c (on suppose que a < b), qui affiche tous les nombres entre a et b inclus, et après chaque nombre affiche "petit", "grand" ou "égal" selon que ce nombre est plus petit, plus grand ou égal à c (en utilisant printbis).
affichage=""
def printbis(x):
    global affichage
    print(x)
    affichage= affichage + "\n" + str(x)

def compare_intervalle(a, b, c):
    """Affiche tous les nombres entre a et b inclus, en les comparant à chaque fois à c."""
    
        
compare_intervalle(0,6,3)
assert affichage == "\n0\npetit\n1\npetit\n2\npetit\n3\négal\n4\ngrand\n5\ngrand\n6\ngrand"
affichage=""
compare_intervalle(15,19,18)
assert affichage == "\n15\npetit\n16\npetit\n17\npetit\n18\négal\n19\ngrand"
affichage=""
compare_intervalle(2000, 2006, 5)
assert affichage == "\n2000\ngrand\n2001\ngrand\n2002\ngrand\n2003\ngrand\n2004\ngrand\n2005\ngrand\n2006\ngrand"

print("Exercice réussi: compare_intervalle")

Exercice 16 : puissance

Écrire la fonction puissance(a, n) qui reçoit deux arguments: un float a et un entier positif n, et retourne 'a puissance n', en utilisant une boucle et la multiplication (et pas une fonction toute faite comme l'opérateur puissance '**' de Python ou le module math).

Ne pas modifier a; créer plutôt une nouvelle variable, par exemple 'r', comme 'résultat'.

Remarque: Si l'un des 'assert' ne fonctionne pas (par exemple 'assert puissance(2, 0) == 1.0'), taper directement dans la console 'puissance(2, 0)' pour voir quel est le résultat, ou ajouter un 'print(puissance(2, 0))' dans le programme (avant les 'assert').

Remarque: On peut taper '5**9' et '1.5**4' dans la console pour vérifier que les tests eux-mêmes ont les bonnes valeurs.

Remarque: Le test pour puissance(1.1, 50) semble étrange: il s'agit en fait d'une approximation: 117.39 < 1.1**50 < 117.40. Pourquoi ne pas écrire simplement 'assert puissance(1.1, 50) == 1.1**50'? Taper 'puissance(1.1, 50)' puis '1.1**50' dans la console pour comparer. Que remarque-t-on? Ce problème est dû à la limite de précision pour les nombres flottants: le résultat est précis, mais pas exact.
def puissance(a, n):
    """Retourne a puissance n si n est un entier positif"""
    

assert puissance(2, 4) == 16.0
assert puissance(2, 10) == 1024.0
assert puissance(5, 9) == 1953125
assert puissance(2, 0) == 1.0
assert puissance(1.5, 4) == 5.0625
assert 117.39 < puissance(1.1, 50) and puissance(1.1, 50) < 117.40

print("Exercice réussi: puissance")

Exercice 17 : double_au_bout_de

Écrire la fonction double_au_bout_de(a) qui reçoit un float a (voir la description de la fonction). Utiliser une boucle et la multiplication, mais pas l'opérateur puissance '**' de Python (ou le module math).

Indication: Utiliser une boucle while.

Indication: S'inspirer de la question précédente, en allant jusqu'à un certain n.

Indication: Attention, le résultat n'est pas une puissance de a!

Indication: Pour débugger le programme, on peut ajouter un print au début de la boucle pour afficher la valeur des variables importantes (par exemple 'print(n, r, 2*a)', qui affiche trois valeurs importantes sur une seule ligne, séparées par des espaces).

Remarque: Que se passerait-il si on exécute double_au_bout_de(1)? (Rappel: pour interrompre un programme Python, cliquer sur le bouton rouge (carré rouge ou panneau 'Stop') au dessus de la console.)
def double_au_bout_de(a):
    """Retourne le plus petit entier positif n tel que a**n soit au moins égal au double de a"""
    

assert double_au_bout_de(2) == 2
assert double_au_bout_de(5) == 2
assert double_au_bout_de(1.5) == 3
assert double_au_bout_de(1.1) == 9
assert double_au_bout_de(1.05) == 16
assert double_au_bout_de(1.01) == 71

print("Exercice réussi: double_au_bout_de")

Exercice 18 : affiche_diviseurs

Écrire la fonction affiche_diviseurs(n) qui reçoit un entier n >= 2 (voir la description de la fonction), en utilisant printbis. Utiliser l'opération modulo: '%'. On rappelle que 'n % k' est le reste de la division entière de n par k, donc en particulier 'n % k' est égal à 0 si k divise n.
affichage=""
def printbis(x):
    global affichage
    print(x)
    affichage= affichage + "\n" + str(x)
    
def affiche_diviseurs(n):
    """ Affiche tous les diviseurs entiers de n, compris entre 1 et n exclus, du plus petit au plus grand."""
    
    
affiche_diviseurs(6)
assert affichage == '\n2\n3'
affichage= ""
affiche_diviseurs(15)
assert affichage == '\n3\n5'
affichage= ""
affiche_diviseurs(42)
assert affichage == '\n2\n3\n6\n7\n14\n21'
affichage= ""
affiche_diviseurs(60)
assert affichage == '\n2\n3\n4\n5\n6\n10\n12\n15\n20\n30'

print("Exercice réussi: affiche_diviseurs")

Exercice 19 : affiche_décomposition

Écrire la fonction affiche_décomposition(n) qui reçoit un entier n >= 2 (voir la description de la fonction), en utilisant printbis. Utiliser l'opération modulo: '%'. On rappelle que 'n % k' est le reste de la division entière de n par k, donc en particulier 'n % k' est égal à 0 si k divise n.

Remarque: Il n'est pas nécessaire ici de tester si un nombre est premier.

Indication: (Bien essayer d'abord de résoudre sans lire cette aide.) L'idée est reprendre la fonction affiche_diviseurs, mais de diviser à chaque fois n par le nombre qui vient d'être affiché.

Indication: Utiliser une boucle while et pas une boucle for.
affichage=""
def printbis(x):
    global affichage
    print(x)
    affichage= affichage + "\n" + str(x)
    
def affiche_décomposition(n):
    """ Affiche tous les diviseurs premiers de n, du plus petit au plus grand.
    Si p est un diviseur premier de n et p**k divise n, p est affiché k fois (par exemple, si p au carré divise n, p est affiché 2 fois)."""
    
    
affiche_décomposition(6)
assert affichage == '\n2\n3'
affichage= ""
affiche_décomposition(15)
assert affichage == '\n3\n5'
affichage= ""
affiche_décomposition(42)
assert affichage == '\n2\n3\n7'
affichage= ""
affiche_décomposition(60)
assert affichage == '\n2\n2\n3\n5'
affichage= ""
affiche_décomposition(300)
assert affichage == '\n2\n2\n3\n5\n5'

print("Exercice réussi: affiche_décomposition")