Un petit résumé des instructions du langage Python est disponible au téléchargement en cliquant ici.
Instructions conditionnelles if
: Exercices
Un petit résumé des instructions du langage Python est disponible au téléchargement en cliquant ici.
On considère le code suivant :
##----- Importation des modules -----##
from math import pi
##----- Définition des fonctions -----##
def f(x) :
if x < - 2 :
y = 2*x+3
elif x < 3 :
y = -3*x+1
else :
y = pi
return y
##----- Tests et interaction -----##
a = 2
print(f(a))
Glissez les étiquettes réponses (bande horizontale du bas) sur les cases associées.
Nom d'une bibliothèque Python standard | math |
a = 2 |
affectation |
a |
nom de variable |
f |
nom de fonction définie par l'utilisateur |
fonction prédéfinie | print |
nom du paramètre de la fonction | x |
valeur renvoyée après exécution | -5 |
Programmez l'algorithme ci-dessous sous la forme d'une
fonction nommée plus_petit()
.
a
et b
sont deux nombres donnés
en paramètres et x
est la valeur renvoyée
par l'algorithme :
Si a est plus petit que b
Alors x ← a
Sinon x ← b
On rappelle que le séparateur décimal est le point, pas la virgule.
def plus_petit(a, b):
if a < b:
x = a
else:
x = b
return x
>>> plus_petit(3, 4) 3 >>> plus_petit(-2.1, -2.8) -2.8
Il est possible d'allèger ce code en utilisant une propriété
du mot-clé return
: dès
qu'il est rencontré, le programme sort de la fonction.
Les instructions qui suivent l'exécution d'un
return
ne sont tout
simplement pas lues :
def plus_petit(a, b):
if a < b:
return a
else:
return b
>>> plus_petit(3, 4) 3 >>> plus_petit(-2.1, -2.8) -2.8
Écrire le code d'une fonction nommée valeur_absolue()
et
qui renvoie la valeur absolue d'un flottant entré en paramètre.
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.
Définir une fonction (sans paramètre) qui simule un lancer de dé et qui renvoie 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. Relire la page
[Bibliothèques de fonctions]
→ [Fonctions suplémentaires] pour davantage de précision.
##----- Importation des modules -----##
from random import randint
##----- Définition des fonctions -----##
def gain():
jet = randint(1, 6)
if jet == 2 :
valeur = 3
elif jet == 4 :
valeur = 3
elif jet == 6 :
valeur = 4
else :
valeur = -2
return valeur
>>> gain() -2 >>> gain() 3
A nouveau, on utilise la propriété du mot-clé return
qui permet une sortie anticipée de la fonction sans lire les instructions qui le suivent.
##----- Importation des modules -----##
from random import randint
##----- Définition des fonctions -----##
def gain():
jet = randint(1, 6)
if (jet == 2) or (jet == 4) :
return 3
elif jet == 6 :
return 4
else :
return -2
>>> gain() 4 >>> gain() -2
Vous rencontrerez parfois l'utilisation de la particularité suivante: si
on effectue un calcul tel que 2 * (2 < 3)
faisant intervenir un booléen
et un entier, le booléen est interprété comme étant le nombre 1 dans le
cas True
et comme le nombre 0 dans le cas False
.
Cela pourrait donner la version ci-dessous (à éviter sans doute en lycée) :
##----- Importation des modules -----##
from random import randint
##----- Définition des fonctions -----##
def gain():
jet = randint(1, 6)
return 3*(jet in (2, 4)) + 4*(jet==6) + (-2)*(jet in (1, 3, 5))
somme_de_trois_consecutifs()
qui respecte la spécification
suivante :
Paramètre | un entier relatif n |
---|---|
Valeur renvoyée | la somme des trois entiers consécutifs dont n est le milieu. |
divisible_par_3()
qui respecte la spécification
suivante :
Paramètre | un entier relatif n |
---|---|
Valeur renvoyée | True si n est multiple de 3, False sinon. |
divisible_par_3()
à un résultat de la
fonction somme_de_trois_consecutifs()
.
Quel résultat obtient-on ? Justifier.
def somme_de_trois_consecutifs(n):
return (n-1)+n+(n+1)
>>> somme_de_trois_consecutifs(5) 15
On peut coder ceci de diverses façons. En voici une :
def divisible_par_3(n):
if n%3 == 0:
return True
else:
return False
Une &lacquo; meilleure » version:
def divisible_par_3(n):
return n%3 == 0
Dans les deux cas, l'utilisation dans la console est la même :
>>> divisible_par_3(5) False
Vous pourriez être amené à rencontrer l'utilisation de la spécificité suivante :
False
,True
.
def divisible_par_3(n):
return not(bool(n%3))
def somme_de_trois_consecutifs(n):
return (n-1)+n+(n+1)
def divisible_par_3(n):
return n%3 == 0
>>> divisible_par_3(somme_de_trois_consecutifs(7)) True
La somme (n-1)+n+(n+1)
étant égale à 3×n
, on
obtient évidemment toujours True
.
def intervalle1(x):
return (x > 2) and (x < 7)
x
pour lesquels la valeur renvoyée sera True
.
intervalle2()
qui correspondrait à des
réponses True
pour les réels x
de l'intervalle $ ] -2 ; 21 ] $ et False
pour les autres réels.
Paramètres | trois réels $x$, $a$, $b$ (où $ a \leqslant b $ ) |
---|---|
Valeur renvoyée | True si $ x\in [a;b[$, False sinon. |
L'intervalle est bien entendu l'intervalle $ ] 2 ; 7 [ $.
Notez que Python permet de ne pas
utiliser and
:
def intervalle1(x):
return 2 < x < 7
def intervalle2(x):
return (-2 < x) and (x <= 21)
ou encore :
def intervalle2(x):
return -2 < x <= 21
On a utilisé « fo
» dans le nom de la fonction
pour : fermé (à gauche), ouvert (à droite).
Remarquons qu'une fois de plus, une séparation algorithme - programme serait ici bienvenue.
En effet, même si l'instruction x >= a and x < b
de la fonction
est_dans_fo(x, a, b)
correspond bien, du point de vue
algorithmique (i.e. mathématique), à la caractérisation de l'intervalle
[a ; b [
, c'est nettement plus ambigu avec la représentation des
nombres flottants en machine comme le montre un exemple déjà utilisé auparavant.
Vérifiez que le code suivant renvoie False
:
def reunion1(x):
return ( x > 17 ) or ( x < 7 )
x
pour lesquels la valeur renvoyée sera
True
.
reunion2()
qui correspondrait à des
réponses True
pour les réels x
de l'ensemble $ [ -10; 5 ] \cup ] 7; +\infty [ $ et
False
pour les autres réels.
Paramètres | trois réels x, a, b |
---|---|
Valeur renvoyée | True si $ x\in ]-\infty; a] \cup [b; +\infty[ $, False sinon. |
def reunion2(x):
return (-10 <= x and x <= 5) or (x > 7)
ou encore :
def reunion2(x):
return (-10 <= x <= 5) or (x > 7)