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

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)

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

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 >>> a = 42; print a; a = 'foo'; print a ; 42 foo

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

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)

Fonctions Exemple : Définition d’une fonction par ‘def’ 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

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

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

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

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')

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__ ?

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

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

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

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

Liste >>> l[0:2] # retourne une sous-liste [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 []

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 {1: '1', 2: '2', 3: '3', 4: '4'}

Dictionnaire >>> 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 >>> 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 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(),...

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']

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

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

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

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 : 1 2 Remarque : faire un itérateur infini sans StopIteration

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

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

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)

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)

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

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

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

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)

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/)

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, …

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

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/