Physique, Chimie et Informatique > Terminales Spé. NSI > Révisions de notions de 1ère
Revisions sur la structure de liste en Python
Exercice 1
Écrire une fonction qui reçoit comme argument une liste de nombres à virgule et recherche lequel est le plus grand et lequel est le plus petit.
La spécification de la fonction est la suivante :
defminmax(liste:list[float])->tuple[float]:"""
Retourne un tuple constitué des valeurs minimale
et maximale de la liste
"""
Solution
defminmax(liste:list[float])->tuple[float]:"""
Retourne un tuple constitué des valeurs minimale
et maximale de la liste
"""val_min=liste[0]val_max=liste[0]foriinrange(1,len(liste)-1):ifliste[i]>val_max:val_max=liste[i]ifliste[i]<val_min:val_min=liste[i]returnval_min,val_max
Exercice 2
Écrire une fonction qui reçoit comme argument une liste et détermine le nombre d’éléments dans la liste.
Ne pas utiliser la fonction len du langage.
La spécification de la fonction est la suivante :
deflongueur(liste:list[float])->int:"""
Retourne le nombre d'éléments dans la
liste
"""
Solution
deflongueur(liste:list[float])->int:"""
Retourne le nombre d'éléments dans la
liste
"""longueur=0foriinrange(len(liste)):longueur+=1returnlongueur
Exercice 3
Écrire une fonction qui simule le tirage du Loto. Pour rappel, il s’agit de tirer aléatoirement 6 entiers compris entre 1 et 49.
Remarque. Un numéro ne peut apparaître qu’une seule fois. Il est donc nécessaire de stocker le résultat de chaque tirage dans une liste et de vérifier s’il est présent ou pas.
La spécification de la fonction est la suivante :
defloto()->list[int]:"""
Simule le tirage du Loto. retourne une liste de 6 entiers compris
entre 1 et 49.
"""
Solution
defloto()->list[int]:"""
Simule le tirage du Loto. retourne une liste de 6 entiers compris
entre 1 et 49.
"""tirages=[]nbre_valeurs=6whilelen(tirages)<=nbre_valeurs:tirage=randint(1,49)iftiragenotintirages:tirages.append(tirage)returntirages
Exercice 4
Écrire une fonction qui reçoit une liste de notes comprises entre 0 et 20 comme argument et retourne la moyenne de ces notes et le pourcentage de ces notes comprises dans les intervalles : [0, moy - 3], [moy - 3, moy + 3] et [moy + 3, 20] où moy est la valeur moyenne des notes.
La signature de la fonction est :
defstatistiques(notes:List[float])->Tuple[float]:"""
Détermine les statistiques des notes reçues
en argument : moyenne et notes comprises dans
les intervalles [0, moy - 3[, [moy - 3, moy + 3[,
[moy + 3, 20]
"""
Cette fonction doit utiliser les deux fonctions de signature :
defmoyenne(liste_notes:List[float])->float:"""
Détermine la moyenne des notes reçues en
argument dans la liste passée en argument.
"""
et
defnombre_dans_intervalle(liste:List[float],valeur_min:float,valeur_max:float)->float:"""
Détermine le nombre de valeurs de liste
comprises dans l'intervalle [val_min, val_max[.
"""
Exercice 5
Écrire une fonction qui, partir de deux points de l’espace à trois dimensions, calcule la distance euclidienne entre ces deux points.
Remarque. Les coordonnées d’un point sont stockées dans un tuple.
La spécification de la fonction est :
defdistance(pt1:tuple[float],pt2:tuple[float])->float:"""
Détermine la distance entre les points pt1 et
pt2.
ERREUR si les dimensions des tuples ne
correspondent pas.
"""
Exercice 6
Reprendre l’exercice précédent et considérer que les points appartiennent à un espace de dimension N (N étant potentiellement grand).
La spécification de la fonction est :
defdistanceN(pt1:Tuple[float],pt2:Tuple[float])->float:"""
Détermine la distance entre les points pt1 et
pt2.
ERREUR si les dimensions des tuples ne
correspondent pas.
"""
Solution
frommathimportsqrtdefdistanceN(pt1:tuple[float],pt2:tuple[float])->float:"""
Détermine la distance entre les points pt1 et
pt2.
ERREUR si les dimensions des tuples ne
correspondent pas.
"""iflen(pt1)!=len(pt2):raiseException("Les dimensions ne correspondent pas !")carre_distance:float=0foriinrange(len(pt1)):carre_distance+=(pt2[i]-pt1[i])**2returnsqrt(carre_distance)
Exercice 7
Écrire une fonction qui retourne une la table de multiplication de tous les nombres entiers compris entre 0 et n sous forme d’une liste de listes.
La spécification de la fonction est :
deftable_multiplication(n:int)->list[list[int]]:"""
Détermine la table de multiplication de tous les
entiers compris entre 1 et n.
>>> table_multiplication(4)
[[1, 2, 3, 4], [2, 4, 6, 8], [3, 6, 9, 12], [4, 8, 12, 16]]
"""
Solution
deftable_multiplication(n:int)->list[list[int]]:"""
Détermine la table de multiplication de tous les
entiers compris entre 1 et n.
>>> table_multiplication(4)
[[1, 2, 3, 4], [2, 4, 6, 8], [3, 6, 9, 12], [4, 8, 12, 16]]
"""table=[]foriinrange(1,n+1):ligne=[]forjinrange(1,n+1):ligne.append(i*j)table.append(ligne)returntable
Physique, Chimie et Informatique > Terminales Spé. NSI > Révisions de notions de 1ère
Revisions sur les strucures de boucle en Python
Travail à effectuer
Exercice 1
Écrire et exécuter une fonction qui retourne une chaîne de caractères formée par une suite des 10 premiers termes de la table de multiplication d’un entier a passé en argument.
La spécification de la fonction est :
defmultiplication(a:int)->str:"""
Retourne une chaîne de caractères formées des 10 premiers
nombres de la table de multiplication de a.
>>> multiplication(7)
'7 14 21 28 35 42 49 56 63 70 '
"""
Solution
defmultiplication(a:int)->str:"""
Retourne une chaîne de caractères formées des 10 premiers
nombres de la table de multiplication de a.
>>> multiplication(7)
'7 14 21 28 35 42 49 56 63 70 '
"""chaine_retour=""nbre_tours_boucle=10# for i in range(1, nbre_tours_boucle + 1):# chaine_retour += str(a * i)# chaine_retour += " "i=1whilei<=nbre_tours_boucle:chaine_retour+=str(a*i)chaine_retour+=" "i+=1returnchaine_retour
Exercice 2
Écrire et exécuter une fonction qui retourne une chaîne de caractères formée par une suite des 10 premiers termes de la table de multiplication d’un entier a passé en argument en signalant au passage (à l’aide d’un astérisque) ceux qui sont des multiples de 3.
La spécification de la fonction est :
defmultiplication_multiple_trois(a:int)->str:"""
Retourne une chaîne de caractères formées des 10 premiers
nombres de la table de multiplication de a en signalant au
passage ceux qui sont des multiples de 3.
>>> multiplication_multiple_trois(2)
'2 4 6* 8 10 12* 14 16 18* 20 '
>>> multiplication_multiple_trois(7)
'7 14 21* 28 35 42* 49 56 63* 70 '
"""
Solution
defmultiplication_multiple_trois(a:int)->str:"""
Retourne une chaîne de caractères formées des 10 premiers
nombres de la table de multiplication de a en signalant au
passage ceux qui sont des multiples de 3.
>>> multiplication_multiple_trois(2)
'2 4 6* 8 10 12* 14 16 18* 20 '
>>> multiplication_multiple_trois(7)
'7 14 21* 28 35 42* 49 56 63* 70 '
"""chaine_retour=""nbre_tours_boucle=10foriinrange(1,nbre_tours_boucle+1):resultat_multiplication=a*ichaine_retour+=str(resultat_multiplication)ifresultat_multiplication%3==0:chaine_retour+="*"chaine_retour+=" "returnchaine_retour
Exercice 3
Écrire et exécuter une fonction qui calcule les 50 premiers termes de la table de multiplication d’un nombre a passé en argument mais qui retourne une chaîne de caractères formée seulement par ceux qui sont des multiples de 7.
La spécification de la fonction est :
defmultiplication_multiple_sept(a:int)->str:"""
Calcule les 50 premiers termes de la table de a mais retourne
une chaîne de caractères contenant uniquement les multiples de 7.
>>> multiplication_multiple_sept(2)
'14 28 42 56 70 84 98 '
>>> multiplication_multiple_sept(9)
'63 126 189 252 315 378 441 '
"""
Solution
defmultiplication_multiple_sept(a:int)->str:"""
Calcule les 50 premiers termes de la table de a mais retourne
une chaîne de caractères contenant uniquement les multiples de 7.
>>> multiplication_multiple_sept(2)
'14 28 42 56 70 84 98 '
>>> multiplication_multiple_sept(9)
'63 126 189 252 315 378 441 '
"""chaine_retour=""nbre_tours_boucle=50foriinrange(1,nbre_tours_boucle+1):resultat_multiplication=a*iifresultat_multiplication%7==0:chaine_retour+=str(resultat_multiplication)chaine_retour+=" "returnchaine_retour
Exercice 4
Écrire et exécuter une fonction qui calcule et retourne une chaîne de caractères formée de la liste des diviseurs du nombre passé en argument.
La spécification de la fonction est :
defdiviseurs(a:int)->str:"""
Retourne une chaîne de caractères formée de la liste des diviseurs
de a.
>>> diviseurs(18)
'18 9 6 3 2 1 '
"""
Solution
defdiviseurs(a:int)->str:"""
Retourne une chaîne de caractères formée de la liste des diviseurs
de a.
>>> diviseurs(18)
'18 9 6 3 2 1 '
"""chaine_retour=""diviseur_possible=a# while diviseur_possible >= 1:# if a % diviseur_possible == 0:# chaine_retour += str(diviseur_possible)# chaine_retour += " "# diviseur_possible -= 1foriinrange(a,0,-1):# i est diviseur possibleifa%i==0:chaine_retour+=str(i)chaine_retour+=" "returnchaine_retour
Exercice 5
Écrire une fonction qui retourne une chaîne de caractère formée des 10 premiers termes de la table de multiplication de 1 à 10. Le caractère de passage à la ligne \n doit être utilisé afin de séparer les différentes tables (de 2, de 3, etc.).
Remarque : Utiliser deux boucles imbriquées.
La spécification de la fonction est :
deftable_multiplication()->str:"""
Retourne la table de multiplication des nombres de 1 à 10.
"""
Solution
deftable_multiplication()->str:"""
Retourne la table de multiplication des nombres de 1 à 10.
"""chaine_retour=""nbre_termes=10foriinrange(1,nbre_termes+1):forjinrange(1,nbre_termes+1):chaine_retour+=str(i*j)chaine_retour+=" "chaine_retour+="\n"returnchaine_retour
Remarque : Afin de visualiser le résultat sous forme d’un tableau, utiliser l’instruction suivante, dans la console, pour tester la fonction :
>>>print(table_multiplication())
Exercice 6
Écrire et exécuter une fonction qui demande 10 nombres à l’utilisateur et qui détermine lequel est le plus grand et lequel est le plus petit. Les deux résultats sont retournés au sein d’une unique chaîne de caractères.
Remarque : la fonction qui permet de récupérer du texte entré au clavier est input :
valeur=float(input("Entrez votre valeur : "))
La specification de la fonction est :
defplus_grand_plus_petit()->str:"""
Demande à l'utilisateur d'entrer 10 valeurs et retourne une
chaîne de caractères formée des deux valeurs max et min.
"""
Solution
defplus_grand_plus_petit()->str:"""
Demande à l'utilisateur d'entrer 10 valeurs et retourne une
chaîne de caractères formée des deux valeurs max et min.
"""nbre_tours=10valeur_max=float("-inf")# Plus petite valeur possiblevaleur_min=float("inf")# Plus grande valeur possibleforiinrange(1,nbre_tours+1):valeur=float(input(f"Entrez la valeur {i} : "))ifvaleur>valeur_max:valeur_max=valeurifvaleur<valeur_min:valeur_min=valeurreturnf"Min : {valeur_min}, Max : {valeur_max}"
Exercice 7
Reprendre l’exercice précédent mais en faisant en sorte que le nombre de valeurs demandées à l’utilisateur soit passé en argument à la fonction.
Solution
defplus_grand_plus_petit(nbre_tours:int)->str:"""
Demande à l'utilisateur d'entrer 10 valeurs et retourne une
chaîne de caractères formée des deux valeurs max et min.
"""valeur_max=float("-inf")# Plus petite valeur possiblevaleur_min=float("inf")# Plus grande valeur possibleforiinrange(1,nbre_tours+1):valeur=float(input(f"Entrez la valeur {i} : "))ifvaleur>valeur_max:valeur_max=valeurifvaleur<valeur_min:valeur_min=valeurreturnf"Min : {valeur_min}, Max : {valeur_max}"
Exercice 8
Écrire et exécuter une fonction qui demande à l’utilisateur d’entrer 10
notes et qui retourne la moyenne de ces notes.
La spécification de la fonction est :
defmoyenne()->float:"""
Demande 10 notes à l'utilisateur et retourne la moyenne.
"""
Solution
defmoyenne()->float:"""
Demande 10 notes à l'utilisateur et retourne la moyenne.
"""nbre_notes=10total_notes=0foriinrange(nbre_notes):note=float(input(f"Entrez la note {i+1} : "))total_notes+=notereturntotal_notes/nbre_notes
Exercice 9
Modifier le programme précédent de façon à ce que le nombre de notes à prendre en compte soit passé en argument de la fonction.
Solution
defmoyenne(nbre_notes:int)->float:"""
Demande 10 notes à l'utilisateur et retourne la moyenne.
"""total_notes=0foriinrange(nbre_notes):note=float(input(f"Entrez la note {i+1} : "))total_notes+=notereturntotal_notes/nbre_notes
Exercice 10
Modifier le programme précédent de façon à ce que l’utilisateur n’ait pas à indiquer le nombre de notes qu’il souhaite saisir. Une note négative terminer la saisie.
Remarque : la fonction doit afficher le nombre de notes saisies.
Solution
defmoyenne_auto()->tuple[int,float]:"""
Demande des notes à l'utilisateur tant que ce dernier
ne rentre pas une note négative.
Retourne le nombre de notes et la moyenne.
"""nbre_notes=0total_notes=0stop=Falsewhilenotstop:note=float(input(f"Entrez la note {nbre_notes+1} : "))ifnote<0:stop=Trueelse:total_notes+=notenbre_notes+=1return(nbre_notes,total_notes/nbre_notes)
Exercice 11
Écrire et exécuter une fonction qui simule un tirage du Loto.
La spécification de la fonction est
Remarque. Normalement, lorsqu’un numéro est tiré, il ne peut pas apparaître à nouveau. On acceptera cependant qu’un même numéro puisse apparaitre plusieurs fois puisqu’on ne connaît pas encore de structure de contrôle qui permet de facilement « stocker » plusieurs valeurs.
Écrire et exécuter une fonction qui tire au hasard un nombre entier compris entre 1 et 50 et demande à l’utilisateur de le deviner.
Cette fonction doit indiquer à l’utilisateur si sa tentative est trop grande ou trop petite et quitter dès l’instant où il a deviné le nombre en indiquant le nombre de tentatives.
Remarque. La fonction ne doit rien retourner, elle doit utiliser la fonction print pour afficher à l’écran les informations. Sa spécification est
defdevine()->None:"""
Déterminer aléatoirement un nombre compris en 1 et 50 et demande à l'utilisateur de le deviner.
La fonction affiche des messages qui aident l'utilisateur dans recherche et quitte dès que cette dernière est fructueuse.
"""
Solution
defdevine()->None:"""
Déterminer aléatoirement un nombre compris en 1 et 50 et demande à l'utilisateur de le deviner.
La fonction affiche des messages qui aident l'utilisateur dans recherche et quitte dès que cette dernière est fructueuse.
"""nbre_a_deviner=randint(1,50)nbre_tentatives=0trouve=Falsewhilenottrouve:proposition=int(input("Entrez votre proposition : "))nbre_tentatives+=1ifproposition==nbre_a_deviner:trouve=Trueelifproposition>nbre_a_deviner:print("La proposition est trop grande !")else:print("La proposition est trop petite !")print(f"Nombre de tentatives : {nbre_tentatives}")
Exercice 13
Écrire et exécuter une fonction qui affiche l’alphabet à l’endroit si elle reçoit l’argument "croissant" ou à l’envers si elle reçoit l’argument "decroissant".
Remarque. On peut obtenir le code décimal d’un caractère à l’aide de la fonction ord. À l’opposé, le caractère correspondant à un entier naturel dans la table ASCII est obtenu (si possible) à l’aide de la fonction chr.
La spécification de la fonction est
defalphabet(sens:str)->str:"""
Retourne les lettres de l'alphabet en fonction de la chaîne de caractères
passée en argument.
Les valeurs possibles pour cet argument sont 'croissant' ou 'decroissant'.
Code ascii [97; 122]
"""
Solution
defalphabet(sens:str)->str:"""
Retourne les lettres de l'alphabet en fonction de la chaîne de caractères
passée en argument.
Les valeurs possibles pour cet argument sont 'croissant' ou 'decroissant'.
Code ascii [97; 122]
"""ifsens=="croissant":debut_code,fin_code,increment,pas=97,122,1,1else:debut_code,fin_code,increment,pas=122,97,-1,-1rep=""foriinrange(debut_code,fin_code+increment,pas):rep+=chr(i)returnrep
Exercice 14
Écrire et exécuter une fonction qui détermine les n premiers termes de la « suite de Fibonacci » définie par :
u1u2un=1=1=u(n−1)+u(n−2) pour n>2
Cette fonction doit recevoir en argument la valeur de n et retourner la suite de nombres sous forme de chaîne de caractères. Spécification de la fonction :
deffibo(n:int)->str:"""
Retourne les n premiers termes de la suite de Fibonacci.
"""
Solution
deffibo(n:int)->str:"""
Retourne les n premiers termes de la suite de Fibonacci.
"""rep="0 1 "u=0v=1foriinrange(2,n):z=u+vrep+=str(z)+" "u=vv=zreturnrep
Physique, Chimie et Informatique > Terminales Spé. NSI > Révisions de notions de 1ère
Héron d'Alexandrie
Héron d’Alexandrie est un ingénieur, un mécanicien et un
mathématicien grec du premier siècle après J.-C.
On ne sait pas grand chose de la vie d’Héron, si ce n’est qu’il était
originaire d’Alexandrie ; les historiens se sont même longtemps
divisés sur l’époque où il a vécu. Leurs estimations allaient
du 1er siècle avant J.-C. au 3ème siècle de
notre ère. Aujourd’hui, la querelle est éteinte : il est clairement
établi que Héron est postérieur à Vitruve mort en −20, et
contemporain de Pline l’Ancien (23 – 79), en étant actif autour de l’an
62. Il a donc bien vécu au 1er siècle après J.-C. et sans
doute au début du 2ème siècle, donc sous l’Empire romain,
mais dans l’Alexandrie grecque.
On attribue à Héron d’Alexandrie plusieurs formules mathématiques
et une méthode efficace d’extraction de racine carrée,
c’est-à-dire de résolution de l’équation x2=a, avec a
positif :
Info
Choisir une première valeur raisonnable que l’on note G.
Améliorer cette valeur en calculant la moyenne des valeurs G et x/G.
Vérifier si cette nouvelle valeur convient.
Reprendre l’étape 2 tant que la valeur calculée n’est pas satisfaisante.
L’objectif de cette activité est de mettre en œuvre cette méthode en Python.
Travail à réaliser
Le fichier réponse devra se terminer par les instructions afin de pouvoir y placer les jeux de tests pour les différentes fonctions (on découvrira la signification de cette instruction dans quelques jours).
if__name__=="__main__":
Qu’appelle-t-on la documentation d’une fonction ? La spécification d’une fonction ?
Avertissement
Toute fonction doit être accompagnée de sa spécification !
Définir la fonction moyenne dont la spécification est
defmoyenne(a:float,b:float)->float:"""Calcule et retourne la moyenne des deux nombres a et b
passés en argument.
"""
Ajouter le jeu de test suivant à la fin du fichier :
assertmoyenne(12,16)==14assertmoyenne(0,8)==4
Réponse
defmoyenne(a:float,b:float)->float:"""
Calcule et retourne la moyenne des deux nombres a et b
passés en argument.
"""return(a+b)/2
Définir la fonction valeur_absolue dont la spécification est :
defvaleur_absolue(x:float)->float:"""
Calcule et retourne la valeur absolue du nombre x passé en argument.
"""
Remarque.
Il est interdit d’utiliser la fonction abs intégrée à Python.
Ajouter le jeu de test suivant à la fin du fichier :
defpuissance(x:float,n:int)->float:"""
calcule et retourne le résultat de x à la puissance entière n :
x^n = x . x . x . ... . x (n fois)
"""res=1foriinrange(1,n+1):res*=xreturnres
Définir la fonction amelioration_essai dont la spécification est :
defamelioration_essai(essai:float,x:float)->float:"""Calcule et retourne la moyenne des nombres essai (strictement positif)
et x/essai.
"""
Remarque.
Cette fonction doit utiliser la fonction moyenne définie plus haut.
Ajouter le jeu de test suivant à la fin du fichier :
defamelioration_essai(essai:float,x:float)->float:"""
Calcule et retourne la moyenne des nombres essai (strictement positif) et x/essai.
"""returnmoyenne(essai,x/essai)
Définir le prédicat est_suffisamment_bon dont la spécification est :
defest_suffisamment_bon(essai:float,x:float)->bool:"""
Retourne True si la valeur absolue de la différence du carré du nombre essai
et du nombre x est inférieure à une tolérance donnée (prendre 0.001).
Retourne False sinon.
"""
Remarque.
Cette fonction doit utiliser les fonctions valeur_absolue et puissance définies ci-dessus.
Ajouter le jeu de test suivant à la fin du fichier :
defest_suffisamment_bon(essai:float,x:float)->bool:"""
Retourne True si la valeur absolue de la différence du carré du nombre essai
et du nombre x est inférieure à une tolérance donnée (prendre 0.001).
Retourne False sinon.
"""tolerance=0.001returnvaleur_absolue(puissance(essai,2)-x)<tolerance
Définir la fonction test qui implémente l’algorithme de Héron d’Alexandrie. La spécification de la fonction est :
deftest(essai:float,x:float)->float:"""
Retourne la racine carrée du nombre x. Le calcul est effectué grâce à un
raisonnement itératif depuis une première valeur strictement positive notée essai.
"""
Remarque.
Cette fonction doit utiliser les fonctions est_suffisamment_bon et amelioration_essai.
Ajouter le jeu de test suivant à la fin du fichier :
deftest(essai:float,x:float)->float:"""
Retourne la racine carrée du nombre x. Le calcul est effectué grâce à un
raisonnement itératif depuis une première valeur strictement positive notée
essai.
"""whilenotest_suffisamment_bon(essai,x):essai=amelioration_essai(essai,x)returnessai
Définir la fonction racine_carree dont la spécification est :
defracine_carree(x:float)->float:"""
Retourne le résultat de l'appel de la fonction test avec la valeur 1
pour l'argument essai.
"""
Ajouter le jeu de test suivant à la fin du fichier :