Afficher avec Python

Identification

Infoforall

1 - Afficher sur la console


Cette activité vous présente une première utilisation de Python de façon à afficher des calculs sur la console Python.

Nous allons voir comment utiliser Python à l'aide de la console. Nous pourrons ainsi faire évaluer du code Python en direct.

Nous n'allons pas réellement faire des choses complexes mais une idée devrait émerger : celle que l'interpréteur Python évalue séquentiellement les ordres qu'on lui impose, en respectant des règles qu'on lui a indiqué.

Logiciel nécessaire pour l'activité : Python 3 : Thonny, IDLE ou le site repl.it ...

Evaluation ✎ : questions 02-03-04-06-09-10-11-12-13-15-16-17

Résumé : Version HTML ou imprimable ou ou PDF (couleur ou gris)

1 - Les logiciels de base

Inutile de télécharger et d'installer les logiciels si vous êtes en salle informatique. Tout est déjà installé.

Pour programmer en Python, il vous faut télécharger et installer Python 3 s'il n'est pas encore intégré sur votre ordinateur : Lien vers Python

Si vous êtes chez vous et que vous n'avez pas encore vu le tutoriel Installation, c'est le moment.

Si vous êtes en classe, c'est installé. Mais sachez que vous trouverez des explications d'installation et d'utilisation dans les tutos ci-dessous.

2 - La console Python

Nous commencerons par savoir gérer les affichages vers la console Python. C’est basique en terme d’affichage mais cela ne nécessite aucune gestion des fenêtres. Pour débuter, c’est donc pratique. Et ça permet au passage de savoir que la console existe.

01° Ouvrir un terminal à l'aide des indications ci-dessous :

Sous Windows 10 :

  • Start Menu --- All Apps --- Windows System --- Command Prompt
  • Menu Démarrer --- Système Windows --- Invite de Commandes

Sous Linux Ubuntu :

Il suffit de cliquer sur l'icône Terminal (un écran noir) qui se situe dans le menu des applications (celui avec 9 points formant un carré).

Une fois que vous avez mis la main sur votre invite de commande - terminal, vous allez pouvoir facilement ouvrir la console Python. Il suffit de taper python.

Vous aurez alors la version de Python qui va s'afficher et vous aurez accès à une console Python vous permettant d'executer du code Python en temps réel. Le fait qu'on soit en console Python est facilement reconnaisable : on voit apparaitre 3 chevrons  >>> .

Avec Windows par exemple :

> python Python 3.5.2 (v3.5.2:4def2a901a5, Jun 25 2016, 22:01:18) [MSC v.1900 32 bits (Intel)] on win32 Type "help", "copyright", "credits" or "license" for more information. >>> exit() >

Pour savoir si on est sous Python, on peut voir s'afficher 3 chevrons :  >>> . Lorsqu'on renvoie sous Windows, on a un simple chevron  >  qui s'affiche.

L'instruction exit() permet simplement de ... sortir de Python.

Avec Linux, attention : la commande python lancera python2 par défaut. Si vous voulez lancer python3, il faudra taper python3 tout simplement.

Avec Linux par exemple :

rv@rv-HP2:~$ python Python 2.7.15rc1 (default, Nov 12 2018, 14:31:15) [GCC 7.3.0] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> exit() rv@rv-HP2:~$
rv@rv-HP2:~$ python3 Python 3.6.7 (default, Oct 22 2018, 11:32:17) [GCC 8.2.0] on linux Type "help", "copyright", "credits" or "license" for more information. >>> exit() rv@rv-HP2:~$

L’intérêt de la console vient de ses choix limités d’interaction qui ne nécessitent donc aucune déclaration et aucun réglage préalable : pas de choix de couleur, pas de gestion de souris, pas de taille d’affichage … On lit les informations claviers et on affiche le texte brut. Linux l’utilise beaucoup plus que Windows qui tente de cacher tout l’aspect technique de l’informatique puisqu’il est destiné au grand public.

3 - Premier contact avec Python : opérateurs mathématiques

L’utilisation de Python s’effectue à travers une sorte de console qu’on ouvre en activant le logiciel.

✎ 02° Ouvrir un terminal et activer Python 3 à l'aide d'une ligne de commande. Vous devrez donc obtenir une console Python : celle où l'invite de commande est composée de trois chevrons. Tapez alors les codes suivants. Les valeurs fournies par Python sont-elles justes ?

>>> 5*5

>>> 15 - 4

✎ 03° Tapez maintenant les codes suivants. Les valeurs calculées sont-elles justes ? Comment l'ordinateur parvient-il à choisir quelle opération faire d'abord ?

>>> 9*9 + 2

>>> 2 + 9*9

>>> 12 - 2*0.2

>>> - 2*0.2 + 12

...CORRECTION 1-2...

Pour comprendre ce calcul, il faut se souvenir que l'opérateur multiplication * est prioritaire sur l'opérateur addition +.

L'ordinateur va ainsi évaluer votre calcul progressivement, étape par étape :

>>> 9*9 + 2 >>> (9*9) + 2 >>> 81 + 2 83

Ca ne change rien pour le second du coup, les priorités sont les mêmes :

>>> 2 + 9*9 >>> 2 + (9*9) >>> 2 + 81 83

...CORRECTION 3-4...

Même principe : l'opérateurs multiplication * est prioritaire sur l'opérateur soustraction -.

L'ordinateur va ainsi évaluer votre calcul progressivement, étape par étape :

>>> 12 - 2*0.2 >>> 12 - (2*0.2) >>> 12 - 0.4 11.6

Ca ne change rien pour le second du coup, les priorités sont les mêmes :

>>> - 2*0.2 + 12 >>> - (2*0.2) + 12 >>> - 0.4 + 12 11.6
Déroulement séquentiel

On remarquera qu’on lance des calculs en temps réel et chose importante, l'ordinateur effectue les opérations de façon séquentielle : il ne calcule pas en bloc les expressions.

Au contraire, il définit les priorités et effectue ces calculs avant de lancer la suite de l'évaluation.

Ca a l'air bête, mais c'est fondamental à comprendre lorsqu'on lit un code.

✎ 04° Evaluer de tête ces deux expressions. Donnent-elles le même résultat ?

>>> 3 + 2*3 + 2

>>> (3+2) * (3+2)

...CORRECTION...

L'ordinateur évalue ainsi la première expression :

>>> 3 + 2*3 + 2 >>> 3 + (2*3) + 2 >>> 3 + 6 + 2 >>> (3 + 6) + 2 >>> 9 + 2 11

Pour le second, on respecte juste les parenthèses :

>>> (3+2) * (3+2) >>> 5 * (3+2) >>> 5 * 5 25
Règles de priorité

Retenez donc bien que l'ordinateur n'évalue pas vos expressions au hasard : il utilise les règles qu'on lui a fourni, qui correspondent aux règles de priorité que vous connaissez depuis longtemps :

  • Multiplication et division prioritaires sur addition et soustraction
  • Ordre d'apparition lorsqu'il faut différencier des multiplications ou des divisions
  • Ordre d'apparition lorsqu'il faut différencier des additions ou des soustractions
  • L'évaluation d'une expression située dans une parenthèse est toujours prioritaire

Puisqu’on utilise Python notamment pour faire des calculs, on dispose de nombreuses opérateurs bien pratiques en plus d'addition +, soustraction -, multiplicatione * et division / :

05° Taper les expressions suivantes qui illustrent un nouvel opérateur // : le résultat entier d'une division.

>>> 14 / 3 donne 4.666666667. Un résultat approximatif, un réel à virgule.

>>> 14 // 3 renvoie juste 4, la partie entière de la division de 14 par 3 qui vaut 4,6666666667.

Une autre façon de voir la chose :14 = 4*3 + 2. Ici, c'est le 4 qui est renvoyé.

Réfléchir ensuite sur la réponse donnée par les deux dernières expressions. Vérifier votre réponse en tapant l'expression dans la console.

>>> 12 // 5

>>> 12 // 9

Priorité de l'opérateur //

L'opérateur // possède le même degré de priorité que la multiplication ou la division.

On dit parfois que l'opérateur // permet de faire des divisions entières.

Ce n'est pas entièrement vrai : si on tape >>> 14.0 // 3, on obtient 4.0 un nombre à virgule.

On préférera donc dire que l'opérateur // renvoie la partie entière de la division correspondante.

Lorsque nous parlerons des structures de données, nous verrons d'ailleurs qu'il faut être très vigilant lorsqu'on travaille avec des nombres à virgules sur un ordinateur. Un exemple pour vous en convaincre : 12.7 / 0.1 qui devrait donner 127.

>>> 12.7 / 0.1 126.99999999999999
>>> 12.7 // 0.1 126.0
Vocabulaire

Nous venons de voir que Python ne gère pas de la même façon les nombres entiers et les nombres à virugles.

Les entiers sont nommés des integers.

Les nombres à virgules (même si on place 0 derrière la virgule) sont nommées des float : des nombres à virgules flottantes.

Ainsi :

  • 5 est un integer
  • 5.2 est un float
  • 5.0 est un float aussi.

✎ 06° Comment devrait être évaluer les expressions suivantes ? Donner votre réponse puis vérifier le calcul que Python va affecter sur ces floats.

>>> 3*0.1 - 0.3

>>> 3*0.125 - 0.375

Nous verrons dans une activité spécifique pourquoi les flottants se comportent de cette façon. Pour l'instant, retenez simplement qu'on ne peut pas totalement faire confiance aux résultats incluant des flottants.

07° Taper les expressions suivantes qui illustrent un nouvel opérateur % : le modulo. On parle également de reste d'une division entière.

>>> 14 % 3 donne 2.

En effet, 14 = 4*3 + 2. Ici, c'est le 2 qui est renvoyé.

>>> 11 % 5 donne 1.

En effet, 11 = 2*5 + 1. Ici, c'est le 1 qui est renvoyé.

Réflechir ensuite aux réponses attendues pour les quatre dernières expressions. Vérifier votre réponse en tapant l'expression dans la console.

>>> 25 % 10

>>> 360 % 360

>>> 370 % 360

>>> 380 % 360

Encore une fois, il faut se méfier des résultats d'un modulo comportant des nombres à virgules.

Priorité de l'opérateur %

L'opérateur % possède le même degré de priorité que la multiplication ou la division.

Vous avez vu maintenant plusieurs lignes de calcul possèdant des espacements. Ceux-ci ne sont clairement pas positionnés au hasard :

Ecrire un code clair 1 : les espaces dans les expressions

Lorsqu'une expression ne contient que des opérateur ayant la même priorité, on laisse un espace entre les différentes termes :

Expressions correctement écrites : >>> 25 % 10 >>> 25 + 10 - 5
Expressions posant des problèmes de lecture : >>> 25%10 >>> 25+10+5

Lorsqu'une expression ne contient que des opérateurs ayant des priorités différentes, on ne place pas d'espace sur les opérateurs prioritaires :

Expressions correctement écrites : >>> 10 + 25*5 >>> 25/10 - 5
Expressions posant des problèmes de lecture : >>> 10+25*5 >>> 10 + 25 * 5 >>> 25/10-5 >>> 25 / 10 - 5

S'il faut des parenthèses, on ne rajoute pas d'espace au début ou à la fin de l'expression située dans les parenthèses.

L'expression dans la parenthèse est prioritaire sur la multiplication. Cette fois, on ne placera donc pas d'espace entre le + mais on en place autour du * :

Expressions correctement écrites : >>>(25+5) * 5 >>> (4+5) * (12+55)
Expressions posant des problèmes de lecture : >>> (25+5)*5 >>> (25 + 5) * 5 >>> ( 25+5 ) * 5 >>> ( 25 + 5 ) * 5

Et pour les cas plus complexes ? On fait appel à son bon sens !

08° Taper les expressions suivantes qui illustrent un nouvel opérateur ** : la puissance. Trouver seul les réponses attendues non fournies puis vérifier votre réponse en tapant l'expression dans la console.

>>> 3**2 donne 9.

>>> 4**2 donne 16.

>>> 5**2

>>> 6**2

>>> 2**1

>>> 2**2

>>> 2**3

>>> 2**4

>>> 2**5

>>> 2**6

>>> 2**7

>>> 2**8

✎ 09° Taper l'expression suivante.

>>> 5**2*5**2

L'opérateur puissance a-t-il le même degré de priorité que la multiplication ?

Faire le calcul étape par étape dans les trois cas possibles :

  • aucune n'est prioritaire
  • la multiplication est prioritaire
  • la puissance est prioritaire.

Quelle est alors la forme la plus adaptée à la bonne compréhension de ce que fait le code ?

>>> 5**2*5**2

>>> 5 ** 2*5 ** 2

>>> 5**2 * 5**2

...LES 3 CAS...

Si les opérateurs avaient le même degré de priorité, l'évaluation aurait lieu dans l'ordre de la lecture :

>>> 5**2*5**2 >>> (5**2)*5**2 >>> 25*5**2 >>> (25*5)**2 >>> 125**2 15625

Si la multiplication était prioritaire, nous aurions l'évaluation progressive suivante :

>>> 5**2*5**2 >>> 5**(2*5)**2 >>> 5**10**2 >>> (5**10)**2 >>> 9765625**2 95367431640625

Si la puissance était prioritaire, nous aurions l'évaluation progressive suivante :

>>> 5**2*5**2 >>> (5**2)*5**2 >>> 25*5**2 >>> 25*(5**2) >>> 25*25 >>> 9765625**2 625

La bonne réponse étant 625, on voit clairement que l'opérateur puissance est prioritaire sur les autres.

La "bonne" façon d'écrire cette ligne est donc :

>>> 5**2 * 5**2 625

Bon, c'est bien gentil les divisions entières et les restes de divisions entières, mais ça sert à quoi ? Les autres opérateurs ok, ça permet de calculer mais // et % ?

Pour vous montrer l'utilité de ces deux nouveaux opérateurs // et % prenons par exemple le cas d'un nombre ENTIER dont nous voulons obtenir l'unité, la dizaine et la centaine.

Posons ainsi clairement les données d'entrée voulues pour notre problème et les données de sortie qu'on veut produire :

  • Entrée du problème : un nombre ENTIER positif
  • Exemple d'entrée :  1234 

  • Sorties du problème : un ensemble de nombre entier représentant l'unité, la dizaine et la centaine du nombre d'entrée.
  • Sorties attendues pour l'entrée précédente :

    •  4  pour l'unité
    •  3  pour la dizaine
    •  2  pour la centaine
Nombre M = 1 2 3 4
La case code 1000 100 10 1
On obtient donc 1x1000 = 1000 2x100 = 200 3x10 = 30 4x1 = 4

Pour un humain, pas trop de problème pour sortir les réponses. Mais pour l'ordinateur ?

✎ 10° Taper ceci pour faire évaluer ce calcul. Correspond-t-il à l'unité de 1234 ?

>>> 1234 % 10

✎ 11° Quelles expressions fournissent la dizaine de 1234 ? Quelle est la forme qu'on préférerait voir dans un code pour le rendre plus compréhensible pour un humain ?

>>> 1234 // 10 >>> 1234 // 10 % 10 >>> (1234 // 10) % 10 >>> (1234//10) % 10 >>> (1234//10)%10 >>> 1234//10 % 10

✎ 12° Quelles expressions fournissent la centaine de 1234 ? Quelle est la forme qu'on préférerait voir dans un code pour le rendre plus compréhensible pour un humain ?

>>> 1234 // 100 >>> 1234 // 100 % 10 >>> (1234 // 100) % 10 >>> (1234//100) % 10 >>> (1234//100)%10 >>> 1234//100 % 10

✎ 13° Et pour les milliers ?

4 - Module Turtle

Bon, la console c'est sympa mais c'est un peu lassant lorsqu'on est habitué à de belles animations graphiques. L'intérêt c'est la rapidité et la simplicité.

Voyons maintenant un peu comment créer quelques dessins facilement avec l'un des modules les plus courants de Python dans l'apprentissage de la programmation : le module Turtle qui va vous permettre de vous mettre à la place d'une tortue qui dessine.

Cela nous permettra surtout de bien ancrer la notion de séquence dans l'exécution des instructions envoyées à l'ordinateur.

14° Utiliser les instructions suivantes une à une pour visualiser leurs effets.

Instruction n°1

>>> import turtle as trt

✱ En interne : importe dans l'interpréteur et en mémoire les codes permettant de créer la tortue.

✱ Visuellement : rien.

Instruction n°2

>>> crayon = trt.Turtle()

✱ En interne : on crée une variable crayon et on y place un objet-dessin basé sur le module Turtle.

✱ Visuellement : ouvre une fenêtre graphique et y place une flèche orientée vers la droite : la flèche symbolise le crayon.

Instruction n°3

>>> crayon.right(90)

✱ En interne : on agit sur crayon.

✱ Visuellement : la flèche tourne de 90° vers la droite.

Instruction n°4

>>> crayon.right(90)

✱ Visuellement : idem, on tourne de 90° vers la droite.

Instructions n°5

>>> crayon.forward(50) >>> crayon.forward(100) >>> crayon.forward(-150)

✱ En interne : on agit sur l'objet-crayon.

✱ Visuellement :

  • la flèche avance de 50 pixels dans le sens indiqué et trace un trait noir.
  • la flèche avance de 100 pixels et trace un trait noir.
  • la flèche recule de 150 pixels par rapport au sens indiqué, et trace un trait noir.

Instructions n°6

>>> crayon.pencolor('red') >>> crayon.forward(50)

✱ En interne : on change la couleur du crayon.

✱ Visuellement : on avance en traçant en rouge

Instructions n°7

>>> crayon.penup() >>> crayon.forward(-200) >>> crayon.pendown() >>> crayon.forward(200)

✱ En interne : on empèche l'objet de tracer des traits (symboliquement, on lève la pointe du crayon virtuel.

✱ Visuellement : on recule sans faire de nouvelle trace

✱ En interne : on permet à nouveau à l'objet de tracer des traits (symboliquement, on abaisse la pointe du crayon virtuel sur la feuille.

✱ Visuellement : on avance en traçant un trait

Instructions n°8

>>> crayon.clear()

✱ Visuellement : on fait disparaître les traits créés par l'objet nommé crayon.

Instructions n°9

>>> crayon.home()

✱ Visuellement : on ramène le crayon au centre et on le replace en orientation vers la droite. Comme le crayon était 'posé', il a dessiné un trait.

✎ 15° Dessiner (avec "crayon" déclaré) un carré de 200 pixels de côté en utilisant une séquence d'instructions précises et ordonnées. Les couleurs des côtés devront être red, pink, blue et orange.

...CORRECTION...

>>> crayon.clear() >>> crayon.penup() >>> crayon.home() >>> crayon.pendown() >>> crayon.pencolor('red') >>> crayon.forward(200) >>> crayon.right(90) >>> crayon.pencolor('pink') >>> crayon.forward(200) >>> crayon.right(90) >>> crayon.pencolor('blue') >>> crayon.forward(200) >>> crayon.right(90) >>> crayon.pencolor('orange') >>> crayon.forward(200) >>> crayon.right(90)

✎ 16° Le dessin serait-il le même si on traçait les instructions dans un ordre aléatoire ?

Cette notion de séquence d'exécution est évidente ici puisqu'on tape les instructions une à une. Par contre, il faudra vous en souvenir lorsque nous commencerons à faire de vrais programmes : on doit placer les instructions dans l'ordre logique voulu pour réaliser les tâches demandées.

Quelques commandes disponibles avec Turtle

N'oubliez pas d'importer au préalable le module Turtle avec import Turtle as trt.

Voici quelques méthodes qu'on peut appliquer aux objets de classe Turtle, qu'on crée à l'aide de crayon = trt.Turtle().

Pour avancer : crayon.forward(50) permet d'avancer de 50.

Pour reculer : crayon.backward(50) permet de reculer de 50.

Pour tourner à droite : crayon.right(45) permet de tourner de 45° à droite.

Pour tourner à gauche : crayon.left(45) permet de tourner de 45° à gauche.


Pour aller faire un mouvement linéaire jusqu'au point de coordonnées (x,y) : crayon.setposition(x,y).

Pour faire un mouvement horizontal jusqu'à atteindre la valeur donnée en x : crayon.setx(x).

Pour faire un mouvement vertical jusqu'à atteindre la valeur donnée en y : crayon.sety(y).

Pour revenir au point d'origine : crayon.home().


Pour dessiner un cercle de rayon x : crayon.circle(x).

Pour dessiner un arc de cercle d'angle a et de rayon x : crayon.circle(x,a).

Pour tracer des polygones de "rayon" x possèdant y côtés : crayon.circle(x,360,y).

Pour placer un point de rayon x et de couleur précise : crayon.dot(x,"red").


Pour modifier la vitesse x, x variant de 1 à 10 : crayon.speed(x), x=0 veut dire pas d'animation.


Pour lever la pointe du crayon : crayon.penup().

Pour abaisser la pointe du crayon : crayon.pendown().

Pour changer la couleur du crayon : crayon.pencolor("red").

Pour augmenter la taille du crayon : crayon.pensize(5).

Cela nous suffira mais vous pouvez aller voir la documentation Python pour voir ce que le module peut faire d'autre : DOCUMENTATION TURTLE PYTHON.

✎ 17° Utilisez le temps qu'il vous reste pour réaliser le dessin le plus sympa possible.

Il existe notamment la possibilité de définir une couleur de remplissage avec crayon.fillcolor("yellow").

De signaler de commencer à gérer les traits comme faisant partie d'une forme à remplir : crayon.begin_fill().

De signaler la fin de la zone à remplir : crayon.end_fill().

Un exemple rapide :

>>> crayon.fillcolor("yellow") >>> crayon.begin_fill() >>> crayon.circle(50) >>> crayon.end_fill()

Nous allons réutiliser Turtle un peu plus loin dans le cours car il permet vraiment de tester certaines choses et de rendre visuellement le résultat du code.

Ici, j'espère qu'il vous a permis de 'visualiser' que l'ordre des instructions est important.

Voici pour ce premier contact avec le Shell de Python.

Pour la plupart des activités, vous trouverez un récapitulatif des notions vues dans l'activité. Il ne s'agit pas vraiment d'un résumé, juste d'un rappel des notions vues.

Le menu global de Python vous permet ainsi d'atteindre la page globale des récapitulatif et la page des résumés, plus complets que les récapitulatifs.

Sur les premières activités, la différence entre récapitulatif et résumé n'est pas flagrant car la difficulté des notions abordées est plutôt faible.

LIEN VERS LES RECAPITULATIFS

LIEN VERS LES RESUMES

Activité publiée le 28 08 2019
Dernière modification : 19 07 2020
Auteur : ows. h.