tp en python de boucles

La boucle "pour"

La boucle pour est utilisée quand on connait le nombre de fois où l'on doit répéter une suite d'instructions.

Structure de la boucle "pour" en pseudo code :

Pour i allant de 0 à n-1
  faire :
    ...
    les différentes instructions à répéter
    ...
Fin pour

Pour illustrer ce cours nous allons partir sur un premier exemple : Obtenir la somme des n premiers entiers naturels.
Pour n=4, on veut écrire un programme qui renvoie la valeur de 0+1+2+3=6.

Ecriture du programme de l'exemple en pseudo code :

  1. S← 0
  2. Pour i allant de 0 à n-1
  3.   faire :
  4.     S ← S+i
  5. Fin pour

La structure de la boucle "pour" en python


La première ligne fait que la suite du code va être répétée n fois en incrémentant de manière automatique la variable i de 0 à n-1.
Dans un premier temps l'attribut dans range sera un entier, nous verrons dans la suite qu'il peut en être autrement.

for i in range(n):
    ...
    les différentes instructions à répéter
    ...
On remarque ici l'absence de "faire" et de "fin pour". C'est en fait l'indentation qui sert de limitateur de boucle. L'indentation en python n'est pas uniquement un élèment d'hygiène de programmation mais un élément faisant partie intégrante des structures.

Ecriture du programme de l'exemple en python :


def somme(n:int)->int: #les int sont ici pour indiquer le typage des variables d'entrée et de sortie. Ici l'attribut est de type int et la sortie également   
    """""La fonction somme renvoie la somme des n+1 premiers entiers naturels.
    la fonction somme a pour attribut un entier (int) : n et renvoie un autre entier :S
    Pour n=4 : S=0+1+2+3=10""""" 
    S=0 #initialisation de la somme à 0
    for i in range(n):
     
        S=S+i
    return S
somme(20)


somme(20)


Cliquer sur cette adresse : http://pythontutor.com/visualize.html#mode=edit
Copier/coller votre code dans la fenêtre
puis cliquer sur Visualize Execution pour observer la trace d'exécution de votre code pas à pas puis par des clics succéssifs sur le bouton forward.

Exercices

Exercice 1


Modifier la fonction somme(n) pour qu'en sortie on ait la somme des n+1 premiers entiers naturels.
pour n=4, S=0+1+2+3+4=10


def somme(n:int)->int: #les int sont ici pour indiquer le typage des variables d'entrée et de sortie. Ici l'attribut est de type int et la sortie également   
    """""La fonction somme renvoie la somme des n+1 premiers entiers naturels.
    la fonction somme a pour attribut un entier (int) : n et renvoie un autre entier :S
    Pour n=4 : S=1+2+3+4=10""""" 
    S=0 #initialisation de la somme à 0
    for i in range(n): 
        S=S+i
    return S


#test de la fonction somme avec l'attribut 4
somme(4) #la réponse doit être 10

Exercice 2

Ecrire une fonction TableMulti() qui reçoit en entrée un nombre entier n compris entre 1 et 10 et affiche en sortie la table de multiplication de ce nombre. Par exemple, si l’algorithme reçoit en entrée le nombre 7, il affichera la table de multiplication.
1 fois 7 = 7
2 fois 7 = 14
3 fois 7 = 21
etc...


#Aide à l'affichage du résultat:
i=5
n=8
print("La multiplication de", i, "par", n, "est",i*n   )


def tableMulti(n:int)->None:
    """Renvoie la table de multiplcation de n"""
    
    return None


#test de la fonction :
tableMulti(5)
tableMulti(9)

Exercice 3

A la naissance d'Apolline, son grand-père Joël, lui ouvre un compte bancaire. Ensuite, à chaque anniversaire, le grand père d'Apolline verse sur son compte 100 €, auxquels il ajoute le double de l’âge d'Apolline.
Par exemple, lorsqu’elle a deux ans, il lui verse 104 € ce qui lui fait un total de 100+102+104=306 € à la deuxième année.
Ecrire une fonction TresorApo() qui en entrée reçoit un entier n et en sortie la somme présente sur le compte d'Apolline à sa nième année.


def tresorApo(n:int)->int:
    
    return tresor


#teste de la fonction :
tresorApo(2) #la valeur de sortie doit être 306
tresorApo(10) #la valeur de sortie doit être 1210

Exercice 4

L'instruction range peut prendre différents attributs. Dans cet exercice nous allons utiliser l'instruction :

for i in range(depart,arrivée,pas):

qui permet de repéter la boucle et d'incrémenter i de départ à arrivée-1 avec une incrémentation de pas.
Les finances de Joël ne sont pas au mieux, il décide de ne donner à Apolline qu'une année sur deux en conservant la même règle.
A deux ans Apolline aura donc :100+104=204 €
Reprendre l'énoncé de l'exercice 3 en écrivant une fonction tresorApoB() qui prend en entrée un entier n et renvoie un entier.


def tresorApoB(n:int)->int:
    
    return tresor


#Test de la fonction
tresorApoB(3) #la valeur de sortie doit être 204


Dans cet exercice nous allons donner à l'instruction range un attribut de type list.
Nous allons écrire une fonction estDansListe qui prend en entrée une liste lst et un entier n et qui renvoie True si l'entier est dans la liste et False sinon.
Pour cela nous allons utiliser l'instruction :

for i in lst:


Qui va répéter les instructions autant de fois que d'éléments dans la liste et qui à chaque étape va donner à i une valeur de la liste lst en commençant par la première.
Indication : Vous devez utiliser une boucle conditionnelle "Si"


def estDansListe(lst:list,n:int)->bool:
    test=False
   
    return test


#test de la fonction
l=[0,1,2,3,4,5]
estDansListe(l,8) #doit renvoyer False
estDansListe(l,5) #doit renvoyer True

La boucle "tant que"

La boucle "tant que " est utilisée quand on ne connait pas le nombre de fois où l'on doit répéter une suite d'instructions.
Elle est souvent utilisée également pour remplacer une boucle dans un souci d'optimisation du code.
Une autre différence majeure avec la boucle pour est l'absence d'incrémentation automatique.

Structure de la boucle "tant que" en pseudo code :

Tant que "condition : booléen"
  faire :
    ...
    les différentes instructions à répéter
    ...
Fin pour

Pour illustrer ce cours nous allons partir sur le premier exemple vu précédemment: Obtenir la somme des n premiers entiers naturels Pour n=4, on veut écrire un programme qui renvoie la valeur de 0+1+2+3=6.

Ecriture du programme de l'exemple en pseudo code :

  1. S← 0
  2. i← 0
  3. Tant que i<4
  4.   faire :
  5.     i ← 1+i
  6.     S ← S+i
  7. Fin tant que

La structure de la boucle "tant que" en python


La première ligne fait que les instructions dans la boucle vont être répétées tant que les conditions indiquées derrière le while sont vérifiées.
L'écriture des conditions est ici simple, elle peut être composée de plusieurs conditions. Cela offre des possibilités de codes intéressantes et parfois complexes.
Remarque : Dans les premiers exemples la condition est simple et on pourrait remplacer cette boucle while par une boucle for.

While i<4:
    ...
    les différentes instructions à répéter
    ...
On remarque ici l'absence de "faire" et de "fin tant que". Comme pour la boucle pour c'est en fait l'indentation qui sert de limitateur de boucle. On rappelle encore que l'indentation en python n'est pas uniquement un élèment d'hygiène de programmation mais un élément faisant partie intégrante des structures.

Ecriture du programme de l'exemple en python :


def somme(n:int)->int: 
    """""La fonction somme renvoie la somme des n+1 premiers entiers naturels.
    la fonction somme a pour attribut un entier (int) : n et renvoie un autre entier :S
    Pour n=4 : S=0+1+2+3=10""""" 
    S=0 #initialisation de la somme à 0
    i=0
    while i<n:
        i+=1 #on aurait pu écrire aussi i=i+1; incrémente i de 1 à chaque passage dans la boucle     
        S=S+i
    return S


#Test de la fonction :
somme(4)


Cliquer sur cette adresse : http://pythontutor.com/visualize.html#mode=edit
Copier/coller votre code dans la fenêtre
puis cliquer sur Visualize Execution pour observer la trace d'exécution de votre code pas à pas puis par des clics succéssifs sur le bouton forward.

Exercices

Exercice 5


Modifier la fonction somme(n) pour qu'en sortie on ait la somme des n+1 premiers entiers naturels.
pour n=4, S=0+1+2+3+4=10


def somme(n:int)->int: 
    """""La fonction somme renvoir la somme des n+1 premiers entiers naturel.
    la fonction somme a pour attribut un entier (int) : n et renvoie un autre entier :S
    Pour n=4 : S=0+1+2+3+4=10""""" 
    S=0 #initialisation de la somme à 0
    i=1
    while i<n:
        i+=1 #on aurait pu écrire aussi i=i+1; incrémente i de 1 à chaque passage dans la boucle     
        S=S+i
    return S


#Tester la fonction avec n=4, vous devriez avoir 10 en sortie
somme(4)

Exercice 6


Une entreprise vend un récupérateur d'eau de pluie qui a une capacité de 150 litres d'eau.
Elle voudrait proposer à ses clients un programme qui permettrait au client de savoir en combien de jours le réservoir sera plein en fonction du remplissage moyen quotidien.
Ecrire une fonction full qui prend en argument une entrée du type float indiquant le volume en litre du remplissage moyen quotidien a et en sortie un entier indiquant le nombre de jours nécessaire au remplissage.


def full(a:float)->int:

    return #test de la fonction


#test de la fonction
full(3.1) #la réponse devrait être 49

Exercice 7


Ecrire une fonction qui permet d'écrire une liste d'entiers aléatoires qui s'arrête dès que la somme des nombres dépasse une certaine valeur.
la fonction makeList prend en entrée 3 valeurs entières deb, fin et max correspondant respectivement à la plus petite valeur des nombres aléatoires, à la plus grande et à la valeur à ne pas dépasser en faisant la somme de ces nombres.


#à interpréter en premier
from random import  *

Des instructions nécessaires à la réalisation du programme :


#obtenir un nombre entre deux entiers, 10 et 25 par exemple
randint(10,25)


#pour créer une liste vide qui s'appelle lst on écrit :
lst=[]
#pour rajouter un élément à cette liste par exemple 5 on écrit :
lst.append(5)
print(lst)


def makeList(deb:int,fin:int,max:int)->list:
  
    return 


makeList(2,50,250)

Exercice 8

Reprendre l'exercice 1.5.5 en utlisant une boucle while


l=[0,1,2,3,4,5]
#Pour déterminer la longueur d'une liste on écrit :
len(l)


#Attention aux indices !
l[5]


def estDansListe(lst:list,n:int)->bool:

    return 


#test de la fonction
l=[0,1,2,3,4,5]
estDansListe(l,8) #doit renvoyer False
estDansListe(l,5) #doit renvoyer True

Exercice 9

Écrire une fonction qui demande à l'utilisateur d'entrer des notes, sans que l'on sache à l'avance combien de notes il va saisir : l'arrêt de la saisie se produit dès que l'utilisateur saisit un nombre négatif.
Le programme doit calculer et afficher la moyenne (Attention: le nombre négatif saisi ne doit pas compter dans la moyenne !). On nommera cette fonction moy elle ne prendra aucune entrée et donnera un élément de type float en sortie.


#demander au joueur un nombre et l'affecter à une variable :
a=input("Donner un nombre")
print(a)
#la valeur renvoyée par input est de type str, il faudra donc écrire :
a=int(input("Donner un nombre"))


def moy()->float:
  
    return 


#test de la fonction
# essayer 10,12,14,8,12,6,8
#la sortie devrait être 10
moy()

Exercice 10


Pour commencer l'ordinateur va choisir au hasard un nombre compris entre 1 et 100.
L'utilisateur doit alors deviner ce nombre comme ceci :
L'utilisateur propose un nombre. L'ordinateur lui dit s'il est trop petit ou trop grand, et ainsi de suite jusqu'à ce que l'utilisateur ait trouvé le bon nombre.

Des instructions nécessaires à la réalisation du programme :


#la condition n'est pas égale s'écrit :
!=
#le test d'égalité s'écrit :
==

Ecrire la fonction plusOuMoins() qui en entrée ne reçoit rien et en sortie renvoie le nombre d'essais qu'il a fallu pour trouver l'entier.


def pluOuMoins()->str:

    return None

    


#tester le programme
pluOuMoins()

Exercice 11

On reprend l'exercice précédent en ajoutant une règle. Vous devez ajouter une entrée nbEssais de type int à la fonction qui correspond au nombre d'essais maximum. On nommera cette fonction plusOuMoinB


def plusOuMoinB(nbEssais:int)->str:
  
    return 


plusOuMoinB(10)