Cours Python

Séance 1

Python
 Première version 1989 par Guido van
Rossum ●
Développé par la Python Software Foundation.
●

Open source.
Semi-interpreté (bytecode) multiplateformes.
●

Portable.
Orienté objet
●

Dynamique
●
 Python

Portable

Linux
MacOS
Windows
Solaris
...

3
 Typage dynamique
Python a un système de typage dynamique fort.

●
dynamique = variables non déclarées, non typées (les
types sont inférés au moment de l'exécution)

4
 Syntaxe

●
simple, claire, minimale, explicite, uniforme

●
préférences pour des mots (anglais) vs

symboles

5
 Implémentations
Comme pour C on a plusieurs compilateurs, de même
pour Python on a plusieurs implémentations

CPython (implémentation de référence)

●

Jython
●

IronPython
●

PyPy
●
 6

CPython
Implémentation de référence, par GvR et la PSF
●

Programmée en C
●

Interpréteur
●

La nouvelles caractéristiques du Python sont

●

normalement introduite dans CPython

 www.python.org

Jython
Implémentation en Java
●

exécuté sur la Java Virtual Machine :

●

Python → Java bytecode

 Interopérabilité avec modules Java
●

http://www.jython.org/

IronPython
Implémentation en C#.
●
 Interopérabilité avec les librairies des
●

plateformes .NET et Mono

http://ironpython.net/

PyPy
 Implémentation en (sous-ensemble de)
Python ●
Très innovante, rapide, basée sur un compilateur Just
●

In-Time (JIT)

www.pypy.org

Attention ! PyPy ≠ PyPI

 10

PyPI
PyPI = Python Package Index
une collection de packages (>90000) pour

Python https://pypi.python.org/pypi
 11

Python : 2.x vs 3.x

Deux version incompatibles :

version 2 :
● version courante : Python 2.7.14 non

développée, « bugfixing mode »

●
version 3 :
● version courante : Python 3.6.4

activement
développée●

12

Dans ce cours nous utiliserons principalement

: ● CPython
● on 3
versi
Deux mode d'usage
: ● mode interactif
● pt
scri

13

Mode
interactif
Boucle REPL
(comme la shell unix)

READ EVALUATE PRINT

LOOP

14

Mode interactif
$ python3
Python 3.5.2 (default, Sep 14 2016, 11:28:32)
on linux
[GCC 6.2.1 20160901 (Red
Hat 6.2.1-1)]
"license"
Type "help", for more
"copyright", "credits" or
information.
>>> 5+5
10
>>> 3==3 EVALUATE
True
>>> print('Hello') Hello
>>> PRINT
READ
15
 Mode interactif

Le résultat des instructions est immédiatement visible (sans

phase de compilation etc...)

idéal pour expérimenter

16
 Mode interactif
Prompt primaire : >>>
Prompt secondaire (pour instructions sur plusieurs lignes) :
...
>>> 5 + 3 * (9
... + 7) / 2
29
>>>

On peut couper une instruction longue avec un antislash \

>>> 5 + 3 + \
... 2 + 1
11
>>>
20

Script
Script = fichier avec séquence
d'instructions Exemple 1 : fichier « test1.py
»

test1.py
print(5 + 5)
print("Hello world")
print("Ciao")

% python3
test1.py 10
Hello world
Ciao
%

18

Script
Exemple 2 : fichier exécutable « test2 »

test2
#!/usr/bin/env python3

print(5 + 5)
print("Hello world")
print("Ciao")

% chmod +x test2
% ./test2
10
Hello world
Ciao
%

19

Options de l'interpréteur

python3 -c "print(5)"
●

exécuter une commande et sortir

python3 -i monscript.py
●

passer en mode interactif après exécution

d'un script
 20

Commentaires
Les commentaires commencent par un dièse #, jusqu'à la fin de la
ligne.

>>> x = 5 # Affectation
>>>
Pas de commentaires multi-lignes du style /* ... */

26

Variables, objets, types

 27

Variables
Une variable est créée et définie par
affectation. Une variable est effacée par
l'opérateur del. >>> x = 30
>>> x
30
>>> x = 'hello'
>>>x
'hello'
>>> del x
>>> x
Traceback (most last):
recent call
File line <module>
"<stdin>", 1, in
NameError: name 'x' is
28
>>>
not defined

Variables
Nom des variable (et tous les identificateur) : lettres minuscules (a à
z), lettres majuscules (A à Z), chiffres (0 à 9), caractère souligné (_)
En Python 3 : certains caractères Unicode sont permis (caractères
accentués, alphabets grec et arabe, etc...)

Attention :
● un nom de variable ne doit pas débuter par un chiffre

python est sensible à la casse : foo ≠ Foo

●

on ne peut pas utiliser un mot « réservé

»●

29

Types
 Le système des types en Python est très riche.
Types de haut niveau. Les principaux :
– Booléens (bool)
– Numériques (int, float, complex)

– Chaînes (str, bytes)

s
– Séquences (list, tuple, ...)
e

l
– Dictionnaires, a.k.a. « Tableaux associatifs » (dict)
b

é
– Ensembles (set)
t

Le type d'un objet est donné par la fonctionne type.

Notion de mutabilité.
 33

Booléens
Deux constantes, True et False
(attention aux majuscules !)

>>> x = True
>>> type(True)
<class 'bool'>
>>> type(x)
<class False
>>> 3 'bool'>
> 5
 34

Types numériques
Entiers (int), avec précision arbitraire
●

Floating point (float), équivalent de « double » en

C●
Complexes (complex)
●
 35

Types numériques
>>> 10 # int
10
>>> 0.6 0.6 # float
>>>
 notation scientifique
3.5e-25 # float,
3.5e-25 5j #
>>> 3 + complex
(3+5j)
* 1j # Attention, 1j
et non pas j
>>> 1j (-1+0j)

36

Types numériques
Les opérations principales :
 + addition

- soustraction

* multiplication

/ division

** puissance

// division entière

% modulo

37

Types numériques
Le nom d'un type est souvent aussi
une fonction de conversion :
>>> x x int(6
>>> 6 = .66)

>>> x =
float(2) >>> x
2.0

38

Détour : les attributs

Python est orienté objet : tout est un objet, même les nombres. Un objet peut

avoir des attributs = des donnés qui appartiennent à l'objet. Les attributs

sont accessibles avec la notation :

nom_objet.nom_attribut

>>> x = 3.1 + 5.2j

>>> type(x)
<class 'complex'>
>>> x.imag # Attribut 'imag' de x
5.2
>>> type(x.imag)
<class 'float'>
39

Chaînes
Les chaînes (str) sont un type immuable.
Chaîne = séquence de caractères.

>>> s1 = 'spam'
>>> s2 = "foo"
>>> s3 = phrase
'''longue
... sur lignes''
plusieur ' s3
s
... >>>
'longue phrase\nsur
plusieurs\nlignes' >>> s4 = """une
autre
... longue phrase"""
 40

Chaînes
Les caractères d'échappement : pour introduire des caractères
spéciaux.
>>> print('J\'ai faim')
J'ai faim

Autres séquences : \t pour la tabulation, \n pour newline, etc...

>>> print('\tSeptembre\n\tOctobre')
Septembre
Octobre
 41

Chaînes
Les chaînes aussi ont des attributs. Certains sont des fonctions :

>>> s = 'spam'
>>> s.upper()
'SPAM'
>>> s.capitalize()
'Spam'
>>> s.find('a')
2
 42

Chaînes formatées
Équivalent de la fonction C printf. On a une chaîne de contrôle à
formater, où certaines balises sont remplacées par des valeurs.
Ancienne méthode :
Les séquences sont introduites par le caractère %
Les arguments suivent l'opérateur « modulo » % :
>>> "Hello %s" % "Alice"
'Hello Alice'
>>> "%s a %i ans" % ("Luc", 20)
'Luc a 20 ans'
>>> "La valeur de PI 3.14'
est %.2f" 'La % 3.14159
valeur de PI est

43

Chaînes formatées
Nouvelle méthode :
Le séquence sont du genre {n}, avec n un entier. Les arguments
apparaissent dans la fonction format :
>>> "{0} a {1} ans".format("Luc", 20)
'Luc a 20 ans'
>>> print("{0} {1} {0} {1}
{0}\n{2}".format('une rose', 'est', 'Gertrude
Stein'))
une rose est une rose est une rose
Gertrude Stein

Beaucoup d'options disponibles (décimales, alignement, ...),

voir https://docs.python.org/3/library/string.html
44

Listes
Collection (mutable) d'éléments de type arbitraire, construite avec
des crochets et des virgules:
>>> liste = ['bleu', 'rouge', 'vert', 'jaune']

Accès aux éléments par indice :

>>> liste[0]
'bleu'
>>> liste[2]
'vert'
>>> liste[-1]
'jaune'
>>> liste[-2]
'vert'
46

Listes
La même syntaxe permet de modifier les éléments d'une
liste :

>>> a = [1, 2, 3]
>>> a[0] = 99
 >>> a
[99, 2, 3]

47

Listes
Pour l'extraction d'une sous-liste on utilise la syntaxe liste[début:fin], qui génère une
nouvelle liste avec les éléments compris entre les indices début et fin-1 : >>>
liste = ['bleu', 'rouge', 'vert', 'jaune'] >>>
liste[0:2]
['bleu', 'rouge']
On peut omettre les indices :
>>> liste[2:]
['vert', 'jaune']
>>> liste[:2]
['bleu', 'rouge']
>>> liste[:] # idiome courante pour copier une liste
['bleu', 'rouge', 'vert', 'jaune']
48

Listes
Attention à la différence :
[10, 20, 30,
40, 50]
>>> liste =
>>> liste[1] # un élément
20

>>> liste[1:2] # une liste

[20]

49

Listes
Concaténation avec l'opérateur « + » :
 >>> a = ['lundi', 'mardi']
>>> b = ['mercredi', 'jeudi']
>>> a + b
['lundi', 'mardi', 'mercredi', 'jeudi']

50

Listes
Opérations qui modifient la liste :
>>> a = [1, 2, 3, 4, 5, 6, 7]
>>> a.append(8) # ajoute un élément au fond
>>> a
[1, 2, 3, 4, 5, 6, 7, 8]

>>> # renvoie le dernier élément et l'efface de la liste

>>> a.pop()
8
>>> a
[1, 2, 3, 4, 5, 6, 7]

51

Listes
La fonction list.insert(pos, element) ajoute un élément à la
position pos :
>>> >>> 3, 99) a
a.insert(
[1, 2, 3, 99, 4, 5, 6, 7]

Autres fonctions : reverse, sort, extend ...

>>> a.reverse(); a
6, 5, 4, 1]
[7, 99, 3, 2,
a.sort();
>>> a
2, 3, 4, 6, 99]
7, [1, 5,

>>> [1, , -2, 2, 3, 99, -1, -2,

a.extend([-1 4, 5, 6, 7, -3]
-3]); a
 52

Listes
Attention !
L'affectation ne copie pas une liste (étiquettes et objets) :
= [1, 2,
>>> x 3] = x
>>> y
>>> x[0] =
99 >>> y
[99, 2, 3]
 53

Tuples

Les tuples sont des listes immuables, définis par des

parenthèses et virgules :

>>> t = (20, 30, 40)

>>> t = () # vide
Tuple
>>> t = (30,) "singleton"
# Le tuple
 54

Tuples
L'accès aux éléments et l'extraction de sous-tuples suit la même syntaxe
que les listes :
>>> t = (20, 30, 40)
>>> t[0]
20

Mais :
>>> t[0] = 99
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support
item assignment
55

Tuples

Extraction d'un sous-tuple :

>>> t = (20, 30, 40, 50,

60) >>> t[1:3]
(30, 40)
 56

Listes et tuples
Conversion entre listes et tuples :

>>> t = (20, 30, 40, 50)

>>> liste
>>> liste [20, 30,
= list(t)>>> t2 =
>>> t2 te) 40,
(20, 30,
40, 50] 50)
tuple(lis

57

Structures de contrôle
 58

Tests
Les instructions conditionnelles sont introduites par les mots
réservés if...else :

x = 5
parenthèses de la condition
# Il n'y a pas de if x == 5:
print('Vrai print(x) autour « :
') »
# Notez le
print('Faux')
# Notez le « : »
else:

59

Tests à plusieurs cas

Pour les tests à plusieurs cas, on utilise if...elif...else
if x < 0:
print('Nombre negatif')
elif x == 0:
print('Zero')
elif x % 2 == 0:
print('Nombr positif pair')
e else:

print('Nombre positif impair')

60

Comparaisons
Les principaux opérateurs de comparaisons sont :

< inférieur à
<= inférieur ou égal à
> supérieur à
>= supérieur ou égal à
== égal à
!= différent de
in appartenance

is Identité (en tant qu'objet)

61

Comparaisons
Les connecteurs logiques sont des mots : and, or, not
Pas de symboles ! && || !

>>> 0 == 0 and 3 < 5

True
>>> -1 > 0 or 'foo' == 'foo'
True
>>> not True
False
>>> not 1 in [1, 2, 3]
False
>>> 1 not in [1, 2, 3] # plus lisible
False
62
 Bloc d'instructions
Les blocs sont définis par l'indentation, qui fait donc partie de la
syntaxe de Python.
Dans chaque bloc, l'indentation est arbitraire mais constante.

# Valide
if x == 5:
print 'vrai'
print x
# Erreur
if x == 5:
print 'Vrai' 63

print x
 Bloc d'instructions
# Valide, mais pas conseillé !
if x == 5:
print('vrai')
print(x)
else:
print('faux')
print('blah')

Normalement, 4 espaces
(https://www.python.org/dev/peps/pep-0008/#indentation)
64
 Bloc d'instructions
Blocs imbriqués :

# Un point a coordonnées (x,y)

:'
print
'Le
point
est dans if y > 0:
if x > 0:
print('le quadrant I')
print('le demi-plan supérieur')
elif y < 0:
if x < 0:
 print('le quadrant III')
print('le demi-plan inférieur')
65

Bloc d'instructions
 66

Boucles
En Python on a la boucle for, mais il est un peu différent de ce qu'on
trouve normalement ailleurs.
Avec for on peut itérer sur les éléments d'un objet itérable (e.g.
list, tuple, dict, ...) = un objet qui peut lister ses éléments
l'un après l'autre .

people = ['Ahmed', 'aicha', 'Omar',

'Laila'] for person in people:
print(person)

67

Boucles
Pour reproduire le for traditionnel on peut itérer sur une liste d'entiers :
# Print the squares 0, 1, 4, ... 81
for x in [0, 1, 2, 3, 4, 5, 6, 7, 8,
9]: print(x**2)

Heureusement, il y a une fonction range(n) qui génère une liste de

nombres entiers entre 0 et n-1:
for x in range(10):
print(x**2)

68

Boucles
La boucle while :

x = 0
while x < 10:
print(x)
x = x + 1

69

Interaction avec l'utilisateur

On peut utiliser la fonction input pour demander à l'utilisateur
d'entrer une chaîne :

>>> s = input()
bonjour
>>> s
'bonjour'

73

Interaction avec l'utilisateur

La fonction input accepte un argument facultatif, utilisé comme
« prompt » :

>>> s = input('Entrez un mot :

') Entrez un mot : bonjour
>>> s
'bonjour'

74