Définir une fonction convertir qui prend comme paramètre un entier duree_minute en renvoie un tuple (=couple ici) formé des deux valeurs nb_heures et nb_minutes.
Il peut vous être utile d'utiliser les deux opérateurs // et % définis ainsi :
Appeler cette fonction afin de convertir en nombres d'heures 1000 minutes. Vérifier que vous obtenez comme affichage :
convertir(1000)
(16, 40)
Bonnes pratiques de programmation
Préciser le typage de chacun des paramètres
Le langage Python est plus aisé pour démarrer la programmation pour la concision des codes écrits et pour la gestion automatique du typage par l'interpréteur. Cependant, le but est que vous puissiez à terme être capable de faire basculer
vos compétences acquises en NSI sur Python vers d'autres langages de programmation.
Comme la plupart des langages de programmation nécessitent la spécification du typage des variables, à terme, on vous demandera d'écrire en Python, une fonction en précisant le type de chaque antrée et sortie en suivant le même formalisme
que ci-dessous :
def nomFonction(liste des arguments: type) -> typeRetour:
blocs des instructions
return résultat
La convention PEP8 donne l'habitude de nommer les fonctions (comme les variables) avec des lettres minuscules des tirets bas (celui du "8") _. Pour clarifier la fonction, il est conseillé
d'utiliser un verbe dans son nom (obtenir, donner, get, set, ...).
Documenter ses fonctions
Il est important de documenter vos fonctions, c'est-à-dire de décrire en quelques phrases le rôle de la fonction, de donner des informations sur la fonction, le lien entre les entrées et la sortie.
Pour cela, juste en dessous de la première ligne définissant la fonction, il suffit de mettre ses informations entre """ et """ ; c'est ce que l'on appelle en franglais le docstring de la fonction). En reprenant l'exemple précédent (sans le typage), on peut écrire :
def carree(a):
"""
Fonction permettant de renvoyer le carré du nombre a qui est en paramètre
"""
return a**2 # renvoie l'image de a par la fonction carree
L'intérêt de l'auto-documentation d'une fonction par un texte est double :
- Pour vous : le faire vous oblige à réfléchir au contenu de votre fonction avant de la programmer ; c'est un gain d'efficacité,
- Pour les utilisateurs de votre code (ou pour vous longtemps après avoir programmé la fonction) : Quand on saisit dans la console, après l'exécution de la fonction, l'instruction
help(nom de la fonction), Python affiche
le docstring de la fonction ce qui nous permet d'avoir des informations sur la fonction en cas d'oubli.
>>> help(carree)
Help on function carree in module __main__:
carree(a: float) -> float
Fonction permettant de renvoyer le carré du nombre a qui est en paramètre
>>>
Voici ci-dessous une fonction qui donne le prix soldé d'un article initialement à prix euros après un solde de t%.
def solder(prix,t):
prix_solde = prix * (1 - t/100)
return prix_solde
Améliorer le code précédent en préciser le typage de chaque paramètre et en documentant cette fonction.
Utilisation de modules
Nous avons déjà vues les fonctions print et input. Ce sont deux fonctions prédéfinies dans le langage Python, On appelle ce type de fonction des fonctions natives au langage Python
, elles sont directement utilisables.
D'autres fonctions ont été développées et testées par différents programmeurs mais ne sont pas directement utilisables. Ces fonctions sont regroupées dans des modules, appelés aussi bibliothèques.
En terminale, vous apprendrez même à en créer par vous même !
-
le module math contient de nombreuses fonctions mathématiques usuelles comme la racine carrée (sqrt), ...
-
le module random contient de nombreuses fonctions modélisant le hasard comme l'obtention d'un nombre entier aléatoire compris entre deux nombres entiers a et b (randint(a,b)), ...
-
le module matplotlib.pyplot permet de réaliser des graphiques, des tracés de courbes, ...
Pour pouvoir utiliser ces fonctions, il faut d'abord importer ces modules. Pour cela, il y a plusieurs méthodes :
-
Soit importer tout le module en ajoutant en début de programme :
from nom_module import *
On peut alors utiliser n'importe qu'elle fonction du module sans prendre en utilisant seulement son nom.
from math import * # import de toutes les fonctions du module math
a = (1 + sqrt(5))/2
print("valeur approchée du nombre d'or :",a)
-
Pour éviter des confusions entre deux fonctions portant éventuellement le même nom dans deux modules différents, il peut être utile d'importer un module en lui fixant un nom d'utilisation en ajoutant en début de programme :
import nom_module as nom_raccourci
import matplotlib.pyplot as plt # import de toutes les fonctions du module matplotlib.pyplot mentionné plt dans toute la suite du programme
plt.grid() # utilisation de la fonction grid (qui permet d'obtenir un quadrillage), fonction issue du module plt (=matplotlib.pyplot)
plt.show() # utilisation de la fonction show (qui permet de réaliser le tracé du code précédent), fonction issue du module plt (=matplotlib.pyplot)
-
Il peut suffire d'importer seulement une fonction d'un module en ajoutant en début de programme :
from nom_module import nom_fonction
from random import randint # import de la seule fonction randint du module random
resultat_de = randint(1,6)
La portée des variables
Il faut faire la différence entre les variables utilisé dans le programme (variables globales) et les variables utilisées dans une fonction (variables locales).
Vous allez comprendre cela à l'aide des exemples de l'exercice suivant :
Ecrire dans un jupyter les trois fonctions suivantes puis faire des appels avec différentes valeurs de x pour observer les différences entre ces codes :
Ici, ni les types ni la documentation n'ont été écrites afin de faciliter la vision de la différence entre variable locale et variable globale.
x=-101
def carre(x):
x=x**2
return x
x=-101
def carre_2():
x=x**2
return x
x=-101
def carre_3():
global x
x=x**2
return x
Normalement vous avez dû détecter un problème : il y a une fonction qui ne peut pas être interprétée !
Il faut privilégier les variables locales. La première écriture, celle de carre est la définition à privilégier.
Vous pouvez utiliser des variables globales, comme mais dans carre3, des cas qu'il faudra bien définir en amont.
Le danger des variables globales est quelle peuvent être modifiée à différents endroits d'un programme ce qui plus difficile la prévision du comportement du programme, dès que celui-ci devient assez conséquent.
En résumé, pour l'instant, pas de variables globales.
-
Voici une fonction augmenter_score qui prend comme paramètre d'entrée les points à rajouter et renvoie le nouveau score obtenu.
def nouveau_score(points: int) -> int:
"""
fonction qui renvoie le score du nombre de points donnés comme entrée
paramètres :
points : nombre de points à rajouter à la variable globale score (nombre entier)
retour :
score : nombre de points du score (nombre entier)
"""
global score
score = score + points
return score
Combien de variables apparaissent dans la fonction nouveau_score ? De quel type ?
-
Exécuter le script suivant :
score = 100
def nouveau_score(points: int) -> int:
"""
fonction qui renvoie le score du nombre de points donnés comme entrée
paramètres :
points : nombre de points à rajouter à la variable globale score (nombre entier)
retour :
score : nombre de points du score (nombre entier)
"""
global score
score = score + points
return score
for parties in range(1,4): # 3 répétitions de l'affichage suivant
print("J'ai gagné 10 points ! nouveau_score(10) affiche :",nouveau_score(10))
Est-ce que les appels nouveau_score(10) renvoie toujours la même valeur ?
-
Comme il est préférable d'éviter les variables globales, proposer une modification de la fonction nouveau_score afin de supprimer la ligne global score.
Rajouter un paramètre à la fonction peut-être très utile pour supprimer une variable globale.
-
Tester le script complet précédent avec la fonction nouveau_score modifiée.
À retenir !
-
La structure générale d'une fonction :
def nom_fonction(liste des arguments: type) -> typeRetour:
blocs des instructions
return résultat
-
L'indentation permet de définir ce qui fait partie de la fonction de ce qui en est exclu.
-
Une fois une fonction définie, pensez à l'appeler pour l'utiliser.
-
Toujours terminer une fonction par un return qui doit être pour le mieux unique.
-
Essayer de préciser les types des paramètres et du retour dans l'en-tête d'une fonction.
-
Essayer de documenter ses fonctions : texte explicatif entre triples guillements ou apostrophes.
-
Essayer d'éviter l'utilisation de variables globales.
Précondition et postconditions en Python
Précondition
Voici le code en Python d'une fonction nommée get_unite qui prend comme paramètre un nombre entier et qui renvoie son chiffre des unités.
def get_unite(n: int) -> int:
"""
renvoie le chiffre des unités d'un entier n
"""
while n>=10 : # répétition tant que n est supérieur ou égal à 10
n = n-10
return n
Une documentation a été donnée afin d'expliciter le bon usage de la fonction. Mais on ne pas être certain qu'un utilisateur de la fonction respectera les contraintes implicites ou explicites de la documentation et du typage. Voici quelques exemples d'appel
de la fonction :
>>> get_unite(4567)
7
>>> get_unite(45.67)
5.670000000000002
>>> get_unite(-6)
-6
On voit que l'appel conduit à une réponse à chaque fois, mais que celle-ci ne correspond pas toujours à ce qui est attendu. Pour rendre "robuste" la fonction précédente, on doit vérifier au début de celle-ci certaines contraintes de bon usage que l'on
appelle
précondition.
Dans l'exemple précédent, ces préconditions sont :
- "Précondition 1" :
n est de type entier (par exemple, le programme buggera si une chaîne de caractères est saisie come argument),
- "Précondition 2" :
n est positif (sinon le résultat renvoyé est la valeur négative saisie).
Pour cela, le langage Python possède l'instruction assert qui permet un mécanisme d'assertion.
Les deux préconditions précédentes s'ajoutent à la fonction précédente ainsi :
def get_unite(n: int) -> int:
"""
renvoie le chiffre des unités d'un entier n
"""
assert type(n)==int, "vous devez entrer un nombre entier." # "Précondition 1"
assert n>=0, "le nombre étudié doit être positif ou nul." # "Précondition 2"
while n>=10 : # répétition tant que n est supérieur ou égal à 10
n = n-10
return n
Quelques explications :
a==b renvoie True si l'égalité "a=b" est vraie (même type et même contenu) et False sinon,int est le type "entier". Il existe les types float pour les flottants, str pour les chaînes de cractères, ...- Une telle instruction
assert est suivie :
- d'une condition (une expression booléenne qui vaut
True ou False),
- éventuellement suivie d'une virgule
, et d'une phrase en langue naturelle, sous forme d'une chaine de caractères.
- L'instruction
assert teste si sa condition. Deux cas possibles :
- si la condition est satisfaite, elle ne fait rien (l'interpréteur passe à la ligne suivante)
- sinon elle arrête immédiatement l'exécution du programme en affichant la phrase qui lui est éventuellement associée. Ainsi, l'interpréteur arrête l'exécution de la fonction plutôt que de faire planter
le programme et affiche un message clair pour corriger l'erreur !
Vous pouvez retrouver ici une petite vidéo qui synthétise les appels de modules, les docstring et les assert
Voici un fonction nommée diviser réalisation la division du premier argument par le second.
def diviser(a: float,b: float) ->float:
"""
renvoie le résultat décimal de la division de a par b.
"""
return a/b
Quelle précondition, écrite en langage Python, doit-on rajouter afin d'assurer le bon fonctionnement de la fonction ?
Postcondition
Souvent les fonctions sont appelées au cours de programme ; le type et la qualité du résultat renvoyé est important pour ne pas conduire à un plantage. Des contraintes sur la variable renvoyée sont souvent nécessaires : on les appellent les
postconditions.
Reprenons l'exemple précédent :
def get_unite(n: int) -> int:
"""
renvoie le chiffre des unités d'un entier n
"""
while n>=10 : # répétition tant que n est supérieur ou égal à 10
n = n-10
return n
Voici le résultat de quelques appels effectués :
>>> get_unite(4567)
7
>>> get_unite(45.67)
5.670000000000002
>>> get_unite(-6)
-6
Comme le résultat renvoyé doit être un nombre entier compris entre 0 et 9, on va rajouter les postconditions suivantes :
- "postcondition 1" :
n est un entier naturel.
- "postcondition 2" :
n est positif.
- "postcondition 3" :
n est strictement inférieur à 10
On utilise encore l'instruction assert, juste avant le return pour écrire ces postconditions comme montré ci-dessous :
def get_unite(n: int) -> int:
"""
renvoie le chiffre des unités d'un entier n
"""
while n>=10 : # répétition tant que n est supérieur ou égal à 10
n = n-10
assert type(n)==int, "Le nombre renvoyé devrait être un entier." # "Postcondition 1"
assert n>=0, "le nombre renvoyé doit être positif ou nul." # "Postcondition 2"
assert n<10, "le nombre renvoyé doit être inférieur à 10." # "Postcondition 3"
return n
- Ces mécanisme d'assertion est une aide au développeur qui permet de repérer des erreurs dans le code.
- En supprimant toutes les assertions, le programme doit à la fin toujours fonctionner.
- Normalement, Lors de la finalisation du programme les différentes assertions doivent être ôtées.
TP à réaliser
Document d'aide
Si vous rencontrez des difficultés sur l'utilsation de Jupyter pour :
- comprendre la structure d'une cellule,
- régler des problèmes d'exécution,
- comprendre les différences d'affichages,
- sauvegarder un document (modifié),
vous pouvez lire et utiliser le document suivant :
Télécharger le fichier jupyter d'aide.
Si votre jupyter ne fonctionne pas, vous pouvez au moins utiliser ces espaces de tests :
Travail à effectuer
Fonction
L'indice de Masse Corporelle est un nombre réel utilisé en médecine. Sa formule est pour une $masse$ en kilos et une $taille$ en mètres : $IMC = \frac{masse}{taille^2}$.
-
Écrire en langage Python dans Jupyter un programme qui :
- Demande la masse de l'utilisateur en kg (nombre réel)
- Demande la taille de l'utilisateur en cm (nombre entier).
- affiche l'IMC de l'utilisateur.
-
Est-ce une fonction ou une procédure ? Pourquoi ?
-
Vérifier qu'une personne de 80 kg mesurant 1 mètre 80 a un IMC proche de 24.691358024691358.
Fonction
-
Écrire une fonction saisir_nom qui ne prend pas de paramètre mais renvoie le nom saisi par l'utilisateur comme chaîne de caractères.
-
Est-ce une fonction ou une procédure ? Pourquoi ?
-
Écrire une fonction nommée dire_bonjour ayant comme paramètre un mot qui affiche bonjour suivi du mot.
Exemple : dire_bonjour("Paul") affiche "Bonjour Paul !".
-
Est-ce une fonction ou une procédure ? Pourquoi ?
-
Intégrer ces deux fonctions pour faire apparaître un programme qui :
Précondition
Reprise de l'algorithme obtenu à l'exercice 4 du chapitre A1 (cf. Lien vers l'énoncé initial).
- Écrire une fonction nommée
get_moyenne qui renvoie la moyenne de trois nombres quelconques passés en arguments.
- Proposer une précondition portant sur chacun des paramètres d'entrée pour assurer que la possibilité de calculer la somme.
Fonction
Reprise de l'algorithme obtenu à l'exercice 11 du chapitre A1 (cf. Lien vers l'énoncé initial).
Écrire une fonction appelée echanger qui échange les valeurs
de deux arguments a et b.
Par exemple, echanger("mot",12) renvoie (12,"mot").
La possibilité de stocker un entier dans une variable stockant initialement une chaîne de caractères est possible en Python car c'est un langage non typé : l'interpréteur gère automatiquement le
typage. Attention ! Dans beaucoup d'autres langages de programmation, cela n'est pas possible.
Précondition
-
Documenter la fonction suivante en ajoutant un docstring.
def examen(x,y,z,t):
m=(2*x+2*y+z+t)/6
if m>=10:
print("Le candidat est reçu")
else :
print("le candidat est refusé")
return None
-
Proposer des préconditions écrites sur les variables x, y, z et t en utilisant l'instruction assert qui assurent le bon usage de cette fonction
examen.
Fonction
Voici une fonction cherche_lettre qui affiche si le caractère lettre est présent ou non dans le nom saisi nom, tout deux entrés comme paramètre de la fonction :
def cherche_lettre(nom,lettre):
if lettre in nom:
print(lettre," est dans le nom ",nom)
else:
print(lettre,"n' est pas dans le nom ",nom)
return None
-
Préciser le type de chacun des paramètres d'entrée.
-
Est-ce une fonction ou une procédure ?
-
Proposer des préconditions écrites sur les variables nom et lettre en utilisant l'instruction assert qui assurent le bon usage de cette fonction cherche_lettre.
La longueur d'une chaîne de caractères (c'est-à-dire le nomnbre de caractères) nommée chaine en Python s'obtient avec la commande len(chaine).
Travail complémentaire
Les exercices qui suivent nécessitent d'utiliser les instructions if, for ou while ainsi que des listes.
Reprise de l'algorithme obtenu à l'exercice 10 du chapitre A1 (cf. Lien vers l'énoncé initial).
Écrire une fonction get_max qui prend en paramètre une liste et renvoie le max des éléments de celle-ci.
Indications :
- Une liste en python se note entre crochet
[ ] chaque élément étant séparée d'une virgule ,.
- la longueur d'une liste nommée
liste en Python s'obtient avec la commande len(liste).
Réécriture de l'algorithme obtenu à l'exercice 12 du chapitre A1 sous forme d'une fonction (cf. Lien vers l'énoncé initial).
-
Écrire une fonction div_euclidienne qui prend en paramètre deux nombres entiers a et b, qui effectue la division euclidienne de a par b et qui renvoie
le couple (a,i), respectivement le reste et le quotient de cette division euclidienne.
Un tel couple est appelé tuple.
- Proposer des préconditions sur les paramètres
a et b afin d'assurer le bon usage de la fonction
div_euclidienne.
- Proposer des postconditions sur les deux valeurs renvoyées (
a et i) afin d'assurer le bon usage de la fonction
div_euclidienne.
Réécriture de l'algorithme obtenu à l'exercice 16 du chapitre A1 sous forme d'une fonction (cf. Lien vers l'énoncé initial).
-
Écrire une fonction get_max_position qui prend en paramètre une liste et qui renvoie le couple (le tuple) (PG,IG), respectivement la plus grande valeur de la liste et la position de cette valeur
maximale dans la liste.
Indications :
- Une liste en python se note entre crochet
[ ] chaque élément étant séparée d'une virgule.
- la longueur d'une liste nommée
liste en Python s'obtient avec la commande len(liste)
- Chaque élément d'une liste est positionné à l'aide d'un index compris entre 0 et
len(liste)-1.
- L'élément d'une liste nommée
liste positionné à l'index i est obtenu avec : liste[i].
- Proposer des postconditions sur la valeur renvoyée
IG afin d'assurer le bon usage de la fonction
get_max_position.
Exercices de renforcement
L'ensemble des exercices de renforcement sont corrigés et expliqués dans le document Jupyter accessible avec ce
lien.
On veut pouvoir convertir une durée en heures en une spéficiant le nombre de jours et le nombre d'heures correspondant. Pour cela, il suffit de créer une fonction.
-
Définir une fonction convertir_jour qui prend comme paramètre un entier duree_heure en renvoie un tuple (=couple ici) formé des deux valeurs nb_jours et
nb_heures.
-
Appeler cette fonction afin de convertir en nombres de jours 260 heures.
Voici ci-dessous une fonction qui donne le prix TTC connaissant le prix Hors Taxe pour une TVA à t% :
def TTC(HT,t):
TTC = HT * (1 + t/100)
return TTC
Améliorer le code précédent en préciser le typage de chaque paramètre et en documentant cette fonction.
Parmi les scripts suivants, le(s)quel(s) peuvent correspondre à l'utilisation de la fonction inverse pour calculer l'image de 4 :
# script 1 :
x = 4
def fct1(x):
x = 1/x
return x
# script 2 :
x = 4
def fct2():
x = 1/x
return x
# script 3 :
def fct3(x):
return 1/x
# script 4 :
x = 4
def fct4():
global x
x = 1/x
return x
Un moyen d'estimer la profondeur d'un puits est de lâcher une pierre au dessus du puits et de compter le nombre de secondes avant d'entendre le bruit du "plouf" de son entrée dans l'eau. On note $t$ la durée d'attente du "plouf" (en seconde) et $p$ le
profondeur du puits (en mètre).
On admet que les paramètres $t$ et $p$ sont liés par la relation physique suivante : $t=\sqrt{\frac{p}{4.9}}+\frac{p}{330}$.
-
Première partie : une fois la notion précondition vue
Proposer une fonction temps qui prend en paramètre la profondeur $p$ du puits et renvoie le temps $t$ d'attente du "plouf".
Penser à importer la fonction sqrt du module math.
-
Vérifier que l'on obtient l'affichage suivant pour l'exécution du script suivant :
>>>temps(30)
2.5652673874360583
-
Rajouter à votre programme deux préconditions sur $p$.
-
Seconde partie : une fois la notion postcondition vue
Rajouter à votre programme une postcondition sur le valeur renvoyée.
-
Rajouter une documentation à la fonction temps.
L'énergie cinétique d'un objet de masse $m$ (en kg) qui se déplace à la vitesse $v$ (en $m.s^{-1}$) est donnée par la formule : $E_c=\frac{1}{2}\times m \times v^2$.
- Écrire une fonction nommée
get_energie_cinetique ayant comme paramètres la masse
m et la vitesse v qui renvoie l'énergie cinétique.
- Est-ce une fonction ou une procédure ? Pourquoi ?
- Quelle est l'énergie (en Joule) d'un objet de 3 kg se déplaçant à 1.56 $m.s^{-1}$ ?
-
Écrire une fonction saisir_num_tel qui ne prend pas de paramètre mais renvoie le numéro de téléphone saisi par l'utilisateur comme chaîne de caractères.
-
Est-ce une fonction ou une procédure ? Pourquoi ?
-
Écrire une fonction nommée prevenir_message ayant comme paramètre un numéro de téléphone qui affiche "Vous allez recevoir un message de confimation au .........." où apparaît le numéro de téléphone
saisi.
Exemple : prevenir_message(0665432100) affiche "Vous allez recevoir un message de confimation au 0665432100.".
-
Est-ce une fonction ou une procédure ? Pourquoi ?
-
Intégrer ces deux fonctions pour faire apparaître un programme qui :
Reprise de l'algorithme obtenu à l'exercice 18 du chapitre A1 (cf. Lien vers l'énoncé initial).
- Écrire une fonction nommée
get_moyenne5 qui renvoie la moyenne de cinq nombres quelconques passés en arguments.
- Proposer une précondition portant sur chacun des paramètres d'entrée pour assurer que la possibilité de calculer la somme.
Reprise de l'algorithme obtenu à l'exercice 6 du chapitre A1 (cf. Lien vers l'énoncé initial).
Voici une écriture possible en langage Python de l'algorithme de cet exercice 6 sous forme de fonction :
def exo6(n):
s = 0
for i in range(1,n+1):
s = s + i
return s
-
Documenter la fonction précédente en ajoutant un docstring et préciser le typage des paramètres.
-
Proposer des préconditions écrites sur la variable n en utilisant l'instruction assert qui assurent le bon usage de cette fonction exo6.
-
Proposer un postcondition écrite sur la variable renvoyée.
Reprise de l'algorithme obtenu à l'exercice 15 du chapitre A1 (cf. Lien vers l'énoncé initial).
Voici une écriture possible en langage Python de l'algorithme de cet exercice 15 sous forme de fonction :
def exo15(phrase,lettre):
fin = ""
for elt in phrase:
if elt != lettre:
fin = fin + elt
return fin
-
Documenter la fonction précédente en ajoutant un docstring et préciser le typage de chaque paramètre.
-
Proposer des préconditions écrites sur les variables phrase et lettre en utilisant l'instruction assert qui assurent le bon usage de cette fonction exo15.
-
Proposer un postcondition écrite sur la variable renvoyée.
QCM
Questions issues de la Banque Nationale de Sujets
Propriétaire des ressources ci-dessous : ministère de l'Éducation nationale et de la jeunesse, licence CC BY SA NC
Voici une sélection de questions issues de la banque nationale de sujets, répondez à ces questions (attention, cette sélection n'est pas exhaustive).
On définit deux fonctions :
def f(x):
y = 2*x + 1
return y
def calcul(x):
y = x - 1
return f(y)
Quelle est la valeur renvoyée par l'appel calcul(5) ?
Réponses :
A- 4
B- 9
C- 11
D- 19
On exécute le code suivant
a = 2
b = 3
c = a ** b
d = c % b
Quelle est la valeur de d à la fin de l'exécution ?
Réponses :
A- 1
B- 2
C- 3
D- 4
On définit L = [2,3,5,7,-4].
En demandant la valeur de L[5], qu'obtient-on ?
Réponses :
A- -4
B- 2
C- 3
D- une erreur
On définit L = [4,25,10,9,7,13].
Quelle est la valeur de L[2] ?
Réponses :
A- 4
B- 25
C- 10
D- 9
En Python, quelle est la méthode pour charger la fonction sqrt du module math ?
Réponses :
A- using math.sqrt
B- #include math.sqrt
C- from math include sqrt
D- from math import sqrt
On exécute le script suivant :
def calcul(a,b):
a = a + 2
b = b + 5
c = a + b
return c
a,b = 3,5
calcul(a,b)
À la fin de cette exécution :
Réponses :
A- a vaut 3, b vaut 5 et c vaut 15
B- a vaut 3, b vaut 5 et c n'est pas défini
C- a vaut 5, b vaut 10 et c vaut 15
D- a vaut 5, b vaut 10 et c n'est pas défini
On exécute le script suivant :
def essai():
a = 2
b = 3
c = 4
return a
return b
return c
t = essai()
Quelle est la valeur de t après l'exécution de ce code ?
Réponses :
A- 2
B- 3
C- 4
D- (2,3,4)
La fonction suivante calcule la racine carrée du double d’un nombre flottant :
from math import sqrt
def racine_du_double(x):
return sqrt(2*x)
Quelle est la précondition sur l'argument de cette fonction ?
Réponses :
A- x
< 0
B- x >= 0
C- 2 * x > 0
D- sqrt(x) >= 0
Autres QCM
Les QCM suivants sont issus de https://genumsi.inria.fr.
(Auteur Nicolas Revéret)
On souhaite écrire un programme calculant le triple d'un nombre décimal et affichant le résultat. On a saisi le code suivant :
nombre = input("Saisir un nombre")
triple = nombre * 3
print(triple)
Un utilisateur saisit le nombre 5 lorsque l'ordinateur lui demande. Quel va être le résultat affiché ?
Réponses :
A- nombrenombrenombre
B- 555
C- 15
D- 15.0
(Auteur Nicolas Revéret)
On a saisi le code suivant :
nombre = int (input("Saisir un nombre") )
double = nombre * 2
print(double)
Quel message affiche l’ordinateur lorsque l'utilisateur saisit 8.5 ?
Réponses :
A- 16
B- 16.0
C- 17
D- L'ordinateur affiche une erreur
(Auteur Nicolas Revéret)
On a saisi le code suivant :
a = 8
b = 5
a = a + b
b = a - b
a = a - b
Quelles sont les valeurs de a et b à la fin du programme ?
Réponses :
A- a = 8 et b = 5
B- a = 8 et b = 13
C- a = 5 et b = 8
D- a = 13 et b = 5
(Auteur Christophe BEASSE)
Que contiennent les variables a et b si on execute ce script ?
def func(a):
a += 2.0
return a
a = 5.0
b = func(a)
Quelles sont les valeurs de a et b à la fin du programme ?
Réponses :
A- 5.0 et 5.0
B- 5.0 et 7.0
C- 7.0 et 5.0
D- 7.0 et 7.0
Espace vidéos
Utilisation de la console EDUPYTHON :
Présentation de JUPYTER :
Les fonctions (en mode console EDUPYTHON) :
Savoir faire et Savoir
- Écrire une affection en Python
- Afficher à l'aide de l'instruction
print
- Faire saisir depuis le clavier à l'aide de l'instruction
input
- Écrire une fonction en Python
- Écrire la documentation d'une fonction
- Écrire une précondition à l'aide de l'instruction
assert
- Écrire une postcondition à l'aide de l'instruction
assert
- Connaître la différence entre variable locale et globale