OOP -- K.

RHOFIR 1
  Introduction  Les fonctions
◦ Historique  Gestion des exceptions
◦ Domaines d’application
◦ Forces et faiblesses  Entrées sorties
 Script et langage python ◦ stdin/stout
◦ Quelques remarques utiles ◦ fichiers
◦ Modules et packages  Classes
◦ Importer  Commandes systèmes et
◦ Modules utiles
modules utiles
 Types de données standard ◦ Module os
◦ Types numériques
◦ Module re
◦ Séquences
◦ Chaines de caractères ◦ Module sys
◦ N-uplets et listes ◦ Module subprocess
◦ Dictionnaires  Exemples
◦ sets (ou ensemble) ◦ Pages web lapp
 Structures de contrôle ◦ PyROOT
◦ if/else
◦ for/while/do
 Documentation

OOP -- K. RHOFIR 2
 Introduction

 Langage relativement récent, été conçu à la

fin des années 1980 et son implémentation a
été lancée en décembre 1989 par Guido Van
Rossum (GvR) de CWI aux Pays-Bas en tant
que successeur d’ABC capable de gérer les
exceptions et de s’interfacer avec le système
d’exploitation Amoeba.
 Statut : BDFL (Benevolent Dictator For Life

OOP -- K. RHOFIR 3
 Introduction

 Langage dynamiquement interprété

 Open source pour interpréteur et
bibliothèque standard
 Orienté objet/Ramasse miettes/Facile
d’utilisation (d’appréhension)/souplesse
 Système de gestion d’exceptions
 Nombreux types d’utilisation/bibliothèque
spécialisées

OOP -- K. RHOFIR 4
 Introduction

 Administration système
 Applications Web
 Extension ou scriptage de
C++/C(cPython)/Java(JyThon)/Net(IronPython)
 Interfaces graphiques : usage interactif
 Remplacement environnements calcul (Matlab,
IDL, …)
 …

OOP -- K. RHOFIR 5
 Introduction

 Forces :
◦ Typage dynamique
◦ Langage de script
◦ Clarté, compacité, portabilité (multiplateforme, moins de maintenance, 5 à
10 fois moins de ligne de code que C/C++/Fortran/…)
◦ Vitesse de développement
◦ Erreurs facilement repérables : pas de pointeurs, pile d’appel des fonctions
◦ Pas de compilation : une seule erreur visible mais reste du code tourne =>
robustesse du code
◦ Grande communauté
◦ ….
 Faiblesses
◦ Lenteur à l’exécution
◦ Pas de binaire compilé en natif (.pyc)
◦ Peu d’optimisation de la part de l’interpréteur
◦ Pas de vérification statique du typage
◦ Pas de multithreading (mais librairie multiprocessing)
◦ Addiction très facile
◦ …

OOP -- K. RHOFIR 6
 Script et langage Python

 Pas de déclarations des variables (que des

identifiants : dynamiquement typés)
 La notion d’adresse d’un objet n’existe pas
 Tous les éléments manipulables sont des
objets c.à.d instances de classes, Classes,
Fonctions, Nombres, Chaînes de caractères…
 Identifiants servent à référencer les objets
 Abus de langage : type d’un identifiant ==
type de l’objet qui lui est associé

OOP -- K. RHOFIR 7
 Script et langage Python

 Identifiant principalement créé avec =, def et class

 Identifiants doivent commencer par une lettre ou
un "_" et peuvent contenir lettre, chiffres et le
caractère "_"
 Noms de fichiers doivent être construits comme
des identifiants pour pouvoir être importés
 Les variables doivent être instanciées directement
x => ne marche pas
a=1
a,b=1,2
s = "toto" Identifiant Objet
a=1
a 1
b=2
b 2
b=a

OOP -- K. RHOFIR
a=a+1
8
 Script et langage Python

 Variables locals, globals

◦ Les variables globales sont visibles avec globals()
◦ Les locals ne sont visibles que localement
(fonctions, classes), visualisation avec locals()
 Module __builtin__
◦ Espace des noms pré-définis dans Python (print,
dir, list, dict,str,…)
◦ print dir(__builtins__) permet de visualiser la liste
des objets prédéfinis

OOP -- K. RHOFIR 9
 Script et langage Python

Il existe deux modes de déclarations d'objets

python (variable, classes, fonctions,…)
 un module est un fichier ayant une extension de type
.py qui regroupe des déclarations d'objets
(existe également sous forme de librairie dynamique )

 un package est un répertoire dans lequel est défini un

fichier __init.py__ regroupant un ensemble de
modules ou de sous-packages
(organisation en sous-répertoires possible)

La localisation des modules et des packages est

définie par la variable d'environnement PYTHONPATH

OOP -- K. RHOFIR 10
 Script et langage Python

 On peut importer le contenu d’un module avec la

commande import :
import sys, os
print [Link]["os"] visualisation du nom du fichier physique importé
< module 'os' from '/usr/lib64/python2.3/[Link]'>

 Une partie d’un module, il n’est plus nécessaire de

préciser les identifiants par le nom du module :
[Link] ou from os import path
path

 Fonction dir() permet de lister le contenu d’un

objet (builtins, fonctions, …)
import os
print dir(os)
['EX_CANTCREAT', 'EX_CONFIG', 'EX_DATAERR', 'EX_IOERR’,…]

 Fonction help() : aide sur les modules

help(os)
help([Link])
OOP -- K. RHOFIR 11
 Script et langage Python

 Pour importer l’ensemble du contenu d’un module

from os import *
( tous les identifiants sont importés exceptés ceux dont le nom commence par __)

 Il est recommandé de ne pas importer l'ensemble du

contenu d'un module si cela n'est pas nécessaire :
Masquage des noms déjà définis
from os import * (masque la fonction open())

 Pour visualiser l'ensemble des identifiants importables

par un module : print (<nom_module>.__all__)
 Ne pas importer (charger) trop de modules : saturation
mémoire (lenteur)

OOP -- K. RHOFIR 12
 Script et langage Python

 Exemple :
mon_repertoire/calibration/
 [Link]
 __init.py__
import calibration : charge __init.py__
charge [Link] si [Link] est défini
dans __init.py__
from calibration import piedestal: charge calibration/[Link]
 Ordre :
[Link]
[Link]
[Link] (si +récent que .py) (  fichier binaire créé lors d'un
import )
[Link]
__init__ de <mon_repertoire>/calibration

 Il faut que <mon_répertoire> soit dans PYTHONPATH

OOP -- K. RHOFIR 13
 Script et langage Python

 sys (communication avec l’interpréteur python)

 math (opérations mathématiques)
 os (accès au système d’exploitation)
 shutils (fonctions sur les fichiers)
 getopt (gestion des options en ligne de commande)
 re (expressions régulières)
 logging (gestion de messages, débogage)
 copy (copie de structure complexes)
 random (nombres aléatoires)
 glob (listage de noms de fichiers)
 datetime (heure et date)
 urllib2 (interaction avec le web)
 tempfile (fichiers temporaires)
 codecs ( gestion des encodages de texte)
 numPy (tableaux)
 sciPy (calculs)
 mathplotlib (graphiques)

OOP -- K. RHOFIR 14
 Types de données standards

 Basiques
◦ Booléens (True ou False)
◦ Numériques
◦ Chaines de caractères
 Autres
◦ Séquences
(tuple, listes, en plus des chaînes de caractères)
◦ Dictionnaires
◦ Ensembles (sets)
◦ Fonctions et méthodes
◦ Classes
Pour connaître le type d'une variable v : type(v)

OOP -- K. RHOFIR 15
 Types de données standards

 int (entier long par défaut) : 3,4…

( taille max définie par la variable [-[Link] -1, [Link]])
 long, entier long (précision illimitée)
 float, flottant (basé sur double c++) : 3.13e10, 0.12
 complex, nombres complexes : 3.2+2.5j
Opération Résultat
pow(x,y) x puissance y
divmod(x,y) La paire (x//x,x%y)
[Link]() Le conjugué de c (si c ℂ)
float(x) Conversion de x en flottant
long(x) Conversion de x en entier long
int(x) Conversion de x en entier
str(x) Conversion de x en chaîne de caractère
OOP -- K. RHOFIR 16
 Types de données standards

Opération Résultat
abs(x) Norme de x
-x Opposé de x
x%y Reste de la division entière de x par y
x/y Division de x par y
x // y Division entière de x par y
x*y Produit de x et y
x–y Différence de x et y
x+y Somme de x et y
x ** y x puissance y

OOP -- K. RHOFIR 17
 Types de données standards

 math :
◦ sqrt
◦ Trigonométrie et inverse
◦ Exponentielle et logarithme
◦ Arrondis
◦ Constantes e et π (pi)
◦ >>import math
◦ >>[Link](argument)
◦ ou from math import fonction et fonction(argument)
 numpy : applications scientifiques
◦ Tableau : [Link]()
◦ Matrices : [Link]()
◦ Manipulations de ces objets :
 Redimensionner
 Concaténer
 matplotlib
◦ Visualisation 2D

OOP -- K. RHOFIR 18
 Types de données standards

Opération Résultat
x<y, x<=y x inférieur (ou égal) à y
x>y, x>=y x supérieur (ou égal) à y
x == y x égal? y (valeurs)
x is y Mêmes objets ?
x <> y, x != y x différent de y
x or y, x and y OU et ET logiques
x|y x ou y
x&y x et y
x^ y x ou exclusif y
~x Complément à 2 de x
x << y Décale x de y bits à gauche
x >> y Décale x de y bits à droite

OOP -- K. RHOFIR 19
 Types de données standards

 [Link]
Applicatif/[Link]/Formation_Python/Exos#Exo_comparais
on

OOP -- K. RHOFIR 20
 Types de données standards : les séquences

 2 familles :
◦ Non modifiables :
 Chaines de caractères on ne peut pas modifier le contenu d'une chaine ou
d'un n-uplet en accédant à un élément par son indice
 N-uplets (tuples)
◦ Modifiables : listes
 Indexation
◦ a=‘tapis’
◦ a[0]=t ⇒ séquences avec indice 1er 0
◦ a[-1]=s ⇒ -1 dernier élément de la série
◦ a[2:4]=pi ⇒ tranche i, j commence au ième fini au kème-1
◦ Copie d’une chaine ou séquence avec [:]
◦ Séquence en pas : a[début:fin:pas]

OOP -- K. RHOFIR 21
 Types de données standards : les séquences

Opérations sur les séquences

modifiables et non modifiables

Opération Résultat
x in s True si x ∈ s, False sinon
x not in s True si x ∉ s, False sinon
s+t Concaténation de s et t
s * n ou n * s Concaténation de s, n fois
s[i] ième élément de s
s[i:j] Tranche entre i et j dans s
len(s) Longueur de s
min(s) Plus petit élément de s
max(s) Plus grand élément de s

OOP -- K. RHOFIR 22
 Types de données standards : les chaines de caractères

 Séquences non modifiables

 Délimitation par des apostrophes, guillemets simples
ou triples :
◦ ‘formation ”python”’
◦ ”L’objectif”
◦ ”””L’objectif de cette formation ”python” est…”””
 Caractères spéciaux :\n, \t, \b
 Triples guillemets permettent le retour à la ligne dans
les chaines : documentation de code
Opération Résultat
c in s True si caractère c est dans s
unicode : u'blabla'
<, >, ==, Comparaisons alphanumériques rawstring : r'blabla'
!=
zip(a,b) Colle chaines a et b
OOP -- K. RHOFIR 23
 Types de données standards : les chaines de caractères

 On peut classer les méthodes en plusieurs

catégories :
◦ Gestion des espaces
◦ Gestion des majuscules et minuscules
◦ Test de la nature d’une chaine
◦ Recherche et remplacement
◦ Découpage et collage de chaînes
◦ Formatage
 Une nouvelle chaine est créée et renvoyée par
les méthodes
 L'appel à une méthode ne modifie pas la
chaine en elle-même

OOP -- K. RHOFIR 24
 Types de données standards : les chaines de caractères

Méthode Effet
strip() Supprime les espaces en début et fin de chaine
rstrip() Supprime les espaces en fin de chaine
lstrip() Supprime les espaces en début de chaine
rjust() Justifie le texte à droite pour la largeur demandée
ljust(width) Justifie le texte à gauche pour la largeur
demandée
center(width) Centre le texte pour la largeur demandée
isspace() Renvoie True s’il n’y a que des espaces
expandtabs(tabsize) Remplace les tabulations par des espaces

OOP -- K. RHOFIR 25
 Types de données standards : les chaines de caractères

Méthode Effet
upper() Remplace les minuscules par des majuscules
lower() Remplace les majuscules par des minuscules
capitalize() Passe la 1ère lettre de la chaine en majuscule et les autres
en minuscules
title() Formate comme un titre (1ère lettre de chaque mot en
majuscule, les suivantes en minuscules)
swapcase() Inverse les majuscules et minuscules

OOP -- K. RHOFIR 26
 Types de données standards : les chaines de caractères

Méthode Effet
startswith(prefix) True si la chaine commence par prefix
endswith(prefix) True si la chaine se termine par prefix
isupper() True si la chaine ne contient que des majuscules
islower() True si la chaine ne contient que des minuscules
istitle() True si la chaine est formatée comme un titre
isdigit() True si la chaine ne contient que des caractères
numériques
isalpha() True si la chaine ne contient que des caractères
alphabétiques
isalnum() True si la chaine ne contient que des caractères
alphanumériques

OOP -- K. RHOFIR 27
 Types de données standards : les chaines de caractères

Méthode Effet
index(sub) Renvoie l’index de la 1ère occurrence de la
chaine sub, exception si pas trouvée
rindex() Idem pour la dernière occurrence
find(sub) Comme index mais renvoie -1 si la chaine n’est
pas trouvée
rfind() Idem pour la dernière occurrence
count(sub) Retourne le nbr d’occurrence de la sous-chaine
replace(old, new [,max]) Remplace la sous-chaine old par new, au plus
max fois (par défaut, remplace toutes les
occurrences)
translate(table Supprime les caractères figurant dans
[,deletechars]) deletechar et remplace tous les autres par leur
correspondance dans table

OOP -- K. RHOFIR 28
 Types de données standards : les chaines de caractères

Méthode Effet
split([sep[,max]) Crée une liste de chaine en découpant la chaîne
suivant sep au plus max fois. Par défaut split
utilise les espaces, tabulations les sauts de ligne
comme séparateur
splitlines([keepend]) Crée une liste en découpant la chaine suivant les
sauts de lignes. Ces sauts de ligne sont
conservés si keepend est True
join(list) Concatène tous les éléments de list en utilisant
la chaine comme jointure. Tous les éléments de
la liste doivent être des chaines de caractères.

OOP -- K. RHOFIR 29
 Types de données standards : les chaines de caractères

 Il est possible de créer une chaine en formatant

son contenu avec l’opérateur %
◦ équivalent à printf de C
◦ print "Les chaines à formater sont %s et %s"
%(val1,val2)
 Les chaines à formater sont introduites par le
caractère % suivie du type de variable
Format Signification
%% Le caractère ‘%’
%s Chaîne
%c Caractère
%f Flottant
%e Flottant (notation expo)
%d Entier décimal
%x Entier hexadécimal
%o Entier octal
OOP -- K. RHOFIR 30
 Types de données standards : les chaines de caractères

 Les nombres aussi se formatent, ce qui est utile

pour le nombre de chiffres significatifs. Ceci est de
la forme [flag][taille][.presision] ex :
>>> print "val = %8.4f" %5.787767
val = 5.7878

Flag Signification
0 Chaine remplie de 0 à gauche
+ Mettre un ‘+’ devant les nombres positifs
⊔ Mettre un espace devant les nombres positifs
# Utiliser le format python pour notations
hexadécimales et octales

OOP -- K. RHOFIR 31
 Types de données standards : les chaines de caractères

Voir page Twiki :

[Link]
Applicatif/[Link]/Formation_Python/Exos#Exo_cha.C
[Link]

OOP -- K. RHOFIR 32
 Types de données standards : N-uplets et listes

 Tuples sont des séquences non modifiables, entre

parenthèses ou suite de valeurs séparées par des
virgules :
◦ (a, b, c)
◦ 1,2
◦ (1,) : seul manière de définir un tuple à un seul élément
◦ (1,["k7",1,-0.7],4.5,"z")

 Listes sont des séquences modifiables, entre [] :

◦ [a, (1,2), ”Python”]
◦ [(3,), (5,),] : possibilité de mettre une virgule après
dernier élément

OOP -- K. RHOFIR 33
 Types de données standards : N-uplets et listes

Opération Résultat

len(x) Taille de la séquence x

s[i]=x Affecte la valeur x au ième élément de s

del s[i] Supprime le ième élément de s

s[i:j]=t Remplace la tranche i:j par la séquence t

del s[i:j] Supprime la tranche i:j de s

s += t Ajoute le contenu de t à la fin de s

u=s+t Renvoie une nouvelle liste u dont le

contenu est la concaténation de s et de t

OOP -- K. RHOFIR 34
 Types de données standards : N-uplets et listes

Méthode Résultat
append(x) Ajoute x en fin de liste
insert(i,x) Ajoute x à l’index i
pop(i) Retourne et supprime l’élément d’index i ou le dernier
si i non précisé
remove(x) Supprime le 1er élément de valeur x
count(x) Retourne le nombre d’occurrences de x
index(x) Retourne l’index du 1er élément de valeur x
reverse() Renverse la liste
sort([func]) Trie la liste. Une fonction de comparaison peut être
donnée

OOP -- K. RHOFIR 35
 Types de données standards : N-uplets et listes

Si vous copiez une liste dans une autre avec

l'opérateur '=', les deux listes pointent sur la
même zone mémoire
Toute modification faite sur l'une des listes impacte l'autre

Pour copier une liste : lnew= linit[:]

[Link]
Applicatif/[Link]/Formation_Python/Exos#Exo_Listes

OOP -- K. RHOFIR 36
 Types de données standards : les dictionnaires

 Fonctionnent par correspondance clef / valeur

 Un dictionnaire est représenté avec des accolades, sous la forme
suivante {1:’Formation’,2:’Python’,3:’Lapp’}
(clefs :1,2,3 ; valeurs : ‘Formation', 'Python',’Lapp' )
 Les clefs peuvent être de type numérique, chaine de caractères ou
N-uplets, mais pas de type dictionnaire ou liste
 Les valeurs sont de type quelconque
 On peut faire une liste de dictionnaires
 L’ordre des éléments n’est pas conservé en manipulant les
dictionnaires
Opération Résultat
len(a) Nombre de valeurs dans a
a[k] Valeur de la clef k
a[k] = v Assigne la valeur v à la clef k
del a[k] Supprime la valeur a[k] de a
k in a True si existe valeur associée à la clef k
k not in a True si aucune valeur associée à la clef k
OOP -- K. RHOFIR 37
 Types de données standards : les dictionnaires

Méthode Effet
keys() Renvoie la liste des clefs du dictionnaires
values() Renvoie la liste des valeurs du dictionnaires
items() Renvoie la liste des couples (clefs:valeur) du
dictionnaires
has_key() Vrai si existe valeur associée à la clef k
get(k[,default]) Retourne la valeur associée à la clef k ou default si
pas de valeur
clear() Vide le dictionnaire
copy() Retourne une copie de surface du dictionnaire
update(dict) Met à jour le dictionnaire à partir d’un autre
dictionnaire

OOP -- K. RHOFIR 38
 Types de données standards : les chaines de caractères

 Les valeurs à formater peuvent être introduite dans la

chaine avec la syntaxe %(nom) format
 Le nom fait référence à la valeur d’un dictionnaire
associé à la clef nom
 Ceci est utile quand on a à changer plusieurs fois un
nom par des valeurs différentes
>>> a = "Le %(legume)s est un %(variete)s "
>>> valeurs = {'legume':'poireau', 'variete':'allium'}
>>> print a % valeurs
Le poireau est un allium.
>>> valeursII = {'legume':'concombre', 'variete':'cucurbitacee}
>>> print a % valeursII
Le concombre est un cucurbitacee.

OOP -- K. RHOFIR 39
 Types de données standards : les dictionnaires

Si vous copiez un dictionnaire dans un autre

avec l'opérateur '=', les deux dictionnaires
pointent sur la même zone mémoire
Toute modification faite sur l'un des dictionnaires impacte l'autre

Pour copier une liste : dnew= {}

[Link](dinit)

[Link]
Applicatif/[Link]/Formation_Python/Exos#Exo_Dictionnaire

OOP -- K. RHOFIR 40
 Types de données standard : les sets

 Avant python 2.4 :

>>> import sets
>>> b=[Link](….)

 Un set est une collection non ordonnée d’objets sans

doublon
 Le module sets existe avec les deux classes suivantes :
◦ set (modifiable)
◦ et imutableSet (non modifiable)
 Un ensemble peut être créé à partir d’une liste, d’un
dictionnaire, d’une chaine ou un tuple. Si des doublons
éventuels existent, ils seront alors absents de
l’ensemble
 Ex : >>> a="seed"
>>> b=set(a)
>>> print b
set(['s', 'e', 'd'])
OOP -- K. RHOFIR 41
 Types de données standard : les sets

Méthode Effet
add(elt) Ajoute un élément à l’ensemble
remove(elt) Retire un élément de l’ensemble
pop() Retire un élément au hasard de l’ensemble et le renvoie
union(s) Renvoie l’union de l’ensemble original et de s
intersection(s) Renvoie l’intersection de l’ensemble original et de s
difference(s) Renvoie la différence entre l’ensemble original et s
issubset(s) Renvoie True si l’ensemble original est un sous
ensemble de s, False sinon
issuperset(s) Renvoie True si l’ensemble original contient, False sinon

s = [Link](s2) s = s1 + s2
[Link](s2) s1 |= s2
s = [Link](s2) s = s1 & s2
S1.intersection_update(s2) s1 &= s2
s = [Link](s2) s = s1 - s2
s1.difference_update(s2) s1 -= s2
OOP -- K. RHOFIR 42
 Structures de contrôle

 Tests (if, elif et else)

 Boucles (for, while)
 Gestions d’exceptions (do, until)
 Contrairement au C++, les variables créées
dans les structures sont accessibles à
l’extérieur de celles-ci
 Par contre, les variables créées dans les
fonctions, les méthodes et les classes ne sont
accessibles qu’à l’intérieur de celles-ci

OOP -- K. RHOFIR 43
 Structures de contrôle

 Tester une valeur :

if a==1 (test1):
print "a est bien egal a 1"
elif a==2 (test2):
print "a est bien egal a 2"
else:
print "a est egal a ",a

 Les blocs sont exécutés en fonction de la valeur de

a
 if est la condition, elif une(des) alternative(s) et else
si aucune condition précédente n’est respectée
 pas d‘instruction de type switch

OOP -- K. RHOFIR 44
 Structures de contrôle

 for : itération sur valeurs d’une séquence définie ou à

définir >>range(4)
 for i in range(j,k): (de j à k-1) [0, 1, 2, 3]
>>range(3,7)
 for valeurs in list: (boucle sur valeurs de la liste) [3, 4, 5, 6]
 for keys in dict: (boucle sur clefs du dictionnaire) >>range(7, 4, -1)
[7, 6, 5]
 while : itération tant que condition vérifiée
 while test:
 #corps de la boucle

 break permet de sortir de la boucle

 continue permet de passer à l’itération suivante
 Pas de do ou until :
while true:
#corps de la boucle
If condition_sortie
break
OOP -- K. RHOFIR 45
 Structures de contrôle

 Boucle sur les éléments d'une liste:

liste=[("janv",31),("fev",28),("mars",30),…]
for mois,nJour in liste:
…
mois est le premier élément de chaque n-uplet
nJour est le second élément de chaque n-uplet

liste=["janv","fev","mars",…]
for i,mois in enumerate(liste):
…
i est l'indice de l'élément
mois est la valeur de l'élément

OOP -- K. RHOFIR 46
 Structures de contrôle

 Syntaxe concise de construction et lisibilité

 Nouvel objet peut être créé (conseillé)
 Simplification des boucles pour produisant liste
 Exemples :
Une liste Deux listes
>>> liste = [1, 3, 5] >>> liste1 = (1, 2, 3)
>>> [3*x for x in liste] >>> liste2 = (‘a’, ‘b’)
[3, 9, 15] >>> [(a,b) for a in liste1 for b in liste2]
>>> [3*x for x in liste if x [(1, ‘a’), (1, ‘b’), (2, ‘a’), (2, ‘b’), (3, ‘a’), (3, ‘b’),
>2] ]
[6, 15] >>> [(a,b) for a in liste1 for b in liste2 if a%2]
>>> [3*x for x in liste if [(1, ‘a’), (1, ‘b’), (3, ‘a’), (3, ‘b’), ]
x<1]
[]

OOP -- K. RHOFIR 47
 Structures de contrôle

[Link]
Applicatif/[Link]/Formation_Python/Exos#Exo_Structure

OOP -- K. RHOFIR 48
 Les fonctions

 Nouvelle fonction définie par def

 Appelée par son nom en lui passant des
paramètres en argument
 Les variables numériques et non modifiables
passent par valeur et les variables modifiables (liste
et dictionnaire) par référence
 Renvoi des valeurs ou objets (même compliqués,
ex classe)
def fonction(arg1,arg2):
#bloc de la fonction
arg3=arg1+arg2
return arg3

b=1, c=2
a = fonction(b,c)
print a
OOP --
3
K. RHOFIR 49
 Les fonctions

[Link]
Applicatif/[Link]/Formation_Python/Exos#Exo_Fonctions

OOP -- K. RHOFIR 50
 Gestion des exceptions

 C++, Java et Python ont un mécanisme de

gestion d’erreur appelé gestion d’exception :
◦ Interrompt le déroulement normal d’un programme
et remonte à un niveau quelconque dans la pile
d’appel des fonctions
◦ Contrairement au mécanisme classique de retour de
code d’erreur, les fonctions d’une pile d’appels ne
sont pas toutes obligées de gérer l’erreur

OOP -- K. RHOFIR 51
 Gestion des exceptions

 Exemple de code générant une erreur :

>>> a=8
>>> b=0
>>> a/b
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ZeroDivisionError: integer division or modulo by zero

 Code implémentant try/except :

try:
c=a/b
print c
except ZeroDivisionError:
print "Attention: division par 0 "
except:
print "Erreur de division : ",a,"/",b
raise

Liste des erreurs : [Link]

OOP -- K. RHOFIR 52
 Gestion des exceptions

 Syntaxe : try:
…
…
code à tester
except erreur_1 :
si le code testé génère une erreur de type
erreur_1
except erreur_2 :
si le code testé génère une erreur de type
erreur_2
except :
si le code testé génère une autre erreur
else:
optionnel
si le code n'a pas généré d'erreur

 Géneration d'une erreur (qui va stopper le programme) : raise

try:
…
except erreur_1 :
si le code testé génère une erreur de type erreur_1 l'erreur va être générée
raise
ou raise Exception(code erreur, texte erreur)
erreur personnalisée
pass (si on veut passer cette erreur)
… -- K. RHOFIR
OOP
53
 Gestion des exceptions

 saisie d'un entier au clavier

while true:
try: ...
x = int(raw_input("Please enter a number: "))
break
except ValueError:
print "Oops! That was no valid number. Try again..."

 Ouverture / lecture d'un fichier

import sys
try:
f = open('[Link]')
s = [Link]()
i = int([Link]())
except IOError:
print "I/O error"
raise ou traitement de l'erreur
except ValueError:
print "Could not convert data to an integer."
raise ou traitement de l'erreur
except:
print "Unexpected error:", sys.exc_info()[0] dernière exception
raise
OOP -- K. RHOFIR 54
 Entrées/sorties

 Print et saisie clavier

◦ print est le mot clef
 Pas appel de fonction
 Affiche les arguments (séparés par des virgules) sur la sortie standard
 Termine automatiquement par un saut de ligne (sauf si le dernier
caractère est ,)
 Arguments convertis en chaine de caractères avec str()

◦ raw_input est fonction de base de l’interpréteur

 Interrompt exécution du programme et attend une entrée
 Valeur renvoyée par la fonction sous forme de chaine de caractères

age = raw_input("quel age as tu ?")

print age

OOP -- K. RHOFIR 55
 Lecture/écriture de fichiers

 Fichiers sont un des systèmes d’entrées/sorties de

base
 Fichier créé avec la fonction open(filename[,mode])
 Fichier lu avec la fonction open(filename,"r").read()
Mode Signification
r Lecture seule
w Ecriture (fichier
préexistant écrasé)
a Ecriture en fin de fichier
r+ Ecriture et lecture
w+ Ecriture et lecture (fichier
préexistant écrasé)
a+ Ecriture et lecture
(Ecriture en fin de fichier)
OOP -- K. RHOFIR 56
 Lecture/écriture de fichiers

[Link]
Applicatif/[Link]/Formation_Python/Exos#Exo_In.2FOut

OOP -- K. RHOFIR 57
 Les classes

 Une classe est un objet défini avec le mot clef

class
 Elle contient des valeurs et des méthodes
 Ses méthodes sont définies avec le mot clef
def
 Le 1er argument d’une méthode est
traditionnellement appelé self, il sert de
référence à la classe elle-même
 Les attributs d’une classe ainsi que les
variables ne sont pas déclarés mais sont
créés à la première affectation (constructeur)

OOP -- K. RHOFIR 58
 Les classes

 C’est le constructeur de la classe

 Elle initialise la création de la classe, et donne
une valeur aux attributs de la classe
 Elle ne renvoie pas de valeur
 L’initialisation de tous les attributs à une valeur
par défaut ou spécifique est généralement faite
dans cette méthode

OOP -- K. RHOFIR 59
 Les classes

class Chat:
def __init__ (self,nom="M’sieur"):
[Link] = nom
[Link] = False

def Ronronne(self):
print "Prrrrrr !"

def Faire_Caresses(self):
"Ronronne si déjà des caresses"
if [Link]:
[Link]()
else:
[Link] = True
def Repos(self):
[Link] = False

OOP -- K. RHOFIR 60
 Les classes

 On crée un objet classe en appelant la classe

et en fournissant les arguments requis par sa
fonction __init__.
 On peut ensuite appliquer à cet objet les
différentes méthodes de la classe
 Ex:
class Chat:
def __init__ (self,nom):
[Link] = nom
def get_nom(self):
return [Link]

>>>Minou = Chat("M’sieur")
>>>print Minou.get_nom()
M’sieur

OOP -- K. RHOFIR 61
 Les classes

 Dans le corps de la méthode, il est nécessaire

d’utiliser cette référence pour accéder aux attributs
de l’instance
 Lorsque l’on appelle une méthode sur une
instance, il ne faut pas spécifier cet argument
◦ Celui-ci est placée de manière transparente par Python lors
de l’accès à la méthode
◦ [Link](param) ==
[Link](instance,param)
◦ 2nde notation utile pour appeler explicitement une méthode
d’une classe parente redéfinie dans une classe fille

OOP -- K. RHOFIR 62
 Les classes

 Supporté par Python

 On note le nom de chaque classe parente
entre parenthèses après le nom de la classe
dérivée
 Il faut initialiser la classe parente dans la
classe dérivée de la façon suivante :
class Chat:
def __init__ (self,nom="Le chat"):
[Link] = nom

class MonChat(Chat):
def __init__ (self,nom="M’sieur", couleur="Roux"):
Chat.__init__(self,nom)
[Link] = couleur

OOP -- K. RHOFIR 63
 Les classes

 Lorsqu’une classe dérivée redéfinit une

méthode d’une classe de base celle-ci est
alors masquée dans la classe dérivée
class Chat:
def Consommation_croquettes(self,jours):
return self.get_consommation()*jours
def get_consommation(self):
return [Link]*0.05
class MonChat(Chat):
def __init__(self):
Chat()
[Link]=4
def get_consommation(self):
return [Link]*0.07

Msieur = MonChat()
print Croquettes = Msieur.Consommation_croquettes(31)

OOP -- K. RHOFIR 64
 Les classes

 Si nécessaire d’appeler la méthode de la mère, il faut

utiliser la méthode non liée de la classe, en donnant
une valeur explicite à self
class Chat:
def __init__(self):
[Link]=4
def Consommation_croquettes(self,jours):
return self.get_consommation()*jours
def get_consommation(self):
return [Link]*0.05

class MonChat(Chat):
def __init__(self):
Chat()
[Link]=4
def get_consommation(self):
return [Link]*0.07
def get_consommationMere(self):
return Chat.get_consommation(self)

OOP -- K. RHOFIR 65
 Les classes

[Link]
Applicatif/[Link]/Formation_Python/Exos#Exo_Classes

OOP -- K. RHOFIR 66
 Les commandes système

 Organisation des fichiers : module os

 Module re
 Système : module sys
 Process : module subprocess

OOP -- K. RHOFIR 67
 Le module os

 Il fournit un moyen d’accéder de manière

uniforme à des fonctionnalités dépendant du
système d’exploitation
 On y trouve :
◦ Des constantes liées au système d’exploitation
([Link], [Link], [Link]…)
◦ Un accès aux variables d’environnement avec le
module [Link]
◦ Des fonctions pour le lancement et le contrôle de
nouveaux processus (popen(), fork(), spawn, etc…)
◦ Des fonctions de gestions de fichiers (listdir(),
chdir, etc)

OOP -- K. RHOFIR 68
 Le module os

Méhode Effets
getcwd() Renvoie le répertoire de travail
courant
chdir(path) Positionne le répertoire de travail
courant à path
listdir(path) Renvoie la liste du contenu du
reperoire path
walk(path) Visite récursivement path et
génère une liste de triplets
(dirpath, dirnames, filenames).
Cette fonction accepte un
argument optionnel topdown qui
permet de préciser le sens de la
visite

OOP -- K. RHOFIR 69
 Le module os

 Il offre un certain nombre de fonctions très

utiles pour analyser ou transformer des
chemins du système de fichiers
 Il permet de s’affranchir complètement des
spécificités de système d’exploitation
 Quelques fonctionnalités :
◦ Possibilité de tester le type d’objet référencé par un
chemin (répertoire, fichier, lien symbolique, etc)
◦ Concaténation de plusieurs chemins
◦ Normaliser un chemin

OOP -- K. RHOFIR 70
 Le module os

Fonctions Effets
isfile(path) Renvoie True si le chemin fait
référence à un fichier sinon False
isdir(path) Renvoie True si le chemin fait
référence à un répertoire sinon
False
join(path,*paths) Concatène tous les chemins passés
en paramètres en utilisant le
séparateur approprié en fonction
de la plateforme. Si un des
chemins est absolu, tous ceux qui
précèdent sont ignorés
normpath(path) Renvoi les chemin normalisé
équivalent à path. Tous les
séparateurs redondant sont
enlevés et les caractères de
navigation comme . ou .. sont
interprétés
OOP -- K. RHOFIR 71
 Le module os

Fonctions Effets
diname(path) Renvoie le répertoire contenant path
abspath(path) Renvoie path sous forme de chemin
absolu (basé sur le répertoire de
travail courant)
getsize(path) Renvoie la taille du fichier path
getctime(path) Renvoie la date de création de path
getmtime(path) Renvoie la date de dernière
modification de path (en secondes)
walk(path,visit,arg) Visite tous les répertoires dans l’arbre
dont la racine est path. Pour chaque
répertoire, appelle visit(arg, dirname,
names) où dirname est le nom du
répertoire visité, et names la liste des
fichiers ou répertoires qui s’y
trouvent

OOP -- K. RHOFIR 72
 Le module os

import os
from os import path
def simple_visit(arg,dirname, names):
for file_name in names:
file_path=[Link](dirname, file_name)
if [Link](file_path):
print '[file] : ',file_path
elif [Link](file_path):
print '[directory] : ',file_path

[Link]('/web/lapp/informatique/PYTHONFORMATION/',simple_visit,'unused')

OOP -- K. RHOFIR 73
 Le module os

 [Link]
Applicatif/[Link]/Formation_Python/Exos#Exo_os

OOP -- K. RHOFIR 74
 Le module re

Fonctions Effet
search(regexp,string) Renvoie un MatchObject
correspondant à la recherche
match(regexp,string) Renvoie None si la chaîne ne
correspond pas et un MatchObject
sinon
findall(regexp,string) Renvoie une liste de tous les
éléments trouvés
sub(regexp,repl,string) Remplace toutes les sous-chaînes
correspondant à l’expression par
repl
split(regexp, string[,maxsplit) Découpe string selon toutes les
sous-chaînes correspondant à
l’expression et renvoie la liste
obtenue

OOP -- K. RHOFIR 75
 Le module re

 [Link] :
>>> [Link](r"\W","abc;- def/") ['abc', ' ', ' ', 'def', ' '] abc;|-| def/|
>>> [Link](r"\W+","abc;- def/") ['abc', 'def', ' ']
r : raw string (interprétation \)
>>> [Link](r"(\W)","abc;- def/") ['abc', ';', ' ', '-', ' ', ' ', 'def', '/', ' ']
\W : tout caractère non alpha
>>> [Link](r"(\W+)","abc;- def/") ['abc', ';- ', 'def', '/', ''] numérique

>>> [Link](r"[-;\n\t_0-5]+","Aujourd'hui, le chien;lechat\n--07") ["Aujourd'hui, le

chien", 'lechat', '7']
split selon : - \n \t _ 0 1 2 3 4 5

 [Link] :
>>> [Link]('\d*\.\d*', "24 78 67.56") ['67.56']
>>> [Link]('\d*\.?\d*', "24 78 67.56") ['24', ' ', '78', ' ', '67.56', ' ']

>>> [Link]('(\d*)\.(\d*)', "24 78 67.56 .89") [('67', '56'), (' ', '89')]
>>> [Link]('(\d*)\.?(\d*)', "24 78 67.56 .89") [('24', ' '), (' ', ' '), ('78', ' '), (' ', ' '), ('67', '56'),
('', ''), ('', '89'), ('', '')]

 [Link] :
>>> m = [Link](r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcom
Reynolds") >>> [Link]('first_name') 'Malcom'
>>> [Link]('last_name') 'Reynolds'

Toutes les explications : [Link] 76

OOP -- K. RHOFIR
 Le module sys

 [Link]() : arrête le programme

 [Link] : liste des arguments en input
python [Link] formation Python

import sys
print "Bienvenue à la "+[Link][1]+" "+[Link][2]

Le module optparse permet de parser les paramètres donnés en input

( ex : prog -v --report /tmp/[Link] foo bar )

 [Link] (out, err) : flux de données

import sys
fsock = open('[Link]', 'w')
[Link] = fsock
[Link] = fsock
…. ( ne pas oublier de fermer le fichier )
OOP -- K. RHOFIR 77
 Le module subprocess

 Remplace les modules de Python < 2.4 :

[Link] [Link]* [Link]* popen2.* commands.*

 Commande system simple :

le processus appelant lance la commande et attend qu'elle soit executée

[Link](*popenargs, **kwargs)

le nom de la fonction et ses arguments sont

passés sous forme d'une liste

[Link](["ls","-lRt"])
sCommand=" prog -v --report /tmp/[Link] foo bar "
[Link]([Link](''"))

o call retourne le résultat de l'execution de la commande

o une erreur générée dans la commande est remontée au processus appelant
( gestion par try… except … des erreurs du process appelé )
OOP -- K. RHOFIR
 Le module subprocess

 Processus père - fils :

[Link](args, bufsize=0, executable=None, stdin=None,
stdout=None, stderr=None, preexec_fn=None,
close_fds=False, shell=False, cwd=None, env=None,
universal_newlines=False, startupinfo=None, creationflags=0))

 args est le nom de la commande si shell=True

 args est une liste si shell=False
 stdin, stdout, stderr : pipes de communication avec le procesus fils

le processus père doit toujours attendre la fin du processus fils

pour récupérer son status, sinon le fils devient zombie
communication par pipe : finir chaque échange par '\n' + flush
fils = [Link]("commande_fils", shell=True,
stdin=[Link], stdout=[Link],
père
…)
[Link]( "…blablabla…\n")
[Link]() input_test = [Link]()
… … fils
… [Link]("….\n")
[Link]() / [Link]() [Link]()
OOP -- K. RHOFIR
 Exemple : page web

 Pages de vérification de l’installation de

versions de logiciels par la grille (LHCb,
Atlas,uds)
 Pages construites avec Java Script
 Pages dynamiques :
◦ cron job
◦ Sub-process pour chaque version de soft
 Construction identiques pour chaque page
◦ Fichier python de construction identique
◦ Pour chaque expérience un dictionnaire différent
construit dynamiquement en fonction des logiciels
installés
OOP -- K. RHOFIR 80
 Exemple : page web

 Même canvas pour les pages LHCb et Atlas

seuls dictionnaires d’entrées changent =>
importer le dictionnaire adéquate
Config={"Comment":"Automatic processing of checking LHCb softs installed (or published as) at Lapp",
"LHCSoftwareList":["Gauss","Boole","Brunel","DaVinci"],
"SoftwareChainingProcess":0,
"MailingList":["rospabe@[Link]","elles@[Link]"],
Dictionnaire LHCb
"CheckGridReleasesCommand":"ldapsearch -x -H ldap://[Link] -b mds-vo-name=IN2P3-LAPP,o=grid
| grep -i GlueHostApplicationSoftwareRunTimeEnvironment",
"ToolDir":"/lapp_data/calcul/supap/SiteTest/Check_LHCb_Softs",
"TestJob":"python [Link]",
"Shell":".csh",
"Machine":"lappsl4g",
}
Software={ Config={"Comment":"LAPP site Atlas software tests",
"Gauss":{"Comment":"LHCb simulation : Gauss", "LHCSoftwareList":["Offline","Production"],
………………} "SoftwareChainingProcess":0,
} "MailingList":["rospabe@[Link]","elles@[Link]"],
"CheckGridReleasesCommand":"ldapsearch -x -H ldap://[Link] -b mds-vo-
name=IN2P3-LAPP,o=grid
| grep -i GlueHostApplicationSoftwareRunTimeEnvironment",
"ToolDir":"/lapp_data/calcul/supap/SiteTest/Check_Atlas_Softs",
"TestJob":"python [Link]",
"Shell":".sh",
"Machine":"lappsl4h",
} Dictionnaire Atlas
Software={
"Offline":{"Comment":"Athena releases",
…………….}
OOP -- K. RHOFIR } 81
 Exemple : page web

 Même canvas pour les pages LHCb et Atlas

seul entrées du dictionnaire changent =>
importer le dictionnaire et prendre valeurs de
clefs choisies
TimeDict={
"Atlas":[1243885982, 1243972382, 1244058782, 1244145182, 1244231582, 1244317983, 1244404381],
"LHCb":[1243885982, 1243972382, 1244145182, 1244231582, 1244317983, 1244404381],} Dictionnaire
DataDict={
"Atlas":{
commun
"relPublished":{'Offline': ['14.1.0', '14.2.0', '14.2.10', '14.2.20', '14.2.21', '14.2.22', '14.2.23',……..}, LHCb/Atlas
"relInstalled":{'Offline': ['12.0.31', '12.0.6', '12.0.7', '12.0.8', '13.0.20', '13.0.40', '14.0.0', ‘………,},

"LHCb":{
"relPublished":{'Boole': ['v12r10', 'v14r7', 'v14r8'], 'Brunel':……………..}

import sys,os,time
import commands
import TestJobs Construction page
import SiteTestDictionary
……… web LHCb (même
sDataDict = [Link]["LHCb"]
lSoftList=sDataDict["softlist"] chose Atlas)
print lSoftList

OOP -- K. RHOFIR 82
 Exemple : calibration Atlas

Script [Link] : parcours les répertoires Castor et crée un fichier

[Link] contenant un dictionnaire ( executé périodiquement indépendamment du
script principal) :
CastorLArmonFiles={
('EndCap-HEC-FCAL', '00117970', 'Ramp', 'EB-FCAL'):
('/castor/[Link]/grid/atlas/DAQ/lar/ElecCalib/2009/00117970',
['data09_calib.00117970.calibration_LArElec-[Link]._lb0000._EB-FCAL._0001.data',
'data09_calib.00117970.calibration_LArElec-[Link]._lb0000._EB-FCAL._0002.data',
]
),
('EndCap-HEC-FCAL', '00117970', 'Ramp', 'EB-HEC'):
('/castor/[Link]/grid/atlas/DAQ/lar/ElecCalib/2009/00117970',
['data09_calib.00117970.calibration_LArElec-[Link]._lb0000._EB-HEC._0001.data',
'data09_calib.00117970.calibration_LArElec-[Link]._lb0000._EB-HEC._0002.data',
'data09_calib.00117970.calibration_LArElec-[Link]._lb0000._EB-HEC._0003.data',
'data09_calib.00117970.calibration_LArElec-[Link]._lb0000._EB-HEC._0004.data',
]
),
...
…
}
Script principal :

from LArmonFiles import CastorLArmonFiles

CastorLArmonFiles[(partition,runnumber,job_type,sous_détecteur)]
donne directement la liste des fichiers disponibles
OOP -- K. RHOFIR 83
 Exemple de PyROOT

 Versions de ROOT:
◦ /grid_sw/lhcb/lib/lcg/external/root
 Versions de python:
◦ /grid_sw/lhcb/lib/lcg/external/python
setenv ROOTSYS
/grid_sw/lhcb/lib/lcg/external/root/<VERSION>/<CMTCONFIG>/root
setenv PYTHONDIR
/grid_sw/lhcb/lib/lcg/external/Python/<VERSION>/<CMTCONFIG>/

setenv PATH ${ROOTSYS}/bin:${PYTHONDIR}/bin:${PATH}

setenv LD_LIBRARY_PATH
${ROOTSYS}/lib:${PYTHONDIR}/lib:${LD_LIBRARY_PATH}
setenv PYTHONPATH ${ROOTSYS}/lib:${PYTHONPATH}

#librairie castor
ln -s ${LCG_LOCATION}/lib/[Link] [Link].2.1
setenv LD_LIBRARY_PATH ${PWD}:${LD_LIBRARY_PATH}
OOP -- K. RHOFIR 84
 Exemple de PyROOT

 Module(s) à importer
◦ import ROOT
◦ from ROOT import **** (Tfile, TH1F,…)
 Ouverture de fichiers
◦ Les uns à la suite des autres
 input = [Link](“[Link]”)
 mytree=[Link]('n1')
 pas plus de 30Mo de fichiers => Mélanger les fichiers ou autre
méthode ROOT
◦ Chainer les fichiers et les ouvrir tous en même temps
 chain = TChain('n1')
 [Link](“[Link]”)
 entries=[Link]()

OOP -- K. RHOFIR 85
 Exemple de PyROOT

 Ouverture à distance
◦ [Link](“rfio:[Link]”)
◦ input = [Link](“rfio:[Link]”)
 Copie locale, ouverture, effacement
◦ dpns-ls -l /dpm/[Link]/home/.../[Link]
◦ rfcp /dpm/in2p3/home/.../[Link] ./[Link]
 Plus efficace d’ouvrir les fichiers à distance depuis
lappsl4
 Même chose si job est sur le cluster du Lapp

OOP -- K. RHOFIR 86
 Exemple de PyROOT

fNewFile = TFile("Name","Create,Recreate,…")
fNewTree=TTree("Name", "Name")

sBranch_struct="struct cluster_t{\
Int_t size;\
Float_t eX[SIZE];\
};"

sClusters_struct=sClusters_struct.replace("SIZE",str())
[Link](sClusters_struct);
[Link]('clusters',cluster_t,'@size/I:[Link]['+str([Link])+']/F')

[Link]=[Link]
[Link]=array('f',range([Link]))

for j in range(0,[Link]):
[Link][j]=float([Link][0][0][j])

[Link]()
OOP -- K. RHOFIR 87
  Page officielle : [Link]
 Tutoriel : [Link]
[Link]
 PyROOT :
[Link]
 Bibliothèque de référence :
[Link]
 Cours :
[Link]
[Link]
[Link]

OOP -- K. RHOFIR 88