Instructions conditionnelles if : Exercices
Écrire un programme demandant à l'utilisateur d'entrer un réel et affichant en sortie la valeur absolue de ce réel.
x = float(input("Entrez un nombre : "))
print("Sa valeur absolue est : ", end ='')
if x > 0 :
print(x, end=".")
else :
print(-x, end=".")
On est déjà ici dans la situation où l'utilisation d'une fonction clarifie le code (séparation des rôles de calcul et des rôles d'affichage).
On lance un dé (équilibré, six faces). Le joueur gagne 3 euros s'il tombe sur une face paire inférieure à 6 et gagne 4 euros s'il tombe sur 6. Il perd 2 euros s'il tombe sur une face impaire.
Écrire un programme qui simule un lancer de dé et affiche le gain correspondant.
Le langage Python contient des fonctions prédéfinies
comme input(), print(), type(), etc...
Il est aussi possible d'importer des bibliothèques de fonctions supplémentaires
appelées module.
On peut simuler le lancer d'un dé en utilisant la fonction randint()
du module random. Pour cela, il faut commencer par importer cette
fonction supplémentaire. C'est le rôle de la première ligne dans le script
ci-dessous :
from random import randint
def jeter_le_de(n):
""" n : nombres de faces du dé.
On tire au hasard un entier parmi 1, 2, 3, ..., n."""
return randint(1,n)
def gain(jet):
if jet == 2 or jet == 4 : return 3
elif jet == 6 : return 4
else : return -2
jet = jeter_le_de(6)
print(gain(jet))
Écrire une fonction (procédure) en Python qui respecte la spécification suivante :
| Paramètres | xA, yA, xB, yB coordonnées des points A et B dans un repère du plan |
|---|---|
| Valeur renvoyée | / |
| Affichage écran | équation de la droite (AB) |
def f(xA,yA,xB,yB):
if xA == xB: # ou utilisation de isclose()...
print( "L'équation de la droite (AB) est : x = {}.".format(xA) )
else :
m = (yB-yA)/(xB-xA)
p = yA - m * xA
print( "L'équation de la droite (AB) est : y = {}*x+{}.".format(m,p) )
f( 1,2,5,9)
Écrire une fonction en Python qui respecte la spécification suivante :
| Paramètres | a, b, c réels (a non nul) et k un nombre quelconque |
|---|---|
| Valeur renvoyée | Le nombre de solutions de l'équation \(a x^2 + b x + c = k\) |
from math import isclose
def nombre_solutions(a,b,c,k) :
"""
renvoie le nombre de solutions de l'équation ax^2+bx+c = k
a non nul
"""
x = -b/(2*a)
y = a*x**2+b*x+c
if isclose(k,y) : return 1
if a>0 :
if k < y : return 0
else : return 2
else :
if k > y : return 0
else : return 2
print(nombre_solutions(1,1,1, 3/4))
print(nombre_solutions(1,1,1, 1))
print(nombre_solutions(1,1,1, -5))
from math import isclose
def nombre_solutions(a,b,c,k) :
"""
renvoie le nombre de solutions de l'équation ax^2+bx+c=k
a non nul
"""
discriminant = b**2 - 4*a*(c-k)
if isclose(discriminant,0) : return 1
elif discriminant > 0 : return 2
else : return 0
print(nombre_solutions(1,1,1, 3/4))
print(nombre_solutions(1,1,1, 1))
print(nombre_solutions(1,1,1, -5))
| Paramètres | m coefficient directeur d'une droite d. a coefficient directeur d'une droite d'. |
|---|---|
| Valeur renvoyée | True si les droites sont parallèles, False sinon |
| Paramètres | m, p coefficient directeur et ordonnée à l'origine d'une droite d. a, b coefficient directeur et ordonnée à l'origine d'une droite d'. |
|---|---|
| Valeur renvoyée | / |
| Affichage | L'intersection des droites d et d' |
def sont_paralleles(m, a):
return m == a # ou utilisation de isclose()...
print(sont_paralleles(2,3))
def intersection(m,p, a,b) :
print("Intersection des droites d'équation y={}x+{} et y={}x+{}.".format(m,p,a,b) )
if m == a :
if p != b:
print("Ensemble vide.")
else :
print("La droite.")
else :
x = (b-p)/(m-a)
print("L'ensemble réduit au point de coordonnées ({}; {}).".format( x, m*x+p) )
intersection(2,3, 2,4)
intersection(2,3, 2,3)
intersection(2,3, 4,1)
| Paramètres | a, b, c entiers |
|---|---|
| Valeur renvoyée | Celui des trois nombres qui est compris entre les deux autres. |
| Paramètres | a, b, c entiers |
|---|---|
| Valeur renvoyée | la plus petite des trois valeurs |
| Paramètres | a, b, c entiers |
|---|---|
| Valeur renvoyée | la plus grande des trois valeurs |
| Paramètres | a, b, c entiers strictement positifs. |
|---|---|
| Valeur renvoyée | True si l'on peut construire un triangle de côtés a, b, c. False sinon. |
def intermediaire(a,b,c) :
if a <= b <= c or c <= b <= a : return b
if b <= a <= c or c <= a <= b : return a
else : return c
a = int(input("Entrez a : "))
b = int(input("Entrez b : "))
c = int(input("Entrez c : "))
print(intermediaire(a,b,c))
def mini(a,b,c) :
if a <= b and a <= c : return a
if b <= a and b <= c : return b
else : return c
a = int(input("Entrez a : "))
b = int(input("Entrez b : "))
c = int(input("Entrez c : "))
print(mini(a,b,c))
def maxi(a,b,c) :
if a >= b and a >= c : return a
if b >= a and b >= c : return b
else : return c
a = int(input("Entrez a : "))
b = int(input("Entrez b : "))
c = int(input("Entrez c : "))
print(maxi(a,b,c))
def intermediaire(a,b,c) :
if a <= b <= c or c <= b <= a : return b
if b <= a <= c or c <= a <= b : return a
else : return c
def maxi(a,b,c) :
if a >= b and a >= c : return a
if b >= a and b >= c : return b
else : return c
def mini(a,b,c) :
if a <= b and a <= c : return a
if b <= a and b <= c : return b
else : return c
def triangle_possible(a,b,c) :
return maxi(a,b,c) < mini(a,b,c) + intermediaire(a,b,c)
a = int(input("Entrez a : "))
b = int(input("Entrez b : "))
c = int(input("Entrez c : "))
print(triangle_possible(a,b,c))
Écrire un programme qui demande en entrée les longueurs des trois côtés d'un triangle et affiche ensuite s'il est rectangle ou non, et s'il est rectangle affiche s'il est isocèle ou non.
Attention, on rappelle que pour comparer des float, l'utilisation de == ne donnera
pas un comportement du script satisfaisant.
Utilisez un test (distance inférieure à une borne epsilonesque) ou utilisez la fonction isclose
du module math.
On peut coder ceci de diverses façons. En voici une :
from math import isclose
a = float(input("Entrez la longueur du premier côté : "))
b = float(input("Entrez la longueur du second côté : "))
c = float(input("Entrez la longueur du troisième côté : "))
print("Rappel : il s'agit de calculs numériques en machine.")
print("Les conclusions ne sont donc que conjectures.")
# on range les trois nombres en ordre croissant :
if a > b: a,b = b,a
if b > c: b,c = c,b
if a > b: a,b = b,a
if not(isclose(c*c, a*a + b*b)) :
print("Triangle non rectangle")
elif isclose(a,b) :
print("Triangle rectangle isocèle.")
else :
print("Triangle rectangle non isocèle.")
L'usage de fonctions clarifie l'ensemble (séparation des fonctions de calcul et des instructions ne servant qu'à l'échange avec l'utilisateur).
from math import isclose
def est_rectangle(a, b, c) :
return isclose(c*c, a*a + b*b) or isclose(a*a, c*c + b*b) or isclose(b*b, c*c + a*a)
def est_isocele(a, b, c) :
return isclose(a, b) or isclose(a, c) or isclose(c, b)
def message_avertissement() :
print("\n#######################################################")
print("Rappel : il s'agit de calculs numériques en machine.")
print("Les conclusions ne sont donc que conjectures.")
print("#######################################################\n")
a = float(input("Entrez la longueur du premier côté : "))
b = float(input("Entrez la longueur du second côté : "))
c = float(input("Entrez la longueur du troisième côté : "))
message_avertissement()
if not(est_rectangle(a, b, c)):
print("Triangle non rectangle")
elif est_isocele(a, b, c):
print("Triangle rectangle isocèle.")
else:
print("Triangle rectangle non isocèle.")