420-SN1-RE - Programmation en sciences - Semaines 1 et 2
Ce test de pratique couvre tout ce qu'on a vu aux semaines 1 et 2 : variables, conditions, boucles, listes, recherche, fonctions, dictionnaires, numpy, fichiers et graphiques. Réponds à tout, puis clique sur Corriger mes réponses. Les parties A à D et F sont corrigées automatiquement ; pour la partie E (écrire du code), le corrigé s'affiche et tu t'auto-évalues. Recommençable autant de fois que tu veux.
Choisis VRAI ou FAUX. 2 points par question.
return sert à la fonction pour retourner le fruit de son travail.
return, la fonction ne renvoie rien (None).np.array([1, 2, 3]) * 2 donne [2 4 6] (chaque élément est multiplié).
for tour in range(5): exécute son bloc de code 5 fois.
tour = 0, 1, 2, 3, 4.plt.show() sert à afficher le graphique déjà préparé à l'écran.
Choisis la bonne réponse - ou toutes les bonnes réponses quand la question le demande. 2 points par question.
13 % 4 ?
% est le modulo : le reste de la division de 13 par 4 (13 = 3 × 4 + 1).calculer ?
def calculer(): (mot-clé def, parenthèses, deux-points).{ } avec des paires clé: valeur. a) est une liste, c) une chaîne, d) un nombre.eleves = [
{"nom": "Maya", "note": 88},
{"nom": "Liam", "note": 73},
]
Que vaut eleves[1]["nom"] ?
"Liam". eleves[1] est le 2e dictionnaire (l'indice commence à 0), puis ["nom"] en lit la valeur.matplotlib.pyplot (souvent importé comme plt).len(maListe)csv :
with open("mesures.csv") as fichier:
for ligne in fichier:
valeurs = ligne.split(",")
Que contient valeurs à chaque tour de boucle ?
split(",") découpe la ligne en une liste de chaînes : les nombres restent du texte. Pour calculer avec, il faut les convertir (int(...) ou float(...)).inventaire = {
"fruits": ["pomme", "kiwi", "prune"],
"outils": ["marteau"],
}
Que vaut inventaire["fruits"][2] ?
"prune". inventaire["fruits"] donne la liste, puis [2] en prend le 3e élément (l'indice commence à 0).catalogue = [
{"titre": "Python", "prix": 30},
{"titre": "Algèbre", "prix": 25},
]
Comment décrit-on le mieux catalogue ?
catalogue est une liste [ ] dont chaque élément est un dictionnaire { } (paires clé: valeur). C'est la forme typique d'un tableau de fiches (ex. les lignes d'un CSV).temperature) est égale ou plus petite que 0 ? Coche toutes les bonnes réponses.
<= 0 couvre « plus petit OU égal » ; not (temperature > 0) dit la même chose (si ce n'est pas plus grand que 0, c'est donc ≤ 0). b) < 0 exclut le 0, et d) >= 0 teste l'inverse.Écris exactement ce qui s'affiche à l'écran. La correction ignore les espaces et la casse des majuscules.
masse = 1 volume = 10 print(masse / volume)
0.1 (la division / donne toujours un nombre décimal).print(23 // 2, 23 % 2)
11 1 (// = quotient entier : 23 = 11 × 2 + 1 ; % = reste, ici 1 car 23 est impair).temperature = 4
if temperature < 0:
print("Glace")
elif temperature < 100:
print("Liquide")
else:
print("Vapeur")
Liquide (4 n'est pas < 0, mais il est < 100).population = 2
generations = 0
while population < 20:
population = population * 2
generations = generations + 1
print(generations)
4. (2→4 g1 ; 4→8 g2 ; 8→16 g3 ; 16→32 g4 ; 32 n'est plus < 20, on arrête.)mesures = [3.1, 4.5, 2.0, 9.8, 5.5] print(mesures[1]) print(mesures[-1]) print(mesures[1:3])
4.5, 5.5 (le dernier), [4.5, 2.0] (indices 1 et 2, le 3 est exclu).return :
def calculerAireRectangle(largeur, hauteur):
return largeur * hauteur
print(calculerAireRectangle(3, 4))
12def calculer():
total = 10
return total
print(total)
NameError). total est une variable locale à la fonction calculer : elle n'existe pas à l'extérieur. Pour s'en servir dehors, il faut la retourner et la récupérer : resultat = calculer().planete = {"nom": "Mars", "lunes": 2}
print(planete["nom"])
print(planete["lunes"] + 1)
Mars et 3.main = [
{"valeur": "Roi", "couleur": "Pique"},
{"valeur": "As", "couleur": "Trèfle"},
]
for carte in main:
if carte["couleur"] == "Trèfle":
print(carte["valeur"], "♣")
else:
print(carte["valeur"], carte["couleur"])
Roi Pique et As ♣. La boucle visite chaque carte ; le if détecte le trèfle et affiche le symbole ♣ à la place du mot.import numpy as np temperatures = np.array([10, 20, 30, 40]) print(temperatures.mean()) print(temperatures * 2)
25.0 (la moyenne) et [20 40 60 80] (chaque élément ×2).Choisis VRAI ou FAUX. 2 points par question.
def s'exécute toute seule, même si on ne l'appelle jamais.
def ne fait que définir la fonction ; il faut l'appeler pour l'exécuter.plt.bar() trace un diagramme à barres, tandis que plt.plot() trace une courbe.
tableau.mean() calcule la moyenne des éléments.
return.Écris ton code Python ci-dessous. Après correction, compare au corrigé et auto-évalue-toi.
convertirCelsiusVersFahrenheit(celsius) qui renvoie la température en degrés Fahrenheit. Formule : celsius × 9 / 5 + 32. Ensuite, appelle-la, stocke sa valeur dans une variable et affiche le résultat.
def convertirCelsiusVersFahrenheit(celsius):
return celsius * 9 / 5 + 32
resultat = convertirCelsiusVersFahrenheit(100)
print(resultat) # 212.0eleve avec une clé "nom" valant "Maya" et une clé "note" valant 85.
eleve = {"nom": "Maya", "note": 85}temperatures = [12, 18, 25, 9, 30]. Écris le code qui affiche seulement les températures supérieures à 15.
temperatures = [12, 18, 25, 9, 30]
for temperature in temperatures:
if temperature > 15:
print(temperature)1, et tu ne veux pas écrire de boucle. Avec numpy (np), crée ce tableau dans cellules, puis affiche sa longueur et sa première valeur.
cellules = np.ones(1000) print(len(cellules), cellules[0]) # 1000 1.0
np.ones(1000) fabrique d'un coup un tableau de 1000 fois 1.0 - aucune boucle nécessaire. (np.zeros ferait pareil avec des 0.)np), crée un tableau mesures contenant 6.0, 4.0 et 5.5. Affiche le tableau trié, puis sa médiane : la valeur du milieu une fois le tableau trié.
mesures = np.array([6.0, 4.0, 5.5]) triees = np.sort(mesures) print(triees) # [4. 5.5 6. ] milieu = triees[len(triees) // 2] print(milieu) # 5.5 (valeur du milieu)
np.sort() rend une copie triée du tableau. La médiane d'un nombre impair de valeurs est alors la case du milieu : on trouve son indice avec len(triees) // 2 (division entière).scores = [
{"joueur": "Zoe", "points": 120},
{"joueur": "Max", "points": 95},
]
Écris une boucle for qui affiche, pour chaque entrée, le joueur et ses points.
for entree in scores:
print(entree["joueur"], entree["points"])
Chaque entree est un dictionnaire ; on lit ses clés "joueur" et "points". Affichage : Zoe 120 puis Max 95.scores.
scores.append({"joueur": "Marc", "points": 0})
append() ajoute un nouvel élément à la fin de la liste - ici un dictionnaire. La liste scores compte maintenant 3 joueurs.ligne contient "tulipe;15;5.5" : l'item acheté, la quantité et son prix. Écris le code qui en extrait les 3 valeurs, puis affiche le nom de l'item et la multiplication quantité × prix.
ligne = "tulipe;15;5.5"
valeurs = ligne.split(";")
nom = valeurs[0]
quantite = int(valeurs[1])
prix = float(valeurs[2])
print(nom) # tulipe
print(quantite * prix) # 82.5
split(";") rend des chaînes : il faut int() et float() avant de multiplier (sinon Python répéterait le texte au lieu de calculer).estSimilaire qui reçoit deux nombres réels et vérifie s'ils sont presque égaux, en acceptant une différence maximale égale à la constante TOLERANCE. Appelle-la avec nombre1 = 5, nombre2 = 5.001 et TOLERANCE = 0.1, et affiche le résultat.
TOLERANCE = 0.1
def estSimilaire(nombre1, nombre2):
return abs(nombre1 - nombre2) <= TOLERANCE
print(estSimilaire(5, 5.001)) # True
On compare l'écart entre les deux nombres (abs(...) = valeur absolue) à la tolérance. Ici l'écart vaut 0.001, bien en dessous de 0.1 : True. C'est ainsi qu'on compare des décimaux, car == est risqué avec les flottants.estPair(nombre) qui renvoie True si le nombre est pair, False sinon (indice : le modulo %). Teste-la en affichant estPair(4).
def estPair(nombre):
return nombre % 2 == 0
print(estPair(4)) # TrueGlisse chaque étiquette dans la bonne case. 1 point par bonne association.
.csv.json.xml.py.xlsx.csv → valeurs séparées par des virgules · .json → paires clé-valeur · .xml → balises <...> · .py → programme Python · .xlsx → classeur de tableur.tableaux numpy · chaque ligne d'un fichier → une boucle for · retrouver vite des données par leur nom → un dictionnaire · traiter deux sortes de données différemment → if / else · tracer un graphique → matplotlib.