Bases Python

Présentation Superviseur Aster

Christian Caremoli • Introduction à Python • Le superviseur Aster et Python

Introduction à Python

• Utiliser Python, structure d’un programme • Variables et types intégrés • Instructions, tests et boucles • Fonctions, modules et packages • Classes et objets • Exceptions

Utiliser Python en interactif • Utilisation interactive % python Python 1.5.2 (#0, Apr 13 1999, 10:51:12) [MSC 32 bit (Intel)] on win32 Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam >>>

• ^D (control-D) termine l’exécution >>> ^D %

• Les commentaires commencent par ‘#’ >>> 4 >>> 2 >>> >>> 0

2+2

# Commentaire sur la même ligne

7/3 # Les nombres sont entiers par défaut x = y = z = 0 # Affectation multiple z

3

Exécuter des programmes Python • En général % python myprogram.py

• On peut créer des scripts exécutables – Rendre le fichier exécutable : % chmod +x myprogram.py

– La première ligne du script indique comment l’exécuter : #!/usr/bin/python

– Ensuite, on peut simplement taper le nom du script pour l’exécuter % myprogram.py

4

Structure d’un programme Python • Pas de déclaration de type ; Une variable est directement affectée avec l’opérateur ‘=‘ • Les blocs de codes sont indiqués par indentation (pas de {}, comme en C) homogène i = 0 while i < 10: print i i = i + 1

– En interactif, prompt secondaire ... >>> if a >1: ... print "a plus grand que 1"

• Il est possible de mettre plusieurs instructions sur la même ligne et d’étendre une instruction sur plusieurs lignes a=10;b=12;c=5 x=2*a + \ 4*b

5

LES VARIABLES • L’affectation • Règles sur les noms de variables

6

L’affectation • Il est important de bien comprendre les principes de l’affectation (a=b) – – – –

L'affectation permet de lier des objets à des noms de variables. L’affectation crée des références pas des copies. Les noms sont créés automatiquement à la première affectation. Les noms doivent être créés avant d'être référencés. C’est une erreur d’utiliser un nom pas encore associé à une valeur. – Les variables sont modifiables et n’ont pas de type, c'est une simple référence sur un objet qui lui comporte un type. Il est donc possible d’affecter successivement plusieurs objets de types différents à une même variable. – Utiliser le module copy quand on veut un nouvel objet plutôt qu’une référence sur un objet existant.

7

Règles sur les noms de variables • Syntaxe : (blanc souligné ou lettre) + (un nombre quelconque de chiffres ou lettres ou blancs soulignés) – _rick est un nom correct – 2_rick ne l’est pas

• Sensible à la casse – Rick est différent de rick

• Mots 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

8

LES TYPES INTEGRES • Types numériques • Chaînes

9

Les types numériques • Entier court (32 bits) A = 1 b = 3/5

# 0, à cause de la troncature

• Entier long (taille illimitée) C=314314314L

• Flottant pi = 3.1415927;x=2.3e5;y=4.8E6

• Octal, Hexadécimal O=0132 H=0x9ff

• Complexe C=1.+2j

10

Les chaînes • Les variantes MyString = "this is a string" myotherstring = 'this is also a string' NewString = MyString + " " + MyOtherString "If you mix quotes it doesn't end the string« S="""cette chaine est sur plusieurs lignes grâce aux triples guillemets """

• Indiçage et extraction 0 1 2 3 -3 -2 -1 "e x e m p l e d e c h a i n e" [: :]

• Il est impossible de modifier une chaîne en place. Il faut en créer une nouvelle. 11

Les objets conteneurs • Les conteneurs portent des collections d'autres objets • Listes – Séquence d'objets de types quelconques – On peut ajouter, supprimer, changer des éléments a = ['Hi',1,0.234]

• Tuples – Semblables aux listes mais non modifiables atom = (atomic_symbol,x,y,z)

• Dictionnaires – Conteneur indexé par des clés (pas exclusivement des chaînes) atomic_number = {'Dummy' : 0,'H' : 1,'He' : 2} atomic_number['He']

# retourne 2

12

Exemples de manipulation de listes >>> a = ['spam', 'eggs', 100, 1234] >>> a ['spam','eggs',100,1234] >>> a[0] # Listes démarrent à 0, comme en C 'spam' >>> a[3] 1234 >>> a[-2] # Les indices négatifs partent de la fin 100 >>> a[:2] # ":" indique un intervalle ['spam','eggs']

13

Étendre des listes >>> a + ['bacon'] ['spam','eggs',100,1234,'bacon'] >>> a.append('!') ['spam','eggs',100,1234,'!'] >>> 2*a ['spam','eggs',100,1234,'!','spam','eggs',100, 1234,'!']

14

Les objets fichiers • Permettent d'accéder depuis Python à des fichiers • Sont créés par la commande open >>> mon_fichier = open('fichier', ‘w’)

• Sont dotés de méthodes, dont : – read : pour lire le contenu du fichier – write : pour écrire dans le fichier – close : pour fermer le fichier

15

LES INSTRUCTIONS • Expressions • L'instruction print • Instructions de contrôle de flux : if, while, for

16

Expressions • Appel de fonction spam(ham, eggs)

• Référence à des éléments de Liste/dictionnaire spam[ham]

• Appels de méthode spam.ham spam.ham(eggs)

• Expressions composites spam < ham and ham != eggs

• Tests d'intervalle spam < ham < eggs

17

L'instruction print • La commande print imprime les variables sur la sortie standard >>> a b >>> ab >>> a

print "a", "b" print "a"+"b" print "%s b

%s" % (a,b)

• Notes – Print ajoute un retour chariot ; utiliser print ..., pour le supprimer – print(string) est equivalent à sys.stdout.write(string + '\n')

18

if et tests de vérité

Tests if • Forme de base : if : elif : else:

• Exemple: x = 'killer rabbit' if x == 'roger': print 'How\'s Jessica?' elif x == 'bugs': print 'What\'s up, Doc?' else: print 'Run away! Run away!'

# Affectation

20

Tests de vérité • En général, – vrai : nombre différent de zéro ou objet non vide. – faux signifie non vrai : zéro, un objet vide ou None. – Les tests d'égalité et les comparaisons retourne 1 ou 0 (Vrai, Faux), 2 < 3 3 <= 2

# vrai, retourne 1 # faux, retourne 0

– les opérateurs and et or retournent un objet opérande vrai ou faux. X and Y # retourne X si faux sinon Y (vrai ou faux) X or Y # retourne X si vrai sinon Y (vrai ou faux) not X # vrai si X est faux (retourne 1 ou 0)

– Égalité versus identité x == y x is y

# x et y ont la même valeur # x et y référencent le même objet # id(x) == id(y)

21

while et for

Boucles while • Forme de base : while : else: interrompue

# test # corps de la boucle # optionnel # exécuté si la boucle n'est pas

• Exemples while 1: # boucle infinie print 'type Ctrl-C to stop me!' a,b = 0,10 while a < b: print a, a = a + 1

23

break, continue, pass, else • break – Sort de la boucle

• continue – Saute à la fin de la boucle la plus imbriquée (itération suivante)

• pass – Ne fait rien (bouche-trou) while : if : break if : continue else:

24

Boucles for • for est un itérateur de séquence – Parcourt les items d'une liste, chaîne, tuple, etc. – Forme de base : for in <séquence>: else: # optionnel # exécuté si la boucle n'est pas # interrompue par un break

– On peut utiliser break, continue, pass comme dans un while – Peut être utilisé avec range pour gérer un compteur de boucle for i in range(10): print i

25

Fonctions

Pourquoi utiliser des fonctions ? • Réutilisation de code – Regrouper des instructions que l'on veut utiliser à plusieurs endroits.

• Décomposition procédurale – Découper une tache complexe en plusieurs taches – Plus facile pour le lecteur à comprendre

27

Définition des fonctions • def crée une fonction et lui affecte un nom • return renvoie un résultat à l'appelant • Les arguments sont passés par référence (comme dans une affectation) • Les types des arguments et de la valeur de retour ne sont pas déclarés • Forme de base : def <nom>(arg1, arg2, ..., argN): return

• Exemple : def times(x,y): return x*y

28

Autre exemple : tronc commun de deux séquences def intersect(seq1, seq2): """Retourne une liste contenant tous les éléments de seq1 présents dans seq2.""" res = [] # démarre avec une liste vide for x in seq1: if x in seq2: res.append(x) return res

29

Règles de contexte pour les fonctions • Règle LGB : – Les références à un nom sont recherchées dans 3 contextes : local, global, built-in – Les affectations créent ou changent les noms locaux par défaut – Il est possible de forcer les affectations à opérer dans le contexte global avec la commande global

• Exemple X = 99 def func(Y): Z = X+Y #X est pris dans le contexte global, Z est local global X X=100 #X est affecté dans le contexte global return Z func(1)

30

Passage d'arguments aux fonctions • Les arguments sont passés par affectation – Les arguments sont affectés à des noms locaux – Une affectation à un nom d'argument n'affecte pas l'appelant – Changer un argument mutable peut affecter l'appelant def changer (x,y): x = 2 y[0] = 'hi'

#change seulement la valeur locale de x #change l'objet partagé mutable y

31

Arguments optionnels • Il est possible de définir des valeurs par défaut pour les arguments qui n'ont pas besoin d'être passés def func(a, b, c=10, d=100): print a, b, c, d >>> func(1,2) 1 2 10 100 >>> func(1,2,3,4) 1,2,3,4

• Il est possible d'utiliser le nom de l'argument (clé=valeur) >>> func(b=2,a=1,d=4) 1,2,10,4

32

Modules et packages

Modules • Un module est un ensemble de fonctions et de variables définies dans un fichier séparé • Un module est un espace de noms – Peut être utilisé pour organiser les noms de variables atom.position = atom.position - molecule.position

• Les éléments d'un module sont accédés avec la commande from ou import from module import function function() import module module.function()

•

Variable d'environnement PYTHONPATH – Chemin d'accès aux modules à importer % export PYTHONPATH=.:/ul/rpm/python

34

Pourquoi utiliser des modules? • Réutilisation – Pour les fonctions qui peuvent être utilisées par différents programmes

• Partition de l'espace des noms – Regroupe des données et des fonctions logiquement associées en évitant les collisions de noms

• Permet d'implémenter des données ou des services communs – Permet l'accès à une structure de données partagée par plusieurs sousprogrammes

35

Package • Permet de structurer l'espace des noms de modules Python par l'utilisation de noms de modules hiérarchisés. A.B désigne le sous-module B dans le package A. • Permet d'éviter les collisions de noms de modules entre bibliothèques multi-modules • Les modules d'un package sont regroupés dans un répertoire contenant un fichier __init__.py. Par exemple : Sound/ Top-level package __init__.py Initialize the sound package Formats/ Subpackage for file format conversions __init__.py wavread.py Effects/ Subpackage for sound effects __init__.py echo.py

36

Fonctions de base et modules utiles

Quelques fonctions de base – – – – – – –

str(obj) list(seq) tuple(seq) int(obj) float(x) chr(i) ord(c)

retourne une représentation de obj sous forme de chaîne convertit une séquence en liste convertit une séquence en tuple retourne une représentation entière de obj retourne une représentation flottante de obj retourne le caractère de code ASCII i retourne le code ASCII du caractère c

– min(seq) retourne le plus petit élément d'une séquence – max(seq) retourne le plus grand élément d'une séquence

38

Le module string • string permet de manipuler des chaînes – – – – – – – – –

atof() atoi() capitalize() capwords() replace() split() lower() upper() strip()

Convertit une chaîne en un flottant Convertit une chaîne en un entier Met en capitale le 1er caractère d'une chaîne Met en capitales chaque mot d'une chaîne Réalise une substitution sur une chaîne Découpe une chaîne Convertit une chaîne en minuscule Convertit une chaîne en majuscule Enlève les blancs en tête et en fin de chaîne

39

Module re • Pour manipulations plus avancées de chaînes à base d'expressions régulières. – – – – – – – –

. ^ $ * + | \w tomato

Match any character but newline Match the start of a string Match the end of a string "Any number of what just preceeded" "One or more of what just preceeded" "Either the thing before me or the thing after me Matches any alphanumeric character Matches the string "tomato"

40

Module os • Interface générique vers le système d'exploitation – – – – – – – –

getcwd() listdir() chown() chmod() rename() remove() mkdir() system()

Répertoire courant Liste des fichiers du répertoire Change le propriétaire d'un fichier Change les permissions d'un fichier Renomme un fichier Détruit un fichier Crée un nouveau répertoire Exécute une commande dans un sous-shell

41

Mesure de temps et profiling • Mesure de temps avec le module time – time.clock()

Seconds depuis le premier appel à clock()

• Module profile pour le profiling – profile.run(func(arg1, arg2)) ncalls 100 100 1

tottime 8.541 0.101 0.001

percall 0.086 0.001 0.001

cumtime 8.574 0.101 8.823

percall 0.086 0.001 8.823

filename makezer one_mul do_timi

42

Les classes

Qu'est ce qu'un objet? • Un élément logiciel qui contient des variables et des méthodes • Principes de la conception objet – Encapsulation: sépare le code en une interface publique, et une implémentation privée de cette interface

– Polymorphisme : permet à une méthode d’agir différemment en fonction du type d’objet qui est la cible de l’opération.

– Héritage : permet de créer des sous-classes qui contiennent des spécialisations de leurs parents

44

Classes et objets • Les classes définissent les objets – Les objets sont des instances de classes

__init__ est le constructeur par défaut class atom: def __init__(self,atno,x,y,z): self.atno = atno self.position = (x,y,z)

self indique l'objet lui-même, comme this en Java. 45

Exemple: Classe atom class atom: def __init__(self,atno,x,y,z): self.atno = atno self.position = (x,y,z) def symbol(self): # une méthode return Atno_to_Symbol[atno] def __repr__(self): # surcharge print return '%d %10.4f %10.4f %10.4f' % (self.atno, self.position[0], self.position[1],self.position[2]) >>> at = atom(6,0.0,1.0,2.0) >>> print at 6 0.0000 1.0000 2.0000 >>> at.symbol() 'C'

46

Les exceptions

Exceptions • Mécanisme de contrôle de déroulement de programme – Les erreurs qui se produisent pendant l'exécution d'un programme Python sont des exceptions qui remontent au sommet du processus si elles ne sont pas interceptées. – Il est possible de les intercepter par le mécanisme de try, except

• Forme de base : try : # corps except <nom1>: # exécuté si l'exception <nom1> est # levée dans le try except <nom2>: # exécuté si <nom2> est levée else: # optionnel # exécuté si pas d'exception

48

Instruction raise • Il est possible de lever ses propres exceptions avec la commande raise • Formes de base : raise raise raise raise raise

<nom1> <nom2>, classe,instance instance # re-raise de l'exception courante

49

Instruction assert • Permet de rajouter des contrôles pour le débogage d'un programme • Forme de base : assert , <données> # la partie données n’est pas obligatoire. # " assert" lève toujours l'exception AssertionError

• Raccourci pour : if __debug__ : # enlevé à la compilation avec l'option -O if not : raise AssertionError, <données>

50

Références • Pages Web – http://www.python.org Site Web Python (tutorial) – http://www.ibiblio.org/obp/thinkCSpy A Downey et J Elkner : "How to think like a computer scientist" et adaptation française par G. Swinnen

• Livres – Introduction à Python, par M Lutz & D Ascher, (traduction française) Editions O'Reilly, Paris, 2000, 385 p., ISBN 2-84177-089-3 – L'intro Python, par I Van Laningham, (traduction française), Editions CampusPress, Paris, 2000, 484 p., ISBN 2-7440-0946-6 – Python précis & concis (aide-mémoire), par M Lutz, (traduction française), Editions O'Reilly, Paris, 2000, 80 p., ISBN 2-84177-111-3

51