Introduction à Python

1. Introduction à Python sebastien.martini@gmail.com 14/03/2007

2. Historique • Langage relativement récent, développé au début des années 1990 par Guido Von Rossum (GvR) • Statut : BDFL (Benevolent Dictator For Life)

3. Principales caractéristiques • Langage interprété • Exécution : • python mon_source.py • Mode interpréteur • Génére du bytecode (langage intermédiaire) ex: .pyc >>> def fun(a, b): ... return a + b + 42 >>> dis.dis(fun) 2 0 LOAD_FAST 0 (a) 3 LOAD_FAST 1 (b) 6 BINARY_ADD 7 LOAD_CONST 1 (42) 10 BINARY_ADD 11 RETURN_VALUE

4. Principales caractéristiques • Orienté objet (pas pur ou du moins pas en apparence) • Les espaces sont significatifs • Plus besoin de ; { } • Exemple : If a > 42 : pass else print ‘bar’ • Utiliser un mode python • Dynamique • Pas de déclaration de variables • Exemple : >>> a = 42; print a; a = 'foo'; print a ; 42 foo

5. Principales caractéristiques • Typage dynamique (à l’exécution), pas de type checking • Support des exceptions • Exemple : >>> def fun(): … c = ‘chaine’ ... return c + 42 ... >>> fun() Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 2, in fun TypeError: cannot concatenate 'str' and 'int' objects

6. Principales caractéristiques • Introspection • Examiner ses propres structures à l’exécution (attributs, méthodes, parents, type, …) • Builtins : type(), dir(), locals(), globals(), getattr(),… • Se modifier soi-même • Modifier ses propres structures • cf. exemple plus loin (diapo. sur les Classes)

7. Fonctions • Exemple : def f(a,b=3): if a: return a + b f(2) # retourne 5 f(2, 42) # retourne 44 f(0) # retourne None f(0,42) # retourne None • Définition d’une fonction par ‘def’ • Accepte des arguments par défauts • Ne peut-être surchargée qu’avec ce mécanisme

8. Fonctions • Pas de déclaration de type des arguments ni de la valeur de retour • Duck typing (if it walks like a duck, quacks like a duck,…, it must be a duck) • Retourne l’objet None par défaut (ou en cas de return sans argument) • Une fonction peut être imbriquée dans une autre

9. Classes • Surprenant au premier abord • N’encourage pas l’utilisation d’accesseurs (regarder du côté des descriptors) • Pas de qualifieurs (private, protected) tout est public (en simplifiant), “sorte” de private avec __mymeth() • Pas de destructeur (en simplifiant) • Les méthodes « spéciales » sont encadrées par deux underscores • Exemple de constructeur : def __init__(self): Pass • Nécessité de l’argument self

10. Classes • Pas de notions de classe abstraite • Héritage multiple (à la c++), depth-first, left-to-right • Les méthodes sont toutes virtuelles • Attributs de classe • Méthodes statiques • Fonction super(), pour référer à la classe parente

11. Classes • Exemple 1 : class Test(object): """commentaire""" def __init__(self, a): self._a = a def meth(self): return self._a * 42 def __str__(self): return str(self._a) print 'type de Test:', type(Test) c = Test(2) print 'appel de la methode __str__():', c print 'type de c:', type(c) print 'attributs de c:', dir(c) print 'appel de methode:', c.meth() c.nouvel_attribut = 42 print 'nouvel attribut::', c.nouvel_attribut print 'introspection:', getattr(c,'meth')

12. Classes sundae:~/Desktop$ python test.py type de Test: <type 'type'> appel de la methode __str__(): 2 type de c: <class '__main__.Test'> attributs de c: ['__class__', '__delattr__', '__dict__', '__doc__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', '__weakref__', '_a', 'meth'] appel de methode: 84 nouvel attribut: 42 introspection: 84 • Que contient l’attribut __doc__ ?

13. Classes • Exemple 2 (héritage, self-modication) : class A(object): pass class B(A): pass class C(object): pass print B.__bases__ # (1) B.__bases__ += (C,) print B.__bases__ # (2) Résultats : (<class __main__.A>,) # (1) (<class __main__.A>, <class __main__.C>) # (2)

14. Classes • Exemple 3 (surcharge d’opérateurs): class MyInt(object): def __init__(self, i): self.i = i def __add__(self, rhs): return MyInt(self.i + rhs.i) def __str__(self): return str(self.i) un = MyInt(1) deux = MyInt(2) trois = un + deux print trois sundae:~/Desktop$ python myint.py 3

15. Tuple • Conteneur séquentiel non mutable • Ensemble ordonné d’éléments • Pas forcément constants • Exemples : a = (1,2,3) # instancie un nouveau tuple a[1] # retourne 2 a[0] = 4 # interdit a.append(42) # faux b = a + (4,) # recopie complète de a dans b

16. Liste • Conteneur séquentiel mutable • Exemple >>> l = [1,42] # liste de 2 éléments # Rem: le type des élts n'est pas forcément homogéne >>> len(l) # longeur de la liste 2 >>> l.append(4) # insérer un élément à la fin de la liste >>> l [1, 42, 4] >>> l.sort() # ordonner la liste, # compare les élts 2 à 2, avec la méthode __cmp__() >>> l # pour éviter que l ne soit modifiée, utiliser sorted() [1, 4, 42] >>> l.pop() # retire et retourne le dernier élément de la liste

17. Liste >>> l[0:2] # retourne une sous-liste [1, 4] >>> l[:-1] [1, 4] >>> l[-1] # plus efficace que l[len(l)-1] 4 >>> l.remove(4) # retirer un élt se base sur l’op d'égalité structurelle # au travers de la méthode __eq__() >>> del l[0] # suppression par position >>> l []

18. Dictionnaire • Conteneur associatif • Exemple • >>> d = {1:'1', 3:'3', 2:'2'} # instancier un dictionnaire, la clef doit • # être un objet constant (c’est son hash • # qui détermine sa valeur d’index) • >>> d • {1: '1', 2: '2', 3: '3'} • >>> 1 in d # test d'appartenance • True • >>> d[4] = '4' # insérer un élément • >>> d • {1: '1', 2: '2', 3: '3', 4: '4'}

19. >>> del d[2] # supprimer un élément en fonction de sa clef >>> d {1: '1', 3: '3', 4: '4'} >>> d.keys() # retourne la liste des clefs (peut être très coûteux) [1, 3, 4] >>> d.values() # retourne la liste des valeurs ['1', '3', '4'] >>> d.items() # retourne la liste des couples (clef, value) [(1, '1'), (3, '3'), (4, '4')] >>> d[6] # retourne une exception en cas de clef erronée Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 6 >>> d.get(6) # retourne None Dictionnaire

20. >>> d.get(4) # ou la valeur si la clef est correcte '4‘ >>> d.iteritems() # retourne un itérateur sur les couples d'items <dictionary-itemiterator object at 0xb79b9760> >>> for k,v in d.iteritems(): # itérer sur les couples d'items, ordre des éléments non garanti ... print k, v 1 1 3 3 4 4 >>> sorted(d.iterkeys()) # liste ordonnée des keys [1, 2, 3] >>> d.clear() # réinitialiser le dictionnaire >>> d {} Dictionnaire

21. Dictionnaire • Changements prévus dans Python 3.0 • Inspirés de Java • Ne plus retourner une liste après un appel à .values(), .items(), .keys() mais une view • Plus léger, n’est pas un itérateur • Permet de retirer un élément (pas d'ajouter ?) • Supporte l'itération • => les méthodes retournant un iterateur seront retirées iteritems(),...

22. Autres conteneurs • Conteneur séquentiel d’éléments uniques non ordonnés • Classe Set (contenue dans le module sets) • Conteneur FIFO synchronisé (thread safe) • Classe Queue • Liste comprehension (sera implémenté par un generator dans Python 3.0) >>> [str(i) for i in range(1,6)] # list comprehension ['1', '2', '3', '4', '5']

23. Conteneurs • Les conteneurs peuvent être imbriqués • Par efficacité les conteneurs manipulent des pointeurs sur les objets insérés • En cas de copie, seule une copie superficielle (shallow copy) est souvent effectuée >>> l = [1,2,3]; ll = l; ll[1] = 42; l [1, 42, 3] • La recopie en profondeur doit être explicite >>> l = [1,2,3]; ll = l[:]; ll[1] = 42; l [1, 2, 3] • Dans le cas d’objets complexes, la recopie est à la charge du développeur

24. Itérateurs • Tous les conteneurs séquentiels peuvent être itérés • list, tuple, dict, … • Exemple : for i in [1,2,3,4] print i • Remarque: la suppression d’un élément sur une séquence itérée invalide silencieusement l’itérateur

25. Itérateurs • Classe dont les instances sont itérables class MyList(object): def __init__(self, l): self.l = l self.index = 0 def __iter__(self): return self def next(self): if self.index == len(self.l): raise StopIteration try: return self.l[self.index] finally: self.index += 1

26. Itérateurs • Itérer (consommer) • Méthode classique for i in MyList([0,1,2]): print I • Strictement equivalent à (principe réalisé en interne) it = iter(MyList([0,1,2])) # délégue à __iter__() while True: try: print it.next() except StopIteration: break • Sortie dans les deux cas : 0 1 2 • Remarque : faire un itérateur infini sans StopIteration

27. Exceptions • Lever une exception raise Exception() • Attraper une exception (à la manière Python 2.5) try: # code susceptible de déclencher une exception except Exception(), err: # ou tout type hérité de Exception # code de traitement de l’exception print err # affiche le message d’erreur # peut attraper d’autres types d’exceptions # avec de nouvelles clauses ‘except’ else: # exécutée si la partie critique n’a pas lever une exception finally: # partie exécutée dans tous les cas

28. Exceptions • Hiérachies des exceptions (Python 2.5) BaseException |- KeyboardInterrupt |- SystemExit |- Exception |- (all other current built-in exceptions)

29. Modules • Importer un module (équivalent d’une librairie) >>> import sys # importer tout un module >>> sys.path # import cherche les modules dans ces répertoires ['', '/usr/lib/python25.zip', '/usr/lib/python2.5', '/usr/lib/python2.5/plat-linux2', '/usr/lib/python2.5/lib-tk', '/usr/lib/python2.5/lib-dynload', '/usr/local/lib/python2.5/site-packages', '/usr/lib/python2.5/site-packages', '/usr/lib/python2.5/site-packages/Numeric', '/usr/lib/python2.5/site-packages/gst-0.10', '/var/lib/python-support/python2.5', '/usr/lib/python2.5/site-packages/gtk-2.0', '/var/lib/python-support/python2.5/gtk-2.0', '/usr/lib/site-python'] >>> from foo import bar # n’importe pas tout le module foo # mais seulement bar • Import relatifs (fonctionnalité introduite dans python 2.5)

30. Modules • La librairie standart est installée dans : • /usr/lib/python2.{3,4,5} • Les modules non standarts : • /usr/lib/python2.{3,4,5}/site-packages/ • Outils pour construire des packages (équivalent de ant pour java) • distutils, Python Eggs (produit .egg)

31. Domaines avancés • Appeler du code C à partir du code python • Améliorer les performances de sections critiques • S’interfacer avec des librairies C • Comment créer le « glue » code ? • « à la main » • Utiliser un générateur de code : swig • Génère beaucoup de code mais est assez performant

32. Domaines avancés • Pour la culture, çà existe • Meta-classes • Programmation fonctionnelle • Lambda (fonction anonyme) • >>> filter(lambda x: True if x > 42 else False, [1,84,-42,45,42]) • [84, 45] • Application partielle (Python 2.5) • def add(x,y): • return x+y • plus_un = functools.partial(add, y=1) • >>> plus_un(41) • 42 • Fonctions : map, reduce, filter, sum, all, any, zip, enumerate

33. Domaines avancés • Générateurs (Python 2.4, 2.5) • Mot clef ‘yield’ • Décorateurs (Python 2.4) @decorator def foo(…) […] • Instruction ‘with’ (Python 2.5) • Particulièrement utile pour la manipulation des fichiers et pour les locks • Personnalisable pour ses propres objets • Le module itertools

34. Futur • Court terme (06/07) : Python 2.6 • Continuité de la branche 2.x • Transition avec Python 3.0 (ajout de warnings) • Moyen terme (06/08) : Python 3.0 • Changements incompatibles/importants • Un outil (best effort) doit être écrit pour convertir les incompatibilités contenues dans les anciens codes • …mais pas trop (éviter l’effet Perl 6)

35. Autres interpréteurs Python • Version officielle : CPython (http://www.python.org) • Financé par Google (humour  ) • Pypy : python en python (http://codespeak.net/pypy/) • Financé par l’UE • IronPython : interpréteur en C# pour Visual .net • Financé par Satan (humour ?) • JPython : interpréteur python en Java(http://www.jython.org/)

36. Propagande • YouTube.com est écrit en Python • Python est un des 3 langages officiels chez Google (avec Java et C++) • Django est capable de rivaliser avec RoR • Forte communauté, en particulier sous Linux, de nombreuses librairies, souvent de bons niveaux • Utilisé pour les jeux, le calcul numérique, le dév. Web, la prog. système, …

37. Liens utiles • Plonger dans python (peut donner des exemples de code à lire) : http://www.diveintopython.org/ • Tutoriel (notions de bases) : http://docs.python.org/tut/tut.html • Documentation de la bibliothèque standart (ressource vitale): http://docs.python.org/lib/lib.html • Recettes (contient de bonnes surprises) : http://aspn.activestate.com/ASPN/Python/Cookbook/ • Livres (dans l’idéal commencer par çà) : Learning Python (M. Lutz) • Répertoire de packages (plutôt que de coder tout un module soi-même) : http://python.org/pypi • PEPs (mine d’information) : http://www.python.org/dev/peps/ chaque nouvel idiome du langage fait l’objet préalable d’un draft • Wiki (moyen) : http://wiki.python.org/moin/ • Autres sources : mailing lists, blog de GvR, et des autres core developpeurs

38. Quelques PEPs utiles • Ecrire du code à la « norme » officielle : http://www.python.org/dev/peps/pep-0008/ • WSGI (Web Server Gateway Interface) : http://www.python.org/dev/peps/pep-0333/ • Eléments du langage à éviter pour rester compatible avec les anciennes versions de CPython : http://www.python.org/dev/peps/pep-0291/ • Peps traitant des nouveautés dans python 2.5 : http://docs.python.org/whatsnew/whatsnew25.html • Architecture interne du compilateur : http://www.python.org/dev/peps/pep-0339/