TP no 1 : Prise en main de Python

Lycée Victor Hugo
MPSI-PCSI 2016-2017
TP no 1 : Prise en main de Python
Introduction
Lors de cette séance, nous allons faire connaissance avec le langage Python, plus précisément la version Python 3. Nous n’utiliserons pas directement Python ; nous passerons
par un environnement de développement intégré (en anglais IDE : interactive development environnement) appelé Pyzo.
Nous découvrirons les types de données les plus élémentaires que nous aurons à manipuler : nombres entiers, nombres flottants, booléens, quelques opérations simples réalisables sur ces types de données. Nous aborderons également la notion de variable et le
mécanisme de l’affectation.
I
Lancement de l’IDE Pyzo
Lancer Pyzo : le professeur vous donnera les instructions pour réaliser cette opération.
Une fenêtre apparaît, contenant diverses sous-fenêtres. La sous-fenêtre « shell » doit
présenter quelques lignes ressemblant à
Python 3.4.1 | Continuum Analytics , Inc .| ( default , May 19 2014 ,
13:02:30) on Windows (64 bits ) .
This is the IEP interpreter with integrated event loop for PYSIDE
.
Using IPython 2.1.0 -- An enhanced Interactive Python .
?
-> Introduction and overview of IPython ’s features .
% quickref -> Quick reference .
help
-> Python ’s own help system .
object ?
-> Details about ’ object ’ , use ’ object ?? ’ for extra
details .
In [1]:
Dans cette fenêtre, le symbole In [1]: est le prompt (ou invite) de Python 1 .
Nous pouvons y saisir des instructions élémentaires du langage Python (s’étendant éventuellement sur plusieurs lignes) et observer le résultat, qui apparait derrière un indicateur
Out portant le même numéro :
In [2]: 6*7
Out [2]: 42
1. Quand on utilise Python directement (sans utiliser d’IDE), il s’agira plutôt de >>>.
1
Lycée Victor Hugo
MPSI-PCSI 2016-2017
Nous travaillons alors en mode « ligne de commande interactive ». Python se comporte
alors un peu comme une super calculatrice 2 .
Dans tous les exemples qui suivent, il faudra taper vous-même ce qui se
trouve après le prompt, puis appuyer sur la touche Entrée . Python répond
alors sur la ligne suivante. La maîtrise d’un langage de programmation passe
essentiellement par la pratique !
II
1
Types simples. Valeurs.
Entiers
Python peut manipuler des entiers, positifs ou négatifs, et de taille quelconque.
Tapez les exemples suivants. Ici Python répond alors dans la ligne suivante, en se
contentant de redonner la valeur de l’entier considéré. Pour le moment rien de bien palpitant. Pour l’entier très grand, tapez ce que vous voulez...
In [1]: 1
Out [1]: 1
In [2]: 2
Out [2]: 2
In [3]: -75925
Out [3]: -75925
In [4]: 2 5 6 9 4 8 2 6 5 1 4 0 5 1 4 5 9 1 0 5 6 1 0 5 8 6 1 5 1 5 9 1 5
Out [4]: 2 5 6 9 4 8 2 6 5 1 4 0 5 1 4 5 9 1 0 5 6 1 0 5 8 6 1 5 1 5 9 1 5
Attention Dans les versions antérieures de Python, il y avait deux types d’entiers : les entiers
et les entiers longs. Cette distinction a disparu à partir de la version 3.
On peut alors faire des calculs habituels sur ces entiers de manière très naturelle.
Addition, soustraction, multiplication s’obtiennent ainsi :
In [5]: 5 + 9
Out [5]: 14
In [6]: 5 - 8
Out [6]: -3
In [7]: 78 * 45
Out [7]: 3510
In [8]: 2 5 6 9 4 8 2 6 5 1 4 0 5 1 4 5 9 1 0 5 6 1 0 5 8 6 1 5 1 5 9 1 5 *
71202130156150456015261056
Out [8]:
18295263817931976953295246176894869801857309201762623706240
2. Dans le TP suivant, nous verrons qu’il est possible d’enregistrer des ensembles d’instructions dans
des fichiers, appelés scripts, que l’on pourra faire exécuter par Python, toujours à partir de Pyzo.
2
Lycée Victor Hugo
MPSI-PCSI 2016-2017
La notion de type est fondamentale en informatique. On peut le tester pour les expressions déjà manipulées, à l’aide de l’instruction type. Ici Python répond par “ int ”,
ce qui signifie que les nombres manipulés sont de la classe integer, i.e. des nombres entiers
(relatifs).
In [10]: type (5)
Out [10]: int
In [11]: type (6)
Out [11]: int
In [12]: type (5 + 6)
Out [12]: int
In [13]: type (5 - 6)
Out [13]: int
In [14]: type (5 * 6)
Out [14]: int
Tout ceci est bien naturel, puisque la somme, la différence et le produit de deux entiers
sont toujours des entiers.
Il n’en va pas forcément de même pour la division, puisque en général le rapport de
deux entiers n’est pas un entier. Observons ce qui se passe :
In [15]: 8/3
Out [15]: 2. 66 66 66 66 66 666 66 5
In [16]: type (8/3)
Out [16]: float
On voit donc que le type du résultat d’une division est un nouveau type : le type
“ float ” (nombre à virgule flottante). On le remarque à cause du séparateur décimal (le
point “ . ” en Python).
À l’issue d’une division “ / ”, le résultat sera toujours un flottant, même si le résultat
est mathématiquement un entier :
In [17]: 8/4
Out [17]: 2.0
In [18]: type (8/4)
Out [18]: float
(noter la réponse donnée sous la forme 2.0, avec présence du séparateur décimal)
Attention donc :
— Le résultat d’une division est du type float.
— 2 et 2.0 ne sont pas la même « chose »(à proprement parler, on devrait dire que ce
sont deux types d’objets différents dans Python) car 2 est de type entier et 2.0 est
un nombre à virgule flottante, de type flottant.
Si on veut absolument avoir un résultat entier, il faut utiliser la division entière (division euclidienne). L’opérateur en Python correspondant est “ // ”, comme on le voit
3
Lycée Victor Hugo
MPSI-PCSI 2016-2017
ci-dessous 3 :
In []: 8 // 4
Out []: 2
In []: type (8 // 4)
Out []: int
In []: 8 // 3
Out []: 2
In []: type (8 // 3)
Out []: int
Si le résultat de la division tombe juste, on a donc la réponse exacte, sous forme d’un
entier. Sinon, a // b donne le quotient dans la division euclidienne de a par b (et c’est
aussi un entier).
Attention
Ce comportement était différent dans les versions antérieures de Python.
Pour prendre la puissance d’un entier on peut utiliser deux syntaxes différentes :
l’opérateur ** ou la fonction pow.
In []: 5 ** 4
Out []: 625
In []: pow (5 , 4)
Out []: 625
Nous avons déjà entrevu le type float, que nous approfondissons maintenant.
2
Nombres à virgule flottante
Il s’agit du type naturel pour représenter les nombres réels (et donc ceux utilisés pour
des calculs numériques).
Pour écrire un tel nombre on peut utiliser deux notations. La première utilise juste le
séparateur décimal.
In []: 256.32
Out []: 256.32
Si le nombre est trop grand ou trop petit, on peut utiliser la notation scientifique
en donnant sa mantisse et exposant. Par exemple, pour saisir le nombre 1, 619 . 10−19 ,
l’écriture 1.619*10**(-19) est pénible et peu lisible. On lui préférera toujours :
In []: 1.619 e -19
Out []: 1.619 e -19
In []: 1.619*10**( -19)
Out []: 1.619 e -19
# é criture lourde ...
# ... m ê me r é sultat !
Le “ e-19 ” est donc à remplacer mentalement par “ ×10−19 ”.
3. La numérotation des entrées/sorties n’ayant pas d’importance, on écrira In []: dans l’énoncé à
partir de maintenant.
4
Lycée Victor Hugo
MPSI-PCSI 2016-2017
On dispose bien sûr des mêmes opérations que sur les entiers : addition, soustraction,
multiplication, division, puissance. Ici pas de problème de typage : le résultat de ces
opérations sur deux float est un float.
In []: 6.5 + 3.2
Out []: 9.7
In []: type (6.5 + 3.2)
Out []: float
In []: 6.5 - 3.2
Out []: 3.3
In []: type (6.5 - 3.2)
Out []: float
In []: 6.5 * 3.2
Out []: 20.8
In []: type (6.5 * 3.2)
Out []: float
In []: 6.5 / 3.2
Out []: 2.03125
In []: type (6.5 / 3.2)
Out []: float
Qu’en est-il si un des arguments est un entier et l’autre un nombre à virgule flottante ?
In []:
Out []:
In []:
Out []:
3 + 5.6
8.6
type (3 + 5.6)
float
Vous pouvez essayer avec les autres opérations : on constate donc que dans tous les
cas le résultat est de type float.
Abordons maintenant un point important qui sera développé dans le prochain cours :
les capacités d’un ordinateur étant finies, ce dernier ne peut pas manipuler de manière
exacte tous les nombres réels. Ceux-ci sont donc stockés sous forme approchée par la
machine, et les calculs effectués avec eux sont donc également nécessairement approchés.
Illustrons ceci par le petit exemple suivant :
In []: 0.1
Out []: 0.1
In []: 0.1 + 0.1
Out []: 0.2
In []: 0.1 + 0.1 + 0.1
Out []: 0 . 30 0 0 00 0 0 00 0 0 00 0 0 4
5
Lycée Victor Hugo
MPSI-PCSI 2016-2017
On voit qu’en apparence 0.1 et 0.1+0.1 sont traités de manière exacte. Mais ce n’est
qu’une apparence comme le montre le dernier calcul. La conclusion à tirer est qu’il faut
toujours être prudent vis-à-vis de la précision obtenue dans des calculs numériques avec
des nombres à virgule flottante. Tout ceci sera abordé plus en détail dans le cours.
3
Booléens
Le type booléen ne peut prendre que deux valeurs : vrai / faux. En Python, ce type
s’appelle bool, et les deux valeurs possibles qu’il recouvre s’appellent True et False. Attention à la majuscule, sans quoi Python ne reconnaîtra pas ces valeurs et provoquera
une erreur. Il sert essentiellement pour les instructions conditionnelles (tests) étudiées dans
le prochain TP.
In []: True
Out []: True
In []: False
Out []: False
In []: type ( True )
Out []: bool
In []: false
# oubli de la majuscule !
----------------------------------------------------------------NameError
Traceback ( most recent call last )
< ipython - input -5 -74 d9a83219ca > in < module >()
----> 1 false
NameError : name ’ false ’ is not defined
Une réponse de type bool est produite lorsqu’on compare deux expressions à l’aide
est plus grand que 3,14,
d’opérateurs de comparaison. Par exemple, pour savoir si 22
7
on peut écrire ;
In []: 22/7 > 3.14
Out []: True
Les opérateurs de comparaison à connaître sont les suivants :
==
!=
<
<=
>
>=
est
est
est
est
est
est
égal à
différent de
strictement inférieur à
inférieur ou égal à
strictement supérieur à
supérieur ou égal à.
Attention Pour tester si deux expressions sont égales, il faut utiliser == (deux signes
“ égal ”) et non = (qui sert à l’affectation des variables).
In []: 6*7 == 48
Out []: False
6
Lycée Victor Hugo
MPSI-PCSI 2016-2017
In []: 6*7 = 42
File " < ipython - input -57 -12 c0b6687a2d > " , line 1
6*7 = 48
^
SyntaxError : can ’t assign to operator
In []: 6*7 == 42
Out []: True
On peut tester des affirmations plus complexes en utilisant des opérateurs logiques.
Les trois principaux sont le suivants :
not “ non ”, contraire logique
and “ et ” logique
or
“ ou ” logique (inclusif)
Essayez de bien comprendre les exemples suivants 4 :
In []: not (2 > 3)
Out []: True
In []: (4*5 > 20) and (9 -4*3 <= 0)
Out []: False
In []: (4*5 > 20) or (9 -4*3 <= 0)
Out []: True
Dressez sur un papier la table de vérité des trois opérateurs logiques not, and et or
en faisant calculer à Python tous les cas possibles. En voici deux :
In []: True and False
Out []: False
In []: True or False
Out []: True
Table de vérité du not
not True False
/////
Table de vérité du and
and
True False
True
False
False
Table de vérité du or
or
True False
True
True
False
Une case est déjà remplie d’après les essais précédents.
Remarque Dans la fenêtre shell, vous disposez d’un historique des commandes déjà tapées
dans lequel vous pouvez naviguer à l’aide des touches flèche vers le haut et flèche vers le bas .
Cela permet de gagner un peu de temps et d’éviter de taper trop de choses.
4
Autres types
Il existe bien d’autres types moins rudimentaires et plus structurés. Nous en étudierons
certains dans la suite du cours. On peut citer :
— les chaînes de caractères,
4. Les parenthèses ne sont pas obligatoires mais peuvent rendre le code plus clair.
7
Lycée Victor Hugo
MPSI-PCSI 2016-2017
— les listes,
— les tuples,
— les dictionnaires...
8