les instructions

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 <test1>:
<instructions1>
elif <test2>:
<instructions2>
else:
<instructions3>
• 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 <test1>:
<instructions1>
else:
<instructions2>
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 <test>:
<instructions>
if <test2>: break
if <test3>: continue
<autres instructions>
else:
<plus d'instructions>
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 <item> in <séquence>:
<instructions>
else:
# optionnel
<autres instructions> # 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):
<instructions>
return <valeur>
• 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 :
<instructions>
# corps
except <nom1>:
<instructions1> # exécuté si l'exception <nom1> est
# levée dans le try
except <nom2>:
<instructions2> # exécuté si <nom2> est levée
else:
# optionnel
<autres instructions> # 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>,<data>
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 <test>, <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 <test>:
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