06/09/2020

Langage Python

Fondamentaux
Cours

© Copyright 2020 Cyril Keime & Arnaud Bêche

 PREAMBULE

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 2

 Pourquoi un cours ?
• Les outils utilisés par un ingénieur sont
souvent dotés d’une interface utilisateur
graphique et manuelle : appareils de mesure, Travail quotidien de l’ingénieur

Excel, outils d’exploitation, de dépouillement,

d’analyse, etc.

• Pour réduire les actions manuelles au strict

minimum, pour augmenter la productivité, pour
éviter les erreurs de saisie, pour maîtriser la Automatisation de son activité à l’aide de
scripts Python pilotant les outils et
configuration des données utilisées, utiliser un réalisant les traitements
langage de programmation tel que Python est
un progrès notable.

• Python est aussi beaucoup utilisé dans

d’autres domaines : prototypage rapide, Langage versatile, à la fois professionnel et
développement web, langage de script pour grand public (voir projet Raspberry Pi)
progiciel ou jeu vidéo, etc.
05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 3
 Le cours…

• Objectif : maîtriser les bases du

langage Python et savoir ce qu’il
est possible de faire.

• Le cours est divisé en sessions de

courte durée, théorique (cours et
échanges avec l’intervenant) et
pratique (exercice et assistance
directe de l’intervenant).

• L’ensemble des supports de cours

est disponible sur le site du
cours :
https://learnpython.ovh

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 4

 Les modules…

PRINCIPAL ATELIER

COURS METEO
PYTHON VIEWER
COMPLEMENT

IHM
PYQT
COMPLEMENT

CALCULS
SCIENTIFIQUES
ANNEXE

REGLES DE
CODAGE

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 5

 TABLE DES MATIERES

Introduction
Environnement de développement
Bases du langage
Fonctions et modules
Classes et programmation orientée objet
Paquetages standards
Conclusion
Annexe
05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 6
 INTRODUCTION

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 7

 Langage compilé
C, C++, Haskell, Erlang…

Code source
Plusieurs
étapes

Compilateur
Code assembleur

Code objet
Assembleur (ou code binaire)

Linker
Exécutable
(ou éditeur de liens)

MAÎTRISE DE LA MACHINE

Traduction en code machine avant l’exécution

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 8
 Langage interprété
Python, Javascript, Lua, Java, Ruby, Perl…

Code source
Pas de
compilation

Code de machine
Interpréteur virtuelle (bytecode)

Exécution
Machine virtuelle

PRODUCTIF / MAQUETTAGE RAPIDE

Traduction en code machine au fur et à mesure de l’exécution

Exécution plus lente qu’un programme compilé
05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 9
 Programme Hello,world!
#include <stdio.h>
#include <stdlib.h>
C int main() {
char msg[100] = "Hello,world!"; 7 lignes
(1971)
printf("%s\n", msg);
exit(0);
}

#include <iostream>
#include <string>
using namespace std;
C++ int main() {
8 lignes
(1983) string msg = "Hello,world!";
cout << msg << endl;
return 0;
}

Python msg = 'Hello,world!' 2 lignes

(1991) print(msg)

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 10

 Programmation impérative
C, bash…
• Le problème à résoudre est vu comme une suite d’étapes
modifiant l’état du système jusqu’à la résolution :

Etape Etape Etape

A … B
1 2 n

• Un développeur peut donc coder chaque étape et la tester

unitairement. OK avec Python

• A la fin, tout est assemblé et le logiciel permet d’obtenir B à

partir de A !

• Inconvénient : une étape isolée de son contexte n’est pas

forcément réutilisable…
05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 11
 Programmation impérative
Langages objet : C++, Java…
• Le problème à résoudre est vu comme la collaboration
d’entités autonomes encapsulant un état évolutif :

A Objet 1 Objet 3 B

Objet 2
• Un développeur peut donc coder chaque objet et le tester
unitairement. OK avec Python

• A la fin, tout est assemblé et le logiciel permet d’obtenir B à

partir de A !

• Avantage : un objet isolé de son contexte est très souvent

réutilisable !
05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 12
 Programmation déclarative
Langages fonctionnels : Haskell, Erlang…
• Le problème à résoudre est vu comme une suite de
fonctions autonomes sans effet de bord :

Fonction Fonction Fonction

A … B
1 2 n

• Un développeur peut donc coder chaque fonction et la

tester unitairement. En partie OK avec Python

• A la fin, tout est assemblé et le logiciel permet d’obtenir B à

partir de A !

• Avantage : une fonction isolée de son contexte est

réutilisable et sûre !
05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 13
ENVIRONNEMENT DE
DEVELOPPEMENT

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 14

 Écrire et exécuter un programme

• Python est un langage interprété.

• En pratique, Python est un logiciel

installé dans un système (Windows,
Linux, Mac, etc), et se présente sous la
forme d’un exécutable.

• Deux modes d’exécution :

– Mode interactif :
• Au sein d’une console texte interactive (shell).
• Les commandes sont saisies au clavier et
exécutées une par une.
– Mode fichier :
Vocabulaire
• Dans une console de l’OS ou au sein d’un
éditeur, spécialisé ou non.
Fichier .py module
• Le fichier entier est lu et exécuté. Script Python module
• Exemple dans une console Windows : Programme Python plusieurs modules
python.exe test.py Paquetage Python plusieurs modules

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 15

 IDLE - Integrated DeveLopment Environment

• IDLE est un environnement très simple

fourni avec Python.
EXERCICE
• Il permet de combiner le mode interactif
et le mode fichier. Stocker le résultat de l’opération 5/2 dans
une variable, puis afficher cette variable à
l’écran.
• Mode d’emploi :
1. En mode interactif
– Lancer IDLE. Un shell Python apparaît.
2. En mode fichier
–Choisir File / New File (Ctrl-N) pour
créer un nouveau module.
– Saisir le code du module dans la Indice :
nouvelle fenêtre. print('Hello,World!')
– Exécuter le module : F5. Les résultats
s’affichent dans la première fenêtre.
Autres éditeurs :
Utiliser un encodage UTF-8. Eclipse avec Pydev
Ne pas utiliser de vraies tabulations. PyCharm
(touche TAB = 4 espaces)

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 16

 Documentation

• La documentation de Python est très

Le site python.org
bien faite, et contient de très nombreux
exemples de mise en œuvre. Il contient beaucoup d’informations sur le
langage… ainsi que la documentation
complète et à jour.
• Il est indispensable de savoir naviguer
https://www.python.org/
dans la documentation pour trouver
l’information cherchée.

• Deux chapitres de la documentation

sont utilisés couramment :
– Tutorial
(start here)
– Library Reference type(objet)
(keep this under your pillow) help(objet)

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 17

 BASES DU LANGAGE

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 18

 Les listes (1/5)

• Le type liste est fondamental en

programmation Python.
EXERCICE
• L’utilisation de listes doit être un réflexe,
et la syntaxe doit être connue sans
hésitation. Créer deux listes de 3 éléments, a et b.
• Une liste peut contenir des données de Créer une troisième liste contenant, dans
tout type. l’ordre :

Créer une liste vide • Les éléments de a

a = []
a = list() • Le dernier élément de b
Créer une liste
a = ['lorem', 'ipsum', 12]
• Le premier élément de a
Ajouter un élément • Les éléments de b
a.append(34)
Concaténer deux listes
c = a + b Afficher la liste créée.
Accéder au n ième
élément
a[n-1]

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 19

 Les listes (2/5)

L=
a b c d e
>> 0 1 2 3 …
len(L)-1

… -len(L) -4 -3 -2 -1 <<
1 inclus, 3 exclus, -4 inclus, -2 exclus
Sous-liste de 2 éléments : 3-1 = -2-(-4) = 2
L[1:3] == L[-4:-2] == L[1:-2] == L[-4:3]

 En limite gauche, le début de la liste est noté ainsi : L[:3] == L[0:3]

 En limite droite, la fin de la liste est notée ainsi : L[-2:]
 Si besoin, limites gauche et droite ramenées aux bornes : L[-99:99] == L
 Si incohérence, liste vide : L[4:-1] == []

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 20

 Les listes (3/5)

• Accéder à des éléments :

Le premier / le dernier
EXERCICE
a[0] / a[-1]
Le nième élément depuis le début / la fin
a[n-1] / a[-n] Créer deux listes de 3 éléments, a et b.
Créer une troisième liste contenant, dans
• Extraire des sous-listes : l’ordre :

Toute la liste (ie copier une liste !) 1. Les deux premiers éléments de a
b = a[:]
Tous les éléments, sauf le premier 2. Les deux derniers éléments de b
a[1:]
Les deuxième et troisième éléments
a[1:3] Afficher la liste créée.
Les trois premiers éléments
a[:3]
Les trois derniers éléments
a[-3:]
Taille d’une liste L : len(L)

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 21

 Les listes (4/5)

• En Python, une boucle for opère sur

une liste.
EXERCICE
• La boucle for commence par le
premier élément de la liste, et se Soit le texte :
termine après avoir « consommé » le « Roma in Italia est »
dernier. Afficher le texte, un mot par ligne.

• A chaque itération, la variable muette

Indice :
prend la valeur d’un élément de la liste
(dans l’ordre). 'Lorem ipsum'.split()

for val in [-1, 99, 'foo', 'bar']:

print(val)
En Python, un bloc de code
for item in mylist: est délimité par son indentation.
print(item)

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 22

 Les listes (5/5)

• Il est possible d’utiliser une syntaxe très

concise pour créer des listes (appelée #!/usr/bin/python3
# -*- coding: utf-8 -*-
list comprehension).
a = [0, 1] * 5
print(a)
• En voici différents exemples :
– Création à partir d’une liste d’indices et d’une b = [i*i for i in range(10)]
transformation. print(b)
– Création à partir d’une liste source et d’une
sélection avec condition. c = [i for i in b if i < 50]
– Création à partir d’une liste source et d’une print(c)
transformation avec condition.
d = [i if i < 50 else -1 for i in b]
print(d)

e = [3, 2, 1]
Une liste dispose de méthodes f = sorted(e)
très utiles : cf Tutorial print(f)
5.1. More on Lists e.sort()
print(e)

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 23

 Les dictionnaires

• Le type dictionnaire est très utile : il

permet d’associer une valeur à une clé.
EXERCICE
• Comme une liste, un dictionnaire peut
contenir des données de tout type. Une Créer un dictionnaire à 3 entrées.
clé est généralement une chaîne de
caractères ou un nombre. Afficher les clés et les valeurs à l’aide
d’une boucle for.
Créer un dictionnaire vide
a = {}
a = dict()
Indice :
Créer un dictionnaire non vide a.keys()
a = {k1:v1, k2:v2, k3:v3}

Ajouter ou modifier un couple (clé, valeur)

a[k] = v

Accéder à la valeur associée à une clé

a[k]

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 24

 Les tuples

• Le type tuple est une généralisation de

la notion de couple : un couple est un 2-
EXERCICE
tuple.

• Un tuple permet de grouper des Créer un 3-tuple : une chaîne de

données disparates. Si une fonction caractères, une liste, un dictionnaire.
doit retourner plusieurs valeurs, elle
peut le faire via un tuple : Vérifier qu’il est impossible de remplacer la
return val1, val2, val3 liste ou le dictionnaire par autre chose,
mais qu’il est possible de faire évoluer leur
• A connaître : contenu !
– Créer un tuple (tuple packing)
Point important
• a = x, y, z
– Opération inverse (tuple unpacking) Un tuple est "immutable", contrairement à une
• x, y, z = a liste, qui est "mutable" :
– Obtenir le ième élément
• a[i-1] a[i] = object provoque une erreur

Attention… a[i] n’est pas forcément constant !

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 25

 Les named tuples (1/2)

• Un named tuple est un tuple dont les

champs sont nommés, ce qui permet
EXERCICE
une manipulation aisée :
Employee.name au lieu de
Employee[0] Créer un namedtuple Friend permettant de
stocker nom, prenom, telephone.
• Un named tuple fonctionne comme un Créer une liste d’amis et trier cette liste
tuple ! Il est cependant nécessaire de le avec sort(). Constat ?
définir au préalable. Créer un namedtuple Friend2 permettant
de stocker en plus une adresse, puis
• A connaître : convertir votre liste de Friend en Friend2.
(En Python 3 : utiliser l’opérateur *)
– Créer une classe namedtuple spécifique
• Point = namedtuple('Point', ['x', 'y'])
– Créer un namedtuple Point important
• p = Point(x=11, y=22) # ou Point(11,22)
En début de module, écrire :
– Manipuler les éléments d’un namedtuple from collections import namedtuple
• p.x + p.y # ou p[0] + p[1]
>>> 33
(fonctionnalité standard mais non native)

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 26

 Les named tuples (2/2)

• Depuis Python 3.6, un named tuple

peut être déclaré comme suit :
EXERCICE
from typing import NamedTuple
Trier votre liste par ordre décroissant de
class Employee(NamedTuple):
name: str numéro de téléphone.
id: int

Indice :
• Ce code est équivalent à :
Utiliser le paramètre key pour spécifier la
fonction de calcul de la clé.
Employee = namedtuple(
'Employee', ['name', 'id'])
def getkey(x):
return x.telephone
sort(key=getkey)
ou bien :
Consulter la
documentation !
sort(key=lambda x:x.telephone)

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 27

 Les itérables

• Un itérable est un objet pouvant être utilisé

par une boucle, avec les caractéristiques
d’une liste (début, fin, élément suivant).
# seq : séquence à transformer en
Note : un itérable peut être converti en une vraie liste. itérable (par exemple [1,2,3])
Si x est un itérable, list(x) est une liste contenant tous it = iter(seq)
les éléments que fournirait progressivement x. A next(it)
utiliser avec précaution !

# mylist : liste à énumérer

• Exemples de fonctions built-in renvoyant un for i,item in enumerate(mylist):
itérable : print(i, item)
iter()
enumerate()
zip() # klist : liste des clés
# vlist : liste des valeurs
d = dict(zip(klist, vlist))
• Obtention de l’élément suivant :
next()

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 28

 Les fichiers

• Ouvrir un fichier : open

– En écriture
• f = open('myfile.txt', 'w') EXERCICE
– En lecture
• f = open('myfile.txt', 'r')
– Ecrire une ligne Demander à l’utilisateur de saisir deux
•
•
f.write('Lorem ipsum\n')
f.write('Result: ' + str(result) + '\n')
valeurs numériques.
– Lire une ligne Enregistrer la somme et la différence dans
• line = f.readline() un fichier texte.
– Fermer un fichier NE PAS OUBLIER !
• f.close() Relire et afficher le fichier texte créé.

• Utiliser un bloc with et for : Indice :

s = input()
with open('myfile.txt', 'r') as f:
for line in f:
data = line.strip()[:72] En Python 2, écrire : s = raw_input()
print(data)
# fin du bloc with
# appel automatique de f.close() !

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 29

 Les conditions

• En Python, l’instruction if permet de

définir un test.
EXERCICE
if x > 0:
x -= 1

if x > 0:
Créer une liste vide, et une autre non vide.
x -= 1 Test sur des nombres Utiliser successivement chacune de ces
elif x == 0:
x = 10 deux variables comme expression d’une
else: condition.
x = -1
Idem avec des chaînes de caractères.
if s == 'Lorem': Test sur des chaînes de
if s != 'Lorem': caractères

if x: Test sur des booléens

if not x: if True: if 1:
if x and not y: if False: if 0:
L’instruction pass ne fait rien !
if item in mylist: Test sur des listes (mais remplace un bloc de code)
if item not in mylist: Très important !

if x is y: Test sur des objets

if x is None: is compare l’identité de
if x is not None: deux objets. None = null
05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 30
 Les boucles

• En Python, deux types de boucle sont

disponibles.
EXERCICE
• La boucle for, déjà étudiée, permet
d’exécuter un bloc de code pour Quel est l’effet d’une instruction break
chaque élément d’une liste, dans une boucle ?
successivement et dans l’ordre. Coder un exemple.
Idem avec l’instruction continue.
• La boucle while permet d’exécuter un
bloc de code tant qu’une condition est
vraie.
Chercher dans la
documentation Python !
for item in mylist:
pass

while expression:
pass

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 31

 Exceptions

• Certains morceaux de code sont

risqués et peuvent provoquer une
EXERCICE
erreur run-time.

• Gérer une erreur run-time est possible Demander à l’utilisateur de saisir un entier.
grâce aux exceptions. Si l’utilisateur saisit une valeur invalide,
gérer l’exception et renvoyer -1.
• Voici un exemple très simple de code
fatal : Indice :
1/0 Déterminer d’abord l’exception à gérer en
• Et de gestion d’exceptions : faisant un essai sans bloc try.
try:
1/0
except ZeroDivisionError:
print('Division par 0.')
except:
print('Erreur inattendue.')

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 32

 Pour finir…

liste = ['a', 'b', 'c']

• Une sélection de morceaux de code à for item in liste:
connaître et à réutiliser ! if item not in ['a', 'z']:
print(item)

result1 = 2.54
– Listes, boucle et condition result2 = float('+00002.540')
print('Result: ' + str(result1))
print('Result: ' + str(result2*100))
– Conversions nombre / chaîne de caractères print('Result: ' + str(int(result2)*100))

a = 1
b = 11
– Echange de deux valeurs a, b = b, a
print(a, b)

– Affichage formaté print('{} + {} = {}'.format(a, b, a+b))

print(f'{a} + {b} = {a+b}') # Python 3.6

d = {name[:3].upper():name for name in

– dict comprehension
['France', 'Australie', 'USA']}
print(d)

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 33

 FONCTIONS &
MODULES

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 34

 Les fonctions (1/4)

• Une fonction est un regroupement de

code. En Python, le mot-clé def permet
EXERCICE
de définir une fonction.

• Ce mot-clé permet aussi de créer des Développer la fonction spécifiée par :

fonctions membres d’une classe en
programmation orientée objet. Un ENTREE : une liste de phrases.
exemple sera donné dans la suite du
cours. TRAITEMENT :
- Créer un dictionnaire associant le
def myfunction(param1, param2):
premier mot de chaque chaîne à la
"""Ma fonction.""" chaîne elle-même.
sum = param1 + param2
diff = param1 - param2
- Trier la liste fournie en entrée par ordre
return sum, diff alphabétique.
print(myfunction(5, 3))

SORTIE : le dictionnaire et la liste triée.

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 35
 Les fonctions (2/4)

• Lors de la déclaration d’une fonction, il est def myfunctionA(param1, param2):

possible de donner une valeur par défaut à print(param1, param2)

chaque argument. def myfunctionB(param1, param2, param3=False, param4=0):

print(param1, param2, param3, param4)

• La valeur par défaut d’un argument est la def myfunctionC(param1, param2='a', param3=False, param4=0):
print(param1, param2, param3, param4)
valeur que prend l’argument s’il n’est pas
myfunctionA(1, 'a')
spécifié lors de l’appel de la fonction. myfunctionB(1, 'a')
myfunctionB(1, 'a', param3=True)
myfunctionB(1, 'a', param4=1)
• Par ailleurs, lors de l’appel d’une fonction, myfunctionB(1,
myfunctionB(1,
'a',
'a',
param4=1, param3=True)
True, 1)
il est possible de spécifier la valeur d’un myfunctionC(1)
myfunctionC(1, 'b')
argument quelconque de deux façons : myfunctionC(1, param4=1, param3=True, param2='b')

Par sa position : la valeur souhaitée est écrite

directement, et Python associe la valeur au bon
argument grâce à sa position dans l’appel.
D’abord les arguments « position »
Par son nom : le nom de l’argument devient un puis les arguments « mot-clé »
mot-clé permettant de spécifier sa valeur. Dans
ce cas, la position n’intervient pas.

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 36

 Les fonctions (3/4)

def getheadtemperature(config):
"""Get head temperature (°C)."""
simu, t = config
if simu:
headtemperature = [25 + i*2.5 for i in range(24)]
return headtemperature[t]
else:
return testbench.gettemperature()

def getemittedpower(config):
"""Get emitted power (W).""" Un exemple à étudier !
simu, t = config
if simu:
emittedpower =\
[1000, 1025, 1050, 1075] +\
[1100 - i*50 for i in range(20)]
return emittedpower[t]
else:
return testbench.getpower()
05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 37
 Les fonctions (4/4)

def runtest(simu=False):
"""Run test (24 h)."""
reporttemplate = '{:4d}; {:4.1f}; {:4.0f}'
report = []
report.append('{:4}; {:4}; {:4}'.format('time','temp','pow'))
for t in range(24):
headtemperature = getheadtemperature((simu, t))
emittedpower = getemittedpower((simu, t))
report.append(reporttemplate.format(
t,
headtemperature,
emittedpower))
for line in report:
print(line)
Un exemple à étudier !

#runtest()
simu = True
runtest(simu)

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 38

 Affichage formaté

• Formater une chaîne de caractères

pour un affichage sur écran ou un
enregistrement sur disque est une
bonne pratique.

• Méthode 1 : définir une chaîne de mytemplate = '{:2d} + {:2d} = {:3d}'

formatage, puis l’utiliser pour formater for a,b in [(1,2),(3,4),(99,99)]:
print(mytemplate.format(a,b,a+b))
plusieurs lignes : format strings

a = 5
• Méthode 2 : formater une chaîne de b = 6
manière immédiate : f-strings print(f'{a} + {b} = {a+b}')
print(f'{a:2d} + {b:2d} = {a+b:3d}')

f-strings : Python 3.6+

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 39

 Les modules (1/3)

• Un module est un fichier Python (.py)

contenant du code réutilisable, et
EXERCICE
définissant un espace de noms.

• Un module peut donc être réutilisé, via Importer le paquetage standard permettant
la commande import, dans un autre de gérer la date et l’heure.
module ou script Python.
Afficher l’heure courante.
• Ce mécanisme est fondamental pour
organiser le code correctement, et
permettre sa maintenance.
import module
import module as name
• La commande import permet aussi de from module import object
from module import object as name
réutiliser un ensemble complet de
modules, appelé paquetage (ou
package).

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 40

 Les modules (2/3)

#!/usr/bin/python3
• Un module doit être organisé, et sa # -*- coding: utf-8 -*-
structure peut être normalisée. """
Multi-line comment.
(module)
• Ci-contre un exemple de normalisation, """

à suivre dorénavant pour toute création import os

de module. import sys
– Fichier source unicode.
– Description du module. def myfunction(myarg):
"""Multi-line comment.
– Utilisation des paquetages standards os et
(function)"""
sys.
print('myfunction')
– Définition d’une fonction (plusieurs fonctions print(myarg)
peuvent être définies, ainsi que des classes). pass # Do nothing.
– Définition d’une fonction de test du module.
– Test de lancement du module par la def mytest(): # Module test.
commande import. print('mytest')
myfunction('This is a test.')
pass # Do nothing.

if __name__ == '__main__':
mytest()
05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 41
 Les modules (3/3)

• Un module peut être utilisé de deux

manières différentes :
– Exécution directe.
EXERCICE
– Importation par la commande import.
Saisir le code donné en exemple.
• Exécution directe :
– python mymodule.py
– Dans ce cas la condition de fin est vraie, et la
Dans une console système, exécuter le
fonction de test est exécutée. module. Que constatez-vous ?
– Autrement dit, il s’agit d’une méthode très Dans une console Python, importer le
simple pour implémenter et exécuter un test module. Que constatez-vous ?
unitaire de module.

• Commande import :
– import mymodule
sys.path est la liste des dossiers
– Dans ce cas la condition de fin est fausse, et
pouvant contenir un module
la fonction de test n’est pas exécutée.
– Les constantes, fonctions et classes du
module importé sont maintenant disponibles !

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 42

 CLASSES &
POO

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 43

 Notion d’objet

• Un objet est un conteneur qui contient des informations et des mécanismes.

• Souvent un objet représente informatiquement quelque chose de tangible,
appartenant au monde réel.
• Les informations sont des variables appelées attributs ou données membres
qui caractérisent l’état de l’objet.
• Les mécanismes sont des fonctions appelées méthodes ou fonctions membres
qui manipulent les attributs de l’objet pour en modifier ou retourner l’état.
• Un objet est créé (instancié) à partir d’un modèle appelé classe.
• Une fois créé un objet est manipulé via son interface publique (un sous-
ensemble documenté des attributs et des méthodes destiné à l'utilisateur).
• La programmation orientée objet (POO) consiste à structurer un programme
comme un ensemble d'objets : la plupart des variables et des fonctions
appartiennent aux objets ("sont rangés" dans des objets).
• Le développement du code consiste alors à définir les modèles d'objets
(classes), à créer (instancier) les objets à partir des classes et à programmer la
manière dont ils interagissent les uns avec les autres (relations entre objets).

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 44

 Notion d’objet

Exemple : simulation de robots autonomes sur un circuit (équipe R contre équipe D)

x
Création d’un robot :
D1 r1 = Robot("R", x=0, y=0)
R1
en-but

en-but
D2 Déplacement d'un robot :
R2
r1.deplacer([r2, d1, d2], w, h)
4 objets « Robot », 1 objet « Plateau »,
y 1 objet « Jeu »

Robot Plateau Jeu

Attributs Equipe : "R" ou "D" Largeur : w 1 liste de N robots

Position : x, y Hauteur : h 1 plateau
Direction : theta

Méthodes initialiser() Aucune initialiser()

deplacer(liste_autres_robots, (il n’évolue pas) next()
xmax, ymax)

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 45

 Définition d’une classe

• Une classe est modèle d'objet class MyClass:

"""La classe."""
regroupant des données et des def __init__(self): # Constructeur
fonctions. En Python, le mot-clé class self.wordlist = ['Lorem', 'ipsum']
permet de définir une classe.
def addword(self, word):
"""Add a word."""
• Une fonction membre (ou méthode) est self.wordlist.append(word)
définie comme une fonction normale, def getid(self, n):
avec deux contraintes : """Compute id of word list."""
– Elle doit être définie dans le bloc de code de result = ''
la classe. for word in self.wordlist:
– Elle a forcément un premier argument, result += word[:n]
habituellement nommé self. Cet argument return result
permet d’identifier l’objet appelant.
c = MyClass()
c.addword('New word...')
• Une fois l’objet créé, une méthode peut print(c.getid(1))
être appelée en omettant le premier print(c.getid(3))
argument (il est implicite). print(c.wordlist)

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 46

 Définition d’une classe

class Robot:
    def __init__(self, equipe, but, x=0, y=0):
        self.equipe = equipe
        self.but = but
        self.x = x
        self.y = y
        if self.but > 0:
            self.angle = 90
        else:
            self.angle = -90
    
    def deplacer(self, autres_robots, xmax, ymax):
        # coder ici une stratégie de déplacement vers le but
        # self.x = ...
        # self.y = ...
        # self.angle = ...
        pass

class Plateau:
    def __init__(self, width, height):
        self.width = width
        self.height = height

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 47

 Définition d’une classe

class Jeu:
    def __init__(self, width, height):
        self.plateau = Plateau(width, height)
        self.liste_robots = [ Robot("R", self.plateau.width, 0, 0), 
Robot("R", self.plateau.width, 0, self.plateau.height),
                              Robot("D", 0, self.plateau.width, 0), 
Robot("D", 0, self.plateau.width, self.plateau.height)]
    
    def next(self):
        # déplacer tous les robots
        for robot in self.liste_robots:
            autres_robots = self.liste_robots[:]
            autres_robots.remove(robot)
            robot.deplacer(autres_robots, self.plateau.width, self.plateau.height)
        # une équipe a-t-elle gagné ? (en pseudo-code)
        si tous les robots R sont arrivés à droite:
            return "R"
        sinon si tous les robots D sont arrivés à gauche:
            return "D"

if __name__ == "__main__":
    jeu = Jeu(20, 10)
    while True:
        vainqueur = jeu.next()
        if vainqueur:
            print(f"L'équipe {vainqueur} a gagné")
            break

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 48

 Méthodes spéciales

• Une classe peut définir un certain

class A:
nombre de fonctions spéciales. Parmi def __init__(self, state):
ces fonctions : self.state = state
__str__(self) : cette méthode doit renvoyer
def __repr__(self):
une chaîne de caractères décrivant l’objet, et return f'repr={self.state}'
compréhensible par un être humain. Appelée
implicitement par print(). def __str__(self):
return f'str={self.state}'

__repr__(self) : cette méthode doit renvoyer a = A(42)

une chaîne de caractères décrivant print(a)
complètement l’objet d’un point de vue s = str(a)
print(s)
informatique. l = [A(i) for i in range(5)]
print(l)

• Remarques :
__repr__() remplace __str__() si celle-ci
n’est pas définie. En pratique,
toujours définir
__repr__()
__str__() d’un conteneur (list par exemple)
utilise __repr__() pour le contenu.

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 49

 Méthodes spéciales

__eq__(self, obj) : cette

méthode compare l'objet self à un
autre objet obj du même type (égalité class A:
des attributs). Elle renvoie True en def __init__(self, state):
self.state = state
cas d'égalité, False sinon. Elle est
appelée lorsque deux objets sont def __eq__(self, obj):
comparés avec l'opérateur == if self.state == obj.state:
voir aussi : __lt__, __le__, __gt__, return True
__ge__, __ne__ return False

def __add__(self, obj):

return A(self.x + obj.x)
__add__(self, obj) : cette
a1 = A(42)
méthode retourne un nouvel objet, a2 = A(40)
qui est la somme (au sens qu'en a2 == a1 => False
donnera le code de la méthode) de a3 = A(42)
l'objet self et de l'objet obj. Elle est a3 == a1 => True
appelée lorsque l'opérateur + est
a4 = a1 + a2
utilisé entre deux objets de la classe
a4 == A(82) => True
considérée
voir aussi : __sub__, __mul__

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 50

 Exercice : mini Pacman (1ère partie)

EXERCICE

Partir des fichiers model.py, view.py et game.py fournis (disponibles sur learnpython.ovh).
Dans le module model.py :

Compléter la classe Point

Créer les attributs x et y (de type entier) dans le constructeur

Implémenter la méthode __repr__ A faire également :

Ajouter une méthode permettant d’ajouter deux objets Point (__add__) • Tester la comparaison de 2 objets Point avant
d’implémenter la méthode __eq__

Ajouter une méthode permettant de comparer deux objets Point (__eq__) • Analyser le comportement de Python lors de

Compléter la classe Entity la « copie » d’un objet, par exemple :

Attributs de la classe définis dans le constructeur : p1 = Point(1, 2)
p2 = p1

Utiliser la classe Point pour stocker la position courante de l’entité (Réponse : création d’une référence et non copie !)

Utiliser la classe Point pour stocker la position précédente de l’entité

Utiliser une chaîne de caractères pour stocker le nom de l’entité

Implémenter la méthode __repr__

Méthode move() : implémenter la fonction pour déplacer l’entité de 1 case (diagonales autorisées) de manière aléatoire mais en
respectant les règles suivantes :

L’entité ne doit pas rester sur place

L’entité ne doit pas revenir à sa position précédente

L’entité doit rester dans le cadre fourni en arguments (xmin, ymin, xmax, ymax)
Important : Tester ces classes pendant le codage ! Pour cela, créer une fonction de test dès le début et tester les fonctionnalités au fur
et à mesure qu’elles sont implémentées.

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 51

 Exercice : mini Pacman (1ère partie)

EXERCICE

Dans le module game.py :


Avant la boucle du jeu :

Créer un objet Board (classe définie dans view.py) de dimensions w (width) par h (height)

Créer 3 objets Entity et les positionner initialement dans 3 des coins du Board

Rem : donner un nom d’un seul caractère (ex : "A", "B", "C"…) aux entités.

Créer une liste contenant ces 3 entités

Afficher le board et les entités dans leur état initial, en utilisant les méthodes de la classe Board

Puis, dans la boucle du jeu :

Déplacer chaque entité en appelant leur méthode move() (utiliser une boucle for pour itérer sur la liste d’entités)

Afficher à nouveau le board et les entités

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 52

 Exercice : classe Complexe

EXERCICE

Créer une classe capable de représenter un nombre complexe et de traiter les opérations suivantes :
• Retourner la partie réelle
• Retourner la partie imaginaire
• Implémenter __repr__()
• Retourner le module
• Retourner l’argument
• Modifier la valeur en inversant le nombre complexe
• Modifier la valeur en ajoutant un autre nombre complexe.

Important ! Tester cette classe pendant le codage !

Pour cela, créer une fonction de test dès le début et tester les fonctionnalités au fur et à mesure qu’elles
sont implémentées.

Pour les plus rapides : définir des opérateurs pour cette classe : +, *
Note : complexe est un type de base en Python. Voir la documentation !

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 53

 Notions de programmation orientée objet

– Classes et instances de classe (les Note : utiliser la décoration @staticmethod pour

définir une méthode de classe
objets).

– Encapsulation : les attributs d’une

Préfixer par __ (double underscore) un attribut
classe ne doivent être connus/modifiés ou une méthode qui doit être inaccessible de
que par la classe elle-même. (Utilisation l’extérieur de la classe (membre privé).
de méthodes get/set.) Utiliser le mécanisme property() pour
Mécanisme Python décrit ci-contre. implémenter les méthodes get/set d’un attribut.

– Héritage : une classe peut être définie class BaseClass:

comme l’extension d’une autre classe. def __init__(self, a):
self.a = a
Mécanisme Python décrit ci-contre.
class MyClass(BaseClass):
def __init__(self, a, b):
– Polymorphisme : capacité d’exécuter super().__init__(a)
un code identique sur des objets self.b = b
différents, mais partageant une En Python 2, écrire :
interface. BaseClass.__init__(self, a)
Mécanisme Python implicite. à la place de :
super().__init__(a)

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 54

 Héritage : exemple
• Dans la simulation de robots, Alice et Bob veulent confronter leurs talents de
programmation, pour savoir qui a programmé le meilleur robot.
• Dérivons la classe Robot en classes RobotAlice et RobotBob
class RobotAlice(Robot):
    def deplacer(self, autres_robots, xmax, ymax):
        # méthode deplacer programmée par Alice
        pass

class RobotBob(Robot):
    def deplacer(self, autres_robots, xmax, ymax):
        # méthode deplacer programmée par Bob
        pass

• Le constructeur de Jeu instancie des RobotAlice (équipe R) et des RobotBob (équipe D)

class Jeu:
    def __init__(self, width, height):
        self.plateau = Plateau(width, height)
        self.liste_robots = [ RobotAlice("R", self.plateau.width, 0, 0), 
RobotAlice("R", self.plateau.width, 0, self.plateau.height),
                              RobotBob("D", 0, self.plateau.width, 0), 
RobotBob("D", 0, self.plateau.width, self.plateau.height)]

• Le reste du programme est inchangé

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 55

 Exercice : mini Pacman (2ème partie)

EXERCICE

Dans le module model.py :


Créer une classe Pacman en dérivant la classe Entity

Réimplémenter la méthode move() de Pacman de la manière suivante :

L’argument de la méthode est une liste d’entités à pourchasser

L’entité Pacman se déplace en direction de l’entité la plus proche de lui (déplacement de 1 case, incluant les diagonales)

Lorsque le Pacman est arrivé sur la case d’une entité, la méthode retourne l’entité dévorée (sinon elle retourne None)
Dans le module game.py :

En dehors de la boucle de jeu : créer un objet de type Pacman, en le positionnant initialement dans le 4e coin disponible

Dans la boucle de jeu :

Déplacer le Pacman à chaque tour en appelant sa méthode move()

Si le Pacman a dévoré une entité, retirer cette entité de la liste des entités du jeu

Ajouter le Pacman à la liste des entités affichées par la méthode draw_entities() de Board

Modifier la condition d’arrêt de la boucle du jeu, pour que celle-ci s’arrête dès que le Pacman a dévoré toutes les entités

Important : Tester ces classes pendant le codage ! Pour cela, créer une fonction de test dès le début et tester les fonctionnalités au fur
et à mesure qu’elles sont implémentées.

Pour les plus rapides : Dériver la classe Entity pour créer une classe TeleportableEntity qui implémente une entité capable de se téléporter
n’importe où (en restant dans le tableau) tous les 5 déplacements (le reste du temps elle se déplace de manière aléatoire comme une
entité normale).

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 56

 Exercice : classe FigureGeometrique

Attention ! Ne pas oublier ()

lors de l’appel d’une fonction
EXERCICE ou d’une instanciation

1. Écrire une classe FigureGeometrique définissant une interface de classe contenant les fonctions
Perimetre() et Surface(). Ajouter également à la classe FigureGeometrique un attribut privé nommé
« NomObjet » de type chaîne de caractères. Implémenter la méthode __repr__().

2. Écrire une classe Rectangle et une classe Cercle héritées de la classe FigureGeometrique et
implémentant les fonctions Perimetre() et Surface(). Le constructeur des classes Rectangle et Cercle permet
d’initialiser le nom et les dimensions des objets créés.

3. Écrire une classe Carre héritée de la classe Rectangle.

4. Créer et initialiser des objets des classes Rectangle, Carre et Cercle puis stocker ces objets dans une
liste.

5. A l’aide d’une boucle, afficher le nom, le périmètre et la surface de chaque objet, sans réaliser de test
sur le type ou le nom de l’objet.

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 57

 PAQUETAGES
STANDARDS

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 58

 math

math — Mathematical functions

• This module is always available. It

provides access to the mathematical
functions defined by the C standard.

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 59

 os.path

os.path — Common pathname

manipulations

• This module implements some useful

functions on pathnames. To read or
write files see open(), and for accessing
the filesystem see the os module.

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 60

 datetime

datetime — Basic date and time types

• The datetime module supplies classes

for manipulating dates and times in both
simple and complex ways. While date
and time arithmetic is supported, the
focus of the implementation is on
efficient member extraction for output
formatting and manipulation. For related
functionality, see also the time and
calendar modules.

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 61

 random

random — Generate pseudo-random

numbers

• This module implements pseudo-

random number generators for various
distributions.
A retenir :
• For integers, there is uniform selection shuffle, choice, randint

from a range. For sequences, there is

uniform selection of a random element,
a function to generate a random
permutation of a list in-place, and a
function for random sampling without
replacement.

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 62

 pickle

class MyClass:
pickle — Python object serialization def __init__(self, a):
self.a = a
• The pickle module implements a
fundamental, but powerful algorithm for # Serialize
serializing and de-serializing a Python import pickle
from myclass import MyClass
object structure. “Pickling” is the l = [MyClass(123), MyClass('abc'),
process whereby a Python object MyClass(10**10)]
hierarchy is converted into a byte f = open('myclasslist.bin', 'wb')
pickle.dump(l, f,
stream, and “unpickling” is the inverse
pickle.HIGHEST_PROTOCOL)
operation, whereby a byte stream is f.close()
converted back into an object hierarchy.
Pickling (and unpickling) is alternatively
# Deserialize
known as “serialization”, “marshalling,” import pickle
[1] or “flattening”, however, to avoid f = open('myclasslist.bin', 'rb')
confusion, the terms used here are l = pickle.load(f)
f.close()
“pickling” and “unpickling”.
for instance in l:
print(instance.a)

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 63

 re

re — Regular expression operations

• This module provides regular

expression matching operations similar
to those found in Perl. Both patterns
and strings to be searched can be
Unicode strings as well as 8-bit strings.

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 64

 unittest

unittest — Unit testing framework

• The unittest unit testing framework was originally inspired by JUnit and has a similar
flavor as major unit testing frameworks in other languages. It supports test
automation, sharing of setup and shutdown code for tests, aggregation of tests into
collections, and independence of the tests from the reporting framework.

• To achieve this, unittest supports some important concepts in an object-oriented

way:
– test fixture : a test fixture represents the preparation needed to perform one or more tests, and any
associate cleanup actions.
– test case : a test case is the individual unit of testing. It checks for a specific response to a particular
set of inputs.
– test suite : a test suite is a collection of test cases, test suites, or both. It is used to aggregate tests
that should be executed together.
– test runner : a test runner is a component which orchestrates the execution of tests and provides the
outcome to the user.

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 65

 CONCLUSION

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 66

 Pour aller plus loin…

Lire la documentation de Python

Consulter régulièrement python.org

Explorer le site https://learnpython.ovh

Apprendre avec la communauté Python sur le web

Apprendre avec des livres (Head First Python) ou des MOOC

Pratiquer !
05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 67
 M E R C I

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 68

 ANNEXE

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 69

 Morceaux de code
# Fonctions lambda
liste = [('a',1,'dummy'), ('x',2), ('y',2)]
print(liste)
liste.sort(key=lambda item: item[1], reverse=True)
print(liste)

# isinstance
a = 5
if isinstance(a, float):
print('a -> float')
elif isinstance (a, int):
print('a -> int')
print(isinstance ('', str))

# Opérateur +
class Book:
def __init__(self, title, nbpages):
self.title = title
self.nbpages = nbpages
def __repr__(self):
return '{} : {:d} pages'.format(self.title, self.nbpages)
def __add__(self, other):
return Book(' / '.join([self.title, other.title]),
self.nbpages + other.nbpages)
a = Book('Pavé', 1000)
b = Book('Résumé', 1)
print(a+b)
05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 70
 Morceaux de code

# * et **
def myfunc(*args, **kwargs):
s = ' '.join(args)
for k,v in kwargs.items():
s += ' {}={}'.format(k,v)
return s

print(myfunc('a'))
print(myfunc('a', 'b'))
print(myfunc('a', 'b', hello='world', good='bye'))

# set
a = {1,2,99,4,1,1,2,1,6,1,1,1,1,1,1,9,99,2}
print(a)
print(len(a))

b = [1,2,99,4,1,1,2,1,6,1,1,1,1,1,1,9,99,2]
c = list(set(b))
c.sort()
print(c)

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 71

 Morceaux de code

# Générateurs
# En lecture seule une seule fois et de longueur inconnue !
generator = (x**2 for x in range(3))
for val in generator:
print(val)
for val in generator: # vide...
print(val)

# yield
# Dans une fonction, la transforme en générateur !
def compute(exp):
mylist = range(3)
for i in mylist:
yield i**exp

generator1 = compute(2)
generator2 = compute(3)
for val in generator1:
print(val)
for val in generator2:
print(val)

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 72

 Morceaux de code

# for/else
def search(data, value):
for v in data:
if v == value:
print('FOUND')
break
else:
print('NOT FOUND')
v = None
return v
 
print(search([1, 42, 99, 51], 42))
print(search([1, 42, 99, 51], 43))
 
 
# with
with open('expourfinir3.py') as f:
for i,line in enumerate(f):
if i == 19:
print(line.strip())
break
05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 73
 Morceaux de code

# enum
from enum import Enum
class Color(Enum):
RED = 1
GREEN = 2
BLUE = 3
 
for const in Color:
print(const.value)
 
print(Color.RED is Color.RED)
print(Color.RED is Color.GREEN)
 
 
# itertools
import itertools
data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
print(data)
print(list(itertools.accumulate(data, max)))
print(list(itertools.compress(data, [1,0,1,0,1,1])))

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 74

 Morceaux de code

# next
def gencolours():
while(True):
yield 'RED'
yield 'GREEN'
yield 'BLUE'
colours = gencolours()
for i in range(10):
print(next(colours))
 

05/10/2020 © Copyright 2020 Cyril Keime & Arnaud Bêche 75