Programmation

Python

Sommaire
Introduction
Bases du langage
Oprateurs et expressions
Structures de contrle
Fonctions
Modules
Structures de donnes
GUI
Fichiers
Exceptions
2

1
Python

Sommaire (2)
Processus
Regexp
P.O.O
Syntaxe avance
Aide au dveloppement
Runtime
Accs aux SGBD
Accs rseau
Dploiement d'applications et packages
Intgration C/C++
Versions futures
3

Python

2
Introduction

Introduction

Historique
Caractristiques du langage
Installation
Premier programme

Introduction

Historique

Dvelopp depuis 1989 par Guido Van Rossum

employ chez Google
Souhaits initiaux :
langage portable, dynamique, extensible, gratuit
approche modulaire et oriente objet
Versions :
courante : 2.6, 2.7, 3.4
Utilisateurs estims : 1 million

3
Introduction

Caractristiques du langage
Portable
Supporte toute taille de programme
Syntaxe simple avec types de donnes volus
Gestion automatique des ressources
LOO avec multi-hritage et surcharge des oprateurs
Gestion des exceptions
Langage dynamique, orthogonal, rflectif et introspectif
Typage dynamique des donnes
Richesse de la bibliothque standard
7

Introduction

Applications types
Scripts d'administration
Scripts pour Internet (CGI, XML, email, Zope/Plone,
Twisted...)
GUI (Tk, wxPython, Qt, Gtk...)
Integration de composants (C/C++...)
Accs aux SGBD
Programmation distribue (CORBA, COM, .NET, SOAP,
XML-RPC)
Dveloppement et prototypage rapide
Analyseurs de langage (parsers)
Traitement d'images, IA, jeux...
8

4
Introduction

Installation
Dj install sur Linux
test par :
$ python -V
Python 2.6.4

Pour Windows
voir www.python.org/download
test par :
PATH=%PATH%;C:\Python26
Python -V

Introduction

Mon premier programme

Lancement de l'interprteur sur la ligne de
commande :
$ python
Python 2.6.4
Type "help", "copyright",...
>>> print 'hello world'
hello world
>>> Ctrl-D
$

10

5
Introduction

Mon premier script

Soit le fichier helloworld.py contenant le
script suivant :
#!/usr/bin/python
print 'Hello World'
Lancement du script par :
$ python helloworld.py
Hello World
ou
$ chmod +x helloworld.py
$ ./helloworld.py
Hello World
11

Introduction

Lancement de l'interprteur

En mode interactif :
python
>>> import this
Avec une commande excuter :
python -c "print 'coucou'"
En activant un module comme un script :
python -m module ["commande..."]

12

6
Introduction

Personnalisation du prompt

La variable d'environnement PYTHONSTARTUP

peut indiquer le nom d'un script excuter au
lancement de l'interprteur
possibilit de grer un historique
grer la compltion des noms des mthodes, des
attributs...

13

Introduction

Obtenir de l'aide
Si la variable d'environnement PYTHONDOCS
est positionne sur le rpertoire contenant les
docs, python peut afficher de l'aide en ligne :
$ export PYTHONDOCS=/usr/share/doc/python-2.4.3
$ python
>>> help('print')
----------------------------------------------------------
6.6 The print statement

print_stmt ::= "print" ( [expression[1] (","

expression[2])* [","]]

Mode intractif avec : help()

14

7
Introduction

Codage des caractres spciaux

Par dfaut, Python utilise le jeu ASCII

(Python Enhancement Proposal PEP-0263)
Exemples :
# -*- coding: latin-1 -*-
# -*- coding: utf-8 -*-
# -*- coding: iso-8859-15 -*-
Gnre une exception si l'encodage n'est pas
support

15

Introduction

Comment Python excute le code ?

Le code est lu et traduit dans un langage intermdiaire
(le bytecode)
Le bytecode est excut par la PVM
Quand un module est import la 1re fois, le bytecode est
sauv sous la forme d'un .pyc
Il existe des compilateurs/traducteurs vers d'autres
langages
Psyco pour le calcul
PyPy qui implmente une PVM optimise
Jython
Parrot
Shed Skin qui traduit en C++ (12 45 fois plus rapide)
16

8
Python

17

Bases

Valeurs litrales
Nombres :
entiers : 2
flottants (double prcision): 3.23, 52.3E-4
complexes : (-5 + 1j), (2.3 - 4.6j)
Chaines :
'exemple de chaine'
"pas de pb comme d'habitude"
'''texte sur plusieurs
lignes'''
peut aussi utiliser les triples guillemets """

18

9
Bases

Chaines (suite)
Caractre d'chappement \ :
'l\'alphabet'
"chaine1\nchaine2"
"chaine1\
chaine2"
Chaine sans traitement (raw string) :
r"le \n n'est pas interprt"
R"idem"
Chaine Unicode :
u"chaine1"
U"chaine2"
Les chaines sont immuables
La concatnation est automatique
19
"chaine1" "chaine2"

Bases

Variables - Identifieurs
Sont des catgories d'identifieurs
le 1er caractre doit tre une lettre (min/maj) ou un
soulign (_)
les autres caractres autoriss sont des lettres, des
chiffres ou le soulign
les noms sont sensibles la casse
norme "PEP 8"

20

10
Bases

Exemple d'utilisation
# Fichier var.py
i = 5
print i
i = i + 1
print i

s = '''ligne multiple
voici la deuxieme ligne.'''
print s

Rsultat de l'excution:
$ python var.py
5
6
ligne multiple
voici la deuxieme ligne.

21

Bases

Lignes logiques et lignes physiques

Ligne physique = ligne qu'on peroit
Ligne logique = instruction perue par python
Python considre logique = physique
Implicitement, Python encourage l'utilisation
d'une instruction par ligne physique
production de code plus lisible
on peut toujours utiliser le point-virgule (;) pour
sparer des instructions sur une mme ligne
le backslash (\) permet de crer des lignes logiques
sur plusieurs lignes physiques

22

11
Bases

Indentation
Certains espaces sont importants !
Les espaces (et les tabulations) en dbut de
ligne dfinissent l'indentation
L'indentation dfinit les blocs d'instructions
Les instructions possdant la mme indentation
successive appartiennent au mme bloc
Exemple d'erreur :

i = 5
print "valeur de i=", i
^
SyntaxError: invalid syntax

23

Bases

Commentaires

Dbutent par un #
Ou bien sont encapsuls par des triples quotes
ou guillemets

# un commentaire
i = 5 # commentaire !

sur plusieurs lignes

24

12
Python

25

Oprateurs

Oprateurs
Astuce : python value directement les
expressions
>>> 2 + 3
5
+ : ajoute 2 objets
>>> 3+5
8
>>> 'a' + 'b'
'ab'
- : soustraction

26

13
Oprateurs

Oprateurs (2)
* : multiplication
>>> 2*3
6
'ab' * 3
'ababab'
** : puissance
/ : division
>>> 4/3
1
>>> 4.0/3
1.333333333
27

Oprateurs

Oprateurs (3)
// : (floor) arrondi infrieur du quotient
>>> 4 // 3.0
1.0
% : module (reste de la division)
>>> 8 % 3
2
>>> 25.5 % 2.25
0.75
<< : dcalage gauche
>> : dcalage droite
28

14
Oprateurs

Oprateurs (4)
& : "et" binaire
| : "ou" binaire
^ : "ou" exclusif
~ : complment un (= -(x+1))
<, >, <=, >=, ==, != : test d'ingalit
retournent 1 (True) ou 0 (False)
criture v1 < v2 <= v3 possible !
not : ngation boolenne
and : "et" logique
or : "ou" logique
retournent la dernire expression "vraie" 29

Oprateurs

Prcdence des oprateurs (partielle)

**
~
+ et - unaires
*, /, %
+ et - binaires
<<, >> <, >, <=, >=, != , ==
& is, is not
^ in, not in
| not x
and
or
30

15
Oprateurs

Distinguer le "vrai" du "faux"

Les valeurs suivantes sont considres comme fausses :
None
False
toute valeur numrique gale 0 : 0.0, 0L, 0j, 0x0
toute squence vide (voir plus loin: '', (), [])
les chaines sont des squences !
tout dictionnaire vide : {}
tout objet possdant les mthodes __nonzero__() ou
__len__() et qui retournent False ou 0

Tout le reste est "vrai"

31

Oprateurs

Rsultat des comparaisons

Lors de l'valuation d'une expression pour obtenir une
valeur boolenne (valuation d'une condition) :
si aucun oprateur boolen (>, <, == ....) n'est utilis, l'expression
est value True ou False comme indiqu prcdemment
si un oprateur boolen est utilis :
le rsultat est toujours False si les oprandes sont de type diffrents
>>> False == None # est faux
>>> [] == False # est faux
sinon, la valeur des oprandes est compare

32

16
Oprateurs

Cas du and et du or

and et or retournent la dernire expression

value (circuit "court")
'a' and 'b' # vaut 'b'
'a' or 'b' # vaut 'a'
Cas du and-or :
1 and 'a' or 'b' # retourne 'a'
0 and 'a' or 'b' # retourne 'b'
1 and '' or 'b' # retourne 'b' !!!

33

Oprateurs

Affectations

Affectation simple :
a = 1
Affectations multiples :
a,b = 1,2
Affectations composes :
a += 3
a -= 1

34

17
Python

35

Instructions

Types d'instructions
Python supporte 3 instructions de contrle :
le test avec if
(pas de switch)
la boucle for
la boucle while

36

18
Instructions

Le "if"

#!/usr/bin/python
# Fichier: if.py

number = 23
guess = int(raw_input('Donnez un entier : '))

if guess == number:
print "Bravo !"
elif guess < number:
print "Non, trop petit !"
else:
print "Non, trop grand !"

print "Fin"

37

Instructions

Expressions conditionnelles (v2.5+)

L'criture :
x = true_value if condition else
false_value
est quivalente :
if condition:
x = true_value
else:
x = false_value

38

19
Instructions

Le "while"
#!/usr/bin/python
# Fichier: while.py

number = 23
running = True

while running:
guess = int(raw_input('Donnez un entier : '))

if guess == number:
print "Bravo !"
running = False
elif guess < number:
print "Non, trop petit !"
else:
print "Non, trop grand !"
else:
print "boucle finie" # pas sur un break

print "Fin"
39

Instructions

Le "for"

#!/usr/bin/python
# Fichier: for.py

for i in range(1,5):
# boucle de 1 4
print i
else:
print "boucle finie"

40

20
Instructions

Le "break"

Permet de quitter le bloc englobant :

#!/usr/bin/python
# Fichier: break.py

while True:
s = raw_input('Entrez qqc : ')
if s == 'quit':
break
print "la longueur de la chaine est ",len(s)
else:
print "pas excut en cas de break"

print "Fin"

41

Instructions

Le "continue"

Permet d'aller la prochaine itration d'une

boucle :
#!/usr/bin/python
# Fichier: continue.py

while True:
s = raw_input('Entrez qqc : ')
if s == 'quit':
break
if len(s) > 3:
continue
print "chaine de longueur insuffisante"

print "Fin"

42

21
Instructions

L'instruction pass

Permet de dfinir un bloc vide l o un bloc est

attendu

#!/usr/bin/python
# Fichier: pass.py

a = 10

if a > 11:
# bloc vide, mais syntaxe OK
pass
else:
print "OK"

43

Python

44

22
Fonctions

Introduction

Les fonctions sont des blocs d'instructions

rutilisables
Il existe des fonctions prdfinies (len,
range...)
Il est possible de dfinir ses propres fonctions
l'aide du mot-cl def
L'identifieur qui suit def est le nom de la
fonction

45

Fonctions

Exemple de fonction

#!/usr/bin/python
# Fichier: fonction1.py

def ditBonjour():
print "Bonjour tous !"
# Fin du bloc = fin de la fonction

# Appel de la fonction
ditBonjour()

46

23
Fonctions

...avec des paramtres

#!/usr/bin/python
# Fichier: fonction2.py

def printMax(a,b):
if a > b :
print "le plus grand est ", a
else:
print "le plus grand est ", b

# Appel de la fonction
printMax(3,4)
x = 5
y = 7
printMax(x,y)

47

Fonctions

Porte des variables

Toutes les variables ont la porte (visibilit) du

bloc dans lequel elles sont dfinies : elles sont
locales

#!/usr/bin/python
# Fichier: fonction3.py

def fonction(x) :
print "x vaut ",x
x = 2
print "x vaut ",x

x = 50
fonction(x)
print "x vaut ",x

48

24
Fonctions

Accs aux variables globales

Pour indiquer qu'on souhaite accder en
modification une variable dfinie l'extrieur
du bloc, on utilise le mot-cl global
pratique non recommande
#!/usr/bin/python
# Fichier: fonction4.py

def fonction() :
global x
print "x vaut ",x
x = 2
print "x vaut ",x

x = 50
fonction()
print "x vaut ",x 49

Fonctions

Paramtres par dfaut

Il est possible de spcifier des valeurs

constantes pour les paramtres en fin de liste
Ce sont des valeurs par dfaut

#!/usr/bin/python
# Fichier: fonction5.py

def affiche(message, nbocc = 1):

print message * nbocc

affiche("coucou")
affiche("bye ",2)

50

25
Fonctions

Note sur les paramtres par dfaut

Ils sont valus une seule fois : lors de la
dfinition de la fonction
#!/usr/bin/python
# Fichier: fonction6.py

def f(a, L=[]):

L.append(a)
return L

print f(1)
print f(2) # les args sont accumuls

def g(a, L=None):

if L is None:
L = []
L.append(a)
return L

print g(1)
print g(2) 51

Fonctions

Paramtres nomms

Il est possible de donner des valeurs aux

paramtres en les nommant !
l'ordre des paramtres est quelconque
supporte les modifications formelles

#!/usr/bin/python
# Fichier: fonction6.py

def func(a, b=5, c=10):

print "a=",a," b=",b," c=",c

func(3,7)
func(25,c=24)
func(c=50,a=100)

52

26
Fonctions

L'instruction return

Pour sortir du code d'une fonction

Permet aussi de "retourner" une valeur
en l'absence de valeur explicite, la valeur retourne
est None (type spcial de python)

#!/usr/bin/python
# Fichier: fonc_return.py

def maximum(x,y):
if x > y:
return x
else:
return y

print maximum(2,3)
53

Fonctions

Dfinitions "en avant"

Les fonctions doivent tre dfinies avant leur

appel effectif
#!/usr/bin/python
# Fichier: ex-funcorder.py

def f():
print "avant appel de g()"
g() # OK

f() # NON ! car g() n'est pas dfini

def g():
print "dans g()"

f() # OK : tout est dfini

54

27
Fonctions

Les DocStrings
Syntaxe spcifique qui permet d'auto-
documenter les programmes
La ligne sur la 1re ligne logique d'une fonction
est sa docstring
par convention, la docstring est une chaine s'talant
sur des lignes multiples
la 1re ligne dbute par une majuscule et termine par
un point
la 2me ligne est vide

55

Fonctions

Les DocStrings (2)

#!/usr/bin/python
# Fichier: docstring.py

def printMax(x,y):
'''Affiche le max de 2 valeur.

Les 2 valeurs doivent tre des entiers.'''

x = int(x)
y = int(y)

if x > y:
print "le max est ",x
else:
print "le max est ",y

printMax(3,5)
print printMax.__doc__

# __doc__ est un attribut

56

28
Fonctions

Utilisation des docstrings

Cration implicite des attributs __doc__

associs aux modules, classes, fonctions
>>> import os
>>> os.access.__doc__
Utilises par d'autres outils pour fournir de l'aide
hypertexte, HTML
pydoc

57

Python

58

29
Modules

Introduction

Comment partager ou rutiliser des fonctions

dfinies dans d'autres programmes
En utilisant des modules
Un module contient le code des fonctions
rutilisables ainsi que des variables globales
Le nom du fichier doit avoir l'extension .py
Les modules peuvent tre regroups en
packages

59

Modules

Utilisation de modules

Un module est import avec le mot-cl import

python recherche son code en ajoutant .py au
nom du module

#!/usr/bin/python
# Fichier: using_sys.py

import sys

print "Les arguments de la ligne de commande sont:"

for i in sys.argv:
print i

print "PYTHONPATH vaut: ",sys.path,"\n"

60

30
Modules

Fichiers compils
Pour gagner du temps lors de l'importation, il est
possible de compiler les modules
Les modules compils portent l'extension .pyc
le fichier "compil" contient la date de dernire modification du
fichier source
chaque chargement du fichier source (.py), une tentative est
faite pour crer le fichier .pyc
L'option -O de python produit un fichier .pyo
supprime les "assert"
.pyc et .pyo procurent un gain de temps au
chargement

61

Modules

L'instruction from...import

Pour viter l'criture sys.argv et utiliser argv

sans notation prfixe, on peut utiliser
l'instruction from...import
Exemples :
from sys import argv
permet de rfrencer argv directement
from sys import *
permet de rfrencer tous les symboles de sys directement

...mais nuit la comprhension du programme

62

31
Modules

Chemins des modules imports

Les modules intgrs (builtins) sont recherchs en 1er

Les rpertoires examins sont ceux lists par la
variable sys.path (sys est un module prdfini)
le rpertoire courant est consult en 1er
puis sys.path contient PYTHONPATH
et des chemins qui dpendent de l'installation de Python
Les importations recherchent par dfaut les modules
dans des chemins absolus :
from pkg import module
le module est sous le rpertoire pkg 63

Modules

Chemins relatifs

Une importation effectue dans un package est

implicitement recherche dans le package
Mais il est possible d'utiliser explicitement la
notation relative :
dconseille car le module ne pourra peut-tre pas
tre invoqu en standalone
from . import module
from .. import module
le module est ct ou sous le rpertoire parent

64

32
Modules

L'attribut __name__ des modules

Quand un module est charg son bloc principal

est excut
Comment distinguer si le module est invoqu
partir d'un autre module ou bien invoqu
directement (mode standalone) ?

#!/usr/bin/python
# Fichier: using_name.py

if __name__ == '__main__':
print "Le module est appel directement"
else:
print "Le module est import par un autre module"

65

Modules

Ecrire un module

C'est un script python

L'utilisation se fait avec import
#!/usr/bin/python
# Fichier: module1.py

def ditBonjour():
print "Salut tous !"

version = '0.1'

#!/usr/bin/python
# Fichier: module1_demo.py

import module1

module1.ditBonjour()
print 'Version=',module1.version
66

33
Modules

La fonction dir()

Permet de lister les identifieurs dfinis par un

module
= noms des fonctions, classes et variables
sans argument, retourne les noms dfinis dans le
module courant, sinon, retourne les noms dfinis
dans le module nomm
$ python
>>> import sys
>>> dir(sys)
[ '__displayhook__', '__doc__',...
...]
>>> a=5
>>> dir()
[ '__builtins__',...,'a','sys' ] 67

Modules

Packages

Manire de structurer les modules entre eux

le nom A.B reprsente le module B du package A
permet de limiter la porte des noms
Exemple de structure :

malib/ ; racine du package

__init__.py ; initialisation
modA/ ; module A
__init__.py
fichier1.py
fichier2.py
modB/
__init__.py
fichierA.py
68

34
Modules

Structure des rpertoires

Les fichiers __init__.py sont ncessaires

pour indiquer que le rpertoire contient un
package
ce fichier peut tre vide ou contenir des initialisations
Les packages sont recherchs dans la liste des
chemins indiqus par sys.path

69

Modules

Importations de contenus de packages

La syntaxe de l'importation devient :
>>> import malib.modA
>>> malib.modA.ressource.....
>>> from malib import modA
>>> modA.ressource...
>>> from malib.modA import *
charge les modules lists par la variable __all__ dfinie
dans le fichier __init__.py situ sous le rpertoire
malib/modA
__all__ = [ "sousmod1", "sousmod2" ]
si __all__ n'est pas dfini, n'importe pas les sous-modules
70

35
Modules

Librairies standard
Traitement de chaines :
string, re, stringIO, difflib...
Types de donnes :
datetime, calendar, deque, collections, heapq,
array, set, sched, mutex, Queue...
Traitement numrique et mathmatique :
math, cmath, decimal, random, functools,
itertools...
Donnes de l'Internet :
email, mailbox, mimetools, rfc822, base64, uu...
Traitement *ML :
HTMLParser, htmlparser, xml.parsers, xml.dom,
xml.sax,
71

Modules

Librairies standard (2)

Formats de fichiers :
csv, configParser, robotparser, netrc, xdrlib
Services de cryptographie :
hashlib, hmac, md5, sha
Accs au systme de fichiers :
os.path, fileinput, stat, filecmp, tempfile,
glob, fnmatch, linecache, shutil, dircache
Compression :
zlib, gzip, bz2, zipfile, tarfile
Persistance des donnes :
pickle, shelve, marshal, anydbm, whichdb, dbm,
gdbm, dbhash, sqlite3
72

36
Modules

Librairies standard (3)

Accs l'O.S :
os, time, optparse, getopt, logging, getpass,
curses, errno, ctypes
Services optionnels de l'O.S :
select, thread, threading, mmap, readline,
rlcompleter
Services spcifiques Unix :
posix, pwd, grp, crypt, dl, tty, ...
IPC :
subprocess, socket, signal, popen2, asyncore,
asynchat
Multimdia :
audioop, imageop, aifc, wave...
73

Modules

Librairies standard (4)

Protocoles Internet :
webbrowser, cgi, urllib, urllib2, httplib,
ftplib, poplib, imaplib, smtplib, smtpd,
telnetlib, uuid, urlparse, SocketServer,
BaseHTTPServer, Cookie, xmlrpclib

GUI avec Tk
Internationalisation :
gettext, locale

Outils de dveloppement :
pydoc, doctest, unittest, debugger, profiler

74

37
Python

75

Structures

Introduction

Python dfinit les structures suivantes :

listes (lists)
N-uplets (tuples)
dictionnaires (dictionary)
ensembles (set)
squences
rfrences
chaines (le retour !)

76

38
Structures

Introduction aux objets et aux classes

Avec python, "tout est objet"

exemple : "i" est une instance (un objet) de la classe
int (tapez help(int) pour vous en persuader)
Les classes dfinissent des comportements
communs tous les objets de la classe
Les oprations applicables aux objets d'une
mme classe sont appeles les "mthodes"
(fonctions)
Les classes peuvent dfinir des attributs d'objets
77

Structures

Les listes

Elles sont dfinies l'aide des crochets [...]

Les mthodes permettent d'ajouter, supprimer
ou rechercher des lments dans une liste
Une liste est donc modifiable (mutable)

78

39
Structures

Exemple de liste
#!/usr/bin/python
# Fichier: liste1.py

# ma liste de courses:
maliste = [ 'pomme', 'mangue', 'carotte', 'banane' ]
print "J'ai une liste de ",len(maliste)," lments."
print "Ces lments sont:', # voir la boucle...
for item in maliste:
print item,

print "\nJe dois aussi acheter du riz."

maliste.append('riz')
print 'Ma liste de courses est maintenant ',maliste

maliste.sort()
print "La liste est trie: ",maliste

print "Le 1er lment de la liste est: ",maliste[0]

olditem = maliste[0]; del maliste[0]
print "J'ai achet les ",olditem
print "Il me reste acheter: ",maliste
79
maliste[0] = 'poire'

Structures

Les N-uplets (Tuples)

Comme les chaines et contrairement aux listes, les
tuples sont immuables (immutables)
Ils sont dfinis l'aide de liste entoures par des
parenthses (...)
Note :
un tuple l'intrieur d'un tuple ne perd pas son identit de tuple
(contrairement Perl)

Un tuple vide se note : liste = ()

Un tuple avec 1 lment se note : liste = (e,)

80

40
Structures

Exemple de tuple

#!/usr/bin/python
# Fichier: tuple1.py

# mes animaux prfrs:

maliste = ( 'boa', 'fourmi', 'loup', 'coq' )
print "Le nombre d'animaux est ",len(maliste)

maliste2 = ( 'singe', maliste )

print "Au total, il y a ",len(maliste2)," animaux"
# affiche la liste dans des (...)

print "Les animaux du zoo sont : ",maliste2

print "exemple d'animal: ", maliste2[1][2]

81

Structures

Les tuples et l'instruction print

print peut utiliser des spcifieurs suivis d'un %

puis d'un tuple pour formater (convertir) les
paramtres

#!/usr/bin/python
# Fichier: tuple2.py

age = 2
nom = "Dupont"

print "Je m'appelle %s et j'ai %d ans" % (nom,age)

print "Bonjour %s "% nom

82

41
Structures

Les Dictionnaires

= table de hachage, tableau associatif

sont des objets de la classe dict
Les cls sont uniques et immuables
nombres, chaines, tuples...
Les valeurs sont quelconques
Syntaxe d'initialisation :
d = { k1 : v1, k2 : v2, ... }
d = dict(k1=v1, k2=v2)
d = dict([(x,x*2) for x in (2,4,6)])
83

Structures

Exemple de dictionnaires
#!/usr/bin/python
# Fichier: dict1.py

# un carnet d'adresses:
ca = { 'bob' : '[email protected]',
'alice' : '[email protected]'
}
print "L'adresse d'alice est: %s" % ca['alice']

# Ajout d'une paire cl/valeur:

ca['dede'] = '[email protected]'

# Destruction d'une entre

del ca['alice']

print "Il y a %d contacts\n" % len(ca)

for nom,adresse in ca.items():

print "Le contact %s a pour adresse %s" % (nom,adresse)

if 'bob' in ca: # ou bien ca.has_key('bob')

print "L'adresse de bob est %s" % ca['bob'] 84

42
Structures

Les Ensembles (sets)

Ensemble = collection non ordonne d'lments

non dupliqus
Supporte les :
tests d'appartenance
intersection
union
diffrence
diffrence symtrique

85

Structures

Exemple d'ensemble
panier = ['pomme', 'orange', 'pomme', 'poire', 'orange', 'banane']
fruit = set(panier) # supprime les doublons
print fruit
# affiche set(['orange', 'poire', 'pomme', 'banane'])
print 'orange' in fruit
# affiche True
print 'cerise' in fruit
# affiche False

a = set('abracadabra')
b = set('alacazam')
print a # lettres uniques de a
# affiche set(['a', 'r', 'b', 'c', 'd'])
print a - b # lettres dans a mais pas dans b
# affiche set(['r', 'd', 'b'])
print a | b # lettres dans a ou b
# affche set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
print a & b # letters dans a et b
# affiche set(['a', 'c'])
print a ^ b # lettres dans a ou b mais pas les 2
# affiche set(['r', 'd', 'b', 'm', 'z', 'l'])
86

43
Structures

Les squences

Les listes, tuples et chaines sont des squences

Les squences supportent deux types
d'oprations :
l'indexation qui permet d'extraire un lment
particulier de la squence
s[i]

le tranchage (slicing) qui permet d'extraire un sous-

ensemble de la squence
s[i:j] : de [i] inclus [j] non inclus
s[i:j:k] : ...et de k en k
87

Structures

Exemple de squences
#!/usr/bin/python
# Fichier: seq1.py

fruits = [ 'banane', 'orange', 'fraise', 'pomme' ]

# indexation
print "Fruit 0: ", fruits[0]
print "Fruit 1: ", fruits[1]
print "Dernier fruit: ", fruits[-1]
print "Avant-dernier fruit: ", fruits[-2]

# Tranche de liste
print "Fruits 1 3: ", fruits[1:3] # 3=n d'arrt
print "Fruits partir de 2: ", fruits[2:]
print "Du 1er l'avant-dernier: ", fruits[1:-1]
print "Tous les fruits: ", fruits[:]

# Avec une chaine:

nom = "van rossum"
print "caractres de 1 3: ", nom[1:3]
print "Caractres de 2 la fin: ", nom[2:]
print "Caractres de 1 l'avant-dernier: ", nom[1:-1] 88

44
Structures

Exemple de squences (2)

#!/usr/bin/python
# Fichier: seq2.py

fruits = [ 'banane', 'orange', 'fraise', 'pomme' ]

# Tranches de liste (suite)

# la syntaxe s[i:j:k] permet de spcifier un incrment
# qui peut tre ngatif !

print "De 0 la fin, 2 par 2: ", fruits[::2]

print "De 1 3, 2 par 2: ", fruits[1:3:2]

print "Tout l'envers: ", fruits[::-1]

print "De 3 1, en ordre inverse: ", fruits[3:1:-1]

89

Structures

Boucles sur les structures

La fonction iteritems() retourne les paires cls-
valeurs successives d'un dictionnaire

for k, v in seq.iteritems():
print k, v

La fonction enumerate() est utilise sur les squences

for i, v in enumerate(['tic', 'tac', 'toe']):

print i, v

Pour un parcours l'envers, utiliser reversed()

for i in reversed(xrange(1,10,2)):
print i
90

45
Structures

Boucles sur les structures (2)

Pour parcourir une squence trie, utiliser la

fonction sorted() :
panier = ['pomme', 'orange', 'banane', 'poire', 'pomme' ]
for f in sorted(panier):
print f

La fonction zip() permet de combiner des

squences en parallle :
questions = ['nom', 'prenom', 'age']
reponses = ['Dupont', 'Jean', '30']
for q, r in zip(questions, reponses):
print 'Votre %s est %s.' % (q, r)

91

Structures

Comparaisons de squences

Les comparaisons d'objets de type diffrents

sont possibles
Les comparaisons de squences sont lexicales

(1, 2, 3) < (1, 2, 4)

[1, 2, 3] < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4) < (1, 2, 4)
(1, 2) < (1, 2, -1)
(1, 2, 3) == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)

92

46
Structures

Les rfrences

Quand on cre un objet et qu'on l'assigne une

variable, la variable rfrence l'objet
elle ne contient pas directement l'objet
on appelle ce mcanisme la liaison (binding)
les variables rfrencent des objets
=> il y a un impact subtil...

93

Structures

Objets et rfrences
#!/usr/bin/python
# Fichier: reference.py

print "Simple affectation"

fruits = [ 'banane', 'orange', 'fraise', 'pomme' ]

copie = fruits # juste un alias sur le mme objet !

del fruits[0]

print "Liste des fruits: ", fruits

print "Contenu de la copie: ", copie

# Effectue une copie par "slicing":

copie = fruits[:]
del copie[0]

# Preuve que les objets sont diffrents:

print "Liste des fruits: ", fruits
print "Contenu de la copie: ", copie
94

47
Structures

Les chaines sont des objets !

Les chaines sont des instances de la classe str
#!/usr/bin/python
# Fichier: str_methods.py

nom = "Rolling Stones"

if nom.startswith('Rol'):
print "OK, le nom commence par 'Rol'"

if 'o' in nom:
print "OK, le nom contient n 'o'"

if nom.find('tone') != -1:
print "OK, le nom contient la chaine 'tone'"

delimiteur = '_*_'
liste = [ 'France', 'Italie', 'Espagne' ]
print delimiteur.join(liste)
print nom[0]
95

Structures

Mthodes de traitement de chaine

capitalize : met la 1re lettre en majuscule
count : nb d'occurrences d'une sous-chaine
endswith, startswith : teste la fin (le dbut) d'une chaine
find, rfind : cherche une sous-chaine
index, rindex : cherche une sous-chaine (lve une exception)
is* : teste les classes de caractres
join : concatne des chaines
lower, upper : conversion min/maj
lstrip, rstrip, strip : supprime les espaces
replace : remplace des sous-chaines
split, rsplit : dcoupe une chaine
translate : supprime et/ou convertit des caractres
splitlines : dcoupe une chaine en lignes
zfill, rjust, ljust : formatage, justification
96

48
Structures

Programmation fonctionnelle

Les fonctions suivantes s'appliquent sur les

squences :
filter(func,seq) : retourne une squence
contenant les lments de seq pour lesquels
func(seq) est True
map(func,seq) : appelle func(sec) pour chaque
lment de la squence
reduce(func,seq) : retourne une unique valeur en
invoquant successivement func(e1,e2) puis
func(res1,e3), func(res2,e4), etc...
97

Structures

Exemples
def f(x): return x % 2 != 0 and x % 3 != 0
print filter(f, range(2, 25))
# affiche [5, 7, 11, 13, 17, 19, 23]

def cube(x): return x*x*x

print map(cube, range(1, 11))
# affiche [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

seq = range(8)
def add(x, y): return x+y
print map(add, seq, seq)
# affiche [0, 2, 4, 6, 8, 10, 12, 14]

def add(x,y): return x+y

print reduce(add, range(1, 11))
# affiche 55

# mais la fonction sum(seq) existe deja !

def sum(seq):
def add(x,y): return x+y
return reduce(add, seq, 0)

print sum(range(1, 11))

print sum([])
98

49
Structures

Petit quizz

Qu'affiche
print list[0].split()[-1]
si list vaut :
list = [ "jean dupont", 42,3000 ]
quelles sont les erreurs ?
animal = "chat"
animal[0] = 'C'
animal = animal.capitalize()

99

Python

100

50
GUI

Interfaces textuelles

Utilisation de la librairie Snack base sur newt

Utilis par RedHat pour ses outils de
configuration et d'installation textuelles
#!/usr/bin/python
from snack import * screen.gridWrappedWindow(g, "Title Text")
f = Form()
screen = SnackScreen() f.add(g)
upperleft = Widget() result = f.run()
upperright = Widget() screen.popWindow()
lowerleft = Widget() screen.finish()
lowerright = Widget()
g = Grid(2, 2)
g.setField(upperleft, 0, 0, (0, 0, 1, 1))
g.setField(upperright, 1, 0)
g.setField(lowerleft, 0, 1)
g.setField(lowerright, 1, 1, growx = 1, growy = 1)

101

GUI

Interfaces graphiques

Python dispose de librairies pour concevoir des

interfaces graphiques
Tkinter : base sur Tcl/Tk - standard Python
wxPython, pyQT, py-GTK
plus puissantes, plus complexes, moins portables

102

51
Tkinter

Classes d'objets de Tkinter

Importer le module Tkinter
Classes de widgets :
Button
Canvas : pour disposer divers lments graphiques
Checkbutton
Entry : saisie de texte
Frame : surface rectangulaire dcorable
Label, Listbox, Menu
Menubutton
Message : variante de Label qui adapte le texte affich une certainte taille
Radiobutton
Scale : fait varier la valeur d'une variable l'aide d'un curseur
Scrollbar : en association avec Canvas, Entry, Listbox, Text
Text, Toplevel
Programmation vnementielle
103

Tkinter

Classes de base communes

Widget, BaseWidget :
gre une widget et ses descendants
Misc :
gestion des actions, des timers, focus, couleurs...
Pack, Grid, Place :
gestionnaires de placement des widgets

104

52
Tkinter

Exemple de programme simple

#!/usr/bin/python
# Fichier: tkinter1.py

from Tkinter import *

fen1 = Tk()
text1 = Label(fen1,text='Bonjour tout le monde !',fg='red')
text1.pack()
bou1 = Button(fen1,text='Quitter',command=fen1.destroy)
bou1.pack()
fen1.mainloop()

105

Tkinter

Exemple de trac de lignes

#!/usr/bin/python

from Tkinter import *

from random import randrange

# Definition des gestionnaires d'evenements

def drawLine():
"Trace une ligne dans le canevas can1"
global x1,y1,x2,y2,coul
can1.create_line(x1,y1,x2,y2,width=2,fill=coul)

# modification des coordonnees pour la ligne suivante:

y2,y1 = y2+10,y1-10

def changeColor():
"Changement aleatoire de la couleur du trace"
global coul
pal =
['purple','cyan','maroon','green','red','blue','orange','yellow' ]
c = randrange(8) # genere un nb aleatoire de 0 a 7
coul = pal[c] 106

53
Tkinter

Exemple de trac de lignes (2)

# Programme principal

# variables globales:
x1,y1,x2,y2 = 10,190,190,10 # coordonnees de la ligne
coul = 'dark green' # couleur de la ligne

# Creation du widget principal:

fen1 = Tk()

# Creation des fils:

can1 = Canvas(fen1,bg='dark grey',height=200,width=200)
can1.pack(side=LEFT)
bou1 = Button(fen1,text='Quitter',command=fen1.quit)
bou1.pack()
bou2 = Button(fen1,text='Tracer une ligne',command=drawLine)
bou2.pack()
bou3 = Button(fen1,text='Autre couleur',command=changeColor)
bou3.pack()

fen1.mainloop()
fen1.destroy() 107

Tkinter

Rsultats de l'excution

108

54
Tkinter

Utilisation de la mthode pack()

Paramtres de placement :
after=widget
anchor=NSEW (position suivant une direction)
before=widget
expand=bool (s'adapte la taille du parent)
fill=NONE|X|Y|BOTH
in=master
ipadx=amount (padding interne)
ipady=amount
padx=amount
pady=amount
side=TOP|BOTTOM|LEFT|RIGHT
109

Tkinter

Exemple de positionnement

#!/usr/bin/python

from Tkinter import *

fen = Tk()
fen.wm_title("Demo")
label1 = Label(fen,text="Bonjour")
but1 = Button(fen,text="Bouton1")
but2 = Button(fen,text="Bouton2")
label2 = Label(fen,text="au revoir")

label1.pack(anchor=N,padx=5,pady=5)
but1.pack(anchor=W,fill=X)
but2.pack(anchor=E)
label2.pack(anchor=S,padx=5,pady=5,expand=1)

fen.mainloop() 110

55
Tkinter

Utilisation de la mthode grid()

Paramtres de placement :
column=number
columnspan=number
in=master
ipadx=amount
ipady=amount
padx=amount
pady=amount
row=number
rowspan=number
sticky=NSEW
111

Tkinter

Exemple de positionnement
#!/usr/bin/python
from Tkinter import *
fen = Tk()

txt1 = Label(fen,text="Champ 1")

txt2 = Label(fen,text="Champ 2")
txt3 = Label(fen,text="Champ 3")
ent1 = Entry(fen)
ent2 = Entry(fen)
ent3 = Entry(fen)
can = Canvas(fen,width=160,height=160,bg='white')
photo = PhotoImage(file='image.gif')
item = can.create_image(80,80,image=photo)
txt1.grid(row=1,sticky=E)
txt2.grid(row=2,sticky=E)
txt3.grid(row=3,sticky=E)
ent1.grid(row=1,column=2)
ent2.grid(row=2,column=2)
ent3.grid(row=3,column=2)
can.grid(row=1,column=3,rowspan=3,padx=10,pady=5)

fen.mainloop() 112

56
Tkinter

Gestion des vnements

La mthode bind associe des fonctions des
vnements
il est possible d'enchainer des fonctions
la syntaxe des vnements est :
<MODIFIER-MODIFIER-TYPE-DETAIL>
MODIFIER : Control, Mod1, M1, Mod2, M2, Shift, Mod3, M3,
Lock, Mod4, M4, Button1, B1, Mod5, M5, Button2, B2, Meta, M,
Button3, B3, Alt, Button4, B4, Double, Button5, B5, Triple
TYPE : Activate, Enter, Map, ButtonPress, Button, Expose,
Motion, ButtonRelease, FocusIn, MouseWheel, Circulate,
FocusOut, Property, Colormap, Gravity, Reparent, Configure,
KeyPress, Key, Unmap, Deactivate, KeyRelease, Visibility,
Destroy, Leave
DETAIL : Keysym (pour KeyPress et KeyRelease)
113

Tkinter

Interaction et Fonction eval()

Objectif :
raliser une "calculatrice"
Mthodes mises en jeu :
BaseWidget.configure()
configure une widget
BaseWidget.bind()
lie une action utilisateur une fonction
eval()
value du code Python dans un script

114

57
Tkinter

Calculatrice basique
#!/usr/bin/python

from Tkinter import *

from math import *

def evaluer(event):
chaine.configure(text = "Resultat = " +
str(eval(entree.get())))

fenetre = Tk()
entree = Entry(fenetre)
entree.bind("<Return>",evaluer)
chaine = Label(fenetre)
entree.pack()
chaine.pack()

fenetre.mainloop()

115

PyGTK

Introduction PyGTK

Interface au-dessus de GTK+

Offre un bibliothque de widgets de plus haut-
niveau que Tkinter
Livr avec des programmes de dmonstration :
pygtkconsole.py
pygtk-demo
Coupl avec Glade permet de dissocier
l'interface (dcrite en XML) du code Python qui
gre les vnements utilisateurs
116

58
PyGTK

1er programme
#!/usr/bin/python
# example base.py

import pygtk
pygtk.require('2.0')
import gtk

class Base:
def __init__(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.show()

def main(self):
gtk.main()

print __name__
if __name__ == "__main__":
base = Base()
base.main()

117

PyGTK

Signaux, callbacks et vnements

La fonction gtk.main() attend l'arrive

d'vnements et passe le contrle la fonction
responsable de son traitement
les vnements sont appels des "signaux"
mais il existe aussi de "vrais" vnements pour
supporter les vnements de l'interface X-Window

118

59
PyGTK

Gestion des signaux

Interception d'un signal :
handler_id = object.connect(name, func,
func_data)
object = instance de GtkWidget qui met le signal
name = chaine reprsentant le signal grer
func = callback invoquer
func_data = donnes passes la callback

Prototype d'une fonction callback :

def callback_meth(self, widget,
callback_data)
self = widget (si mthode d'objet)
widget = widget ayant mis le signal
callback_data = func_data
119

PyGTK

Gestion des vnements

Interception d'un vnement l'aide de la
mthode connect()
Prototype d'une fonction callback pour les
vnements :
def callback_meth(self, widget, event,
callback_data)
event= vnement de type GdkEvent

Exemples d'vnements :
event button_press_event button_release_event scroll_event
motion_notify_event delete_event destroy_event expose_event
key_press_event key_release_event enter_notify_event
leave_notify_event configure_event focus_in_event focus_out_event
map_event unmap_event property_notify_event selection_clear_event
selection_request_event selection_notify_event proximity_in_event
proximity_out_event visibility_notify_event client_event
no_expose_event window_state_event
120

60
PyGTK

Placement des widgets

Les widgets sont placs dans des "boxes" qui
sont des containers invisibles :
gtk.VBox, gtk.HBox
pack_start() place les widgets de haut en bas ou
gauche droite
pack_end() fait l'inverse
options possibles : expand, fill, padding
Alternative : utilisation de "tables"
dfinit le nombre de lignes et colonnes
les widgets peuvent tre places dans des cellules
prcises

121

Python

122

61
Fichiers

Introduction

Modules sys et os
Gestion des rpertoires
Fichiers texte
Fichiers binaires

123

Fichiers

Le module sys

Fournit des services pour intragir avec

l'interprteur
gre les flux stdin, stdout, stderr
gre les arguments de la ligne de commande
gre les exceptions (voir plus loin)

124

62
Fichiers

Le module sys (2)

dir(sys)
sys.platform, sys.maxint, sys.version
sys.path : liste des rpertoires inclure
sys.path.append(r"C:\tmp")
sys.modules : liste des modules chargs
sys.argv : arguments de la ligne de
commande
sys.exit(nu)
sys.stdin, sys.stdout, sys.stderr
125

Fichiers

Le module os

Principale interface vers les services de l'O.S

Permet d'accder aux environnements de
processus, aux fichiers, aux rpertoires, aux
commandes...
Contient un sous-module os.path pour crire
des chemins de manire portable

126

63
Fichiers

Le module os (2)
Variables shell : environ
Lancement de programmes : system, popen,
startfile, fork, pipe, exec, waitpid, kill
Fichiers, verrous : read, write, lock
Gestion des fichiers : remove, rename, mkfifo,
mkdir, rmdir, getcwd, chdir, chmod,
getpid, listdir, walk
Portabilit : sep, pathsep, linesep, curdir,
path.split, path.join, path.exists,
path.isdir, path.isfile
127

Fichiers

Gestion des chemins

>>> os.path.isdir("/etc")
True
>>> os.path.isfile("/tmp")
False

>>> os.path.exists("/etc/group")
True

>>> os.path.split("/etc/group")
('/etc','group')

>>> os.path.basename("/etc/passwd")
'passwd'

>>> os.path.abspath("../images")
'/opt/formation/python/images'

128

64
Fichiers

Lecture d'un fichier texte

#!/usr/bin/python
import os
input = open("/etc/passwd","r")
while 1:
ligne = input.readline()
if ligne == "":
break
print ligne

input.close()

#!/usr/bin/python
import os
#!/usr/bin/python
import os input = open("/etc/passwd","r")
for ligne in input.readlines():
# avec un itrateur: print ligne
for l in open("/etc/passwd"):
print l input.close()

129

Fichiers

Ecriture dans un fichier

#!/usr/bin/python
import os
output = open("data.txt","w")

output.write("ligne 1\n")
output.write("ligne 2\n");

output.close()

#!/usr/bin/python
import os
output = open("data.txt","a")

output.write("ligne 3\n")
output.write("ligne 4\n");

output.close()

130

65
Fichiers

Excution de commandes
os.system("cmd")
excute la commande
os.popen(...) permet de connecter les flux

#!/usr/bin/python
import os

listing = os.popen("ls /tmp").read()

listing

pipe = os.popen("/bin/cat","w")
pipe.write("coucou\n")

131

Fichiers

Redirections de flux

A l'aide de la fonction print :

print >> objet-fichier, arguments
import sys
print >> sys.stderr, "coucou"

En manipulant sys.stdout, sys.stdin :

>>> sys.stdin = objet-fichier
l'objet doit avoir une mthode read()

>>> sys.stdout = objet-fichier

l'objet doit avoir une mthode write()

132

66
Fichiers

Exemple avec StringIO

#!/usr/bin/python

from StringIO import StringIO

import sys

buff = StringIO()
buff.write("demo") # supporte write()

temp = sys.stdout
sys.stdout = buff # donc, a marche !

print 42, 'spam', 3.141

sys.stdout = temp
print buff.getvalue()

133

Fichiers

Fichiers binaires
Ouverts avec "rb", "wb" ou "ab"
\r\n sous Dos est converti en \n en mode texte

Utilisation du module struct qui associe un

enregistrement binaire une structure
mthodes pack, unpack et calcsize
spcifieur de format :
< (little-endian), > (big-endian), = et @ (mode natif)
rptiteur de type
type : x (padding), c (char), b (signed byte), B (unsigned byte), h
(short), H (unsigned short), i (int), I (unsigned int), l (long), L
(unsigned long), f (float), d (double), s (string), P (pointeur), q (long
long), Q (unsigned long long)
134

67
Fichiers

Exemple d'utilisation

#!/usr/bin/python

from struct import *

fmt = '<3l32s256scc'
len = calcsize(fmt)
print 'la taille d\'un enregistrement est : ',len

input = open(fichier,"rb")
while True:
buff = input.read(len)
if not buff: break

# Autant de variables que de champs dans le format:

(v1,v2,v3,s1,s2,b1,b2) = unpack(fmt,buff)
....

135

Fichiers

Gestion des rpertoires

O suis-je ?
>>> import os
>>> print os.getcwd()
/chemin/courant
Changer de rpertoire :
>>> from os import chdir
>>> chdir("/nouveau/repertoire")
Lire le contenu d'un rpertoire :
>>> f = os.listdir("/etc")
136

68
Fichiers

Parcourir des rpertoires

1re mthode: avec popen
retourne les "fin-de-ligne"
for n in os.popen("ls -R /tmp").readlines():
print n[:-1]

2me mthode : avec glob (import glob)

retourne le chemin relatif
for n in glob.glob('*.dir/*.py'):
print n

3me mthode: avec os.listdir

retourne le nom de base
137

Fichiers

La rcursivit avec os.(path.)walk

#!/usr/bin/python
import os

# callback:
def lister(dummy,dirname,filesindir):
print '[' + dirname + ']'
for n in filesindir:
print os.path.join(dirname,n)

os.path.walk('.',lister,None)

#!/usr/bin/python
import os
matches = []

for (dirname,dirshere,fileshere) in os.walk('.'):

for fname in fileshere:
if fname.endswith('.py'):
pathname = os.path.join(dirname,fname)
matches.append(pathname)
print matches 138

69
Python

139

Exceptions

Introduction

Gestion des erreurs != gestion des exceptions

Erreurs = traitement synchrone des retours de
fonction
Exception = traitement asynchrone maitris des
anomalies

140

70
Exceptions

Exemples d'exception

Division par 0 :
>>> print 99/0
ZeroDivisionError: integer division or
modulo by zero
Erreur de syntaxe :
>>> Print "coucou" !"
File "<stdin>", line 1
Print "coucou"
Syntax Error: invalid syntax
141

Exceptions

Bloc try - except - else

Les instructions du bloc try sont excutes

sous rserve qu'une exception survienne
Dans ce cas, les instructions du bloc except
sont excutes
Si aucune exception ne survient, le bloc else
est jou aprs le bloc try
le bloc else est optionnel

142

71
Exceptions

Exemple de traitement d'une exception

#!/usr/bin/python
import os

def existe(fname):
try:
f = open(fname,"r")
f.close()
return 1
except:
return 0

filename = raw_input("Veuillez entrer un nom de fichier : ")

if existe(filename):
print "OK - le fichier existe"
else:
print "BOUM ! Le fichier n'existe pas"

# Comparez sans prsence du bloc try..except...

143

Exceptions

Slection des exceptions

Un mme bloc peut "lever" des exceptions

diffrentes : il est possible de les discriminer

#!/usr/bin/python
import sys

try:
s = raw_input('Saisissez qqc : ')
except EOFError:
print '\nVous avez saisi un EOF'
sys.exit()
except:
print '\nUne autre exception a t leve'

print "Fin"

144

72
Exceptions

Formats des clauses d'un try

except:
intercepte toutes les exceptions restantes
except nom:
intercepte seulement l'exception nom
except nom, info:
intercepte l'exception nom et les infos associes
except (nom1,nom2) [, info [, info ...]] :
intercepte une des exceptions nommes
pour connaitre les infos associes une exception:
>>> dir(IOError())
else:
instructions excutes si aucune exception n'est survenue
finally:
toujours excut en sortie du bloc try

145

Exceptions

Comment "lever" une exception ?

Il faut crer un objet qui drive de Error ou
Exception, puis appeler l'instruction raise
class ShortInputException(Exception):
def __init__(self,length,atleast):
Exception.__init__(self)
self.length = length
self.atleast = atleast

try:
s = raw_input('Saisissez qqc : ')
if len(s) < 3:
raise ShortInputException(len(s),3)
# traitement normal ici...
except EOFError:
print "\nEOF saisi"
except ShortInputException, x:
print "Trop peu de caractres : %d" % (x.length)
else:
print "OK" 146

73
Exceptions

Diffrentes syntaxes de raise

raise chaine
correspond une clause except dont le nom est identique chaine
raise chaine, info
passe info avec l'exception. Elle est assigne la variable X d'une
clause except chaine,X
raise instance
quivalent raise instance.__class__, instance
raise classe, instance
correspond une clause except qui nomme cette classe ou l'une des
ses classes parentes. Passe l'objet instance l'exception qui sera
affecte la variable X de except classe,X
raise
redclenche l'exception courante
147

Exceptions

Bloc try - finally

Le bloc finally est excut dans tous les cas

#!/usr/bin/python
import time

# Ctrl-C arrte le programme !

try:
f = file("/etc/group")
while True:
line = f.readline()
if len(line) == 0:
break
time.sleep(2)
print line,
finally:
f.close()
print "Fichier ferm"
148

74
Exceptions

Unification du bloc try-except-finally

(v2.5+) Possibilit de mlanger les clauses

except et finally
try:
block-1 ...
except Exception1:
handler-1 ...
except Exception2:
handler-2 ...
else:
else-block
finally:
final-block

149

Exceptions

Classes d'exceptions prdfinies

Exception (base 1) AssertionError AttributeError

StandardError (base 2) EOFError FloatingPointError

ArithmeticError IOError ImportError

LookupError IndexError KeyError

EnvironmentError OverflowError ZeroDivisionError

AssertionError OSError AttributeError

ImportError KeyboardInterrupt MemoryError

NameError NotImplementedError ReferenceError

RuntimeError StopIteration SyntaxError

SystemError SystemExit TypeError

UnboundLocalError UnicodeError UnicodeEncodeError

UnicodeDecodeError UnicodeTranslateError ValueError

WindowsError SyntaxWarning
Warning UserWarning PendingDEprecationWarning

RuntimeWarning FutureWarning DeprecationWarning 150

75
Exceptions

Gestion des avertissements

Avertissent d'un risque de future non-

compatibilit
Emission avec warnings.warn(message)
Possibilit de filtrage avec
warnings.filterwarnings :
action : ignore
message : regexp de filtrage
category : type de l'avertissement
module : filtre sur les modules
151

Exceptions

Exemple de gestion des warnings

#!/usr/bin/python
import warnings

warnings.warn("avertissement 1")

warnings.filterwarnings(
action = 'ignore',
message = '.*',
category = DeprecationWarning,
module = '__main__')

warnings.warn("avertissement 2",DeprecationWarning)

152

76
Python

153

Processus

Introduction

Processus
Threads
IPC
Signaux

154

77
Processus

Cration de processus (fork)

#!/usr/bin/python

import os

def child():
print "Coucou de la part du fils - PID = ",os.getpid()
os._exit(0)

def parent():
while 1:
newpid = os.fork()
if newpid == 0:
child()
else:
print "Coucou du parent - PID = ",os.getpid(), \
" - PID-fils = ",newpid
if raw_input() == 'q': break

parent()
155

Processus

Excution de commandes avec exec*

os.execv(pgm,arg-tuple)
os.execl(pgm,arg1,...,argn)
os.execv(pgm,(arg1,...,argn))
os.execlp, os.execvp
cherche le pgm dans l'aide de $PATH
os.execle, os.execve
le dernier argument est un dictionnaire contenant les
variables d'environnement
os.execvpe, os.execlpe
156

78
Processus

Exemple avec fork/exec

#!/usr/bin/python

import os

parm = 0
while 1:
parm += 1
pid = os.fork()
if pid == 0:
# processus fils
os.execlp('python','python','ex-fils.py',str(parm))
assert False,'erreur de execlp'
else:
print 'Le PID du fils est ',pid
if raw_input() == 'q': break

#!/usr/bin/python

import os,sys
print 'Bonjour, je suis le fils, mon PID est: ',os.getpid()
print '...et mon parametre est: ',sys.argv[1] 157

Processus

Le module thread

#!/usr/bin/python

import thread,time

def counter(myId,count):
for i in range(count):
#mutex.acquire()
time.sleep(1)
print '[%s] => %s' % (myId,i)
#mutex.release()

mutex = thread.allocate_lock()
for i in range(10):
thread.start_new_thread(counter,(i,3))

time.sleep(4)
print 'Sortie du thread principal'

158

79
Processus

Autres mcanismes

Le module threading
repose sur le module thread
implmente une smantique " la Java" (join, lock...)
Le module Queue
FIFO accs synchronis

159

Processus

Utilisation du module threading

Les threads sont des instances d'une classe
drive de threading.Thread
doit implmenter __init__() et run()
run() est invoqu quand le thread dmarre
Attention au GIL (Global Interpretor Lock) :
l'interprteur Python n'est pas "thread-safe" : chaque
thread qui veut accder un objet doit verrouiller le
GIL
=> faire du multi-threading sur du calcul n'apporte pas
plus de performance, avec des I/O, oui
=> sinon, il faut utiliser le modle du multi-processing

160

80
Processus

Exemple de multi-threading
#!/usr/bin/python
for i in xrange(10):
# Fichier: prime-thread.py
t = MonThread(q)
t.setDaemon(True)
import threading
t.start()
import Queue
# On remplit la queue:
# Objet de synchro inter-thread
for i in xrange(100):
q = Queue.Queue()
queue.put(i)
class MonThread(threading.Thread):
# On attend que les threads
def __init__(self,q):
# aient fini
super(MonThread,self).__init__()
queue.join()
self.q = q

def run(self):
x = self.q.get()
pass
self.q.task_done()

161

Processus

Le module multiprocessing
Les processus sont des instances de la classe
Process et sont dmarrs par la fonction
start()
imite le fonctionnement du module threading
Ncessite des objets de synchronisation :
Queues, Pipes, Lock...
Les objets Value et Array sont placs dans
des segments de mmoire partags
les manager permettent de partager des
dictionnaires, listes...
La classe Pool permet de crer et grer un
ensemble de "worker process" 162

81
Processus

Exemples de multi-processing
#!/usr/bin/python

from multiprocessing import Process

def f(name):
print 'hello', name

if __name__ == '__main__':
p = Process(target=f, args=('bob',))
p.start()
p.join()

import multiprocessing

def ma_fonction(val):
pass

# Obligatoire pour le multiprocessing

if __name__ == '__main__':
pool = multiprocessing.Pool(10)
pool.map(ma_fonction, xrange(100))163

Processus

IPC : les tubes (pipes)

os.pipe : retourne deux descripteurs inputfd et

outputfd qui permettent de lire et crire dans un
pipe
os.mkfifo : permet de crer un tube nomm

164

82
Processus

Le module signal et les signaux

Les gestionnaires de signaux sont restors

aprs leur dclenchement
#!/usr/bin/python

import sys,signal,time

def now():
return time.ctime(time.time())

# Enoyez-moi le signal pass en paramtre avec kill -N !!

def onSignal(signum,stackframe):
print "J'ai captur le signal ",signum, " ",now()

signum = int(sys.argv[1])
signal.signal(signum,onSignal)
signal.alarm(100) # au cas o !
while 1: signal.pause()
165

Python

166

83
Regexp

Introduction

Rappel du concept ? de la syntaxe ?

Le module regex (dprci) supporte les
regexp de awk, sed, grep
Le module re gre les regexp " la Perl"

167

Regexp

Rappels syntaxiques
a, b, ... : expression atomique
. : n'importe quel caractre
[abc], [a-jmn], [^a-k] : ensemble et intervalle
^, $, \b, \B : ancres
*, ?, +, {m}, {m,n} : rptiteurs
? : non-gourmandise (ou paresse)
| : alternative
\n : correspond la valeur d'un groupe entre ()
\xxx, \s, \w.. : classes de caractres
168

84
Regexp

Recherche de bases
La mthode re.match() met en relation un modle et
du texte :
>>> pat = '[ \t]*Bonjour[ \t]+(.*)'
>>> line = "Bonjour tout le monde"
>>> mobj = re.match(pat,line)
>>> mobj.group(1)
'tout le monde'

Si la mme regexp doit tre utilise plusieurs fois, on

peut la compiler avec re.compile() :
>>> patobj = re.compile(pat)
>>> mobj = patobj.match(line)
169

Regexp

Autres mthodes du module re

match cherche les chaines implicitement
ancres en dbut de chaine
search n'utilise pas d'ancre implicite
split dcoupe un texte en utilisant une regexp
comme dlimiteur
sub et subn effectuent des substitutions
findall retourne toute les occurrences
disjointes d'un modle (finditer retourne un
itrateur)
170

85
Regexp

Options de recherche
Dernier argument de compile, match, search, find*
peuvent tre multiples et spares par des '|'
re.I ou (?i) : ignore la casse des caractres
re.L ou (?L) : les \w, \b, etc... deviennent dpendants de la
localisation (sur 8 bits)
re.M ou (?m) : multilignes
re.S ou (?s) : le . correspond aussi au fin de ligne
re.U ou (?u): les \w, \b, etc... deviennent dpendants des
proprits Unicode
re.X ou (?x) : mode verbeux

171

Regexp

Objet rsultat

En cas de succs, match et search retournent

un objet dont les attributs principaux sont :
start() : index de la position de dbut de
correspondance
end() : index de la fin de la correspondance
string : chaine passe en paramtre
group : chaine correspondant un groupe (0 est la
chaine complte)
groups : n-uplets de tous les groupes

172

86
Python

173

POO

Tout est objet...

On modlise les objets du monde rel en "objets

informatiques"
Les objets sont caractriss par:
des attributs (des variables stockant des informations
sur l'objet)
des mthodes qui caractrisent son comportement
(fonctions membres)
une identit (ID ou valeur de pointeur)

174

87
POO

Principe d'abstraction

Les classes regroupent les informations

communes aux objets qu'elles reprsentent
Les objets sont alors des "instances de classe"

Exemple:
la classe "figure gomtrique" dfinit que ses objets
possdent des sommets et des artes
les objets "triangles" et "carrs" appartiennent la
classe "figure gomtrique"
175

POO

Principe d'encapsulation
Objectif: cacher l'implmentation de la classe,
en masquant tout ce qui n'est pas un service
propos
Permet de modifier l'implmentation sans
changer l'interface
Notion de visibilit des attributs et mthodes
La visibilit peut tre:
publique, prive, protge
mais avec Python, tout est public !
176

88
POO

Principe d'hritage

Objectif: raffiner une classe et en crant une

nouvelle qui hrite de son comportement. La
nouvelle classe propose de nouveaux attributs
et/ou services (spcialisation)

Exemple:
la classe "quadrilatre" est drive de la classe
"figure gomtrique" mais elle ajoute une contrainte
supplmentaire sur le nombre d'artes
177

POO

Le polymorphisme

Objectif: proposer une version unifie des

mthodes exportes par les objets alors que ces
mthodes sont particulires chacun d'eux

Plusieurs polymorphismes:
polymorphisme d'hritage (mme nom de mthode
mais comportement diffrent)
polymorphisme paramtrique (mme nom de
mthode mais paramtres de types diffrents)
178

89
POO

Nouveaux mots-cls

class dfinit une classe

self est le 1er paramtre des mthodes d'une
classe (ce nom est une convention)

#!/usr/bin/python
# Fichier: methode1.py

class Personne:
def direBonjour(self):
print "Bonjour !"

p = Personne()
p.direBonjour()

179

POO

Mthodes prdfinies
__init__ est le constructeur

#!/usr/bin/python
# Fichier: methode1.py

class Personne:
def __init__(self,nom):
self.nom = nom

def direBonjour(self):
print "Bonjour, je m'appelle ",self.nom

p = Personne("alice")
p.direBonjour()

# ou bien:

Personne("alice").direBonjour()

180

90
POO

Mthodes prdfinies (2)

__del__ est le destructeur

#!/usr/bin/python
# Fichier: methode1.py

class Personne:
def __del__(self):
print "Au revoir !"

def direBonjour(self):
print "Bonjour !"

p = Personne()
p.direBonjour()

del p

181

POO

Variables de classes
Ce sont simplement des variables dfinies dans
l'espace de nommage (de visibilit) de la classe
#!/usr/bin/python
# Fichier: objvar.py

class Personne:
population = 0

def __init__(self,nom):
Personne.population += 1
self.nom = nom

def __del__(self):
Personne.population -= 1

p = Personne('alice')
p.direBonjour()
print Personne.population
del p 182

91
POO

Hritage de classes simple

#!/usr/bin/python
# Fichier: heritage.py

class Mammifere:
car1 = "allaite ses petits"

class Carnivore(Mammifere):
car2 = "mange ses proies"

class Chien(Carnivore):
car3 = "il aboie"

medor = Chien()
print medor.car1, medor.car2, medor.car3

183

POO

Types et classes prdfinies

Depuis la v2.2, tous les types prdfinis sont des
classes qui drivent du type de base object
une classe qui drive de object est dite "new style class"
il est recommand de le faire pour profiter des nouvelles
fonctionnalits

Il est possible de driver des classes depuis les types :

object
int, long, bool, float
list, tuple, dict, set
file

184

92
POO

Hritage de classes multiples

#!/usr/bin/python
# Fichier: heritage2.py

class Mammifere:
car1 = "allaite ses petits"

class Carnivore:
car2 = "mange ses proies"

class Chien(Mammifere,Carnivore):
car3 = "il aboie"

medor = Chien()
print medor.car1, medor.car2, medor.car3

185

POO

Polymorphisme
#!/usr/bin/python
# Fichier: heritage.py

class Animal:
def faireDuBruit(self):
print "(silence)"

class Chien(Animal):
def faireDuBruit(self):
print "ouaf, ouaf !"

class Chat(Animal):
def faireDuBruit(self):
print "miaou..."

medor = Chien(); medor.faitDuBruit()

felix = Chat(); felix.faitDuBruit()
animal = Animal(); animal.faitDuBruit()
animal = felix; animal.faitDuBruit()

186

93
POO

Relations entre classes

Une mthode de la classe drive peut appeler
une mthode de la classe parente
Animal.methode(self, parm)
super(Drive,self).methode(parm)
syntaxe supporte si la classe de base drive de object
les paramtres de super() sont facultatifs (v3)

Ainsi, le ctor de la classe drive peut (doit ?)

appeler le ctor de la classe parente :
Animal.__init__(self, parms)
super(Drive,self).__init__(parms)
super().__init__(parms) (Python v3+)
187

POO

Attributs privs
Tout est public !
Il faut adopter des conventions de nommage et les
respecter (PEP 8)
Tout nom qui dbute par un _ n'est pas export par un
module (lors d'un from module import *)
Tout attribut dont le nom dbute par __ est dcor avec
_nomclasse
class MaClasse:
i = 1
__priv = 2

print MaClasse.i
print MaClasse.__priv # erreur
print MaClasse._MaClasse__priv # OK !
188

94
POO

Copie d'objets
Pour viter le partage des rfrences, il faut
parfois forcer la copie des objets
Oprateur [:] pour les squences
Methode copy() pour les dictionnaires et les
ensembles
Sinon, importer le module copy et utiliser les
mthodes :
copy() ou deepcopy() (rcursive)
les objets doivent dfinir les mthodes
__copy__(self) et __deepcopy__(self,memo)
189

Python

190

95
Syntaxe avance

Mthodes spciales ("magiques")

Toutes les fonctions internes et les oprateurs

peuvent tre redfinis pour chaque classe
d'objet
y compris les objets de base
Exemples :
__len__(self) est invoque par len()
__lt__(self,other) est invoque par l'op. <
__getitem__(self,offset) est invoque par les
[...]
191

Syntaxe avance

Exemple de surcharges
#!/usr/bin/python
# Fichier: overload.py

class UneClasse:
def __init__(self,liste = []):
self.valeurs = liste

def __str__(self):
# doit retourner une chaine
return "Contenu: " + str(self.valeurs)

def __len__(self):
return len(self.valeurs)

# Exemple d'utilisation
obj = UneClasse([1,2,3,4])
print "la 'longueur' de l'objet est: ", len(obj)
print "sa reprsentation est: ", obj

192

96
Syntaxe avance

Liste des mthodes magiques

Cration d'un objet :
__new__(cls, ...), __init__(self,...),
__del__(self)

Comparaisons :
__cmp__(self, other), __eq__, __ne__, __lt__,
__gt__, __le__, __ge__

Oprateurs unaires et fonctions :

__pos__(self), __neg__, __abs__, __invert__,
__round__(self,n), __floor__, __ceil__,
__trunc__

193

Syntaxe avance

Liste des mthodes magiques (2)

Oprateurs arithmtiques :
__add__(self,other), __sub__, __mul__,
__floordiv__, __div__, __truediv__, __divmod__,
__pow__, __lshift__, __rshift__, __and__,
__or__, __xor__

Oprateurs arithmtiques rflectifs :

__radd__(self, other), ...

Oprateurs d'affectation :
__iadd__(self,other), ...

194

97
Syntaxe avance

Liste des mthodes magiques (3)

Oprateurs de conversion :
__int__(self), __long__, __float__,
__complex__, __oct__, __hex__, __index__,
__trunc__, __coerce__(self,other)

Reprsentation de classes :
__str__(self), __repr__, __unicode__,
__format__(self, formatstr), __hash__,
__nonzero__, __dir__, __sizeof__

Contrle des accs aux attributs :

__getattr__(self, attr), __setattr__(self,
attr, val), __delattr__, __getattribute__

195

Syntaxe avance

Liste des mthodes magiques (4)

Traitement des squences :
__len__(self), __getitem__, __setitem__,
__delitem__, __iter__, __reversed__,
__contains__, __missing__

Rflexivit :
__instancecheck__(self, inst),
__subclasscheck__(self, subclass)

Objets "appelables" (callables) :

__call__(self, ...)

Context Manager :
__enter__(self), __exit__(self, exception_type,
exception_value, traceback) 196

98
Syntaxe avance

Liste des mthodes magiques (5)

Objets descripteurs :
__get__(self, inst, owner), __set__,
__delete__
Copie d'objets :
__copy__(self), __deepcopy__(self,
moddict={})
Serialisation (pickling) :
__getinitargs__(self), __getnewargs__,
__getstate__, __setstate__, __reduce__,
__reduce_ex__
197

Syntaxe avance

Exemple de Descriptor
#!/usr/bin/python
# Fichier: descriptor.py

class Celsius( object ):

def __init__( self, value=0.0 ):
self.value = float(value)
def __get__( self, instance, owner ):
return self.value
def __set__( self, instance, value ):
self.value = float(value)

class Farenheit( object ):

def __get__( self, instance, owner ): # owner = Temperature
return instance.celsius * 9 / 5 + 32
def __set__( self, instance, value ): # instance = "t"
instance.celsius = (float(value)-32) * 5 / 9

class Temperature( object ): # Owner class

celsius = Celsius()
farenheit = Farenheit()

t = Temperature()
t.farenheit = 450
print t.celsius # conversion automatique !
198

99
Syntaxe avance

Lambda-fonctions

Python permet de dfinir dynamiquement des

fonctions anonymes : les lambda-fonctions
lambda arg, arg ... : expression

#!/usr/bin/python
# Fichier: lambda.py

def make_repeteur(n):
return lambda s: s * n

deuxfois = make_repeteur(2)

print deuxfois('coucou ')

print deuxfois(5)

199

Syntaxe avance

Lambda-fonctions (2)

#!/usr/bin/python
# Fichier: lambda2.py

def sort(seq, func=(lambda x,y: x <= y)): # defaut: ascendant

res = seq[:0]
for j in range(len(seq)):
i = 0
for y in res:
if func(seq[j],y): break
i += 1
res = res[:i] + seq[j:j+1] + res[i:]
return res

table = ({'nom':'jean'}, {'nom':'dupont'})

print sort(list(table),(lambda x,y: x['nom'] > y['nom']))

print sort(tuple(table),(lambda x,y: x['nom'] <= y['nom']))

200

100
Syntaxe avance

Dfinitions fonctionnelles des listes

La syntaxe [...] peut tre enrichie par :
[expression for expr1 in seq1 [if condition]
for expr2 in seq2 [if condition] ...
for exprN in seqN [if condition] ]
meilleures performances

Exemples :
liste1 = [2, 3, 4]
liste2 = [2*i for i in liste1 if i > 2]
liste3 = [ord(x) for x in 'bonjour']
est quivalent :
liste3 = map(ord,'bonjour')
201

Syntaxe avance

Dfinitions fonctionnelles des listes (2)

Permet d'viter la cration d'une fonction

temporaire :
liste = [x**2 for x in range(5) ]
liste = map((lambda x: x**2), range(5))
Les dfinitions avec conditions sont quivalentes
l'utilisation de la fonction filter :
liste = [ x for x in range(5) if x % 2 == 0]
liste = filter((lambda x: x % 2 == 0),
range(5))

202

101
Syntaxe avance

Dfinitions fonctionnelles des listes (3)

Les dclarations fonctionnelles avec des
boucles for imbriques sont similaires au for
"normal" :
[y for x in range(3) for y in range(2)]
est quivalent :
res = []
for x in range(3):
for y in range(2):
res.append(y)
>>> res
[0,1,0,1,0,1]
203

Syntaxe avance

Expressions gnratrices
Produisent des rsultats similaires aux dfinitions
fonctionnelles, mais sans crer la liste
Agissent comme des itrateurs possdant une mthode
next
Exemples :
>>> carres = (x**2 for x in range(5))
>>> carres
<generator object ...>
>>> carres.next()
0
>>> list (x**2 for x in range(5))
[0,1,4,9,16]
204

102
Syntaxe avance

Oprateur "splat" (* et **)

L'oprateur unaire * permet de forcer

l'clatement d'une liste (unpacking)
L'oprateur unaire ** permet de forcer
l'clatement d'un dictionnaire
>>> drapeau = ("bleu", "blanc", "rouge")
# ici on utilise un tuple, mais a marche avec les listes
>>> premiere_couleur = drapeau[0]
>>> deuxieme_couleur = drapeau[1]
>>> print(premiere_couleur)
'bleu'
>>> couleur1, couleur2, couleur3 = drapeau
print couleur1
'bleu'
>>> fonction(*drapeau)
# quivaut appeler un fonction avec 3 paramtres
205

Syntaxe avance

Paramtres listes ou n-uplets

Comment passer des paramtres de longueur

variable des fonctions ?
Un paramtre formel prfix par * reoit toutes
les valeurs situes aprs la liste des paramtres
formels sous forme d'un n-uplet
Un paramtre formel prfix par ** reoit toutes
les valeurs sous forme de dictionnaire cl/valeur,
exceptes pour les valeurs associes des
paramtres formels
206

103
Syntaxe avance

Exemple de paramtres variables

#!/usr/bin/python
# Fichier: varlist1.py

def powersum(power,*args):
'''Retourne la somme de chaque arg lev la
puissance indique par le 1er paramtre'''
total = 0
for i in args:
total += pow(i,power)
return total

print powersum(2,3,4)
print powersum(2,10)

liste = (1,2,3)
print powersum(*liste)

207

Syntaxe avance

Exemple de paramtres variables (2)

#!/usr/bin/python
# Fichier: varlist2.py
#!/usr/bin/python

# * doit tre avant ** :

def superfunc(parm1,*arg,**kwarg):
print "parm1=",parm1
print '-' * 30
for a in arg:
print a
print '-' * 30
for k in kwarg.keys():
print k,":",kwarg[k]

superfunc(3,1,'toto',couleur='rouge',prix=4)

208

104
Syntaxe avance

Fonctions partielles (v2.5+)

Le module functools permet d'utiliser des

fonctions d'aide la programmation
fonctionnelle
Exemple :
cration de fonctions qui en invoquent d'autres avec
remplissage partiel des paramtres

import functools
def log(message,categorie):
print '%s: %s' % (message,categorie)

mail_log = functools.partial(log,categorie='mail')
mail_log('pb de boite aux lettres')
209

Syntaxe avance

Instruction exec et fonction eval

L'instruction exec permet d'excuter du code

Python contenu dans une chaine ou un fichier
>>> exec 'print "coucou"'
L'instruction eval permet d'valuer une
expression Python contenue dans une chaine ou
un fichier
>>> eval('2*3')

210

105
Syntaxe avance

Instruction assert

Utilise pour affirmer que qqc est vrai (True)

Si l'assertion est fausse, une exception
(AssertionError) est leve
>>> assert(False)
Traceback (most recent call last):
file "<stdin>", line 1, in ?
AssertionError

211

Syntaxe avance

Fonction repr
Elle permet d'obtenir une chaine reprsentant un
objet ou une expression
fonction quivalente la forme entre backquotes
>>> i = 4
>>> repr(i)
'4'
>>> repr(2*3)
'6'
>>> `i`
'4'
212

106
Syntaxe avance

Instruction yield

Syntaxe :
yield expression
Suspend la fonction qui la contient et retourne la
valeur de l'expression
A la prochaine itration, l'tat de la fonction est
restaur et l'excution reprend aprs l'instruction
yield def fabrique_entiers(N):
for i in range(N):
yield i

gen = fabrique_entiers(5)
print gen.next()
213

Syntaxe avance

Gnrateurs et itrateurs
Les classes qui implmentent les mthodes
__iter__() et next()sont des itrateurs
__iter__() retourne l'objet itrateur
mthode invoque par l'appel iter(obj)
next() retourne le prochain lment et lve
l'exception StopIteration en fin d'itration
Les fonctions qui contiennent des "yield" sont
compiles en tant que gnrateurs
lorsqu'elles sont invoques, elles retournent un objet
gnrateur qui fournit la mthode next()
214

107
Syntaxe avance

Amliorations des gnrateurs (v2.5+)

Avant : une fois que le code d'un gnrateur produit un
itrateur, on ne peut passer de nouvelles informations
quand la fonction est invoque
les gnrateurs ne produisent que des rsultats en sortie

Maintenant :
yield retourne une expression (ce n'est plus une instruction)
la mthode send permet de spcifier la prochaine valeur
retourne par yield

215

Syntaxe avance

Exemple de gnrateur (v2.5+)

def counter (maximum):
i = 0
while i < maximum:
val = (yield i)
# If value provided, change counter
if val is not None:
i = val
else: # Exemple d'appel
i += 1 >>> it = counter(10)
>>> print it.next()
0
>>> print it.next()
1
>>> print it.send(8)
8
>>> print it.next()
9
>>> print it.next()
Traceback (most recent call last):
File ``t.py'', line 15, in ?
print it.next()
StopIteration 216

108
Syntaxe avance

L'instruction with (v2.5+)

Permet de dfinir une nouvelle structure de contrle
Syntaxe :
with expression [as variable]:
with-block

L'expression doit retourner un objet qui supporte le

"context management protocol"
supporte les mthodes __enter__ et __exit__
avant l'valuation du with-block, __enter__ est appele et
la valeur retourne affecte la variable
en fin de bloc, __exit__ est appele. Les paramtres indiquent
si une exception a t leve ou non

217

Syntaxe avance

Exemple d'utilisation de with

La mthode __enter__() est excute avant

le with-block, la mthode __exit__() est
toujours excute mme en cas d'exception

from __future__ import with_statement

with open('/etc/passwd', 'r') as f:

for line in f:
print line
... suite ...

218

109
Syntaxe avance

Utilisation du Context Management Protocol

class Context(object):
def __enter__(self):
print "Entre..."

def __exit__(self,exception_type,exception_value,
exception_traceback):
print "Quitte..."
if exception_type is None:
print "sans erreur !"
else:
print "avec erreur !"
print exception_value

with Context():
print "Je suis dans le contexte"

with Context():
print "je vais provoquer un bug !"
raise TypeError('je suis le BUG')
219

Syntaxe avance

Dcorateurs
Possibilit d'enrober une fonction dans une
autre fonction
def dec1(f):
"Ajoute 1 au rsultat de la fonction dcore."

def _f(*args, **kwargs):

logging.debug("Inside decorated.")
y = f(*args, **kwargs)
return y + 1

return _f

@dec1
def carre(x):
return x * x

def main():
print "results from square(3): %s." % carre(3)
220
if __name__ == "__main__": main()

110
Syntaxe avance

Fonctionnement interne

La syntaxe avec @ est une "sucrerie" :

@f1
@f2
def func(args): pass
est quivalent :
def func(args): pass
func = f1(f2(func))(args)

221

Syntaxe avance

Dcorateur gnrique (factory)

def dec2(N):
""" Retourne un dcorateur qui ajoute N la valeur
retourne. N est le paramtre pass la fonction dcore.
"""

def decN(f):
def _f(*args, **kwargs):
y = f(*args, **kwargs)
return y + N

return _f

return decN

# et en plus, le dcorateur peut tre appel sur une fn existante:

def ajoute_deux_nb(a,b): return a + b

ajoute_six = dec2(6)
print ajoute_six(ajoute_deux_nb)(1,2) # affiche 9
ajoute_cinq_a_deux_nb = dec2(5)(ajoute_deux_nb)
print ajoute_cinq_a_deux_nb(1,2)
222

111
Syntaxe avance

Utilisations des dcorateurs

Vrification des valeurs des arguments ou des

rsutats d'une fonction
Grer un cache sur les rsultats des fonctions
(memorize)
Implmenter le modle du Proxy pour
intercepter les appels et raliser une tche
pralable (droits d'accs, ...)
Grer correctement un contexte (positionner un
verrou, synchroniser des threads...)
223

Syntaxe avance

Dcorateur memorized
class memorized(object):
def __init__(self, func):
self.func = func
self.cache = {}
def __call__(self,*args):
if args in self.cache:
return self.cache[args]
else:
self.cache[args] = value = self.func(*args)
return value
calls = 0

@memorized
def fibonacci(n):
global calls
calls += 1
if n in (0,1):
return n
return fibonacci(n-1) + fibonacci(n-2)

print fibonacci(5)
print calls # affiche 6 au lieu de 15 !
224

112
Syntaxe avance

Dcorateur de classe (v2.6+)

L'criture suivante est possible :

@foo
@bar
class A:
pass

elle est quivalente :

class A:
pass

A = foo(bar(A))

225

Syntaxe avance

Mthodes de classe

La fonction interne classmethod retourne une

mthode de classe :
fonction qui reoit la classe en premier paramtre
la syntaxe des dcorateurs est permise :
class C:
@classmethod
def f(cls,arg1,arg2,...) : ....

exemples d'appels :
C.f()
C().f()
226

113
Syntaxe avance

Mthodes statiques

La fonction interne staticmethod retourne une

mthode statique :
fonction qui ne reoit pas de paramtre implicite
la syntaxe des dcorateurs est permise :
class C:
@staticmethod
def f(arg1,arg2,...) : ....

exemples d'appels :
C.f()
C().f()
227

Syntaxe avance

Introspection
Chaque objet possde les attributs suivants :
__name__ : son nom (if __name__ == '__main__')
__doc__ : sa chaine de documentation
__file__ : le fichier source pour un module
__class__ : nom de la classe d'un objet
__module__ : nom du module o la classe a t
dfinie
__dict__ : dictionnaire des symboles et de leurs
types
Utilisation du module inspect
228

114
Syntaxe avance

__dict__ et __slots__
__dict__ contient la liste des attributs de
l'objet
il est possible de les dfinir dynamiquement
__slots__ dfinit au niveau de la classe, la
liste des attributs autoriss (new style class)
gain d'espace mmoire
impossible de crer des attributs dynamiquement
class C(object):
__slots__ = ( 'x' )
def __init__(self):
pass

c = C()
c.x = 4
c.y = 5 # Exception 229

Syntaxe avance

Autres mthodes
dir()qui renvoie la liste des attributs d'un objet
type()retourne le type d'un objet
id() renvoie l'identit d'un objet
souvenez-vous qu'il peut y avoir plusieurs rfrences un objet

hasattr(obj,attr) et getattr(obj,attr)
isinstance(obj,type) : retourne un boolen qui
indique si l'objet est du type indiqu
issubclass(derive,parent) : indique si une classe
drive d'une autre classe

230

115
Syntaxe avance

Attributs et proprits
Les attributs sont habituellement crs et
initialiss dans __init__()
mais ils peuvent tre dfinis dynamiquement (sauf si
l'objet est immuable : __slots__)
Les proprits sont des mthodes qui s'utilisent
comme des attributs
syntaxe plus simple
smantique d'affectation plus lisible ?
objet.setAttr(x)
objet.attr = x
231

Syntaxe avance

Cas d'utilisation des proprits

Comme ce sont en fait des mthodes, elles

peuvent faire des calculs :
"eager calculation" : quand un attribut est mis jour
via une proprit, d'autres attributs sont recalculs
"lazy calculation" : les calculs son dfrs quand on
demandera la valeur de la proprit
Cration des proprits :
avec la fonction property()
avec des dcorateurs

232

116
Syntaxe avance

Cration de proprits (1)

La classe prdfinie property relie un attribut
de classe aux mthodes qui le grent :
fget : pour obtenir sa valeur
fset : (optionnelle) pour modifier la valeur
fdel : (optionnelle) sur appel de del
fdoc : (optionnelle) pour dfinir une docstring
class A(object):
def __init__(self):
self._attrib = 1
def _i_get(self):
return self._attrib
attrib = property(_i_get)

obj = A()
print obj.attrib
233

Syntaxe avance

Cration de proprits (2)

Avec des dcorateurs :
class A(object):
def __init__(self):
self.x = 5
self.y = 4

@property
def total(self):
return self.x * self.y

@property
def larg(self): return self.x

@larg.setter
def larg(self, x): self.x = x

# il existe aussi @larg.deleter et @larg.doc

a = A()
print a.total
a.larg = 5
234

117
Syntaxe avance

Mta-programmation
La mthode __new__ est toujours appele lors
de l'instanciation d'un objet
doit retourner une instance de la classe
peut modifier le comportement de la classe avant ou
aprs la cration de l'objet
appel implicite, mme par les sous-classes
(contrairement __init__)

class A(object):
def __new__(cls):
print "ok"
return object.__new__(cls)
def __init__(self):
print "init"
self.a = 1
235

Syntaxe avance

Mta-programmation (2)
L'attribut __metaclass__ permet de lier la classe une
"Factory" personnalise
appele au lieu de type()
accepte en argument le nom d'une classe, le t-uple de ses
classes de base et le dictionnaire des ses attributs valus
retourne un objet de la classe

def meth(clsname,types_base,dict):
# Faire des choses sur le dict ?
dict['demo'] = "a marche !"
return type(clsname,types_base,dict)

class MaClasse(object):
__metaclass__ = meth
def demo(self):
print "ok"

236

118
Syntaxe avance

Mta-programmation (3)
Ou bien, en utilisant une classe :

class MetaClassDescription(type):
def __meth__(clsname,types_base,dict):
# Faire des choses sur le dict ?
dict['demo'] = "a marche !"
return type.__new__(clsname,types_base,dict)

class MaClasse(object):
__metaclass__ = MetaClassDescription

def __init__(self):
print "dans init"

def demo(self):
print "ok"

237

Python

238

119
Outils

Introduction

Documentation de code
Contrle syntaxique
Debugger
Profiler

239

Outils

Gestion de documentation avec pydoc

Extrait l'auto-documentation des sources pour produire :
des fichiers texte
du HTML
(la fonction interne help() invoque pydoc)

Invocation de pydoc :
pydoc nom_fonction
pydoc nom_module
pydoc nom_package
pydoc nom_package.nom_module.nom_classe...
pydoc /chemin/vers/source.py

240

120
Outils

Paramtres de pydoc

Sans paramtre : affiche du texte

-w : crit la doc dans un fichier HTML
-p 1234 : lance pydoc en mode "serveur Web
intgr" sur le port 1234
-g : (v2.5) lance un serveur et un navigateur en
Tkinter
-k mot_cl : affiche la liste des pages
contenant "mot_cl" dans le synopsys

241

Outils

Contrle statique avec pychecker

Dtecte les problmes suivants :
Importation de modules non utiliss
mauvais nombre d'arguments pour les appels de
fonctions
chaines de format avec mauvais nombre de
paramtres
redfinition de fonction dans la mme porte
utilisation de variables non initialises
absence de paramtre self dans les mthodes
absence de docstrings
242

121
Outils

Utilisation de pychecker
pychecker [opt] nom_script.py
ou
>>> import pychecker.checker
>>> import mon_module

243

Outils

Outils d'analyse complmentaires

Pylint
analyse les respects des rgles de nommage (PEP 8)
effectue des analyses de complexit (# param
/fonctions, # instructions/fonctions, etc...)
utilisation :
pylint --generate-rcfile > ~/.pylintrc
pylint monscript.py

CloneDigger
analyse les portions de code similaires

244

122
Outils

Contrle qualit

Principe : crire les tests unitaires et les lancer

priodiquement
Utilisation de doctest :
extrait des modules les commentaires spciaux
contenant la doc et les tests et les excute
les tests doivent ressembler des des sessions
interactives
def identite(n):
"""fonction identite
>>> identite(3)
3
"""
return n
245

Outils

Lancement de doctest

Ajout dans le script prcedent :

def _test():
import doctest
doctest.testmod()
Puis appel du script :
if __name__ == "__main__":
python script.py _test()

pas d'affichage => aucune erreur

sinon, affichage des erreurs
l'option -v permet d'avoir un rapport dtaill mme en
cas de succs

246

123
Outils

Options et directives
Possibilits d'ajouter des options dans des
commentaires spciaux :
IGNORE_EXCEPTION_DETAIL :
vrai si le type de l'exception est celui attendu mais le dtail
quelconque
SKIP :
ne joue pas le test. Pour de la doc uniquement
REPORT_UDIFF, REPORT_CDIFF :
format de rapport des erreurs
REPORT_ONLY_FIRST_FAILURE
Exemple :
>>> print range(20) # doctest:+ELLIPSIS
[0, 1, ..., 18, 19]
247

Outils

Tests unitaires avec unittest

unittest est un framework qui propose des

classes pour automatiser les tests
Concepts :
test fixture : actions ncessaires la prparation d'un
test et son "nettoyage"
test case : petite unit de test
test suite : collection de test cases
test runner : excute les tests et rapporte les rsultats

248

124
Outils

Exemple d'utilisation
import random
import unittest
class TestSequenceFunctions(unittest.TestCase):
def setUp(self):
self.seq = range(10)

def testshuffle(self):
random.shuffle(self.seq)
self.seq.sort()
self.assertEqual(self.seq, range(10))

def testchoice(self):
element = random.choice(self.seq)
self.assert_(element in self.seq)

def testsample(self):
self.assertRaises(ValueError, random.sample, self.seq, 20)
for element in random.sample(self.seq, 5):
self.assert_(element in self.seq)

if __name__ == '__main__':
unittest.main() 249

Outils

Commentaires sur unittest

Un cas de test drive de unittest.TestCase
Les mthodes dont le nom dbute par test sont des
tests raliser par le testrunner
Les tests sont valids par :
assert_() : vrifie une condition
assertRaises() : vrifie qu'une exception s'est produite
assertEqual() : vrifie la valeur d'une expression

La mthode setUp() initialise les tests

La mthode tearDown() nettoie les tests

250

125
Outils

Le Debugger

Le module pdb offre un debugger interactif

Invocation :
>>> import pdb
>>> import monmodule
>>> pdb.run('monmodule.test())')
ou :
$ python -m pdb monmodule.py

251

Outils

Commandes du debugger
l(ist) [deb[,fin]]: affiche les 11 lignes "courantes"
h(elp) [commande]
w(here) : affiche la pile
d(own), u(p) : dplacement dans la pile
b(reak) [[fichier:]nuligne | fonction[,cond]] et t(break) :
positionne un point d'arrt (temporaire)
cl(ear), disable, enable, ignore, condition, commands :
gestion des points d'arrt
s(tep), n(ext) : excute la prochaine instruction (step-in, next-over)
r(eturn) : sort de la fonction courante
c(ontinue)
j(ump) nuligne
p expression ou pp expression : affiche le rsultat d'une expression
q(uit)
252

126
Outils

Le Profiler
Fournit des statistiques sur l'excution des scripts
Plusieurs modules :
profile : module standard
cProfile : profiler crit en C
hotshot : crit en C, amlior pour la v2.5 (prennit ?)
timeit : mesure de temps d'excution de "petits" scripts
guppy : donne des indications sur l'utilisation mmoire
# easy_install guppy
>>> from guppy imlport hpy
>>> hp = hpy()
>>> print hp.heap()

253

Outils

Exemple d'utilisation de profile

Mode intractif :
>>> import profile
>>> profile.run('mafonction()')
>>> profile.run('mafonction()','resultat.stat')
En mode ligne de commande :
python -m profile monscript.py
python -m profile -o res.stat monscript.py
Lecture des rsultats :
avec le module pstats :
>>> import pstats
>>> p = pstats.Stats('resultat.stat')
>>> p.print_stats()

254

127
Outils

Aperu des statistiques

primitive = appels directs (non dus une rcursion)
ncalls = nombre d'appels
tottime = temps total pass dans la fonction en excluant
le temps pass dans les sous-fonctions
percall = temps moyen
cumtime = temps total avec temps des sous-fonctions
x/y = # appels total (avec rcursivit) / # appels directs
2706 function calls (2004 primitive calls) in 4.504 CPU seconds

Ordered by: standard name

ncalls tottime percall cumtime percall filename:lineno(function)

2 0.006 0.003 0.953 0.477 pobject.py:75(save_objects)
43/3 0.533 0.012 0.749 0.250 pobject.py:99(evaluate) ...
255

Outils

La classe stats
Exporte les mthodes suivantes :
strip_dirs() : limine les chemins des noms de fichiers
add(fichier) : ajoute les rsultats issus d'un fichier
dump_stats(fichier) : sauve les stats dans un fichier
sort_stats(cl) : les critres de tri peuvent tre multiples et
pris dans : calls, cumulative, file, module, pcalls, line, name, nfl
(name/file/line), stdname, time
reverse_order() : pour un tri ascendant
print_stats(restrictions) : en % et regexp sur nom des
fichiers
print_callers(restrictions) : fonctions appelantes
print_callees(restrictions) : fonctions appeles
256

128
Outils

Outils divers

Performances :
mesurer les pystones
Analyseur de l'tat de la mmoire :
Guppy-PE
easy_install guppy

Heapy

257

Python

258

129
SGBD

Introduction

Persistance des objets

Interface MySQL
Interface MongoDB
Autres solutions

259

SGBD

Srialisation avec pickle et cPickle

Le module pickle permet de sauver tout objet dans un
fichier ou dans une chaine, puis de le recharger
on prfrera cPickle, crit en C...

#!/usr/bin/python
# Fichier: cPickle.py

import cPickle as p

class Animal:
def __init__(self,nbp,coul):
self.nb_pattes = nbp
self.couleur = coul

a = Animal(2,'gris') del a
f = open("animal.txt","w") f = open("animal.txt","r")
p.dump(a,f) a = p.load(f)
f.close() print a
260

130
SGBD

Utilisation de fichiers DBM

Permettent de stocker des informations relatives

une cl
Les interfaces permettent deux types
d'oprations :
la recherche par cl
l'affectation d'une valeur une cl
=> comme un dictionnaire !

261

SGBD

Le module anydbm

#!/usr/bin/python
# Fichier: anydbm.py

import anydbm

# cre un nouveau fichier DBM si ncessaire:

db = anydbm.open("fichier.dbm","c")

db['banane'] = 'jaune'
db.keys()
db['banane']
len(db) # affiche 1
db.has_key('banane') # affiche 1

del db['banane'] # supprime l'entre

db.close()

262

131
SGBD

Combiner pickle et anydbm : shelve

Permet de stocker des structures d'objets dans

des fichiers DBM
facilit d'utilisation de anydbm
transparence d'utilisation de pickle
Effectue de la srialisation et de la
dsrialisation d'objets dans des fichiers DBM
L'interface ressemble l'utilisation d'un
dictionnaire

263

SGBD

Exemple d'utilisation de shelve

#!/usr/bin/python
# Fichier: shelve.py
import shelve
db = shelve.open("dbase")
obj1 = [ 'Bonjour', '', 'tous' ]
obj2 = { 'Banane':'jaune', 'Cerise':'rouge' }
obj3 = { 'Pomme':'verte', 'imbrique':obj2 }

db['obj1'] = obj1
db['complique'] = obj3
db.close()
...
db = shelve.open("dbase")

db.keys() # affiche 'obj1' et 'complique'

db['obj1'] # affiche le contenu de obj1

for k in db.keys():
print k, '=>'
for f in db[k].keys():
print ' ',f,'=',db[k][f] 264

132
SGBD

Contraintes d'utilisation
Les cls doivent tre des chaines
Les objets sont uniques que pour une cl
donne - sinon, ils sont dupliqus
Les mises jour du shelve doivent tre
explicites
Les classes des objets stocks doivent tre
importables
Les modifications des classes doivent tre
compatibles
265

SGBD

Interface SQL

Objets mis en oeuvre :

connection : reprsente une connexion une base,
gnre les curseurs, gre le commit/rollback
cursor : reprsente une instruction SQL soumise et
peut tre ensuite utilis pour parcourir les rsultats
query results : liste de tuples reprsentant des lignes
de rsultats
Ajouts de nouvelles exceptions

266

133
SGBD

Le module MySQLdb

Les mthodes principales sont :

connect(*args,**kwargs)
cls : db, user, passwd, host, port
retourne un object de la classe connection

escape_*(...)
Ajoute de nouvelles exceptions :
DataError, DatabaseError,
InterfaceError, IntegrityError,
MySQLError...

267

SGBD

Classe connection

Les mthodes principales sont :

query : excute une requte SQL
on recommande plutt d'utiliser cursor() pour obtenir un
curseur, puis invoquer la mthode execute() du curseur
commit/rollback
select_db : slectionne la base courante
close : ferme la connexion

268

134
SGBD

Classe cursor
Les mthodes principales sont :
execute : excution d'une requte SQL
execute("select * from table where col > %s",
(valeur,))
executemany(req,[('v1','v2'),('w1','w2')]
rowcount : nombre de lignes impactes
fetchall : retourne la liste des lignes sous forme de
tuples de tuples
fetchone : retourne la prochaine ligne de la liste des
rsultats
close : ferme le curseur
269

SGBD

Exemple de mise en oeuvre

#!/usr/bin/python
# Fichier: mysql1.py

import MySQLdb,sys

# Il faut capturer les exceptions

cnx = MySQLdb.connect(db=...,user=..., passwd=..., host=...)

cursor = cnx.cursor()

req = "SELECT * FROM table"

cursor.execute(req)
lignes = cursor.fetchall()

for ligne in lignes:

for col in ligne:
print col;
print

270

135
PyMongo

API Python

Installation :
pip install pymongo
pip-python install pymongo
easy_install pymongo
Mise jour :
pip install --upgrade pymongo
easy_install -U pymongo

271

PyMongo

Connexion au serveur

Utilise l'objet MongoClient

cre une connexion vers un serveur
possibilit de dfinir le port, la taille du pool de
connexions ainsi que des paramtres "fins" (attente
de rplication, journalisation, mode sync/async...)

from pymongo import MongoClient

c = MongoClient() # default=localhost, port=27017
db = c.une_base # accde la base
col = db.une_collec # accs la collection
for d in col.find(): # boucle sur tous les documents
print d
c.close() # ou c.disconnect()

272

136
SGBD

ZODB (Zope Object Database)

Similaire l'utilisation des shelves

Ajoute les fonctionnalits suivantes :
mises jour concurrentes
l'aide du serveur ZEO (Zope Enterprise Objects)

transactions avec commit et rollback

m..j automatiques quand les objets changent en
mmoire
cache sur les objets
stockage indpendant des plates-formes

273

SGBD

Cration d'une base ZODB

from ZODB import FileStorage,DB

storage = FileStorage.FileStorage('/tmp/zodb.db')
db = DB(storage)
connection = db.open()
root = connection.root()

objet1 = (1, 'texte', 4, 'coucou !')

objet2 = [[1,2,3],[4,5,6]]
objet2.append([7,8,9])
objet3 = { 'nom' : [ 'Jean', 'Dupont' ],
'age' : 42 }

root['machaine'] = 'bon' * 3
root['montuple'] = objet1
root['maliste'] = objet2
root['mondict'] = objet3

get_transaction().commit()
storage.close()
274

137
SGBD

Modification des objets

from ZODB import FileStorage,DB

storage = FileStorage.FileStorage('/tmp/zodb.db')
db = DB(storage)
connection = db.open()
root = connection.root()

print len(root),root.keys()

print root['maliste']
print root['mondict']
print root['mondict']['nom'][-1]

# Appliquons des modifications:

rec = root['maliste']
rec.append([10,11,12]) # modif. memoire
root['maliste'] = rec

get_transaction().commit()
storage.close()
275

SGBD

Rendre une classe persistante

Pour que les modifications apportes un objet
soient sauves automatiquement, il faut que :
les objets doivent driver de classes hritant de la
classe Persistence.Persistent
ils deviennent des objets persistants
les sous-objets doivent tre persistants ou immuables
La classe Persistent rcrit les fonctions
prdfinies __setattr__ et __getattr__
elles ne doivent pas tre rimplmentes
le format de stockage utilise celui de pickle
276

138
SGBD

Exemple de classe persistante

import ZODB
from Persistence import Persistent

class Personne(Persistent):
def __init__(self,nom,age):
self.nom = nom
self.age = age

def changeAge(age):
self.age = age # m.a.j la DB automatiquement

def __str__(self):
return "Nom: %s, age: %d" % (self.nom,self.age)

# ... init usuelle de l'objet 'root'

alice = Personne('alice',25)
bob = Personne('bob',50)
caro = Personne('caro',37)
root['personnes'] = []
root['personnes'].append(alice)
root['personnes'].append(bob)
root['personnes'].append(caro) 277

Python

278

139
Clients Internet

Introduction

Client FTP
Client de messagerie
Client Web

279

Clients Internet

Clients FTP avec le module ftplib

Exporte la classe FTP
constructeur FTP([host[,user[,pass[,acct]]]])
retourne un objet FTP ou lve une exception
Principales mthodes sur l'objet FTP :
connect(host[,port])
login([user[,pass[,acct]]])
sendcmd(cmd)
retrbinary(cmd,cback[,maxblksz[,rest]])
retrlines(cmd[,cback])
storbinary(cmd,file[,blksiz])
storlines(cmd,file)
nlst(arg), dir(arg)
rename(from,to), delete(file), size(file)
cwd(path), mkd(path), rmd(path), pwd()
quit(), close() 280

140
Clients Internet

Exemple d'utilisation
import os,sys
from getpass import getpass

nonpassive = False
filename = "boot.iso" # fichier a telecharger
#userinfo = ('jd',getpass("mot de passe ? ")
userinfo = ()
if len(sys.argv) > 1: filename = sys.argv[1]

print 'Connexion...'
from ftplib import FTP
localfile = open(filename,"wb")
cnx = FTP("localhost")
cnx.login(*userinfo)
cnx.cwd("/pub/centos-5.1/images")
if nonpassive: cnx.set_pasv(False)

print "Telechargement..."
cnx.retrbinary('RETR ' + filename,localfile.write,1024)
cnx.quit()
cnx.close() 281

Clients Internet

Plus simple avec urllib

Module de plus haut niveau

Supporte la syntaxe des URL
Supporte les proxy sans authentification l'aide
des variables d'environnement http_proxy,
ftp_proxy
la prise en compte dans les mthodes est aussi
possible

282

141
Clients Internet

Exemple d'utilisation

import os,sys
import urllib

fname = "boot.iso"

srvaddr = "ftp://user:%[email protected]/%s;type=i" % (pwd,fname)

# mthode la plus simple:

# urllib.urlretrieve(remoteaddr,fname)

# ou bien:
remotefile = urllib.urlopen(remoteaddr)
localfile = open(fname,"wb")
localfile.write(remotefile.read())
localfile.close()
remotefile.close()

283

Clients Internet

Clients POP3

La librairie poplib permet d'crire un client

POP3

import poplib,os,sys

server = poplib.POP3("smtp.free.fr")
server.user("Bob")
server.pass_("secret")

try:
msgCount,msgBytes = server.stat()
print "Il y a %d messages dans votre b.a.l", msgCount
finally:
server.quit()

284

142
Clients Internet

Envoyer du courrier

Plusieurs solutions :
en invoquant la commande externe mail :
os.popen('mail -s "sujet"
[email protected]','w').write(msg)

de manire identique, en inviquant sendmail

l'aide de la librairie smtplib

285

Clients Internet

Exemple d'utilisation
import os,sys,time
import smtplib

From = raw_input('De? ').strip()

To = raw_input('A? ').strip()
To = to.split(';') # permet une liste de destinataires
Subject = raw_input('Sujet? ').strip()
Date = time.ctime(time.time())
Text = ('From: %s\nTo: %s\nDate: %s\nSubject: %s\n\n'
% (From, ';'.join(To), Date, Subject))
print 'Tapez le message, et finissez par Ctrl-D:'
while 1:
line = sys.stdin.readline()
if not line: break
Text += line

srv = smtplib.SMTP("smtp.free.fr")
failed = srv.sendmail(From,To,Text)
srv.quit()
if failed: # exceptions possibles
print "Il y a eu des erreurs"
else: print "OK" 286

143
Clients Internet

Client HTTP
Modules disponibles :
httplib (bas niveau)
urllib
urllib2

import sys,os,urllib,urlparse
page = "http://srv/page.php?p=v"
#(scheme,server,path,parms,query,frag) = urlparse.urlparse(page)
rempage = urllib.urlopen(page)
date = rempage.readlines()
rempage.close()

# ou :
# urllib.urlretrieve(page,fichierlocal)

287

Clients Internet

Le module urllib2

Pour des clients plus complexes :

support des redirections
gre les authentifications basic et digest
gre les cookies...
Exemples :
>>> import urllib2
>>> f = urllib2.urlopen('http://www.python.org/')

>>> print f.read(100)

288

144
Clients Internet

Autres exemples sur urllib2

# Utilisation d'une authentification basique:

# cre un gestionnaire d'authentification
auth_handler = urllib2.HTTPBasicAuthHandler()
auth_handler.add_password(realm='MonAppli',
uri='https://srv/page.py',
user='bob',passwd='secret')
opener = urllib2.build_opener(auth_handler)

# ...et le chaine pour l'utiliser avec urlopen:

urllib2.install_opener(opener)
urllib2.urlopen('http://srvbis/login.html')

# Ajout d'enttes:
import urllib2
opener = urllib2.build_opener()
opener.addheaders = [('User-agent', 'Mozilla/5.0')]
opener.open('http://www.example.com/')

289

Python

290

145
Dploiement

Introduction

distutils
pip
virtualenv

291

Dploiement

Le module distutils

Python est fourni avec le module distutils

qui contient les outils pour crer une application
distribuer
propose un squelette pour les mta-donnes
un outil pour empaqueter le code

292

146
Dploiement

distutils pour le dveloppeur

Doit crire un fichier setup.py

Un fichier de configuration optionnel
setup.cfg, utilis pour permettre l'utilisateur de
modifier des paramtres avant l'installation
Cre une distribution pour les fichiers sources
Cre une distribution binaire (optionnelle)

293

Dploiement

Script de dploiement setup.py

Script qui contrle le processus de cration et

dploiement du package
Contient les informations sur le package (nom,
version...)
Exemple :
# Exemple de script setup.py
from setuptools import setup
setup(name='monpackage', version='1.0.0.0',
py_modules = ['mod1', 'mod2'] )

# 'monpackage' est le nom du rpertoire racine

# de l'application empaqueter
294

147
Dploiement

Cration du package
On utilise l'option sdist qui cre une archive
partir de l'arborescence originale
$ python setup.py sdist
l'archive (tar.gz) est stocke sous le rpertoire ./dist
d'autres formats sont possible (rpm, bzip2...)

le fichier MANIFEST.in liste les fichiers (Python,

README...) inclure dans l'archive
bdist produit une archive avec les scripts
compils
bdist_egg produit une archive compatible avec
295
l'arborescence standard (mode recommand)

Dploiement

Tlchargement sur PyPI

(Python Package Index)

Il faut avoir un compte
Puis utiliser la commande register
Puis tlcharger le package avec la commande
upload
Utilisation de .pypirc possible

296

148
Dploiement

Installation et dsinstallation

L'option install construit le package si

ncessaire (build) et gre les dpendances
ajout de l'attribut
install_requires = ['mod1', ... ]

les modules sont recherchs dans PyPI

Pas d'option de dsinstallation, on peut utiliser
l'option --record de install pour obtenir la
liste de fichiers crs

297

Dploiement

L'outil alternatif setuptools

Gre les dpendances entre les packages
Utilise le dpt standard Python Package Index (PyPI)
Installation par un package (RPM, DEB) ou par Easy
Install :
wget http://peak.telecommunity.com/dist/ez_setup.py
python ez_setup.py setuptools

Installation d'une extension Python par :

easy_install -U setuptools
easy_install nom_extension
easy_install logilab.pylintinstaller

298

149
Dploiement

L'outil alternatif pip (recommand)

Plus sr en cas de problme d'installation
Permet d'installer des packages de PyPI :
pip search nom_package
pip install nom_package
Mais permet aussi :
de les dsinstaller :
pip uninstall nom_package

de lister les packages installs :

pip list
pip list --outdated
299

Dploiement

Dploiement avec pip

La commande pip install gre les versions:

pip install module==a.b.c
pip install 'module>=a.b.c,<x.y.z'
Possibilit d'utiliser un fichier de prrequis
externe :
pip freeze > requirements.txt
pip install -r requirements.txt
Supporte GIT, Subversion, Mercurial...

300

150
Virtualenv

Problme de versions : Virtualenv

Le problme :
les versions successives de Python ne sont pas
toujours parfaitement compatibles
comment faire cohabiter des versions diffrentes de
Python ?
La solution : virtualenv
installation par yum ou aptitude ou pip

301

Virtualenv

Cration des environnements

Chaque version est cloisonne dans son propre
rpertoire
Cration d'un environnement :
$ virtualenv --distribute un_rep
cre le rpertoire un_rep et les sous-rpertoires bin,
lib et include
l'option --no-site-packages permet d'viter de
recopier les packages dj installs sur le systme
pour une version particulire de python :
$ virtualenv --distribute --no-site-packages
un_rep -p /chemin/vers/pythonx-y 302

151
Virtualenv

Utilisation des environnements

Pour utiliser un environnement :
$ cd un_rep
$ source bin/activate
(un_rep)$ python
>>> ...
$ deactivate
Pour aller plus loin :
possibilit de personnalisation des scripts
extension avec virtualenvwarpper
303

Python

304

152
Interface C/C++

Sommaire

SWIG
Cython

305

Interface C/C++

Rappels sur l'importation de modules

Comment Python interprte le mot-cl import ?

import module
le module peut tre un module interne compil avec Python
dans ce cas la valeur module.__FILE__ est nulle
le module peut tre un fichier module.py ou module.pyc
situ dans un des rpertoires de recherche
le module peut tre un binaire (module.so)
situ sous /usr/lib/python/lib-dynload

306

153
Interface C/C++

Interface Python / C

Il faut crire un wrapper autour de la fonction C :

// la fonction C est: int fact(int n) {...}
#include <Python.h>
PyObject *wrap_fact( PyObject *self, PyObject *args) {
int n, result;
if( !PyArg_ParseTuple(args, "i:fact",&n)) // INPUT
return NULL;
result = fact(n);
return Py_BuildValue( "i", result); // OUTPUT
}

307

Interface C/C++

Interface Python / C

Le module pour Python doit aussi contenir :

la liste des fonctions embarques
une fonction d'initialisation

static PyMethodDef exampleMethods[] = {

{ "fact" , wrap_fact, 1},
{ NULL, NULL }
};
void initexample( ) {
PyObject m;
m = Py_InitModule("example", exampleMethods);
}

308

154
SWIG

Prsentation de SWIG

Interface entre le langage C et les autres

Utilise un macro-langage pour dfinir l'interface
qui produit un "wrapper"
pratique pour l'enrobage automatique des fonctions
Installation :
yum install swig

309

SWIG

Principe de SWIG
/* fichier.c */ /* fichier.h */
int int add(int x, int y);
add(int x, int y) {
return x+y; fichier.c + fichier.h => fichier.o
}
fichier.o => libfichier.so

fichier.h + fichier.i =>

/* fichier.i */ fichier_wrap.c + fichier.py
%module fichier
%{ fichier.h + fichier_wrap.c =>
#include "fichier.h" fichier_wrap.o
%}
int add(int, int); libfichier.so + fichier_wrap.o =>
_fichier.so
310

155
SWIG

Exemple
gcc -c fichier.c -o fichier.o
gcc -shared fichier.o -o libfichier.so
swig -python fichier.i
gcc -c fichier_wrap.c \
-I /usr/include/python \
-o fichier_wrap.o
ld -shared fichier_wrap.o libfichier.so \
-o _fichier.so
mv libfichier.so /usr/lib/
import fichier

fichier.methode(parms)
311

SWIG

Traduction C => Python

Dclarations :
fonctions C => fonctions Python
variables globales => attributs de l'objet cvar
constantes (#define, const, enum) => variables
Python
Types :
int, short, long => integer (long)
float, double => float (double)
char, char * => string
void => None
bool => Boolean
long long, long double => non support ?
312

156
SWIG

Traduction C => Python

Support des tableaux - mais toujours passage
par rfrence
Passage de paramtres :
par valeur pour les types simples
par rfrence sinon (avec un wrapper si ncessaire)
Retour de fonctions :
si le code C ne retourne pas une rfrence sur un
type complexe, SWIG doit allouer de la mmoire pour
retourner un pointeur
la libration de la mmoire est la charge du
dveloppeur
313

SWIG

Goodies
Outre la traduction de types, SWIG permet :
l'ajout de contraintes
double sqrt(double NONNEGATIVE)
renommage
%rename (print) __str__
en cas de conflit entre le C et Python
la dclaration de variables en lecture seule
%immutable
l'insertion de code
%inline
le passage du fonctionnel l'objet

314

157
Cython

Prsentation de Cython

Langage de programmation qui permet de crer

des extension C avec la facilit de Python
permet de compiler des extensions Python en C
permet de compiler des pgm Python en C
Installation :
yum install Cython
installe des librairies Cython crites en Python
un outil de compilation en C : cython

315

Cython

Principe de Cython

// fichier.pyx fichier.pxy => fichier.c

cdef int add(int x, int y):
return x + y

fichier.c => fichier.so

// test.py
import fichier
print add(3,4)

Si on type les fonctions et les variables (ici avec le mot-cl cpdef), le code
gnr est plus performant
Sans le typage, le code est seulement meilleur de 20 35% seulement
316

158
Cython

Exemple
cython fichier.py[x]
gcc fichier.c -I /usr/include/python/ \
-o fichier.so -shared -pthread

import fichier

fichier.add(3,4)

317

Python

318

159
Python 2.6

Introduction

Etape prparatoire la migration vers Python

3.0
Ajout des syntaxes de la v3 - tout en restant
compatible avec la v2
Nouvelles librairies
+250 patches
+600 bugs corrigs / v2.5

319

Python 2.6

Importations relatives

Le nouvel attribut __package__ indique que les

importations sont relatives cet attribut plutt
qu' la valeur de __name__
Les scripts excutant des modules l'intrieur
des packages fonctionnent
voir PEP 328, 338 et 366
rappels :
les imports sont absolus par dfaut
une notation "pointe" permet de dfinir des importations
relatives
320

160
Python 2.6

Rpertoire site-packages par utilisateur

Le module sys.path inclut en fin un rpertoire qui

rfrence des packages disponibles pour tous les
utilisateurs (site-packages)
Maintenant les utilisateurs peuvent se dfinir leur propre
rpertoire :
dfaut :
~/.local/lib/python2.6/site-packages
%APPDATA%/Python/lib/python2.6/site-packages
surchargeable par $PYTHONUSERBASE ou %APPDATA%
suppression de la fonctionnalit avec l'option -s ou la variable
$PYTHONNOUSERSITE
321

Python 2.6

Nouveaux packages
multiprocessing
dfinit les objets Process, Queue et les IPC
permet de des processus d'changer et partager
des informations
json
JavaScript Object Notation
de TRES nombreuses modifications dans les
modules dj existants

322

161
Python 2.6

Formatage avanc des chaines

(backport de Python 3.0)

Les chaines supportent la mthode format()
>>> # Substitution par numro:
>>> "User ID: {0}".format("root") 'User ID: root'
>>> # Substitution par nom:
>>> "User ID: {uid} Last seen: {last_login}".format(
... uid="root",
... last_login = "5 Mar 2008 07:20")
'User ID: root Last seen: 5 Mar 2008 07:20'
>>> # Field 0: left justify, pad to 15 characters
>>> # Field 1: right justify, pad to 6 characters
>>> fmt = '{0:15} ${1:>6}'
>>> fmt.format('Registration', 35)
'Registration $ 35'
>>> fmt.format('Tutorial', 50)
'Tutorial $ 50' 323

Python 2.6

print devient une fonction

Il est possible de la redfinir
Pour activer cette fonction il faut l'importer :

>>> from __future__ import print_function

>>> print('# of entries', (dictionary), file=sys.stderr)

La signature est :
def print(*args, sep=' ', end='\n', file=None)

args : arguments afficher

sep : sparateur des valeurs
end : texte final
file : fichier destination
324

162
Python 2.6

Support des classes abstraites

Le module collections contient des classes
abstraite (ABC - Abstract Base Classes) qui
dfinissent des interfaces
Iterable indique une classe qui dfinit
__iter__()
Container indique une classe qui dfinit
__contains__()
MutableMapping indique une classe qui dfinit
keys(), values() et items()
import collections
class Storage(collections.MutableMapping):
... 325

Python 2.6

Cration de classes abstraites

Le module abc dfinit la mta-classe ABCMeta
et les dcorateurs @abstractmethod et
@abstractproperty
from abc import ABCMeta, abstractmethod
class A:
__metaclass__ = ABCMeta
@abstractmethod
def foo(self):
pass

A() # gnre TypeError

class B(A):
def foo(self): print(42)

B() # OK 326

163
Python

327

Python 2.7

Introduction

La dernire version 2.x

Backport de nouveauts de la v3.1
Par dfaut n'avertit plus sur les futurs problmes
de portabilit (DeprecationWarning)
car faisait "peur" aux dveloppeurs
alors que la v2 a encore de nombreuses annes
vivre

328

164
Python 2.7

Syntaxe de cration des ensembles

Il n'est plus ncessaire d'utiliser la fonction

set()
On peut utiliser les accolades

>>> {1,2,3,4}
set([1,2,3,4])

# Mais pour un ensemble vide:

>>> set()

329

Python 2.7

Comprhension de dictionnaires

La "comprhension" de liste s'tend aux

dictionnaires et aux ensembles

>>> {i-1 for i in {1,2,3,4}}

set([0,1,2,3])

>>> {name.upper() for name in {'dupont':'jean'}}

set(['DUPONT'])

# Mais on n'a pas obtenu un dictionnaire modifi !

>>> names = {'Dupont':'Jean', 'Durand','Jacques'}

>>> {name: names[name].upper() for name in names}
{'Durand':'JACQUES', 'Dupont':'JEAN'}

330

165
Python 2.7

Vues de dictionnaires

Une vue permet de gnrer la liste des cls ou

des valeurs d'un dictionnaire, mais toute
modification sur la vue ou le dictionnaire est
dynamique

>>> mydict = { 'Dupont':'Jean', 'Durand':'Jacques'}

>>> k = mydict.viewkeys()
>>> v = mydict.viewvalues()
>>> k
dict_keys(['Dupont','Durand'])
>>> mydict['Durand'] = 'Pierre'
>>> v
dict_values(['Jean','Pierre'])
331

Python 2.7

Instruction with avec plusieurs contextes

Les with imbriqus peuvent tre simplifis :

>>> with A() as a:

... with B() as b:
... pass

# peut tre crit :

>>> with A() as a, B() as b:

... pass

332

166
Python 2.7

Gestion des champs avec str.format()

Depuis la v2.6, il est possible de spcifier des

formats avec des marqueurs par numro
maintenant, la numrotation est automatique
possibilit de faire des nommages partiels

>>> 'I have {0} cats and {1} dogs.'format(3,4)

I have 3 cats and 4 dogs.
>>> 'I have {} cats and {} dogs.'format(3,4)
I have 3 cats and 4 dogs.
>>> 'I have {} cats and {dogs} dogs.'format(3,dogs=4)
I have 3 cats and 4 dogs.

333

Python 2.7

Amliorations diverses
Le module io est prfrable au module file
(utilisation de la fonction open())
meilleures performances
Le module collections propose :
les dictionnaires ordonns (OrderedDict) qui
conservent l'ordre d'insertion
les compteurs (Counter) qui fonctionnent avec les
chaines, les listes, les tuples
Le module argparse analyse les lignes de
commande au lieu de optparse
334

167
Python

335

Python 3.0

Principales modifications
http://docs.python.org/dev/3.0/whatsnew/3.0.htm
De nombreux changements syntaxiques :
print est une fonction
l'oprateur d'affichage % est supprim
les fichiers texte imposent un encodage
nouvelle hirarchie des exceptions (BaseException)
dcorateurs de classes, classes abstraites
fin du <> (!= obligatoire), nouveaux mots-cls (as, with, True,
False, None)
Des fonctions disparaissent, d'autres sont cres
Idem pour les modules
fin de cPickle : pickle obligatoire
336

168
Python 3.2

Principales modifications
Dictionnaires ordonns (3.1+)
De nouveaux modules qui en rendent d'autres obsoltes :
argparse (issu de 2.7 - au lieu de optparse et getopt)
concurrent.futures pour la gestion des threads
Des modules enrichis ou optimiss :
logging (configuration via des dictionnaires)
ensembles (sets), pickle, json, traitement de chaines
Nouveau format de nom pour les fichiers caches (.pyc)
regroups dans le rpertoire __pycache__ du paquet
leur nom contient le nom et la version de l'interprteur
Options de l'interprteur :
option -q (mode silencieux)
option ResourceWarning (-Wdefault) qui avertit sur l'utilisation des
ressources

337

Python 3.0

Modification des mthodes magiques

Les chaines tant toutes Unicode :
__unicode__ est supprime
__bytes__ est utilise pour construire des tableaux
d'octets
La division par dfaut est la "vraie" division,
__div__ a disparu
__coerce__ a t supprime car redondante
et ambigu
__cmp__ a t supprime car redondante
__nonzero__ a t renomme __bool__

338

169
Python

Erreurs frquentes
Oubli des ':'
Erreurs d'indentation aprs un reformatage !
Confondre attribut et mthode (oublier les parenthses)
Oublier d'appeler les constructeurs des classes de base
Confondre les ',' et les '+' avec print
Oublier de faire des conversions de chaine en int
Oublier que __repr__() et __str__() retournent des
chaines
Nommer un fichier comme un module Python existant et
l'importer !
339

170