TP PYTHON CORRECTION

Transcription

1 Lycée Thiers TP PYTHON CORRECTION [Qu. 1] Les espaces ne sont pas interprétés : on peut en mettre ou non, cela ne change rien... sauf en ce qui concerne la lisibilité! Une réserve toutefois : on ne commence pas une ligne de code par un espace (sauf si cette ligne doit être indentée relativement à la précédente : pour les questions d indentation, voir par exemple les questions 33, 40 et 48). [Qu. 2] Le caractère # marque le début d un commentaire (= texte purement et simplement ignoré par l interpréteur). Un commentaire s étend jusqu au bout de la ligne. [Qu. 3] Les «opérateurs binaires» acceptent deux opérandes (l un avant l opérateur, l autre après ; par exemple : X + Y). A distinguer des «opérateurs unaires», comme par exemple le signe - (qu on utilise pour désigner l opposé d un nombre) ou encore le not (opérateur booléen de négation). [Qu. 4] L évaluation de ces deux expressions donne respectivement le quotient et le reste de la division euclidienne de 100 par 7, c est-à-dire 14 et 2. [Qu. 5] L opérateur / permet d effectuer une division entre deux nombres décimaux (type float) : le résultat est de type float. L opérateur // permet quant à lui de calculer le quotient de la division euclidienne d un entier (type : int) par un autre, et le résultat est de type int. [Qu. 6] L évaluation de (125 // 8) * 8 équivaut à celle de 15 * 8 et donne ainsi 120, alors que l évaluation de (125 / 8) * 8 donne (attention : le premier résultat est de type int et le second de type float). [Qu. 7] L évaluation de 1/3 + 1/3 + 1/3 + 1/3 + 1/3 + 1/3 donne et non pas 2.0 comme on pouvait s y attendre. Cette anomalie provient de la représentation en machine des nombres de type float : cette représentation n est qu approchée et il en résulte d inévitables erreurs d arrondi dans les calculs. [Qu. 8] L expression est de type float. D une façon générale, la combinaison au sein d une même expression des types int et float donnera un résultat de type float. [Qu. 9] L évaluation de 3 < 3 donne False. Celle de 3 <= 3 donne True. [Qu. 10] L évaluation de (2 > 0) and not (32 % 8 == 0) équivaut à celle de True and not True. Elle donne donc False. [Qu. 11] L évaluation de type(3) == type(3.0) donne False, ce qui est logique puisque les expressions 3 et 3.0 sont de types distincts (int et float respectivement). [Qu. 12] Le nombre n est qu une valeur aprochée de la fraction 1/7, et pourtant le système considère ces deux valeurs comme égales. A nouveau, cette anomalie est à mettre sur le compte d une représentation des nombres qui n est qu approchée avec le type float. [Qu. 13] L affectation u = u + v augmente de 5 la valeur de u (qui passe donc à 15). Ensuite, l affectation v = u + v augmente de 15 la valeur de v (qui passe à 20). Au final, on calcule u - v, ce qui donne -5. [Qu. 14] Ces instructions ont pour effet de permuter les valeurs de a et b. La variable t est utilisée pour stocker temporairement la valeur initiale de a : ceci évite que cette valeur ne soit perdue lors de l affectation a = b qui suit. [Qu. 15] Le système détecte une chaîne de caractères de longueur 1 (la chaîne c ) suivie de quelque chose qui est syntaxiquement incorrect.

2 TP PYTHON CORRECTION 2 [Qu. 16] L expression len( Hello * len( Hello )) équivaut à len( Hello * 5), c est-à-dire à len( HelloHelloHelloHelloHello ), ce qui donne finalement 25. [Qu. 17] Les variables de type str ne sont pas modifiables : l affectation s[0] = S est illégale. [Qu. 18] On peut proposer : s[0] == s[len(s) - 1] ou plus simplement : s[0] == s[-1] [Qu. 19] Etant donnée une chaîne de caractères s, l évaluation de type(s) == type(s[0]) donne True. Cela nous apprend qu en Python, les caractères qui composent une chaîne sont eux-mêmes de type str (ce sont des chaînes de longueur 1). [Qu. 20] A l issue des instructions suivantes : s = tangente t = hyperbole k = 2 x = # chaine vide x = x + t[k] k = k - 1 x = x + t[k] k = k - 1 x = x + s[k] x = x + t[1 // 2] + t[-3] + s[len(s) // 4] la valeur de x sera python. En effet : après... la valeur de x est... la valeur de k est... x = x + t[k] p k = k x = x + t[k] py k = k x = x + s[k] pyt Ensuite, l expression t[1 // 2] + t[-3] + s[len(s) // 4] est équivalente à t[0] + t[-3] + s[2], c est-à-dire à h + o + n ou encore hon. D où le résultat annoncé. [Qu. 21] La liste [1, [2, 3], [4, [5, 6]]] est de longueur 3. [Qu. 22] La valeur de l expression [1, 2, 3] == [1, [2, 3]] est False (ces deux listes ne sont déjà pas de même longueur!) [Qu. 23] A l issue des instructions suivantes : x = [1, 2] x = x + [1 + len(x)] x = [1, 2, x] la valeur de x sera [1, 2, [1, 2, 3]] [Qu. 24] L expression len([1, 2] + [3, [4] + [5, 6]]) a pour valeur 4 (on concatène deux listes de longueur 2). [Qu. 25] En écrivant : x = len([1,2,3] * 10) < 40

3 TP PYTHON CORRECTION 3 on définit une variable x de type bool (et de valeur True puisque la chaîne [1, 2, 3] * 10 est de longueur 30). [Qu. 26] A l issue des instructions suivantes : x = [] x.append(1) x.append([2,3]) x.extend([3,4]) la valeur de x sera [1, [2, 3], 3, 4] [Qu. 27] On vérifie à la main que 13, 64, 87 et 89 ne sont pas des nombres de Lychrel. [Qu. 28] La fonction ceil calcule la partie entière par excès de son argument. Elle va de pair avec la fonction floor, qui calcule la partie entière par défaut de son argument. En anglais : ceil = plafond et floor = plancher. [Qu. 29] L affichage de la valeur de p est instantané (ce qui est plutôt impressionant, vue la taille plus qu astronomique de cet entier!). Pour connaître le nombre de chiffres décimaux de p, il n est évidemment pas question de les compter à l écran! En revanche, comme le suggèrent les exemples vus juste avant la question 28, on peut évaluer : >>> ceil(log10( * 2 ** )) ce qui donne tout de même chiffres. Attention, la formule générale donnant le nombre N q de chiffres décimaux d un entier q 1 est : N q = log 10 ( q ) + 1 La formule log 10 ( q ) donnera le même résultat tant que l entier q n est pas une puissance de 10. [Qu. 30] L expression len(str( * 2 ** )) donne aussi le nombre de chiffres décimaux de l entier qui nous intéresse. Disons qu il s agit là d une méthode plus «informatique», alors que la formule encadrée ci-dessus correspond à une méthode plus «mathématique». [Qu. 31] Aucune réponse attendue ici. [Qu. 32] L expression randint(1,6) produit un entier au hasard entre 1 et 6 (bornes incluses). C est une façon de simuler le lancer d un dé (équilibré). [Qu. 33] Comment modifier le dernier script pour qu il affiche, x+y, x et y, exclusivement lorsque x+y>6 est vraie. Il suffit de faire : x = randint(1,6); y = randint(1,6) if (x+y) > 6 : print(x+y) print(x) print(y) et attention à l identation! [Qu. 34] Le script ci-dessous x = randint(1,6); y = randint(1,6) print((x+y>6)*(str(x+y)+ \n +str(x)+ ; +str(y))) n affichera rien si la condition x + y > 6 n est pas remplie, car dans ce cas la valeur de l expression x + y > 6 est False et cette valeur est (implicitement) convertie en l entier 0 : l argument de print est donc une chaîne vide. Si, en revanche, la valeur de x + y > 6 est True, alors cette valeur est convertie en l entier 1 : si par exemple x, y valent respectivement 5 et 3, l argument de print sera la chaîne :

4 8 + \n ; + 3 d où l affichage : 8 5 ; 3 [Qu. 35] Le script : if randint(0,1) == 0 : print( Pile ) print( Face ) ne marche pas! Il faut réduire l identation du «else» : if randint(0,1) == 0 : print( Pile ) print( Face ) [Qu. 36] Script modifié : x = randint(0,1) if x == 0: print( Pile ) print( Face ) [Qu. 37] Script modifié : from math import sqrt for x in [0, 0.5, 1, 1.5, 2, 3, 4] : print( (, x,,, sqrt(x + 1), ) ) Voici l affichage obtenu : ( 0, 1.0 ) ( 0.5, ) ( 1, ) ( 1.5, ) ( 2, ) ( 3, 2.0 ) ( 4, ) TP PYTHON CORRECTION 4 [Qu. 38] La fonction range renvoie un objet de la classe range. Un tel objet est un «itérable», ce qui signifie que l on peut déclencher une boucle en le parcourant. Une chaîne de caractères est aussi un itérable, comme on le constate avec : for i in hello : print(i) ce qui produit l affichage suivant :

5 TP PYTHON CORRECTION 5 h e l l o Autre exemple d itérable : une liste (cf. question 37). [Qu. 39] En remplaçant range(1,5) par range(0,4), rien ne change. C est normal puisque le corps de la boucle ne fait pas intervenir k ; ainsi seule compte la longueur de la boucle. Il n en irait pas de même si l on avait écrit par exemple : u = 1 for k in range(1,5): u = u ** 2 + k print(u) Cette fois-ci, le remplacement de range(1,5) par range(0,4) ne serait plus sans effet! [Qu. 40] Il suffit d indenter l instruction d affichage de manière à ce qu elle fasse partie intégrante du corps de la boucle : u = 1 for k in range(1,5): u = u ** print(u) [Qu. 41] Il est impossible de prévoir le nombre de fois que le corps de la boucle s effectuera. On sait seulement à quelle condition il sera exécuté : si la valeur de x est distincte de 1. [Qu. 42] On n est même pas certain que la boucle se termine!! Il se pourrait a priori que l entier x, produit au hasard, ne prenne jamais la valeur 1. Mais cet événement a fort peu de chances de se produire... [Qu. 43] Script modifié : x = 0; n = 0 while x!= 1: x = randint(1,6) print(x) n = n+1 print( Nombre de lancers du dé :, n) [Qu. 44] On peut ré-écrire le script initial sans utiliser de variable : n = 0 while randint(1,6)!= 1: n = n + 1 print( Nombre de lancers du dé :, n) En revanche, ce n est pas le cas du script modifié (cf. question 43). En effet, si l on envisage ceci : x = 0; n = 0 while randint(1,6)!= 1: print(randint(1,6)) n = n+1 print( Nombre de lancers du dé :, n)

6 TP PYTHON CORRECTION 6 la fonction randint est invoquée deux fois à chaque tour, ce qui va généralement produire deux résultats différents! [Qu. 45] La valeur de la variable x est augmentée de 1/4. [Qu. 46] La suite de terme général H k = diverge vers +. Ce résultat (qu on démontrera k en cours de maths) explique qu on finit toujours, quelle que soit la valeur de l entier n > 1, par trouver un entier k pour lequel : k 1 < n k [Qu. 47] Le script suivant effectue le travail demandé : k_list = [] for n in [10, 11, 12, 13, 14, 15]: x=1 ; k=1 while x < n : k = k+1 x = x+1/k k_list.append(k) print(k_list) for i in range(0,5): print(k_list[i+1] / k_list[i]) Quelques valeurs du quotient k n+1 /k n : n k n k n+1 /k n Ces valeurs évoquent fortement la constante e (base du logarithme népérien). Cela s explique (comme en le verra en cours de maths) par le fait que tend vers + «comme» k ln (k). De façon précise, on peut montrer que : [Qu. 48] Le script suivant répond à la question : lim k k ln (k) a = int(input( Point de départ : )) n = int(input( Rang du terme à calculer : )) u = a for k in range(0,n): if u % 2 == 0: u = u // 2 u = 3 * u + 1 print(u) = 1

7 TP PYTHON CORRECTION 7 En identant la dernière ligne d un cran vers la droite, on obtient l affichage de tous les termes calculés (et pas seulement du dernier). [Qu. 49] Si u n = 1 pour un certain n, alors les suivants sont 4, 2, 1, 4, 2, 1,... on entre dans une boucle sans fin. Le fait que, quel que soit le point de départ a choisi, on finisse toujours par atteindre ce cycle, autrement dit l existence d un rang n pour lequel u n = 1, est un problème ouvert! Les expériences menées à ce jour suggèrent que cette suite finit toujours par tomber sur le cycle (4, 2, 1), mais personne ne sait le prouver. Si vous avez une idée, vous serez gentils de nous en parler : ça nous permettra de passer à la postérité :) Le script suivant calcule, pour différentes valeurs de a, le plus petit n pour lequel u n = 1 : for a in range(2, 101): u = a k = 0 while u!= 1: if u % 2 == 0: u = u // 2 u = 3 * u + 1 k = k + 1 print( a =, a, k =, k) [Qu. 50] Image-miroir d une chaîne de caractères : s = input( Entrer une chaîne de caractères : ) L = len(s) miroir_s = for k in range(0, L): miroir_s = miroir_s + s[l k] print(miroir_s) [Qu. 51] La méthode «reverse and add» : n = int(input( Entrer un entier n : )) q = 0 # Nombre d étapes s = str(n) L = len(s) miroir_s = for k in range(0, L): miroir_s = s[k] + miroir_s while miroir_s!= s: q = q + 1 n = n + int(miroir_s) print(n) s = str(n) L = len(s) miroir_s = for k in range(0, L): miroir_s = s[k] + miroir_s print("nombre d étapes = ", q)

8 TP PYTHON CORRECTION 8 Par exemple : Entrer un entier n : Nombre d étapes = 24