Plaidoyer pour la console Python

mardi 7 décembre 2021
par  Alain BUSSER

La console (shell chez Casio) de Python ne fait qu’une chose, mais elle le fait bien :

  1. elle attend que l’utilisateur entre une expression (informatique)
  2. elle évalue cette expression (c’est-à-dire qu’elle détermine sa valeur à l’aide d’une stratégie d’évaluation (informatique) ; en effet une expression a une valeur, c’est connu depuis les encyclopédistes)
  3. elle affiche le résultat de cette évaluation.

Elle le fait de façon répétitive, et son usage permet de familiariser les élèves avec la notion même d’expression, ce qui facilite grandement l’apprentissage ultérieur de Python et même de l’algèbre et de la logique.

  1. >>> 6*7
  2. 42
  3. >>> 3e-2
  4. 0.03
  5. >>> 2<3<5
  6. True
  7. >>> 4 in range(8)
  8. True
  9. >>> 2+2==4
  10. True
  11. >>> True or not True
  12. True
  13. >>> from math import pi
  14. >>> type(pi)
  15. <class 'float'>
  16. >>> 1/float('inf')
  17. 0.0
  18. >>>

Télécharger

Accès à la console

La console s’appelle souvent shell : on la voit comme une coque séparant le moteur Python de l’utilisateur. En fait l’image du génie d’Aladin est plus parlante :

à ceci près que

  • la console n’exauce pas seulement 3 vœux mais, aveu, autant de vœux qu’on veut
  • les vœux que l’on donne à la console sont en fait des expressions Python à évaluer.

Au lieu de dire « maître quel est le prochain souhait que tu veux que j’exauce ? », le génie se contente d’afficher trois chevrons :

  1. >>>

Unix

Dans un terminal Linux ou Mac, il suffit d’écrire la commande python3 pour transformer la console bash en une console Python :

  1. ♟️ python3
  2. Python 3.4.2 (default, Feb  7 2019, 09:32:19)
  3. [GCC 4.9.2] on linux
  4. Type "help", "copyright", "credits" or "license" for more information.
  5. >>> 6*7
  6. 42
  7. >>>

Télécharger

Numworks

Sur la calculatrice Numworks, on commence par aller vers l’application python :

On sélectionne cette application par appui sur le bouton OK puis on descend avec la flèche vers le bas pour descendre en dessous des scripts :

Un autre appui sur OK suffit alors à ouvrir la console :

Ti

Sur la Ti 83 Premium CE Edition Python, on constate qu’il y a écrit apps au-dessus du bouton résol. En faisant 2nde résol on ouvre donc le menu des applications. Parmi celles-ci on choisit Python (évidemment !) et à ce moment on voit apparaître un menu en bas de l’écran. Dans ce menu, le texte shell apparaît juste au-dessus du bouton trace. En appuyant sur ce bouton, on accède alors au « shell » qui n’est autre que la console Python.

Casio

Sur la Graph 90+E ou la Graph 35+EII, appuyer sur le bouton MENU permet de naviguer parmi les applications. Là évidemment on choisit celle qui s’appelle Python puis on appuye sur EXE. On voit alors un menu en bas de l’écran. Parmi les entrées de ce menu, le mot SHELL est juste au dessus de la touche F4. Un appui sur la touche F4 permet donc de démarrer le « shell », également appelé console Python.

Shell

Dans beaucoup de logiciels permettant de programmer en Python, est présente une fenêtre appelée « shell » et permettant d’interagir avec Python : c’est la fameuse console présentée ici. On la voit notamment dans

  • IDLE
  • PyCharm
  • Spyder
  • Thonny
  • Anaconda
  • Pyzo

etc.

Basthon

En ligne, il y a aussi une console dans Basthon. Et le site repl.it comme son nom l’indique, permettait d’expérimenter sur une console. Hélas, ce site est devenu payant.

Capytale aussi possède une console Python.

Skulpt aussi possède une console.

Gimp

Si vous faites du traitement d’image, le logiciel Gimp a sa console (c’est un filtre photo) appelée python-fu.

Le logiciel Blender aussi a une console Python. On l’ouvre en cliquant sur « Python console », elle s’ouvre alors à la place de la vue 3D, de la timeline etc.

La console Python ne fait qu’une chose, mais cette chose s’avère extrêmement utile pour l’apprentissage simultané de Python, et des mathématiques (en particulier l’algèbre). Dans la suite de cet article, on verra des exemples qui ont déjà été donnés en classe (en particulier en voie technologique) en quelques heures [1].

expressions numériques

Théoriquement, les élèves qui arrivent au lycée savent déjà ce qu’est une expression, puisqu’ils ont eu l’occasion de les manipuler

Dans les deux cas, il faut cliquer sur l’expression (bloc vert) pour voir apparaître dans un phylactère, le résultat de l’évaluation.

En Python, on écrit le « calcul » au clavier, puis on appuie sur la touche « entrée » pour voir affiché le résultat de l’évaluation :

  1. >>> 6*7
  2. 42

Télécharger

Entiers

L’addition se note + en Python, cela ne pose pas de poblème. Mais il est bon de laisser aux élèves le temps de se le rappeler. Quant au signe « - », il a deux significations selon qu’on le considère comme un signe (entier négatif) ou une soustraction :

  1. >>> +2
  2. 2
  3. >>> 5-2
  4. 3
  5. >>> -2
  6. -2
  7. >>> 0-2
  8. -2
  9. >>> 3-5
  10. -2

Télécharger

Alors que les notations + et - sont naturelles pour l’addition et la soustraction, il faut quand même, à un moment, expliquer aux élèves comment on note, en Python, les autres opérations.

Le principe est le même que dans les calculatrices : le nombre zéro est sous-entendu devant le signe de soustraction et -2 désigne le nombre 0-2 en fait.

La multiplication se note par un astérisque en Python. Mais il y a plusieurs divisions possibles, l’une renvoyant un flottant (voir onglet suivant), l’autre renvoyant un entier :

  1. >>> 6*7
  2. 42
  3. >>> 22/7
  4. 3.142857142857143
  5. >>> 22//7
  6. 3
  7. >>> 22%7
  8. 1
  9. >>> divmod(22,7)
  10. (3, 1)
  11. >>> 1/0
  12. Traceback (most recent call last):
  13.   File "<stdin>", line 1, in <module>
  14. ZeroDivisionError: division by zero

Télécharger

Le quotient entier, en Python, se note donc par un double slash. Attention à ne pas s’imaginer qu’il suffise de le dire une seule fois aux élèves ! L’algorithme donnant ce quotient entier (nombre maximum de fois qu’on peut soustraire le dividende au diviseur sans que le résultat soit négatif) est au programme de 2nde. On constate au passage que Python ne sait pas diviser par zéro, ou plutôt qu’il sait qu’on ne peut pas diviser par zéro.

La division euclidienne ne donne pas qu’un quotient, elle donne aussi un reste. Ce reste se note par le symbole « pourcent » en Python. On reverra cette no(ta)tion plus bas, lorsqu’on abordera la divisibilité. Mais déjà, on peut résoudre ce genre de problème :

Sept mille secondes après minuit, quelle heure est-il ?

Déjà, 7000 secondes, cela fait 116 minutes et 40 secondes :

  1. >>> 7000//60
  2. 116
  3. >>> 7000%60
  4. 40
  5. >>> 116//60
  6. 1
  7. >>> 116%60
  8. 56

Télécharger

Ensuite, 116 minutes font une heure 56 minutes. La solution de l’exercice est donc une heure cinquante six minutes quarante secondes.

Après les 4 opérations, voici la cinquième : l’exponentiation

  1. >>> 2**3
  2. 8
  3. >>> 3**2
  4. 9

Télécharger

L’exponentiation se note par un double astérisque en Python, et on peut vérifier que cette opération n’est pas commutative.

L’avantage de la calculatrice est que les élèves apprennent, à leurs dépens (ou plutôt ceux de la calculatrice) à éviter les trop grands nombres :

  1. >>> 2021**2021

C’est aussi l’occasion de vérifier que x0 est égal à 1 et autres souvenirs du collège (notamment sur les priorités opératoires) :

  1. >>> 3**0
  2. 1
  3. >>> 10**0
  4. 1
  5. >>> 10**2
  6. 100
  7. >>> 10**3
  8. 1000
  9. >>> 2**3*5**3
  10. 1000

Télécharger

Algèbre

Python connaît les règles de priorité opératoire, et les parenthèses. Noter que l’usage de crochets ou accolades en guise de parenthèses extérieures, ne convient pas.

Les exemples suivants peuvent donner lieu à des « questions flash » :

  1. >>> 2*5-7
  2. 3
  3. >>> 5*3+4
  4. 19
  5. >>> 5+3*4
  6. 17
  7. >>> 2*10**2
  8. 200
  9. >>> 5*(3+4)
  10. 35
  11. >>> (2*3-1)*(5+3*4)
  12. 85
  13. >>> (2*3-1)-(5+3*4)
  14. -12
  15. >>> (2+3*(5-2))
  16. 11
  17. >>> (2+3*(5-2))*4
  18. 44
  19. >>> -5**2
  20. -25
  21. >>> (-5)**2
  22. 25

Télécharger

Un énoncé typique serait

À quoi s’évalue l’expression Python suivante ?
>>> 2+3*(5-2)

(voire la version sans chevrons ; pour insister sur la présence d’une expression).

réels

En Python, les nombres réels sont modélisés par des flottants. En première approximation, on peut considérer les flottants comme réels :

  1. >>> -5**2
  2. -25
  3. >>> (-5)**2
  4. 25
  5. >>> 3.0
  6. 3.0
  7. >>> 2+3
  8. 5
  9. >>> 2+3.0
  10. 5.0

Télécharger

La convention, typique des calculatrices, de ne pas exiger l’écriture d’un chiffre zéro s’il n’y a pas d’ambigüité, est connue également de Python :

  1. >>> .2+.3
  2. 0.5
  3. >>> .1+.2
  4. 0.30000000000000004

Télécharger

On voit sur l’exemple ci-dessus que certains décimaux ne peuvent être représentés exactement comme des flottants.

Python connaît l’écriture scientifique :

  1. >>> 2*10**3
  2. 2000
  3. >>> 2e3
  4. 2000.0
  5. >>> 2e-3
  6. 0.002

Télécharger

Là encore on peut multiplier les questions flash, cette fois-ci sur les ordres de grandeur et les écritures scientifiques :

  1. >>> 1.25e7*3.2e-5
  2. 400.0

Télécharger

(corrigé sans Python : 1,25×107*3,2×10-5=1,25×3,2×107×10-5=4×107-5=4×102=400)

En apparence, Python ne connaît pas le nombre e. En fait il suffit de l’importer depuis le module math pour bénéficier d’une valeur approchée :

  1. >>> e
  2. Traceback (most recent call last):
  3.   File "<stdin>", line 1, in <module>
  4. NameError: name 'e' is not defined
  5. >>> from math import e
  6. >>> e
  7. 2.718281828459045

Télécharger

En soumettant à la fonction float l’argument « inf » on construit un flottant particulier, noté ∞ :

  1. >>> float('inf')+2
  2. inf
  3. >>> float('inf')-2
  4. inf
  5. >>> float('inf')*2
  6. inf
  7. >>> float('inf')/2
  8. inf

Télécharger

On lit que ∞+2=∞-2=∞×2=∞/2=∞. En fait d’autres limites usuelles de fonctions non moins usuelles apparaissent :

  1. >>> 1/float('inf')
  2. 0.0
  3. >>> 0/float('inf')
  4. 0.0
  5. >>> float('inf')**2
  6. inf
  7. >>> from math import exp
  8. >>> exp(float('inf'))
  9. inf
  10. >>> exp(-float('inf'))
  11. 0.0

Télécharger

Python connaît même certaines formes indéterminées :

  1. >>> float('inf')-float('inf')
  2. nan
  3. >>> float('inf')*0
  4. nan

Télécharger

complexes

Comme la console Python peut rester utile après la 2nde, on peut aussi s’en servir pour effectuer des calculs sur les nombres complexes. Il suffit de savoir que le nombre i est appelé 1j en Python :

  1. >>> 1+2j
  2. (1+2j)
  3. >>> (1j)**2
  4. (-1+0j)
  5. >>> 1+2j+3-5j
  6. (4-3j)
  7. >>> (1+2j)*(3-5j)
  8. (13+1j)
  9. >>> (1+1j)/(4+3j)
  10. (0.28+0.04j)

Télécharger

Pour connaître la partie réelle, la partie imaginaire (deux réels), le conjugué et le module de 4+3i, on a essentiellement à se souvenir que « module » se dit abs en Python :

  1. >>> (4+3j).real
  2. 4.0
  3. >>> (4+3j).imag
  4. 3.0
  5. >>> (4+3j).conjugate()
  6. (4-3j)
  7. >>> abs(4+3j)
  8. 5.0

Télécharger

En évaluant de nombreuses expressions faisant apparaître des nombres complexes, les élèves de STI2D ont plus de chance de pouvoir conjecturer (donc mémoriser) le fait que si deux nombres complexes sont conjugués, alors leur somme et leur produit sont réels.

variables

Pour entrer l’expression (768/1024+1)*((768/1024)**2-5*768/1024+2)*(768/1024-1) il peut être commode de mémoriser une fois pour toutes que x=768/1024 et ensuite évaluer l’expression (x+1)*(x**2-5*x+2)*(x-1) afin de ne pas trop souvent écrire 768/1024 :

  1. >>> x = 768/1024
  2. >>> (x+1)*(x**2-5*x+2)*(x-1)
  3. 0.51953125

Télécharger

L’association entre le nom x et la valeur 768/1024 est une variable. L’espace des variables (globales) peut être consultée depuis la console :

  1. >>> globals()
  2. {'x': 0.75, ......}

Télécharger

None

Associer une valeur (comme 768/1024) à une variable, c’est faire une affectation. Ce genre d’expression ne s’affiche pas dans la console. En fait elle s’évalue à None et c’est None qui ne s’affiche pas :

  1. >>> None
  2. >>> from math import pi
  3. >>> from fractions import *
  4. >>> Fraction(768,1024)
  5. Fraction(3, 4)

Télécharger

Une expression qui s’évalue à None (et donc ne s’affiche pas) s’appelle une instruction. On en a déjà vu deux sortes :

  • l’importation de fonctions ou de constantes depuis un module
  • l’affectation d’une variable

On en verra d’autres plus bas, comme la définition d’une fonction...

En tout cas, l’affectation d’une variable consiste à forcer sa valeur à être le résultat de l’évaluation d’une expression. On voit que l’affectation se note par un signe d’égalité (choix malheureux) en Python.

  1. >>> x = 2
  2. >>> globals()
  3. {'x': 2, ......}
  4. >>> x = 5
  5. >>> globals()
  6. {'x': 5, ......}

Télécharger

évaluation

Les variables sont des expressions comme les autres, on peut donc les évaluer.

Pour évaluer une variable, la règle est simple : une variable s’évalue à sa valeur :

  1. >>> x = 5
  2. >>> globals()
  3. {'x': 5, ......}
  4. >>> globals()['x']
  5. 5

Télécharger

Lorsque la console Python voit un nom de variable (comme x), elle va donc l’évaluer en regardant dans le dictionnaire ce que signifie ce nom x et comme dans le dictionnaire globals(), il est rappelé que x vaut 5, la console évalue x à 5 :

  1. >>> x = 5
  2. >>> x
  3. 5
  4. >>> x+1
  5. 6
  6. >>> (x+1)*(x-1)
  7. 24
  8. >>> 2**x
  9. 32
  10. >>> x
  11. 5

Télécharger

Comme on le voit, il suffit donc d’entrer le nom d’une variable pour que la console donne sa valeur, et cela ne modifie pas la valeur de la variable.

Par exemple, pour incrémenter un compteur, il faut non seulement calculer la somme entre ce compteur et 1, mais mettre le résultat de l’addition dans le compteur :

  1. >>> compteur = 0
  2. >>> compteur + 1
  3. 1
  4. >>> compteur
  5. 0
  6. >>> compteur = compteur +1
  7. >>> compteur
  8. 1

Télécharger

underscore

Dans la console, il y a une variable spéciale, dont le nom est une espace soulignée (ou « tiret du 8 », en anglais underscore) et qui mémorise la dernière expression évaluée. On peut s’en servir comme compteur, en évaluant répétitivement sa somme avec 1 :

  1. >>> 0
  2. 0
  3. >>> _
  4. 0
  5. >>> _+1
  6. 1
  7. >>> _+1
  8. 2
  9. >>> _+1
  10. 3
  11. >>> _+1
  12. 4
  13. >>> _+1
  14. 5

Télécharger

En fait il s’agit ici d’un cas particulier de suite arithmétique dont la raison est 1, mais d’autres suites arithmétiques peuvent être calculées ainsi. Et même des suites géométriques, ou plus compliquées, comme celle-ci qui converge vers le nombre d’or :

  1. >>> 1
  2. 1
  3. >>> 1+1/_
  4. 2.0
  5. >>> 1+1/_
  6. 1.5
  7. >>> 1+1/_
  8. 1.6666666666666665
  9. >>> 1+1/_
  10. 1.6
  11. >>> 1+1/_
  12. 1.625
  13. >>> 1+1/_
  14. 1.6153846153846154
  15. >>> 1+1/_
  16. 1.619047619047619
  17. >>> 1+1/_
  18. 1.6176470588235294
  19. >>> 1+1/_
  20. 1.6181818181818182
  21. >>> 1+1/_
  22. 1.6179775280898876
  23. >>> 1+1/_
  24. 1.6180555555555556
  25. >>> 1+1/_
  26. 1.6180257510729614
  27. >>> 1+1/_
  28. 1.6180371352785146

Télécharger

types

La fonction type permet de connaître le type d’un objet. Avec un nombre elle s’évalue en général à int (si le nombre est entier) ou float (sinon) :

  1. >>> type(3)
  2. <class 'int'>
  3. >>> type(4/2)
  4. <class 'float'>
  5. >>> type(5.2)
  6. <class 'float'>
  7. >>> type(pi)
  8. <class 'float'>

Télécharger

On verra plus bas d’autres types (booléens, ensembles, listes...).

Par extension, le type de la valeur d’une variable (ce à quoi elle s’évalue, vue comme expression) est appelé type de la variable.

logique

Les expressions ne sont pas toutes numériques. Les expressions logiques sont particulièrement utiles en Python.

ordre

Python connaît les relations d’ordre et même les encadrements :

  1. >>> 2+2 == 4
  2. True
  3. >>> 2+2 == 5
  4. False
  5. >>> 2 != 3
  6. True
  7. >>> 2 < 3
  8. True
  9. >>> 2 < 3 < 5
  10. True
  11. >>> 2 <= 3
  12. True
  13. >>> 2 < 2
  14. False
  15. >>> 2 <= 2
  16. True

Télécharger

On remarque que l’égalité est notée par un double signe égal, en effet le simple signe d’égalité a déjà été pris pour noter l’affectation comme on l’a vu dans la partie sur les variables.

Booléens

La logique aristotélicienne est également à la portée de Python.

négation

  1. >>> not True
  2. False
  3. >>> not False
  4. True

Télécharger

conjonction

  1. >>> False and False
  2. False
  3. >>> False and True
  4. False
  5. >>> True and False
  6. False
  7. >>> True and True
  8. True

Télécharger

Disjonction

  1. >>> False or False
  2. False
  3. >>> False or True
  4. True
  5. >>> True or False
  6. True
  7. >>> True or True
  8. True

Télécharger

range

Une relation importante est celle d’appartenance. Elle s’applique entre entiers et collections d’entiers comme range :

  1. >>> range(5)
  2. range(0, 5)
  3. >>> -1 in range(5)
  4. False
  5. >>> 0 in range(5)
  6. True
  7. >>> 1 in range(5)
  8. True
  9. >>> 2 in range(5)
  10. True
  11. >>> 3 in range(5)
  12. True
  13. >>> 4 in range(5)
  14. True
  15. >>> 5 in range(5)
  16. False
  17. >>> 6 in range(5)
  18. False
  19. >>> 1.25 in range(5)
  20. False

Télécharger

Faire évaluer par les élèves, plusieurs dizaines d’expressions de ce genre, est un bon moyen de les aider à conceptualiser la notion de « range », ce qui s’avèrera utile par la suite lorsqu’on abordera les boucles.

Un autre moyen de visualiser un « range » est de lui appliquer la fonction list (voir plus bas) :

  1. >>> list(range(5))
  2. [0, 1, 2, 3, 4]

Télécharger

divisibilité

Le fait que l’entier a est divisible par l’entier b se voit au reste de la division euclidienne de a par b : la divisibilité est caractérisée par la nullité de ce reste euclidien.

Par exemple pour voir si des nombres sont pairs :

  1. >>> 1%2 == 0
  2. False
  3. >>> 3%2 == 0
  4. False
  5. >>> 2021%2 == 0
  6. False
  7. >>> 100%2 == 0
  8. True

Télécharger

Pour voir si des nombres sont divisibles par 7 :

  1. >>> 100%7 == 0
  2. False
  3. >>> 49%7 == 0
  4. True
  5. >>> 21%7 == 0
  6. True
  7. >>> 22%7 == 0
  8. False
  9. >>> 2021%7 == 0
  10. False

Télécharger

Et pour voir si des nombres sont divisibles à la fois par 5 et par 7 :

  1. >>> 35%5==0 and 35%7==0
  2. True
  3. >>> 45%5==0 and 45%7==0
  4. False
  5. >>> 135%5==0 and 135%7==0
  6. False

Télécharger

On aborde ici la notion de diviseurs communs :

  1. >>> 24%8==0 and 16%8==0
  2. True
  3. >>> 24%6==0 and 16%6==0
  4. False
  5. >>> 24%1==0 and 16%1==0
  6. True
  7. >>> 24%4==0 and 16%4==0
  8. True

Télécharger

On verra plus bas, dans la partie sur les listes, ce qu’on peut faire avec les diviseurs communs.

Hasard

Les simulations du hasard sont dans le module random (mot anglais issu du vieux français, qui signifie ... hasard !) :

  1. >>> from random import *

Un dé

Pour simuler le lancer d’un dé, il y a la fonction randint. On lui fournit les bornes (typiquement 1 et 6) :

  1. >>> from random import randint
  2. >>> randint(1,6)
  3. 4
  4. >>> randint(1,6)
  5. 4
  6. >>> randint(1,6)
  7. 6
  8. >>> randint(1,6)
  9. 5
  10. >>> randint(1,6)
  11. 6
  12. >>> randint(1,6)
  13. 1
  14. >>> randint(1,6)
  15. 5

Télécharger

Cela permet de simuler des dés à 4 faces, 8 faces, 12 faces, 20 faces comme dans les jeux de rôle (ou Mathador), mais aussi des dés difficiles à réaliser comme par exemple à 13 faces :

  1. >>> randint(1,13)
  2. 8
  3. >>> randint(1,13)
  4. 5
  5. >>> randint(1,13)
  6. 5
  7. >>> randint(1,13)
  8. 1

Télécharger

Deux dés

Pour jouer à des jeux de déplacement comme le jeu de l’oye, il suffit d’additionner les résultats de lancers de dés :

  1. >>> randint(1,6) + randint(1,6)
  2. 12
  3. >>> randint(1,6) + randint(1,6)
  4. 8
  5. >>> randint(1,6) + randint(1,6)
  6. 7
  7. >>> randint(1,6) + randint(1,6)
  8. 10
  9. >>> randint(1,6) + randint(1,6)
  10. 9
  11. >>> randint(1,6) + randint(1,6)
  12. 4
  13. >>> randint(1,6) + randint(1,6)
  14. 8
  15. >>> randint(1,6) + randint(1,6)
  16. 6
  17. >>> randint(1,6) + randint(1,6)
  18. 7

Télécharger

On peut avec cette technique, explorer le problème du Duc de Toscane ou d’autres jeux comme le senet où on lançait des bâtons tombant sur pile ou face :

  1. >>> randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)
  2. 1
  3. >>> randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)
  4. 3
  5. >>> randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)
  6. 1
  7. >>> randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)
  8. 5
  9. >>> randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)
  10. 5
  11. >>> randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)
  12. 4
  13. >>> randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)
  14. 4
  15. >>> randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)+randint(0,1)
  16. 1

Télécharger

probabilités

On lance un dé, mais on essaye de savoir quelles sont les chances que l’on a, d’avoir un résultat de moins que 5. Pour cela on définit les événements

  • Ω (univers de probabilité)
  • A « le dé donne moins que 5 »
  • B « le dé donne un résultat impair » :
  1. >>> Omega = {1,2,3,4,5,6}
  2. >>> A = {1,2,3,4}
  3. >>> B = {1,3,5}

Télécharger

Alors il est possible de calculer les intersection, réunion et contraire d’événements :

  1. >>> A.intersection(B)
  2. {1, 3}
  3. >>> A.union(B)
  4. {1, 2, 3, 4, 5}
  5. >>> Omega.difference(A)
  6. {5, 6}

Télécharger

Euler définissait une probabilité comme « quotient du nombre de cas favorables par le nombre de cas possibles ». Il est donc possible avec la console de calculer P(A) :

  1. >>> cas_favorables = len(A)
  2. >>> cas_possibles = len(Omega)
  3. >>> cas_favorables/cas_possibles
  4. 0.6666666666666666

Télécharger

Buffon

Pour simuler l’aiguille de Buffon, on a intérêt à utiliser la fonction random du module éponyme :

  1. >>> from math import pi
  2. >>> from random import random
  3. >>> random()
  4. 0.5280980025290867
  5. >>> random()<2/pi
  6. False
  7. >>> random()<2/pi
  8. True
  9. >>> random()<2/pi
  10. False
  11. >>> random()<2/pi
  12. False
  13. >>> random()<2/pi
  14. True
  15. >>> random()<2/pi
  16. False
  17. >>> random()<2/pi
  18. True
  19. >>> random()<2/pi
  20. True
  21. >>> random()<2/pi
  22. True

Télécharger

fonctions

Au bout de quelques heures passées à évaluer des expressions dans la console, les élèves peuvent décrire ce qu’est une expression :

  • un nombre, un booléen sont des expressions
  • une variable est une expression
  • la somme, la différence, le produit, le quotient de deux expressions sont des expressions
  • une expression entre parenthèses reste une expression
  • en appliquant une fonction à une expression, on obtient une expression

Et comme disait Gödel, « rien d’autre n’est une expression, que ce qui est décrit ci-dessus ».

Les fonctions déjà utilisées ci-dessus sont abs (module d’un complexe), exp (exponentielle de base e), float (conversion en flottant), globals (espace des variables), range (voir plus bas les listes) et type (type d’un objet, d’une variable). En plus des fonctions vues en probabilité : random, randint et len (longueur).

Maths

Python ne semble, à première vue, pas très fort en trigonométrie :

  1. >>> cos(0)
  2. Traceback (most recent call last):
  3.   File "<stdin>", line 1, in <module>
  4. NameError: name 'cos' is not defined
  5. >>> from math import cos
  6. >>> cos(0)
  7. 1.0
  8. >>> cos(90)
  9. -0.4480736161291701

Télécharger

En fait, lorsqu’une fonction n’est pas disponible dans la console, c’est souvent parce qu’elle se trouve dans un module et il faut d’abord importer ce module pour pouvoir appeler la fonction. Pour les maths, on s’en doute, le module math est approprié. Donc pour faire des maths en Python, il faut mieux commencer par importer tout ce qui est dans le module math :

  1. >>> from math import *
  2. >>> cos(radians(90))
  3. 6.123233995736766e-17
  4. >>> cos(pi/2)
  5. 6.123233995736766e-17

Télécharger

Un exemple important est la racine carrée (square root en anglais) :

  1. >>> sqrt(8)
  2. 2.8284271247461903
  3. >>> 2*sqrt(2)
  4. 2.8284271247461903
  5. >>> sqrt(25)
  6. 5.0
  7. >>> sqrt(25) == 5
  8. True
  9. >>> sqrt(float('inf'))
  10. inf
  11. >>> sqrt(2)/2
  12. 0.7071067811865476
  13. >>> sin(pi/4)
  14. 0.7071067811865475

Télécharger

Pour calculer des distances euclidiennes, on a besoin de la racine de la somme des carrés de deux nombres. Le mot hypot est en fait le début de hypoténuse :

  1. >>> hypot(4,3)
  2. 5.0
  3. >>> hypot(12,5)
  4. 13.0
  5. >>> hypot(1,1)
  6. 1.4142135623730951

Télécharger

Le logarithme népérien ne se note pas ln mais log :

  1. >>> e
  2. 2.718281828459045
  3. >>> exp(1)
  4. 2.718281828459045
  5. >>> log(e)
  6. 1.0
  7. >>> log(1/e)
  8. -1.0

Télécharger

IMC

Pour calculer un IMC avec Python, on a un problème :

  1. >>> imc(1.8,82)
  2. Traceback (most recent call last):
  3.   File "<stdin>", line 1, in <module>
  4. NameError: name 'imc' is not defined

Télécharger

La fonction imc n’existe pas en Python. Le module imc non plus :

  1. >>> from imc import *
  2. Traceback (most recent call last):
  3.   File "<stdin>", line 1, in <module>
  4. ModuleNotFoundError: No module named 'imc'

Télécharger

C’est maintenant, et maintenant seulement, qu’on va utiliser autre chose que la console [2] : on va le créer, ce module imc. Pour cela, on passe à un éditeur de texte et on y tape le code suivant :

  1. def imc(taille,masse):
  2.     return masse/taille**2

Télécharger

puis on l’enregistre sous le nom imc.py et ensuite on peut dans la console, calculer des IMC :

  1. >>> from imc import *
  2. >>> imc(1.8,82)
  3. 25.30864197530864

Télécharger

Docteur

On peut améliorer le module pour maintenant utiliser la fonction qu’on vient de définir :

  1. def imc(taille,masse):
  2.     return masse/taille**2
  3.  
  4.  
  5. def docteur(taille,masse):
  6.     i = imc(taille,masse)
  7.     s = "le patient "
  8.     if 18 <= i <= 25:
  9.         s = s + "est sain"
  10.     elif i < 18:
  11.         s = s + "doit prendre du poids"
  12.     else:
  13.         s = s + "doit perdre du poids"
  14.     return s

Télécharger

Cela permet de simuler, dans la console, un nutritionniste virtuel (il reste à effectuer les mesures sur les différents patients) :

  1. >>> from imc import *
  2. >>> docteur(1.8,82)
  3. 'le patient doit perdre du poids'
  4. >>> docteur(1.85,81)
  5. 'le patient est sain'
  6. >>> docteur(1.87,72)
  7. 'le patient est sain'
  8. >>> docteur(1.87,65)
  9. 'le patient est sain'
  10. >>> docteur(1.87,58)
  11. 'le patient doit prendre du poids'

Télécharger

Cette partie de l’activité a du succès en 1re ST2S ; elle permet de montrer l’utilité des fonctions mais aussi la manière dont on s’en sert (syntaxe). Elle met en valeur l’interactivité de la console qui évite d’avoir à entrer des données pour un input souvent inutile et handicapant.

Loi normale

Voici un extrait du sujet de bac STL 2019 :

Dans une ville, un cardiologue s’intéresse à la tension artérielle (systolique), mesurée en millimètres de mercure (mmHg), des femmes de plus de 60 ans.

Partie A

On note T la variable aléatoire qui, à chaque dossier médical d’une femme de la ville de plus de 60 ans, associe la tension artérielle de cette femme mesurée en mmHg. On suppose que T suit la loi normale d’espérance µ = 134 et d’écart-type σ = 8,5.
1. Le cardiologue choisit au hasard le dossier médical d’une femme de plus de 60 ans parmi les dossiers médicaux des femmes de la ville.
a. Quelle est la probabilité que la tension artérielle de cette femme soit comprise entre 130 et 140mmHg ? On donnera la valeur arrondie au millième.
b. Quelle est la probabilité que la tension artérielle de cette femme soit supérieure à 140mmHg ? On donnera la valeur arrondie au millième.

Pour résoudre ce problème avec la console de Python, il faut savoir que

  • le module math possède une fonction erf
  • la fonction erf(x/√2)/2 est la fonction de répartition de la variable aléatoire normale centrée réduite
  • on peut toujours centrer et réduire une variable aléatoire en
    • lui soustrayant son espérance µ
    • divisant le résultat par l’écart-type σ

On va donc commencer par

  1. >>> from math import *
  2. >>> def Z(x): return erf(x/sqrt(2))/2
  3. ...
  4. >>> def F(x): return Z((x-134)/8.5)
  5. ...

Télécharger

La solution du sujet de bac est alors donnée par

  1. >>> F(140)-F(130)
  2. 0.44090194332781
  3. >>> 1-F(140)
  4. 0.7401306513767114

Télécharger

Ou mieux encore (autant déléguer tout le travail à Python) :

  1. >>> round(F(140)-F(130),3)
  2. 0.441
  3. >>> round(1-F(140),3)
  4. 0.74

Télécharger

boucles

Comment faire des boucles sans utiliser print ?

En fait, on peut aussi utiliser print dans la console :

  1. >>> for x in range(8): print(x**2)
  2. ...
  3. 0
  4. 1
  5. 4
  6. 9
  7. 16
  8. 25
  9. 36
  10. 49

Télécharger

Mais il existe des moyens de ne pas replonger dans l’addiction au print. Ils ne sont pas au programme de 2nde mais quelqu’un qui a fait en 2nde toutes les activités présentées ci-dessus (sauf l’exponentielle) aura passé plusieurs heures et aura probablement envie de passer à autre chose que des print...

listes

Si on veut la liste des carrés inférieurs à 64, plutôt que la boucle avec print montrée dans l’onglet précédent, on peut regrouper ces carrés en une liste de carrés :

  1. >>> [x**2 for x in range(8)]
  2. [0, 1, 4, 9, 16, 25, 36, 49]

Télécharger

C’est bien plus concis que le print dans des boucles, et il s’agit toujours d’une expression, à laquelle on peut appliquer des fonctions comme

  1. >>> liste = [x**2 for x in range(8)]
  2. >>> len(liste)
  3. 8
  4. >>> sum(liste)
  5. 140
  6. >>> sum(liste)/len(liste)
  7. 17.5
  8. >>> m = len(liste)//2
  9. >>> m
  10. 4
  11. >>> (liste[m]+liste[m+1])/2
  12. 20.5

Télécharger

où on apprend, entre autres, que le carré médian est 20,5 alors que le carré moyen n’est que 17,5.

range

La fonction list permet de convertir son argument en liste. Par exemple avec un range :

  1. >>> list(range(5))
  2. [0, 1, 2, 3, 4]
  3. >>> list(range(3,8))
  4. [3, 4, 5, 6, 7]
  5. >>> list(range(13,5,-1))
  6. [13, 12, 11, 10, 9, 8, 7, 6]

Télécharger

Remarque : il est possible d’éviter l’usage de cette fonction, par les listes en compréhension :

  1. >>> list(range(5))
  2. [0, 1, 2, 3, 4]
  3. >>> [x for x in range(5)]
  4. [0, 1, 2, 3, 4]

Télécharger

Du coup les expériences menées précédemment avec des booléens sur range, sont nettement accélérées :

  1. >>> list(range(3,8))
  2. [3, 4, 5, 6, 7]
  3. >>> list(range(13,5,-1))
  4. [13, 12, 11, 10, 9, 8, 7, 6]
  5. >>> list(range(5))
  6. [0, 1, 2, 3, 4]
  7. >>> [x for x in range(5)]
  8. [0, 1, 2, 3, 4]

Télécharger

Les compréhensions permettent de calculer des tables, comme par exemple cette table trigonométrique :

  1. >>> X = [x for x in range(0,93,3)]
  2. >>> Y = [cos(radians(x)) for x in X]
  3. >>> X,Y

Télécharger

Allée des ifs

Avec les listes en compréhensions, certaines des activités précédentes peuvent être simplifiées. Par exemple l’aiguille de buffon :

  1. >>> [random()<2/pi for _ in range(10)]
  2. [True, True, False, True, True, True, True, True, False, False]
  3. >>> ([random()<2/pi for _ in range(100)]).count(True)
  4. 62
  5. >>> ([random()<2/pi for _ in range(1000)]).count(True)/1000
  6. 0.65
  7. >>> 2/([random()<2/pi for _ in range(10000)]).count(True)*10000
  8. 3.1167212092878294

Télécharger

divisibilité

Une fois qu’on sait comment construire des listes en compréhensions, on revoit le programme de cycle 4 d’une manière pythoniennement rapide.

Listes de diviseurs

On a vu dans la partie sur les booléens, comment voir si un nombre divise un autre. En constatant qu’aucun diviseur de n n’est plus grand que n, on définit la fonction

  1. >>> def ld(n): return [d for d in range(1,n+1) if n%d==0]
  2. ...
  3. >>> ld(12)
  4. [1, 2, 3, 4, 6, 12]

Télécharger

Ensuite on s’intéresse au nombre de diviseurs :

  1. >>> def nd(n): return len(ld(n))
  2. ...
  3. >>> nd(13)
  4. 2
  5. >>> [nd(n) for n in range(1,20)]
  6. [1, 2, 2, 3, 2, 4, 2, 4, 3, 4, 2, 6, 2, 4, 4, 5, 2, 6, 2]

Télécharger

ce qui permet d’aborder la notion de nombres premiers (ceux dont l’image par la fonction nd est 2).

Puis on s’intéresse aux diviseurs communs à deux entiers :

  1. >>> def cd(a,b): return [x for x in ld(a) if x in ld(b)]
  2. ...
  3. >>> cd(24,16)
  4. [1, 2, 4, 8]

Télécharger

Enfin, la fonction max permet d’isoler le plus grand des diviseurs communs :

  1. >>> def pgcd(a,b): return max(cd(a,b))
  2. ...
  3. >>> pgcd(24,16)
  4. 8

Télécharger

turtle

On peut même faire de la robotique dans la console, avec le module turtle.

L’écran où se font les dessins de la tortue s’ouvre en entrant dans la console

  1. >>> from turtle import *
  2. >>> shape('turtle')
  3. >>> reset()

Télécharger

triangle

Une erreur classique avec la tortue est l’oubli de tourner non pas de 60° mais de son supplémentaire pour dessiner un triangle équilatéral (ligne 3 ci-dessous). Alors plutôt que tout recommencer, on peut rajouter (ligne 4) une rotation de 60° pour avoir la bonne orientation de la tortue :

  1. >>> reset()
  2. >>> forward(50)
  3. >>> left(60)
  4. >>> left(60)
  5. >>> forward(50)
  6. >>> left(120)
  7. >>> forward(50)

Télécharger

vecteurs

On peut additionner, soustraire des vecteurs, multiplier un vecteur par un réel, multiplier scalairement deux vecteurs avec la tortue :

  1. >>> u = Vec2D(4,3)
  2. >>> v = Vec2D(5,-1)
  3. >>> u+v
  4. (9.00,2.00)
  5. >>> u-v
  6. (-1.00,4.00)
  7. >>> u*v
  8. 17
  9. >>> 3*u
  10. (12.00,9.00)

Télécharger

On peut aussi faire tourner un vecteur d’un certain angle en degrés :

  1. >>> u.rotate(30)
  2. (1.96,4.60)
  3. >>> u
  4. (4.00,3.00)
  5. >>> u.rotate(90)
  6. (-3.00,4.00)

Télécharger

on peut comparer le produit des normes avec le produit scalaire :

  1. >>> abs(u)
  2. 5.0
  3. >>> abs(v)
  4. 5.0990195135927845
  5. >>> abs(u)*abs(v)
  6. 25.495097567963924
  7. >>> u*v
  8. 17
  9. >>> u*v/abs(u)/abs(v)
  10. 0.6667948594698258
  11. >>> acos(_)
  12. 0.840896668643165
  13. >>> degrees(_)
  14. 48.17983011986423

Télécharger

Où l’on apprend qu’entre les vecteurs (4,3) et (5,-1) il y a environ 48°.

On peut aussi calculer les coordonnées du milieu d’un segment :

  1. >>> (u+v)*.5
  2. (4.50,1.00)

Télécharger

On peut aussi tester si des vecteurs sont colinéaires :

  1. >>> def sont_colin(u,v): return abs(u*v)==abs(u)*abs(v)
  2. ...
  3. >>> sont_colin(u,v)
  4. False
  5. >>> sont_colin(u,3*u)
  6. True
  7. >>> sont_colin(u,-u)
  8. True

Télécharger

fonctions

La tortue sait aussi représenter graphiquement des fonctions, par exemple des arcs de parabole :

  1. >>> reset()
  2. >>> for x in range(100): goto(x,x**2/100)
  3. ...

Télécharger

des arcs d’hyperbole :

  1. >>> reset()
  2. >>> for x in range(1,100): goto(x,100/x)
  3. ...

Télécharger

des vagues :

  1. >>> reset()
  2. >>> for x in range(1,300): goto(x,10*sin(x/10))
  3. ...

Télécharger

courbes

Les courbes paramétrées sont également à la portée de la tortue de Python.

  1. >>> reset()
  2. >>> penup()
  3. >>> goto(200,0)
  4. >>> pendown()
  5. >>> for t in range(360): goto(200*cos(3*radians(t)),200*sin(2*radians(t)))
  6. ...

Télécharger

des spirales :

  1. >>> reset()
  2. >>> for t in range(100): goto(t*cos(10*t),t*sin(10*t))
  3. ...

Télécharger

En résumé, évaluer des expressions dans la console Python

  • prend plusieurs heures/élève si on veut le faire bien et solidement
  • permet de mieux comprendre la notion de fonction
  • doit être fait avant toute autre activité Python
  • plaît aux élèves de la voie technologique

Comme il s’agit bien de mettre Python au service des maths et non l’inverse, je ne saurais trop recommander ce genre d’activités (qui peuvent ensuite être déclinées en questions flash) surtout dans les classes dites difficiles.


[1et sans un seul print !

[2mais toujours pas de print !


Portfolio

PNG - 4.2 ko

Commentaires