Modèle, Espaces de Noms

(1)

Introduction

Guido van Rossum - 1990

Versions ...1.4, 1.5.2, 1.6, 2.0, 2.1, 2.2, 2.3 Python Software Foundation

Licence très libre - compatible GNU-GPL

Langage de script - pseudo-code + modules natifs Multi-plateformes

Lancement

Interactif en ligne de commande:

myhost$ python

Lancement d'un script en ligne de commande:

myhost$ python unscript.py Par fichier exécutable (#!/bin/env python):

myhost$ ./travailler

Par double-click dans un environnement graphique.

Par un menu dans un environnement de développement.

3

Laurent POINTAL - LIMSI COURS PYTHON

Syntaxe

Identificateurs: toto, _titi3, __reserve__

Commentaires: # A terminer...

Blocs d'instruction: indentation if x != res :

print "Intrus trouvé:",x break

Affectation: a = 27 a,b = 42,b/2 a=b=c=0

Instruction nulle: pass

4

Modèle, Espaces de Noms

TOUT est objet.

Certains objets sont mutables (le contenu de l'objet peut être modifié), d'autres sont immutables (non modifiables).

Les variables, fonctions, modules, classes, membres, sont des noms qui références des objets.

Les noms sont définis dans des espaces. A tout moment certains espaces de noms sont utilisés de façon implicite, les autres doivent être spécifiés.

Règle LGB (local, global, builtin)

(2)

Mots clés réservés

and, assert, break, class,

continue, def, del, elif, else, except, exec, finally, for, from, global, if, import, in, is,

lambda, not, or, pass, print, raise, return, try, while, yield

as None

Instructions / Fonctions

Instructions et fonctions pour pouvoir commencer.

print "Bonjour",nom n=input("Compte:")

s=raw_input("Combien?")

7

Types de Base

Numériques: int long float complex bool

Chaînes: str unicode

Conteneurs: tuple list dict (buffer xrange)

8

Valeurs Numériques

421 -3254 (entier décimal) 0x33bac63 0xFFFE4 (entier hexa)

0766 (entier octal)

265438787122L (entier long, hexa, octal) 314159.26E-5 (flottant)

3+4j (3+0j) (3+4j)*2 (complexe) True False (booléens, valeurs 1 et 0)

booléens: tout ce qui n'est pas égal à zéro ou vide est vrai

Les valeurs numériques sont immutables.

(3)

Opérations Numériques

Opérateurs

a+b, a-b, a*b, a/b, a%b, +a, -a, a**b Fonctions

abs(a), divmod(a,b), pow(a,b) int(a), long(a), float(a), bool(a) complex(re,im)

Opérateurs booléens

a or b, a and b, not a

Opérateurs bits (sur entiers or, xor, and, lshift, rshift, invert) x|y, x^y, x&y, x<<n, x>>n, ~x

...module math (math.h du langage C) from math import *

Valeurs Chaînes

Caractère d'échappement \ (idem langage C) Entre " ou '

Plusieurs lignes entre """ ou '''

Préfixe r ou R pour débrayer l'échappement \ (expressions régulières, chemins Windows) Préfixe u ou U pour coder en Unicode Caractère chaîne de longueur 1

Peuvent contenir des flots binaires (octets 0x00 à 0xFF)

11

Opérations sur les Chaînes

Objets immutables.

Méthodes des objets chaînes.

capitalize center count decode encode endswith expandtabs find index isalnum isalpha isdigit islower isspace istitle isupper join ljust lower lstrip replace rfind rindex rjust rstrip split splitlines startswith strip swapcase title translate upper zfill

Fonctions/données du module string.

ascii_letters ascii_lowercase ascii_uppercase capwords digits hexdigits letters lowercase maketrans octdigits printable punctuation uppercase whitespace...

Fonctions builtin len.

12

Indexation Chaînes

s="Un laboratoire"

len(s) 14 s[0] "U"

s[3] "l"

s[-1] "e"

s[-3] "i"

s[3:7] "labo"

s[-7:-4] "rat"

s[:2] "Un"

s[10:] "oire"

s[-4:] "oire"

s[:] "Un laboratoire"

Un laboratoire

-14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1⁰ ¹ ² ³ ⁴ ⁵ ⁶ ⁷ ⁸ 9 10 11 12 13

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

-14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 Index

caractères Index séquences

(slices)

(4)

Conteneurs Séquences (ordonnés n°) list

l1=[14,"bonjour",0.52]

lvide=[]

l2=range(10,101,10)

tuple

(immutable) t1=14,"bonjour",0.52

t2=(14,"bonjour",0.52) tvide=()

tun=("Un élément",)

str

(chaînes=séquence de caractères) s="Un laboratoire"

Autres Séquences

buffer : mapping d'une sous-séquence d'une chaîne ou d'un buffer déjà existant.

s='Un laboratoire' b=buffer(s,3,4) b "labo"

b[0] "l"

len(b) 4

xrange : pseudo-liste dont les valeurs sont générées au fur et à mesure (idéal boucles sur beaucoup d'index en remplacement de range).

for i in xrange(100,10000,2):

...

array.array : tableaux compacts de données numériques du même type.

15

Opérations Séquences

Présence d'un élément e in seq

e not in seq Nombre d'éléments

len(seq)

Elément de valeur minimale/maximale min(seq) max(seq)

Accès à un élément/une séquence d'éléments

seq[i] seq[i:j] (cf indexation chaînes) Concaténation

seq1 + seq2 Répétition

seq * n n * seq Copie dans une nouvelle séquence

seq2=seq[:]

16

Opérations Séquences Mutables

Modification d'un élément ou d'une partie

l[i]=v l[i:j]=[v1,v2,v3]

Suppression d'un élément, d'une partie, d'une valeur

del l[i] del l[i:j] l.remove(v)

Ajout d'un élément ou d'une liste d'éléments

l.append(v) l.extend([v1,v2,v3])

Insertion d'un élément à une position

l.insert(i,v)

Comptage et recherche d'index

l.count(v) l.index(v)

Réordonnancement (modifie l'original sur place)

l.sort() l.reverse() l.reverse(fct)

Comportement en pile (extrait, supprime, retourne) l.pop() l.pop(3)

(5)

Fonctions Pratiques Séquences

filter(fct,seq) : retourne les éléments de la séquence pour lesquels la fonction retourne vrai.

map(fct,seq,…) : retourne tous les éléments de la séquence après leur avoir appliqué la fonction.

reduce(fct,seq,valinit) : retourne la valeur finale de la réduction de la séquence à une seule valeur en appliquant la fonction.

zip(seq1,seq2,…) : retourne une liste de tuple où chaque valeur combine les éléments de même index de chaque séquence.

Conteneurs Mapping

dict

(dictionnaire)

(dictionnaires et listes ne peuvent être des clés) dvide={}

d={'pi':3.1416,'e':2.7183}

d2={1:'un',"verite":42,

(1,"deux"):False, o:"Objet"}

Avec python 2.3:

d=dict(<valeurs>)

d={}.fromkeys(<clées>[,<valeurs>])

Collection de paires (clé valeur) où clé n'est pas forcément un entier, et pas forcément dans un ensemble continu.

19

Opérations Dictionnaires (1)

Mise en place/modification d'une paire clé/valeur

d['pi']=3.141592654

Mise à jour à partir d'un autre dictionnaire

d.update(d2)

Suppression d'une paire

del d['pi']

Nombre de paires clé/valeur

len(d)

Test présence/absence d'un clé

d.has_key('pi') 'pi' in d 'pi' not in d

Copie des paires dans un nouveau dictionnaire

d3=d.copy()

20

Opérations Dictionnaires (2)

Accès à une valeur par son index

d['pi'] 3.1416

Accès, avec valeur par défaut, avec stockage par défaut

d.get('pi',3.14) d1.setdefault('pi',3.14)

Liste des clés, liste des valeurs

d.keys() d.values()

Liste des paires (clé,valeur) (liste de tuple (clé,valeur))

d.items()

Comportement en pile (extrait au hasard, supprime, retourne tuple (clé,valeur))

d.popitem()

Avec Python 2.3: d.pop(k,x)(extrait pour la clé, supprime, retourne tuple (clé,valeur))

(6)

Formatage de Chaînes (1)

"%s-%d %s"%("2déc",231,"Infos")

2déc-231 Infos'

"%s=%0.4f"%('pi',3.141592654)

pi=3.1416'

"%10s:%10s"%("LPNHE","Paris")

LPNHE: Paris'

"%10s:%-10s"%("LPNHE","Paris")

LPNHE:Paris '

% d i o u x X e E f F g G c r s %

Opérateur % appliqué à une chaîne avec des valeurs.

Formatage de Chaînes (2)

"%02d"%5 "05"

d={"nom":"POINTAL", "pre":"Laurent", "lieu":"LPNHE", "dates":[24,25,26,27]}

"%(pre)s %(nom)s in %(lieu)s at %(dates)s"%d

'Laurent POINTAL in LPNHE at [24, 25, 26, 27]'

"%s"%"L'espace"

"L'espace"

"%r"%"L'espace"

'"L\'espace"'

23

Test If

if len(s)<4 : print "Trop petit."

if not s :

logerror("Parametre vide!!!") sys.exit(-2)

elif len(s)<MINLEN :

logerror("Parametre trop petit.") sys.exit(-3)

else :

loginfo("Début traitement...")

Condition vraie si le résultat de l'expression n'est pas égal à zéro ou vide.

24

Boucle While

while i<len(s) : print i,s[i]

finished = False

while i<len(s) and not finished : print "Traite",i,s[i]

finished = process(s[i])

(7)

Boucle For (1)

for variable in sequence : ...

La variable référence tour à tour chaque valeur de la séquence, dans l'ordre croissant des index.

La séquence peut être un conteneur (liste, tuple, chaîne…), ou bien un objet capable de fournir un itérateur.

Si la séquence contient des séquences toutes de la même taille, on peut mettre plusieurs variables.

for x,y,z in liste_coord : ...

Itération sur des séquences, de façon générique.

Boucle For (2)

Si l'on veut accéder aux index de la séquence (par exemple pour la modifier):

index=0

while index<len(sequence) : valeur = sequence[index]

…

index += 1

for index in range(len(sequence)) : valeur = sequence[index]

…

Avec python 2.3, on peut utiliser l'itérateur enumerate:

for index,valeur in enumerate(sequence) : …

27

Alternances dans les Boucles

Dans les instructions de la boucle:

break : sort de la boucle sans terminer l'itération.

continue : passe à l'itération suivante (attention avec les boucles while).

A la fin de la boucle, un else permet de n'exécuter du code qu'en cas de sortie 'normale' (sans break) de la boucle.

for i in seq : …

else : ^…

28

List-comprehension

[expression for variable in sequence]

[expression for variable in sequence if expression]

Exemples:

lstsin = [sin(x) for x in angles]

initiales = [m[0] for m in titre.split()]

listnames = [abspath(n) for n in listnames]

obvals = [o.val() for o in objlist if o.ok()]

Ou, comment construire lisiblement une liste à partir d'une autre avec une itération.

(8)

Itérateurs (1)

A chaque itération, c'est l'itérateur qui se charge de fournir la valeur suivante. C'est lui aussi qui détecte la fin d'itération lorsque tout l'ensemble a été parcouru.

Certaines méthodes des dictionnaires fournissent des itérateurs : iteritems, iterkeys, itervalues.

Les objets fichiers fournissent par défaut l'itération sur leur contenu, ligne par ligne (for ligne in f : …).

Avec Python 2.3, enumerate retourne un itérateur (index,valeur) pour une séquence quelconque.

Moyen de parcourir un ensemble de données.

Itérateurs (2)

Pour qu'un ensemble produise un itérateur implicite (pour pouvoir écrire for i in ensemble:…):

Il doit définir une méthode __iter__ qui retourne un objet itérateur.

Un objet itérateur doit disposer de:

Une méthode __iter__, qui retourne lui-même.

Une méthode next qui retourne l'élément suivant.

La méthode next doit lever une exception StopIteration lorsqu'il n'y a plus d'élément à parcourir.

Note: Voir aussi yield et les générateurs.

31

Fonctions - définition

Définition avec def, code indenté.

def mafonction():

…

Arguments.

def mafonction(p1,p2):

…

(les arguments sont passés par référence)

Les arguments sont accessible implicitement, dans l'espace de noms des variables locales.

Sortie (avec/sans retour de valeur) avec return.

def mafonction(p1,p2):

return p1+p2

(si une fonction ne retourne rien, elle retourne implicitement None)

32

Fonctions - variables

Hors affectation, recherche des noms dans les espaces de noms englobants:

locales, globales (module), builtins Pour les affectations, variables locales par défaut.

def fct(x,y):

a=sqrt(x**2 * y**2)/max(x,y) return arcsin(a)

Pour affecter des variables globales, utiliser global.

def fct(x,y):

global suma

a=sqrt(x**2 * y**2)/max(x,y) suma += a

return arcsin(a)

(erreur courante d'oublier la directive global)

(9)

Fonctions - paramètres (1)

Valeurs par défaut pour les arguments.

def ouvrir(nomfic,mode="wt") : return open(nomfic,mode)

(éviter les valeurs mutables pour les valeurs par défaut - risque d'effet de bord

d'un appel de la fonction sur l'autre) Nombre variable d'arguments tuple.

def imprimer(flot,*args) :

for v in args: flot.write(str(v))

(uniquement après les arguments explicites)

Fonctions - paramètres (2)

Nombre variable d'arguments nommés dictionnaire.

def imprimer(flot,**kargs) : for k in kargs.keys():

flot.write("%s=%s",k,kargs[k])

(uniquement après les arguments explicites) Nombre variables d'arguments nommés ou non nommés.

def imprimer(flot,*args,**kargs) : …

35

Fonctions - appel

Appel avec utilisation de valeurs par défaut.

f = ouvrir("/tmp/mylog")

Appel avec paramètres positionnés.

v = mafonction(3,4)

Appel avec paramètres nommés.

v = mafonction(p2=4,p1=3)

Appel avec paramètres positionnés et nommés.

imprimer(f,"cent","mille",un=1,deux=2)

(les arguments nommés à la fin) Utilisation de conteneurs pour les arguments en nombre variable.

apply(imprimer,(f,)+tuple(lparams),dparams) Avec Python 2.3:imprimer(f,*lparams,**dparams)

36

Fonction - Documentation

def prepare(vals,env):

"""prépare l'environnement.

Arguments:

* vals Liste des nombres.

* env Objet environnement.

L'environnement doit être initialisé.

Retourne: True si préparation ok, False sinon.

"""

…(le code)…

http://docutils.sourceforge.net/index.html

(10)

Lambda Fonctions

Des fonctions anonymes définies en-ligne et utilisées là où l'on doit passer une fonction.

lambda <arguments>:<expression>

filenameslist.sort(lambda f1,f2:

cmp(getsize(f1),getsize(f2)))

(utilisé beaucoup pour les « binding » tkinter)

Module - définition

Regroupement de variables, constantes et fonctions liés par leur fonctionnement.

Création de bibliothèques réutilisables.

Découpage de logiciel volumineux.

Définition Fichier texte toto.py MAX=5

def calc(lvals) : …

return res

Utilisation Import module toto import toto

print toto.MAX a=toto.calc(vals)

39

Module - Recherche

Les modules sont recherchés dans les répertoires listés dans le path Python.

Liste de ces chemins dans sys.path.

Initialisé avec :

Variable d'environnement PYTHONPATH.

Entrées dans la registry sous Windows.

Modifiable dynamiquement

(sys.path est une liste Python)

40

Import d'un Module

Les noms importés sont dupliqués dans l'espace de noms courant. Ils écrasent les noms identiques déjà définis.

Les duplicatas référencent les mêmes objets que les noms importés au moment de l'import.

Syntaxes d'imports import module

import moduleB as B

from moduleC import x as a,y,fct from moduleD import *

Manipulation des noms moduleC.x=23 a=3

res=fct(32.4)

(11)

Exports de symboles d'un module

Si __all__ est défini dans le module : il s'agit de la liste des noms des symboles importables directement.

Sinon : tous les symboles du module qui ne

commencent pas par _ sont importables directement.

Il est toujours possible d'accéder à des noms définis dans un module, en passant explicitement par le module.

Module - Modèle

#!/bin/env python

# -*- coding: ascii -*-

"""Ici la documentation générale.

…

"""

import string,sys,logging import Numeric

from matcalc import mulmat,dispmat __all__ = ["f1","MAX"]

MAX=10 count = 0

def f1(mat1,mat2):

…

def f2(coef,mat):

…

if __name__=="__main__":

…

43

Package

Moyen de regrouper des modules.

Un package est un directory.

Il contient un module __init__.py

Pour pouvoir être importé, le répertoire/package doit être dans un des répertoires listés dans le path Python.

Les modules python dans le package (ie. dans le directory) sont importables par son intermédiaire.

Un package peut contenir des sous-packages.

44

Utilisation d'un Package

On passe simplement par le nom du package.

Fichiers

.../mylibs/calculs/

__init__.py matcalcs.py visu.py docs/

index.html FFT/

__init__.py Fast.py Slow.py

Utilisation:

from calculs.matcalcs import matmult from calculs.visu import *

import calculs

from calculs.FFT.Fast import fft from calculs import *

(12)

Programmation Orientée Objet

Traitements - Algorithmes Données - Structures

Qu'est-ce que l'on manipule.

Quelles relations entre les autres données.

Qu'est-ce que l'on en fait.

Classes - Principes

Définition d'une famille d'objets:

Données, attributs.

Traitements, méthodes.

Héritage entre classes.

Spécialisation des sous-classes, surcharge des méthodes.

Généricité des classes parentes - abstraction.

47

Classes - Définition (1)

class Moteur :

"""Défini les grandes lignes d'un moteur.

"""

cptmoteurs = 0

def __init__(self,modele,nom):

Moteurs.cptmoteurs += 1 self.nom = nom

self.modele = modele def ModNom(self):

return "%s-%s"%(self.modele,self.nom) def Marche(self):

raise NotImplementedError("Marche") …

48

Classes - Définition (2)

class MotLPNHE (Moteur):

"""Gestion moteur modèle LPNHE.

"""

def __init__(self,nom,port="/dev/ttyS0"):

Moteur.__init__(self,"LPNHE",nom) self.serialport = port

def Marche(self):

self.writeserial("start\n") print self.ModNom(),"En marche."

def __del__(self):

self.closeserial() …

(13)

Classes - Utilisation

m1 = MotLPNHE("chassis1.1")

m2 = MotLPNHE("chasses2.1","/dev/ttyS1") print m1.nom,m2.nom,"crees"

m1.Marche() m2.Marche() time.sleep(100) m1.Stop()

m2.Stop()

print "Fini",m1.MotNom() print "Fini",m2.MotNom()

mbad = Moteur("bad","indefini")

Classes - Opérateurs

Surcharge des opérateurs par redéfinition des méthodes correspondantes. Exemples:

def __add__(self,o):

def __repr__(self):

def __str__(self):

def __call__(self,…):

def __len__(self):

def __getattr__(self,nom):

def __getitem__(self,index):

def __getslice__(self,debut,fin):

def __cmp__(self,o):

def __hash__(self):

51

Classes - Avancé

Méthodes statiques class X :

def dothis(arg1,arg2):…

dothis=staticmethod(dothis) Accesseurs.

class X :

def ga(self):…

def sa(self,v):…

def da(self):…

a=property(ga,sa,da,"doc sur a)

52

Exceptions

try :

a = calc1(34) res = b / a

putres("final",res) except :

print "Erreur calcul résultat final."

raise def calc1(x):

if x<MIN :

raise Exception,"param calc1 trop petit"

return sin(x)/COEF def putres(status,value):

…

Un moyen de traiter les cas particuliers, typiquement les erreurs.

(14)

Exceptions - Handlers

Les exceptions sont des objets.

Possibilité de filtrage suivant la classe de l'exception.

try:

…

except IOError, e:

print "Erreur fichier",e except (TypeError,ValueError):

print "Mauvais type/donnée."

except Exception:

print "Erreur."

else:

print "Tout OK."

Exceptions - Finally

Pour s'assurer qu'un code est systématiquement exécuté, même en cas

d'erreur.

try:

…acquisition ressources…

…traitements…

finally:

…libération ressources…