Un petit résumé des instructions du langage Python est disponible au téléchargement en cliquant ici.
Boucle for
: exercices
Un petit résumé des instructions du langage Python est disponible au téléchargement en cliquant ici.
Compléter le programme suivant qui doit afficher les n
premiers entiers
impairs, où n
est un entier choisi par l'utilisateur du
programme. Programme purement interactif dont l'unique but est de vous faire
travailler la boucle for
.
Grâce à la fonction range()
, on parcourt les entiers
de 1 à 2n
avec un pas de 2 :
Nouvelle possibilité, on parcourt les n
premiers entiers
en affichant l'entier impair correspondant.
On parcourt les 2n
premiers entiers naturels et on affiche
uniquement les impairs par test de la divisibilité par 2.
Anticipons un peu sur le paragraphe concernant la boucle while
:
ou encore :
Le joueur n°1 et le joueur n°2 lancent chacun un dé (dé classique, équilibré, à six faces). Le joueur qui obtient une valeur strictement supérieure à celle obtenue par l'autre joueur gagne. En cas d'égalité, la partie est nulle.
jeu()
, qui respecte la spécification suivante :
Paramètres | / |
---|---|
Définition | simule le lancer de deux dés |
Valeur renvoyée | 1 si le joueur n°1 gagne, 2 si le joueur n°2 gagne, 0 en cas de partie nulle. |
frequence()
, qui respecte le cahier des charges suivant :
Paramètre | un entier naturel n |
---|---|
Valeur renvoyée | la fréquence de parties gagnées par le joueur n°1 lors de n parties. |
Observer les valeurs obtenues pour la fréquence de parties gagnées par
le joueur n°1 pour de grandes valeurs de n
.
Expliquer ces valeurs.
random
Les fonctions qui génèrent du pseudo-aléatoire sont contenues dans
le module random
. Exécutez plusieurs fois le programme
ci-dessous afin de bien saisir les résultats obtenus par deux d'entre
elles :
Sur les 36 couples possibles, 15 correspondent à une victoire du joueur 1, 6 à un match nul, 15 à la victoire du joueur 2.
La probabilité de gagner du joueur 1 est donc égale à $ \frac{15}{36} $.
Un prix augmente de 1% chaque année. Écrire une fonction en
Python, nommée augmente
,
qui respecte la spécification suivante :
Paramètre | un entier naturel n (n > 0) |
---|---|
Valeur renvoyée | Le pourcentage d'augmentation après n années. |
for
.
def augmente(n):
coefficient_multiplicateur = 1
for i in range(n) :
coefficient_multiplicateur = coefficient_multiplicateur * (1+1/100)
return 100*(coefficient_multiplicateur-1)
>>> augmente(17) 18.43044313729356 >>> augmente(24) 26.973464853191498
def augmente(n):
coefficient_multiplicateur = (1+1/100)**n
taux = 100*(coefficient_multiplicateur-1)
return taux
>>> augmente(17) 18.43044313729356 >>> augmente(24) 26.973464853191498
1
à n
, où n
est un entier strictement positif donné en paramètre :
S ← 0
Pour ...
somme_entiers()
.1
à 2000
.a
à
b
, a
et b
étant les paramètres de cette fonction. Tester en
déterminant la somme des entiers
successifs de 100
à 1000
.
L'algorithme ci-dessous calcule la valeur de l'entier S
,
somme des entiers de 1
à n
où n
est un entier strictement positif donné en paramètre.
S ← 0
Pour i allant de 1 à n:
S ← S+i
A nouveau, la valeur renvoyée par l'algorithme est donnée par le « cahier des charges » de la question.
La variable S
utilisée dans cette fonction porte
le nom d'accumulateur.
def somme_entiers(n):
S = 0
for i in range(1, n+1): # borne_inf incluse, borne_sup non incluse
S = S+i
return S
>>> somme_entiers(2000) 2001000
Il suffit de modifier les paramètres de la fonction
range()
:
def somme_entiers_bis(a, b):
S = 0
for i in range(a, b+1): # borne_inf incluse, borne_sup non incluse
S = S+i
return S
>>> somme_entiers_bis(100, 1000) 495550