3. PYTHON: UNE SUPER CALCULETTE

3.1. Interpréteur de commandes Python

L’interpréteur de commande Python peut se lancer:

  • par le menu des applications (si disponible).
  • ou en tapant python dans un shell de commandes (sous les systèmes Linux, on trouve souvent dans le menu “Applications”, rubrique “Outils système”, l’application “Terminal” qui permet de lancer un shell de commandes).

Note

Dans l’interpréteur de commandes Python utiliser la touche “Entrée” pour valider et les flèches pour éditer (flèche vers le haut pour reprendre les anciennes commandes).

3.2. Expression de calculs

  • nombres entiers, flottants, et opérateurs: +,-,*,/,% (l’opérateur pour cent donne le reste de la division entière), double étoile ** pour l’élévation à la puissance (entière ou rationnelle), abs(x) pour la valeur absolue d’un nombre x. Priorité des opérateurs: * et / sont prioritaires sur + et -. Notation des puissances de 10 avec ‘e’ ou ‘E’.
Exemple: 1.34E-7 ** 2 donne le carré du nombre 1.34 dix puissance -7.

Warning

Le séparateur décimal est le point . et non la virgule ,

  • nombres complexes (notation avec j au lieu de i), exemple: 4 + 5j. Attention il n’y a pas d’espace devant le j, et pour une partie imaginaire égale à 1, il faut écrire 1j (et pas simplement j). La notation avec un J majuscule est aussi permise. On accède à la partie réelle et à la partie imaginaire avec .real et .imag.
Exemple: (5 + 3.3j).imag vaut 3.3 et (5 + 3.3j).real vaut 5.
  • notion de type des expressions (typage dynamique), voir notamment la différence entre division entière et rationnelle. Exemple: 2/3.0 (ou 2/3.) donne un résultat différent de 2/3 qui effectue une division entière.

Expliquer les résultats suivants:

(5/3) + (1/3.) donne 1.33333333 et 4.0 ** (1/2) donne 1.0.

Warning

(P3) Ce comportement concernant la division en Python version 2.X change en version 3.X. En effet en Python 3.X l’opérateur / est une division flottante.

Note

Pour obtenir en Python 2.X que / soit aussi une division flottante, exécuter l’instruction from __future__ import division (deux symboles blanc souligné avant et après le mot future). Le symbole / dénote alors la division flottante et la division entière se note quant à elle à l’aide d’une double barre: x // y, comme en Python 3.X.

Précision des calculs:

  • depuis Python 2.2 les entiers sont manipulés et stockés de façon exacte sans limite de précision.
  • les nombres flottants sont stockés et manipulés en double précision (ce qui signifie approximativement 17 chiffres et des puissances de 10 de -300 à +300). Les parties réelles et imaginaires des complexes sont des nombres flottants.

Warning

Les calculs avec des nombres flottants ou complexes ne sont donc pas exacts. Ainsi 0.1 + 0.2 + 0.3 - 0.6 peut selon les plateformes donner par exemple 1.1102230246251565e-16 comme résultat au lieu de 0.

3.3. Chaînes de caractères

Les " (les guillemets) et les ' (les quotes) sont utilisés comme délimiteurs pour les chaînes de caractères. Pas de différence entre " et ', mais une chaîne commencée avec " se termine par ", de même pour '. Les opérateurs + et * permettent de concaténer et de répéter des chaînes.

Exemples:

'un texte ...'
"c'est un autre texte contenant une quote"

Exemple de concaténation: "bon" + "jour" donne "bonjour"

Exemple de répétition: "quatre fois:" * 4 donne "quatre fois:quatre fois:quatre fois:quatre fois:".

Warning

Une chaîne contenant seulement des symboles numériques n’est pas un nombre. Par exemple la chaîne '100' n’est pas un nombre entier, c’est un texte contenant simplement comme symboles 1 suivi de 0 suivi de 0, et le calcul suivant provoque une erreur: 2 / '100'. En effet la division d’un nombre par un texte n’a pas de sens. En revanche l’expression 2 * '100' est correcte car * est interprété ici comme une répétition, et l’on obtient '100100'.

Warning

Ne pas confondre la quote ' et l’anti-quote ` qui elle n’a pas de signification particulière.

Warning

Pour utiliser des accents dans les chaînes de caractères voir Support des accents.

3.4. Affectation : instruction pour stocker

Pour stocker en mémoire électronique une donnée on utilise l’instruction suivante:

ma_variable = expression

Ceci est ce l’on nomme une affectation en programmation, et permet de ranger le résultat de l’évaluation d’une expression dans une variable.

Dans l’interpréteur interactif taper par exemple:

z = 6
y = z + 1
y + z
y + x

Pourquoi a-t-on une erreur d’exécution ?

Une variable correspond à un espace de stockage en mémoire. Une variable en informatique ne correspond pas à la notion de variable en mathématique, et encore moins à la notion d’inconnue utilisée dans une équation. L’instruction y = z + 1 n’est pas une équation ! L’interpréteur calcule ce qui est à droite du signe égal (ici z+1) et range le résultat dans l’espace de stockage dont le nom est indiqué à gauche du signe égal (ici y). Si lorsque l’interpréteur essaie d’exécuter l’instruction y = z + 1 la variable z n’a pas encore reçu de valeur, dans ce cas le calcul z+1 ne peut être effectué et ceci provoque une erreur et l’arrêt de l’exécution. En revanche une affectation comme a = 'x * y + z', ne provoque pas d’erreur même si les variables x,y et z n’existent pas. Pourquoi ?

Warning

Les notions de précision et de mélange de types dans les expressions s’appliquent aussi lorsque l’on manipule des variables.

Exemple:

z = '100'
x = 2 / z

provoque une erreur

et

y = 0.2
y+y+y+y

peut selon les plateformes fournir une valeur approchée telle que 0.80000000000000004 au lieu de 0.8

3.5. Identificateurs

Les noms utilisés, notamment pour les noms de variables, s’appellent en programmation des identificateurs.

Un identificateur commence par une lettre, suivi éventuellement d’une combinaison de lettres, chiffres et du caractère _ (le blanc souligné, aussi appelé underscore).

Exemples d’identificateurs:

x
x3
x_3
az_4z__xX_88_z
un_identificateur_tres_long
unPlusCourt

Warning

  • les identificateurs ne peuvent pas contenir d’espace, de lettres accentuées ni de symboles de ponctuation.
  • les majuscules et les minuscules sont des lettres différentes, ainsi Z n’est pas le même identificateur que z.
  • un identificateur peut aussi commencer par un underscore _, mais ceci est réservé par convention à des usages particuliers.

Note

(AV) La fonction permettant de connaître la liste des identificateurs utilisés est vars(). Cette fonction renvoie un dictionnaire des identificateurs. Ce dictionnaire peut contenir d’autres identificateurs que ceux que l’on utilise pour nos propres variables, notamment les identificateurs des variables utilisées par l’interpréteur Python lui-même et dont les noms commencent et finissent par un double blanc souligné (double underscore): __, comme par exemple __name__.

3.6. Affectation : sens précis en trois temps

Python gère les noms de variables en utilisant un dictionnaire des identificateurs, et une affectation ma_variable = expression est en fait exécutée en trois temps:

  1. Evaluation de l’expression en partie droite de l’affectation (à droite du signe égal).
  2. Recherche, dans le dictionnaire des identificateurs, du nom de la variable indiquée en partie gauche. Si cette variable n’existe pas elle est créée.
  3. Stockage dans la variable trouvée ou créée en 2), de la valeur obtenue pour l’expression lors du calcul en 1).

Si une variable contient déjà quelque chose, il est tout à fait possible de faire une nouvelle affectation pour ranger autre chose dans cette variable, mais ceci écrase alors l’ancienne valeur.

Exemple:

x = 4
x * 2
x = 7
x * 2

Cette suite d’instructions affiche d’abord 8, puis 14.

3.7. Sorties: print - instruction pour écrire

Pour réaliser une sortie sur écran on utilise l’instruction print.

Exemples de print (Python 2.X):

print 'hello'
print '1789'
y = 4
print y
print 2*y
print 'trois fois y vaut', 3*y
print 'y vaut', y

Note

(P3) La syntaxe de print est légèrement différente en Python version 3.X où elle nécessite des parenthèses, ainsi au lieu de print 'y vaut', y on écrit en Python 3.X print('y vaut', y).

Chaque print se termine par un passage automatique à la ligne suivante de l’écran. Un print sans argument:

print

fait simplement sauter une ligne.

3.8. Séquence d’instructions

  • écrire un programme c’est en générale écrire une séquence d’instructions dans un fichier. Cette étape s’appelle étape de saisie du programme (par opposition à l’étape d’exécution du programme).

  • un programme Python peut-être saisi avec un éditeur de texte brut (textpad, notepad, vi, kedit, gedit ...). Il ne faut pas utiliser les formats natifs produits par les traitements de textes (word, éditeur open office, ...) qui incluraient des codes non reconnus par Python tels que les tailles des marges, les noms des polices de caractères, ...

  • pour demander à l’interpréteur Python d’exécuter les instructions contenues dans un fichier (c’est à dire un programme) taper dans un shell de commandes: python nom_du_programme

    Les instructions contenues dans le fichier sont alors exécutées dans l’ordre où l’interpréteur Python les rencontre (il commence par la première ligne et ensuite continue ligne par ligne).

  • les lignes vides ou contenant seulement des espaces et/ou des tabulations sont ignorées (ceci permet d’aérer l’écriture des programmes).

Warning

Pour la portabilité entre Windows, Linux et Mac OS, utiliser pour vos noms de fichiers et de dossiers des lettres de a à z, A à Z, des chiffres et le blanc souligné _ mais éviter les accents et les autres symboles (éviter même les espaces).

Note

La convention est d’utiliser comme extension .py pour les fichiers contenant des programmes Python.

3.9. Outils de développement: IDE idle

Pour créer/modifier/tester un programme plus facilement on utilise un IDE “Integrated Development Environment” (ou encore en français EDI “Environnement de Développement Intégré”). L’IDE idle est inclus dans les distributions de Python. Ces fonctionnalités sont réduites mais couvrent l’essentiel et sa prise en main est rapide.

  • lancer idle par le menu des applications (si disponible) ou en tapant idle dans un shell de commandes.

  • par défaut idle ouvre une fenêtre dans laquelle se trouve un interpréteur de commandes Python. Pour ouvrir une fenêtre d’édition permettant de créer un programme dans le menu “File” faire “New Window”.

  • dans idle pour exécuter le programme en cours d’édition: dans la fenêtre d’édition, dans le menu “Run”, lancer la commande “Run module” (raccourci F5).

  • avec idle il est possible de localiser dans le programme une ligne ayant entraînée une erreur lors de l’exécution:

    dans la fenêtre d’exécution de idle, cliquer sur le message d’erreur (celui qui indique le nom du fichier et le numéro de ligne de l’erreur) avec le bouton droit et choisir “aller à” (cette fonction est aussi disponible depuis le menu “Debug”).

  • pour modifier directement un programme existant avec idle:

    • dans l’explorateur de fichiers faire “ouvrir avec” idle
    • ou dans un shell de commande taper: idle chemin_d_acces/nom_du_programme

Voir aussi Historique des commandes de l’interpréteur Python sous idle.

3.10. Entrées: input et raw_input

En cours d’exécution il est possible de demander à l’utilisateur de saisir une valeur au clavier grâce à input.

Exemple:

x = input("Entrer une valeur: ")

Son exécution se déroule de la façon suivante:

  1. le programme affiche sur l’écran le texte Entrer une valeur
  2. le programme est alors suspendu
  3. l’utilisateur saisit une valeur au clavier
  4. l’utilisateur appuie sur le touche “Entrée”
  5. le programme reprend son exécution
  6. la valeur saisie par l’utilisateur est utilisée par le programme à la place de l’expression input("Entrer une valeur: ")
  7. l’affectation est réalisée, c’est à dire que la valeur saisie est rangée dans la variable x.

Pour saisir une valeur lors de l’exécution de input, on tape simplement la valeur si c’est un nombre, alors que pour une chaîne il faut l’entourer avec " ou '. Pour une chaîne, si l’on omet " ou ', dans ce cas Python considère qu’il s’agît d’un identificateur, tel qu’un nom de variable, ce qui souvent provoquera une erreur d’exécution ou un calcul erroné.

Il existe une fonction qui permet de lire seulement des chaînes, et qui ne nécessite pas que l’utilisateur tape les " ou ' lors de la saisie, il s’agit de raw_input:

ma_variable_chaine = raw_input("Entrer un texte :")

Note

Pour interrompre un programme alors celui-ci est en attente d’une saisie par input ou raw_input, taper CTRL-c ou CTRL-d.

Note

(AV) Il est possible avec input de saisir plusieurs valeurs sur une seule ligne et de récupérer ces valeurs dans des variables séparées. Exemple:

a, b, c = input("Donner 3 valeurs : ")

L’utilisateur devra saisir les valeurs en les séparant avec des virgules.

3.11. Modules: le module math

Un module est une bibliothèque qui ajoute des fonctions au langage.

Pour utiliser un module, il faut tout d’abord l’importer. Pour le module math on écrit simplement une fois en début de programme: import math

Ce module contient divers fonctions: log, arrondi, fonctions trigonométriques, conversion degrés-radians, ...

Warning

Les angles sont en radians pour les fonctions trigonométriques.

Exemples d’utilisation:

mon_sinus = math.sin(0.5)

ma_racine = math.sqrt(16)

Noter qu’avec cette forme d’importation il faut préfixer le nom de la fonction par le nom du module.

Le module math contient également les constantes e et pi. Exemple:

r = 10
s = 2 * math.pi * r

Note

Par souci de lisibilité des programmes il est d’usage de placer tous les ‘import’ en début de ficher.

3.12. Documentation: aide en ligne

Dans l’interpréteur de commande Python la fonction help permet d’avoir un bref descriptif d’un module (notamment la liste des fonctions de ce module).

Pour consulter cette aide, le module doit préalablement avoir été importé:

import math
help(math)

On peut obtenir l’aide pour une seule fonction d’un module (toujours après importation), par exemple: help(math.sin)

3.13. Réinitialisation de l’interpréteur Python

Cette réinitialisation permet notamment de détruire toutes les variables et de faire d’oublier tous les modules qui ont été importés.

  • dans l’interpréteur Python: faire un CTRL-d et relancer l’interpréteur.

  • dans l’IDE idle: après l’exécution d’un programme depuis idle, les variables crées par ce programme sont encore visibles dans l’interpréteur interactif sous idle. Il est donc possible de les consulter par exemple pour vérifier le comportement du programme. Si l’on relance ensuite un programme (éventuellement le même) depuis idle, normalement idle fait une réinitialisation de l’interpréteur et l’on voit le message:

    ===================== RESTART =====================

Toutefois si idle a été lancé avec l’option -n, idle ne fait pas de restart et dans ce cas le module s’exécute alors avec des variables déjà crées. Pour éviter toutes interférences, il est possible de forcer un restart depuis la fenêtre “shell” de idle: menu “Shell”, commande “Restart Shell”.

Note

(AV) Il est possible de faire oublier un identificateur avec l’instruction del. Exemple:

x = 4
print 2 * x
del x
print 2 * x

Cette séquence d’instructions provoque un erreur lors du second print car la variable x n’est plus connue (elle a été effacée du dictionnaire des identificateurs par del.

3.14. Affichage: différence entre programme et mode interactif

Lorsque l’on utilise Python en mode interactif, tous les résultats sont affichés (sans nécessiter de print) chaque fois que l’on appuie sur la touche “Entrée”. En revanche lors de l’exécution d’un programme seul les affichages spécifiés par print sont écrits, les autres n’apparaissent pas sur l’écran.

3.15. Nombres: comment arrondir un flottant à la n_ième décimale ?

La fonction round(x,n) permet d’arrondir un flottant x à n décimales. Exemple:

x = 2.51
n = 1
y = round(x,n)
print y
print round(math.pi,4)

cette séquence d’instructions affiche: 2.5 puis 3.1416.

Warning

Le résultat de l’arrondi est lui même représenté de façon approchée, et par exemple round(3.56,1) peut tout à fait sur une plateforme renvoyer comme valeur 3.6000000000000001 au lieu de 3.6.