chapitre2-intro-python

Chapitre 2 et TP2, introduction `a Python : types de variables
Dans la plupart des langages de programmation, les variables sont class´ees par type. Python est
un langage assez souple sur les types, ce qui n’empˆeche pas de devoir bien savoir de quoi on parle
quand on manipule une variable. 1
Table des mati`eres
1 Jouons avec les types de nombres 2
1.1 Les nombres entiers et les op´erations sur ces nombres . . . . . . . . . . . . . . . . . . . 2
1.2 Les nombres d´ecimaux et rationnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Passage entre les types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.4 Pour toutes les fonctions math´ematiques non ´el´ementaires : le module math . . . . . 4
1.4.1 D`es qu’on veut faire une racine carr´ee... . . . . . . . . . . . . . . . . . . . . . . . 4
1.4.2 Autre fa¸con d’importer : import math ....................... 5
1.5 Les nombres complexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 Le type bool´een et les conditions logiques 6
2.1 A quoi sert un bool´een : souvent `a tester des conditions avec if ............. 6
2.2 Les conditions qu’on peut tester : comparaison . . . . . . . . . . . . . . . . . . . . . . . 6
2.3 Les connecteurs logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3 Excursion entre deux types : remarques sur les noms de variables 7
4 Les types “s´equentiels” 7
4.1 Les chaˆınes de caract`eres : type string ............................ 7
4.1.1 Deux types de d´elimiteurs pour les chaˆınes de caract`eres . . . . . . . . . . . . . 8
4.1.2 Un exemple o`u il est bien important de savoir quel est le type . . . . . . . . . 8
4.2 Les tuples : en fran¸cais les uplets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.2.1 Le d´elimiteur pour les tuples est la parenth`ese... ou rien.. l’essentiel est de
s´eparer par des virgules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.2.2 Le secret de l’affectation multiple... l’affectation en tuple . . . . . . . . . . . . 9
4.3 Manipulations communes aux chaˆınes et tuple . . . . . . . . . . . . . . . . . . . . . . . 9
4.3.1 Pour trouver la longueur : command len ...................... 9
4.3.2 Extraire un ´el´ement de tuple et de string : ..................... 9
4.3.3 Concat´enation, multiplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.3.4 Tester si un ´el´ement est dans une telle s´equence . . . . . . . . . . . . . . . . . . 10
4.3.5 Ce qu’on ne peut PAS faire avec des tuples ou des strings : modifier une entr´ee 10
4.4 Les listes : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4.4.1 D´elimit´ees par des crochets : elles sont modifiables . . . . . . . . . . . . . . . . 11
4.4.2 Tout ce que Python sait faire avec les listes : m´ethodes op´erant sur les listes 11
4.5 Transformations d’un type `a un autre : list, tuple,str ................ 12
4.6 Un autre type utile : les range ................................. 12
4.7 Remarque sur les types s´equences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1. En fait, en Python, il vaudrait mieux parler d’objet que de variable, nous y reviendrons.
1

1 Jouons avec les types de nombres
Python distingue les nombres entiers integer, et les nombres r´eels (ou complexes) qui sont dits
nombres en virgule flottante, float.Attention, 1,3 s’´ecrit, `a l’anglo-saxone, 1.3.
L’instruction type permet de savoir `a quoi on a affaire.
Par exemple essayons :
>>>type(1)
>>>type(1.0)
>>>type(1.)
>>>type(5/2)
En ligne de commande, Python effectue les op´erations usuelles +,-,*,/
>>> 2+2
4
Attention : L’exponentation, par exemple 23qui en g´en´eral se note par exemple 2^3 dans la
plupart des langages, se note avec une double ast´erisque en Python.
>>> 2**3
8
Rapidement, on s’aper¸coit qu’il est utile de stocker le r´esultat des calculs dans une variable,
comme suit :
>>> x=7*7
>>> x-12
37
Le symbole =est appel´e symbole d’affectation. A la premi`ere ligne on attribue `a la variable x
la valeur 7 ∗7.
Attention, l’affectation n’est pas un ≪´egal ≫math´ematique.
C’est une op´eration dissym´etrique : on ne pourrait pas poser 7*7=x
Dans d’autres langages de programmation cette dissym´etrie est plus explicite car on utilise
les symboles := ou ←.
Pour faire apparaˆıtre le contenu d’une variable, on utilise la commande print
>>> print(x)
49
N.B. Sur le print. Si on ex´ecute un fichier, Python ne r´eagit par exactement de la mˆeme
fa¸con qu’en ligne de commande. Ainsi, si on rentre dans un fichier (zone fichier de IEP) 2+2 et
qu’on ex´ecute, on ne verra rien. Il faut forcer l’affichage avec print.
1.1 Les nombres entiers et les op´erations sur ces nombres
Pour les entiers, se pose le probl`eme de la division. Par exemple, en Python 3 :
>>>8/2
4.0
Le r´esultat de la division 8/2 est un flottant.
Pour rester dans le monde des entiers, on utilise l’op´erateur de division enti`ere //
>>> 8//2
4
2

Remarque. En Python 2, 8/2 donne un entier. C’est une diff´erence importante entre les deux
versions. En T.P. tester sous I.E.P. en changeant le shell dans l’onglet Python (le plus `a gauche).
Plus pr´ecis´ement, pour deux entiers, en Python 2, le /donnera toujours le quotient de la division
euclidienne. Donc en Python 2, 1/3 donnera ....
Les entiers peuvent ˆetre des nombres tr`es grands ! On va le voir en prenant des puissances
>>>4567**23234
On a d´ej`a parl´e de // qui donne le quotient de la division euclidienne. Le reste de la division
euclidienne s’obtient avec %
>>> x=14//3
>>> y=14%3
>>> print(x)
4
>>> print(y)
2
Noter bien que, tant que le diviseur best positif, c’est la la division euclidienne du cours de
maths, mˆeme si l’entier aest n´egatif. Rappelons le
Th´eor`eme 1. ∀(a, b)∈Z×N∗,∃!(q, r)∈Z2, a =bq +ret 0 ≤r<b.
Autrement dit, le reste est toujours positif, donc que donne :
>>> -14//4, -14%4
Remarque, la r´eponse est couple ou 2-uple, car en Python, en s´eparant les entr´ees par des
virgules, on cr´ee des uplets.
Une alternative est la commande divmod
>>> divmod(-14,4)
1.2 Les nombres d´ecimaux et rationnels
Par d´efaut, tous les nombres non entiers en Python sont des float, des flottants, c’est-`a-dire
des nombres `a virgules. (Nous reviendrons plus pr´ecis´ement sur la fa¸con dont ces nombres sont
sp´ecifi´es en machine dans un prochain cours).
Cela provoque des probl`emes pour certaines manipulations, car ces flottants ont une pr´ecision
limit´ee.
Par exemple :
>>> 0.1+0.1
0.2
>>> 0.1+0.1+0.1
0.30000000000000004
Etrange non ? On comprendra la raison de ce ph´enom`ene un peu plus tard (il est li´e `a l’´ecriture
binaire de 0.1).
Il existe toutefois des modules qui permettent de traiter les d´ecimaux plus convenablement.
>>> from decimal import *
>>> Decimal(’1.1’)+Decimal(’2.2’)
Decimal(’3.3’)
>>> Decimal(’0.1’)+Decimal(’0.1’)+Decimal(’0.1’)
Decimal(’0.3’)
3

Remarque 1 La premi`ere ligne importe tout le contenu du module decimal. C’est le sens de
l’ast´erisque *comme dans le syst`eme d’exploitation (cf. T.P.1).
Remarque 2 les nombres entre quotes forment en fait pour Python une chaˆıne de caract`eres
cf §4.1.
De mˆeme, il existe un module fractions pour g´erer tous les nombres rationnels :
>>> 1/3+2/5
0.7333333333333334 # c’est pas bien hein ?
>>> from fractions import *
>>> Fraction(1,3)+Fraction(2,5)
Fraction(11, 15)
>>> Fraction(5,15)
Fraction(1, 3)
>>> a=Fraction(1,3)
>>>type(a)
<class ’fractions.Fraction’>
La r´eponse dit qu’il s’agit d’une Fraction du module fractions
1.3 Passage entre les types
Les commandes int,float transforment en entier, en flottant. Par exemple
>>> a=Fraction(1,3)
>>> b=float(a)
>>> b
0.3333333333333333
Sur un flottant int va enlever ce qui est apr`es la virgule : on parle de troncature et pas de
partie enti`ere (`a cause des n´egatifs).
>>> int(4.3)
4
>>> int(-3.3)
-3
1.4 Pour toutes les fonctions math´ematiques non ´el´ementaires : le mo-
dule math
1.4.1 D`es qu’on veut faire une racine carr´ee...
Si on veut faire plus que les quatre op´erations, on doit charger le module math.
>>> sqrt(2)
Traceback (most recent call last):
File "<console>", line 1, in <module>
NameError: name ’sqrt’ is not defined
>># Il n’est pas content hein ?
>> from math import *
>> sqrt(2)
1.4142135623730951
Comment voir toutes les fonctions pr´esentes dans un module, pour nous dans math ? La com-
mande dir() permet de voir toutes les commandes possibles, on peut comparer ce qui se passe
avant l’importation de math et apr`es. Dans ce cas, les commandes de math ont ´et´e rajout´e `a la
liste des commandes disponibles. Noter que les autres commandes sont rang´ees dans des modules
comme __builtins__, voir par exemple dir( __builtins__).
4

1.4.2 Autre fa¸con d’importer : import math
Essayons, apr`es avoir ouvert un nouveau shell :
>>> import math
>>> dir(math)
On verra toute la liste des commandes dans math. Bizarrement la commande dir(math) ne marchait
pas avec l’autre m´ethode d’importation. La raison : on avait import´e tout le contenu du module
math, mais pas avec le nom math.
A priori, cette m´ethode pour importer math peut sembler un peu plus lourde `a l’usage. En effet,
en repartant `a z´ero dans un shell :
>>> import math
>>> sqrt(2)
Traceback (most recent call last):
File "<console>", line 1, in <module>
NameError: name ’sqrt’ is not defined
La commande sqrt n’est pas connue. En revanche :
>>> math.sqrt(2)
1.4142135623730951
>>> math.pi
3.141592653589793
Cette fa¸con de faire a cependant des avantages : les fonctions et variables sont bien s´epar´ees
par modules, elles ne vont pas s’´ecraser lors de l’importation d’un nouveau module.
Supposons qu’on ait besoin d’une variable qui s’appelle e. On ne la confondra pas avec
>>>math.e
2.718281828459045
Pour all´eger
>>> import math as m
>>> m.e
2.718281828459045
1.5 Les nombres complexes
Quand vous utiliserez les nombres complexes en physique, comme la variable id´esigne l’intensit´e
du courant ´electrique, vous verrez que la coutume est de les ´ecrire plutˆot a+jb avec a, b des r´eels
et jtel que j2=−1. Cette notation est celle utilis´ee en Python
z=2+3j # sans signe * entre 3 et j
w=4+5j
>>> z*w
(-7+22j)
Cependant cette notation n’est pas tr`es commode, et on pr´ef`ere parfois :
z=complex(2,3)
5