Fonctionnalités avancées de Python

Fonctionnalités avancées de Python
Version 1.0.0
David Froger
03 April 2014
Table des matières
1 Introduction 2
1.1 Fonction pour itérer sur des séquences .................................. 2
1.2 map, reduce ................................................ 2
1.3 Compréhension de listes et de dictionnaires ............................... 3
1.4 Tout est objet ............................................... 3
1.5 Fermeture (closure).......................................... 4
1.6 finally ................................................... 4
2 decorator 5
2.1 Comparaison avec une composition de fonction ............................. 5
2.2 Syntaxe des décorateurs .......................................... 6
2.3 Passage d’arguments ........................................... 7
2.4 Exemple réel ............................................... 7
3 property 7
3.1 Attributs, mutateurs et accesseurs ..................................... 7
3.2 property ................................................ 8
3.3 descriptor .............................................. 10
3.4 descriptor personnalisé ....................................... 12
4 metaclass 13
4.1 Introduction ................................................ 13
4.2 meta classes personnalisées ........................................ 14
4.3 Exemples réels .............................................. 15
5 yield 16
5.1 range VS xrange ............................................. 16
5.2 Iterator ................................................... 16
5.3 Generator ................................................. 17
5.4 Generator expression ........................................... 17
6 with 17
6.1 Exemples d’utilisation .......................................... 18
6.2 Implémentation d’un manageur de contexte ............................... 19
6.3 Utilisation du module contextlib .................................. 20

7 Remerciements 20
Cette présentation traite des fonctionnalités avancées du langage Python. Souvent méconnues, elles permettent au
développeur d’écrire un code plus flexible, sûr et concis.
Cette courte présentation ne rentrera pas dans tous les détails à connaître pour utiliser pratiquement ces fonctionnalités,
mais signalera plutôt leur existence et ce qu’elles peuvent apporter, en donnant les concepts clefs pour aborder plus
facilement les documentations, livres ou articles plus complets traitant de ces sujets.
Les coroutines et yield from sont passés sous silence pour le moment, et pourront faire l’objet de deux nouvelles
sections dans le futur.
1 Introduction
Nous commençons cette présentation de Python avancé par quelques exemples disparates de fonctionnalités de Python
généralement connues, se situant à la limite entre le Python de base et le Python avancé.
1.1 Fonction pour itérer sur des séquences
La fonction enumerate permet d’itérer sur les éléments d’une séquence avec leurs indices :
words =[’Rien’,’ne’,’sert’,’de’,’courir’]
for iword, word in enumerate(words):
print iword, word
0 Rien
1 ne
2 sert
3 de
4 courir
La fonction zip permet de parcourir deux séquences en même temps :
words =[’Rien’,’ne’,’sert’,’de’,’courir’]
lengths =[4,2,4,2,6]
for iword,(word,length) in enumerate(zip(words,lengths) ):
print iword, word, length
0 Rien 4
1 ne 2
2 sert 4
3 de 2
4 courir 6
1.2 map, reduce
Python intègre les fonctions map et reduce :

words =[’Rien’,’ne’,’sert’,’de’,’courir’]
length =map(len, words)
sum =reduce(lambda a,b:a+b, length)
print length, sum
[4, 2, 4, 2, 6] 18
1.3 Compréhension de listes et de dictionnaires
La compréhension de liste permet de créer une liste à partir d’une seule expression :
print [ i**2+1for iin range(5) ]
[1, 2, 5, 10, 17]
Il est possible d’inclure une condition :
print [ i**2+1for iin range(5)if i%2== 0]
[1, 5, 17]
On peut créer des dictionnaires de la même façon :
Introduit dans la version 2.7.
d={i: i**2+1for iin range(5)if i%2== 0}
for key,value in d.iteritems():
print "%i => %2i"%(key, value)
0 => 1
2 => 5
4 => 17
1.4 Tout est objet
Les fonctions en Python sont des objets. On peut par exemple stocker une référence sur une fonction, et passer cette
référence en argument à une autre fonction.
def carre(x):
return x**2
def compute(func,seq):
return [ func(x) for xin seq ]
func =carre
seq =range(5)
print compute(func,seq)
[0, 1, 4, 9, 16]
De même, les classes sont des objets :

class Foo:
def __init__(self,a,b):
self.a=a
self.b=b
def operate(self):
return self.a+self.b
def compute(cls, a, b):
instance =cls(a,b)
return instance.operate()
cls =Foo
print compute(cls,10,20)
30
1.5 Fermeture (closure)
Les règles de visibilité des variables permettent de créer des fermetures. Ici, la fonction add_const utilise la valeur
de const définie dans l’espace de nom de la fonction qui l’englobe.
def create_add_const(const):
def add_const(number):
return number +const
return add_const
add_const =create_add_const(10)
print add_const(2)
12
1.6 finally
Le mot clef finally permet d’exécuter du code quelque soit le résultat d’un code dans un block try :
— si aucune exception n’a été levée,
— si une exception a été levée et capturée,
— si une exception a été levée sans être capturée.
Cela permet de fermer dans le block finally une ressource ouverte (fichier, socket, ...).
Voici un exemple d’utilisation de finally 1:
def divide(x, y):
try:
result =x/y
except ZeroDivisionError:
print "division by zero!"
else:
print "result is", result
finally:
print "executing finally clause"
1. Exemple tiré de la documentation officielle (https ://docs.python.org/2/tutorial/errors.html#defining-clean-up-actions)

divide(2,1)
print
divide(2,0)
print
try:
divide("2","1")
except TypeError:
print "TypeError catched"
result is 2
executing finally clause
division by zero!
executing finally clause
executing finally clause
TypeError catched
2 decorator
Les décorateurs permettent d’annoter un code source Python pour modifier le comportement d’une fonction ou d’une
classe.
2.1 Comparaison avec une composition de fonction
Contrairement à la composition de fonction , dont un exemple simple est, par exemple :
𝑦=𝑔(𝑓(𝑥))
et dont l’équivalent en Python serait, par exemple,
def f(x):
return x+20
def g(x):
return x+300
print g( f(1) )
321
l’action d’un décorateur se symbolise plutôt par
𝑦= (𝑑(𝑓))(𝑥)
Par exemple, la fonction dest un décorateur qui prend en argument un fonction f, et retourne une fonction nouvelle_f,
qui vérifie que le nombre en argument est positif, puis appelle f :
def d(f):
def nouvelle_f(x):
if x<0:
raise ValueError,"On n’accepte que les nombres positifs."
return f(x)
return nouvelle_f