Transcript Document 7135132

Réalisé par :
El Khamlichi Mohsin
&
Heyvaert Xavier
Sommaire
Chap I : ……………………………………………………….... Introduction
Chap II : ……………………………………………………….. Les types intégrés
Chap III : ………………………………………………………. Les instructions
Chap IV : ………………………………………………………. Les Fonctions
Chap V : ……………………………………………………….. Les Modules
Chap VI : ………………………………………………………. Les exeptions
Chap VII : ……………………………………………………… Les classes
Chap VIII : ……………………………………………………... Les outils de Python
CHAPITRE I :
INTRODUCTION
1. Un petit historique…
En 1989, Guido Van Rossum commenca à travailler sur
Python qui n’était alors qu’un projet lui servant d’occupation
durant les vacances de Noël pendant lesquelles son bureau était
fermé.
Le but de Guido était d’inventer un successeur au langage
ABC, un langage d’aprentissage peu apprécié dans le milieu
académique.
Pour cela, il fit appel directement à des utilisateurs Unix
habitués au langage C. il voulu que Python soit facilement
utilisable dans d’autres langages et environnement
contrairement à ABC. Il y réussi globalement…
Le nom Python donné au langage provient d’une série
anglaise appelée « Monty Python Flying Circus »
2. Apercu de ses caractéristiques…
Langage Script
Tout comme Perl, Tcl et Rexx, Python fait partie des langages script
interpretés contairement à Java, au C/C++ qui sont des langages
compilés. Ce qui lui permet d’être plus rapide au develloppement, de
comporter moins de ligne (50% de moins). Par contre, Il est plus lent à
l’execution.
Portable
Python est portable entre les differentes variantes de Unix ainsi
que sur les OS propiétaires comme Mac OS, BEOs, MS-DOS et
les differentes versions de Windows
Gratuit
Python est placé sous Général Public License. Il est facilement
downloadable sur www.python.org
Extensible
Au-delà de la multitude de librairies et de modules déjà existente,
il est possible d’en dévellopper pour ses propres besoins.
Modulable
Python permet de séparer les programmes en modules qui peuvent
être réutilisés dans d'autres programmes en Python
Orienté Objet
Python est orienté-objet. Il supporte l'héritage multiple et la
surcharge des opérateurs.
Syntaxe aisée
La syntaxe de Python est très simple et, combinée à de nombreux
types de données évolués (comme les listes, dictionnaires,tuples...), ce
qui conduit à des programmes à la fois très compacts et très lisibles.
De plus, Python ne nécessite aucune déclaration de variable. Les
variables sont créées lors de leur première assignation.
Peu d’erreurs…
Tout comme Java ou Ada, Python porssède un systeme d’exception qui
facilite la gestion des erreurs.
Gestion des ressources
Python gère ses ressources (mémoire, descripteurs de fichiers...)
sans intervention du programmeur, par un mécanisme de comptage
de références
Case sensitive
Une instruction par ligne
3. Domaines d’application
• Scripts d’administration systemes
ex : Les programmes d'administration système spécifiques à la distribution
Red Hat Linux.
• Tous les dévelloppement lié à l’internet et en particulier au web (moteur de
recherche, navigateur…)
ex : moteurs de recherche yahoo et infoseek
• Accès aux bases de donnée (contextuelle)
• Réalisations d’interfaces graphiques utilisateurs.
• Utilisation pour la résolution de calculs scientifiques
ex : Python est notamment utilisé pour les fusée de la NASA
•…
CHAPITRE II :
LES TYPES INTEGRES
1. Les types numériques
• Tableau des différents types numériques
Les principaux opérateurs pour les types numériques
•
Tableau (dans un ordre de priorité croissant):
Quelques remarques…
• Lors de mélange de types numériques lors d’une opération, la réponse
sera du type de l’opérande la plus complexe.
•
En Python, vrai signifie n’importe quel nombre différent de
zéro ou un objet non vide; faux signifie zéro, none et un objet vide (un
ex.: “a or b” retourne le premier qui est vrai et si les 2 sont faux,
retourne celui de droite (donc b))
• la dernière expression affichée est affectée à la variable _ . Si on
affecte une valeur à cette variable, on crée une variable locale qui
masquera la globale.
• Si nous faisons c = d (où c et d sont 2 variables), c référencera le même
objet que d!!! Ainsi pour les listes, nous ferons une copie de cette
manière c = d[:] et pour les dictionnaires, nous utiliserons la méthode
copy, c = d.copy().
2. Les chaînes
• Déf. une chaîne: séquence de caractères non modifiable càd que si
nous avons une chaîne s=‘dalut’, on ne peut pas faire s[0]=‘s’ mais on
devra faire s=‘s’+s[1:] (une réassignation)
•
Déclaration:Une chaîne peut être déclarée avec un simple guillemet
ou un double. On utilise le triple double quotes (“”” … “””)
pour entrer une chaîne de caractère sur plusieurs lignes
• Rq: le type “char” en C est donc représenté par une
chaîne de taille 1
• On ne déclare donc pas la taille de la chaîne et pour connaître sa
longueur on peut utiliser len( ).
Tableau des opérations
OPERATION
INTERPRETATION
_________________________________________
__________________________________________
S1=’’
Chaîne vide
S2 = “l’oeuf”
Double guillemets
Bloc=”””….”””
Bloc à triple guillemets
S1+S2, S2*S3
Concaténation, répétition
S2[i],S2[i:j],len(S2)
Indice, extraction, longueur
“ Hello %s” % ‘World’
Formatage de chaîne
For x in S2, ‘o’ in S2
Itération, appartenance
Chaînes: concaténation-répétition
• Exemple de concaténation
>>> mot = ‘help’ + ‘a
>>>mot
’helpa’
# pour la répétition:
>>>mot*3
‘helpahelpahelpa’
• Autre manière de faire
>>> ‘help’ ‘a’
‘helpa’
• Rq. on ne peut pas concaténer une chaîne et un nombre avec ‘+’; on
doit d’abord utiliser atoi() pour convertir ce nbr en string et ensuite
concaténer
Chaînes: indiçage et extraction
•
Représentation d’une chaînes:
•
l’indiçage est le fait de sélectionner un élément de la chaîne.
Un indice positif indique que l’on commence à compter par la
gauche et un indice négatif que l’on compte depuis la droite
ex : s[3] donnera e et s[-5] donnera l
•
l’extraction est le fait de sélectionner une partie de la chaîne ainsi, s[2:5]
donnera ‘nex’ (le 5 n’est pas compris)
Suite:
•
Une valeur laissée vierge prend la valeur 0 à gauche et la taille de la chaîne à
droite (s[:5] => s[0:5] et s[3:] => s[3:len(s)]).
•
Un index qui est trop grand est remplacé par la taille de la chaîne, un index de
fin inférieur à l’indice de début retourne une chaîne vide ( s[1:100] donnera
‘onexemple.py’ et s[2:1] donnera ‘’).
•
•
•
•
•
•
Différents exemples:
>>> s[-2] # les deux derniers caractères
>>>’py’
>>> s[-0] # équivalent à s[0]
‘m’
>>>s[-100] # erreur
Remarques…
•
Les opérateurs de comparaison in et not in vérifient si une valeur apparaît (ou
non) dans une séquence.
•
Les opérateurs is et is not vérifient si deux objets sont réellement le même
objet; ceci se justifie seulement pour les objets modifiables comme les listes.
Tous les opérateurs de comparaison ont la même priorité, qui est plus faible
que celle de tous les opérateurs numériques.
•
Les objets de type séquence peuvent être comparés à d'autres objets
appartenant au même type de séquence. La comparaison
utilise l'ordre lexicographique : les deux premiers éléments
sont d'abord comparés, et s'ils diffèrent ceci détermine le
résultat de la comparaison; s'ils sont égaux, les deux éléments suivants sont
comparés, et ainsi de suite, jusqu'à ce que l'une des deux séquences soit
épuisée.
3. Les listes
• Ont une même signification qu’en C: une collection d’objets.
• Déclaration: une liste de valeurs (ou éléments) entre crochets séparés
par des virgules. Les éléments de la liste n’ont pas nécessairement le
même type. Voici une liste de 4 éléments:
>>>a =
[‘spam’, ‘eggs’,100,1234]
>>>a
[‘spam’,
‘eggs’,100,1234]
• Comme les indices des chaînes, les indices des listes commencent à 0,
et les listes peuvent étre découpées, concaténées…(rapidité!!!!)
Les listes sont modifiables,on peut donc changer les éléments
individuellement: remplacement, destruction,... (c’est l’utilité d’une
liste! Important lors des passages de paramètres des fonctions )
Tableau des opérations
Un exemple
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
>>> a = ['spam', 'eggs', 100, 1234]
>>> a
['spam', 'eggs', 100, 1234]
>>> a[0]
'spam'
>>> a[3]
1234
>>> a[-2]
100
>>> a[1:-1]
['eggs', 100]
>>> a[:2] + ['bacon', 2*2]
['spam', 'eggs', 'bacon', 4]
>>> 3*a[:3] + ['Boe!']
['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boe!']
Listes imbriquées (généralisées)
• L = ['abc', [(1,2), ([3], 4)], 5]; ainsi, L[1] donnera [(1,2),([3],4)] et
L[1][1] donnera ([3],4)
Les méthodes de l’objet liste
•
Voici toutes les méthodes des objets listes:
•
insert(i, x)
– Insère un élément à une position donnée. Le premier argument est l'indice
de l'élément avant lequel il faut insérer, donc a.insert(0, x) insère au début
de la liste, et a.insert(len(a), x) est équivalent à a.append(x).
append(x)
– Equivalent à a.insert(len(a), x).
index(x)
– Retourne l'indice dans la liste du premier élément dont
la valeur est x. Il y a erreur si cet élément n'existe pas.
remove(x)
– Enlève le premier élément de la liste dont la valeur est x. Il y a erreur si
cet élément n'existe pas.
•
•
•
Les méthodes: suite
•
•
•
sort()
– Trie les éléments à l'intérieur de la liste.
reverse()
– Renverse l'ordre des éléments à l'intérieur de la liste.
count(x)
– Renvoie le nombre de fois que x apparaît dans la liste.
Exemple pour les méthodes
•
Un exemple qui utilise toutes les méthodes des listes:
• >>> a = [66.6, 333, 333, 1, 1234.5]
• >>> print a.count(333), a.count(66.6),
a.count('x')
•2 1 0
• >>> a.insert(2, -1)
• >>> a.append(333)
• >>> a
• [66.6, 333, -1, 333, 1, 1234.5, 333]
• >>> a.index(333)
•1
• >>> a.remove(333)
• >>> a
• [66.6, -1, 333, 1, 1234.5, 333]
• >>> a.reverse()
• >>> a
• [333, 1234.5, 1, 333, -1, 66.6]
• >>> a.sort()
• >>> a
• [-1, 1, 66.6, 333, 333, 1234.5]
Une fonction intégrée
• "filter(fonction, sequence)" renvoit une liste (du même type, si
possible) contenant les seul éléments de la séquence pour lesquels
fonction(element) est vraie. Par exemple, pour
calculer quelques nombres premiers:
• >>> def f(x): returnx%2 != 0 and x%3 != 0
• ...
• >>> filter(f, range(2, 25))
• [5, 7, 11, 13, 17, 19, 23]
4. Les Tuples
•
Déf. Comme une liste, un tuple est une collection ordonnée d’objets; mais le
tuple n’est pas modifiable .
•
Déclaration: des valeurs (entre parenthèses) séparées par des virgules
>>>tuple=(0,1.4,’world’)
•
Pourquoi les tuples alors que nous avons les listes??
La non-possibilité de modifier les tuples assure une certaine
intégrité car nous pouvons être sûr qu’un tuple ne sera pas
modifié à travers une référence ailleurs dans le programme.
Tableau des opérations
Tuple unpacking
•
L'instruction t = 12345, 54321, 'salut!' est un exemple d' emballage en tuple
(tuple packing).
•
L'opération inverse est aussi possible, par ex.:
• >>> x, y, z = t
Ceci est appelé, fort judicieusement, déballage de tuple (tuple unpacking).
Le déballage d'un tuple nécessite que la liste des variables à gauche
ait un nombre d'éléments égal à la longueur du tuple
•
•
A l'occasion, l'opération correspondante sur les listes est utile:
list unpacking.
Ceci est possible en insérant la liste des variables entre des crochets carrés:
• >>> a = ['spam', 'oeufs', 100, 1234]
• >>> [a1, a2, a3, a4] = a
5. Les Dictionnaires
•
Déf. Un dictionnaire est un ensemble non ordonnés de couples clé:valeur avec
comme contrainte que les clés soient uniques (dans un même dictionnaire).
•
Déclaration: des couples clé:valeur séparés par des virgules et entre accolades
>>> dico = {`japon' :'japan', `chine' :'china'}
•
Un dictionnaire, à la différence des séquences qui sont indexées
par un intervalle numérique (cf.liste,chaîne,tuple),est indexé par
une clé qui peut être n’importe quel type non-modifiable
(les chaînes,les nbrs et les tuples s’ils ne contiennent que des éléments non
modifiables)
Tableau des opérations
Un exemple
• >>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> tel.keys()
['guido', 'irv', 'jack']
>>> tel.has_key('guido')
1
6. Les fichiers
• Tableau des opérations
Le module Pickle
• C'est un module étonnant qui peut prendre presque n'importe quel
objet Python, et le convertir en une représentation sous forme de
chaîne de caractères; ce processus s'appelle pickling. Reconstruire
l'objet à partir de sa représentation en chaîne de caractères s'appelle
unpickling. Entre pickling et unpickling, la chaîne de caractères
représentant l'objet a pu avoir été enregistrée dans un fichier, ou avoir
été envoyée à une machine éloignée via une connexion réseau.
• Si vous avez un objet x, et un objet fichier f ouvert en
écriture, la voie la plus simple de ``pickler'' l'objet prend
seulement une ligne de code:
• pickle.dump(x, f)
• Pour ``unpickler'' l'objet, si f est un objet fichier ouvert en lecture:
• x = pickle.load(f)
CHAPITRE III :
LES INSTRUCTIONS
1. Le test if
L’instruction IF peut comporter plusieurs tests conditionnels ’elif’ et
se termine par un bloc optionnel ‘else’. Le bloc qui sera executé, sera le
premier ou la condition sera vrai sinon se sera le bloc else sans condition
qui sera executé.
Le if s’écrit de la forme suivante:
if <test1>:
<instructions>
elif <test2>:
<instructions>
.....
else:
<instructions>
!!! ATTENTION à l’indentation !!!!
2. La Boucle While
Comme dans beaucoup d’autres langages, la boucle while
éxecute un bloc tant que la condition d’arrêt est vérifiée. La
particularité de ce while est qu’il peut y avoir un else
optionnel dont le bloc sera éxecuté lorsqu’on sort de la boucle
while <test> :
<instructions>
else :
<instructions>
Un exemple…
X=0
While x<6:
print « Dans le boucle while x vaut : » , x
x=x+1
else:
print « Dans le else x vaut : »,x
Utilisation du break, continue, pass
Ces trois instructions permettent à l’utilisateur d’avoir un plus
grand contôle de la boucle.
- Comme en C, l’instruction break permet de sortir de la boucle
instantannément et de passer à la suite. Elle annule le passage
dans la boucle else.
- L’istruction « continue » saute au début de la boucle la plus
imbriquée.
- « pass » ne fait rien du tout mais, comme on ne peut avoir une
expression qui n’est suivie de rien, « pass » peut être utilisé pour
combler ce vide.
Exemple :
y=0
While y<6:
if y==4:
break
else:
print « Dans la boucle while, y vaut : », y
y=y+1
else:
print « dans le else y vaut : », y
3. La Boucle For
La boucle for fonctionne sur les chaînes, les listes, les tuples et
d’autes objets issus de classes.
Elle commence par une ligne d’en-tête qui spécifie une cible
d’affectation, ainsi qu’un objet qui sera itéré :
for <cible> in <objet>:
<instructions>
else :
<instructions>
Ici encore, le else est mis en fin de boucle pour la même raison
que dans la boucle while vue précédemment.
Le for de Python fonctionne différemment que celui du C, il
affecte les objets de l’élément séquence à la cible un par un.
Exemple :
X={« ichi »: « un », « ni »: « deux », « san »: « trois », « chi »: « quatre »}
Print « Les clefs du dictionnaire sont : »,x.keys()
Print « Les Valeurs du dictionnaire sont : », x.values()
For i in x.keys():
print « La clef est : %s la valeur est :%s »%(i,x[i])
Le Range
L’instruction range permet de créer une liste croissante d’entiers
successifs compris dans une certaine borne dépendant du nombre de
paramètres de l’instruction :
1 paramètre : entiers compris entre 0 et le paramètre
2 paramètres : entier compris entre param1 et param2
3 paramètres : entier compris entre parm1 et param2 et de pas param3
Ex : for i in range(10,20,2):
print i
Ce qui donne: 10
12
14
16
18
CHAPITRE IV :
LES FONCTIONS
1. Définition
Outre les fonctions de bases de Python, il est possible d’en
définir de nouvelles grâce à l’instruction « def ». Il faudra bien sur
à nouveau veiller à l’indentation car en python, il n’y pas de
délimiteur pour définir les scopes.
format :
def nom_fct (arg1,arg2,…,argn):
<instruction>
return <valeur>
Lorsqu’on quitte la fonction valeur va directement être assignée
à la fonction appelante. Elle peut être de tous type puisque il n’y a
pas de déclaration de type sous python.
2. Les arguments…
La forme générale pour passer des arguments est
nom_fct(arg1,arg2,…,argn)
Il est possible de définir des paramètres par défaut pour un ou
plusieurs arguments. Ce qui crée une fonction qui pourra être
appelée avec moins d’arguments que ce qui a été défini.
Ex: def nom_fct (arg1=0, arg2=2,…,argn =« hello world »)
Les fonctions peuvent être appelées en utilisant des arguments
mots-clés de la forme « motclé=valeur »
Ex : def perroquet (voltage, etat=‘c\’est du solide’,action=‘voom’):
print « -- Ce perroquet ne feras pas », action,
print « -- si vou le mettez sous », voltage, « volts. »
print « -- Ca », etat, « ! »
pourrait être appelé de l’une des façons suivantes :
perroquet (1000)
perroquet (action = ‘vooooooom’, voltage = 1000000)
Toujours Les arguments…
Une fonction peut être appelée avec un nombre d’arguments arbitraire.
Il est possible de les envoyer sous deux formes différentes :
Soit par dictionnaire :
Définition : Def nom_fct (**arg):
pass
Appel : nom_fct (arg1=1, arg2=2)
Soit par tuple :
Définition : def nom_fct (*arg):
pass
Appel : nom_fct (arg1,arg2)
3. Les formes Lambda
Suite à la demande populaire, quelques caractéristiques trouvée
habituellement dans les langages de programmation fonctionnelle et
dans Lisp ont été ajouté à Python.
Avec le mot-clé « lambda », de petites fonctions anonymes peuvent
être crées. Elles sont limitées syntaxiquement à une expression
unique.
Ex : f=lambda x,y,z: x+y+z
f(2,3,4)
ce qui donne : 9
CHAPITRE V :
LES MODULES
1. Définition
• Un module est un fichier contenant des définitions et des instructions
Python. Le nom du fichier est le nom du module auquel est ajouté le
suffixe .py.
• Avantages: - permet de relancer un même programme sans tout
réécrire (en créant éventuellement un script).
- d’utiliser dans plusieurs programmes une même
fonction sans la réécrire dans chaque
programme.
• Chaque module a sa propre table de symboles privée, qui est utilisée
comme table de symbole globale par toutes les fonctions définies dans
le module. Ainsi, l'auteur d'un module peut utiliser des variables
globales dans le module sans s'inquiéter des désaccords accidentels
avec les variables globales d'un utilisateur.
2. Les instructions
L'instruction "import <module>" importe tout le module <module>, en
exécutant le total du module. Le module est exécuté en premier avant de
pouvoir travailler sur les objets.Pour utiliser ensuite le module, nous écrirons
“<module>.nom”.
L'instruction "from" s'utilise avec "import" de la manière "from
<module> import <nom>". Là seulement l'objet <nom> du module
<module> sera importé, le code restant du module sera aussi exécuté,
mais les objets ne seront pas mémorisés et les éventuelles variables
ne seront pas affectées. Si <nom> est remplacé par *,
on obtient alors une copie de tous les noms définis a la racine du
module.Pour utiliser ensuite nom, nous écrirons juste “<nom>”.
•
Rq. La grande différence entre "import <module>" et "from <module> import
*" est que les noms ne sont pas mémorisés sur le même niveau. Le premier
sera mémorisé sous le nom du module, tandis qu'avec "from" la valeur est
directement visible dans la racine (car dans la table des symboles globaux;
c’est donc là que nous la modifions et pas dans le module!!!! Voir exemple).
•
La fonction "reload" est en fait un fonction se trouvant dans __builtin__
(comme print), cette fonction s'exécute par "reload(<nom>)" et a
pour but de recharger le module <nom>. Le code du module sera
de nouveau exécuté depuis le début et les variables qui auraient
pu changer seront remises à leurs valeurs d'origine. Refaire un “import” ne
servirait à rien car le module est déjà chargé.
•
La fonction intégrée dir() est employée pour découvrir les noms qu'un module
définit. Elle renvoie une liste triée de chaînes de caractères.
B
B
B
G
G
G
L
copie
« module appelant »
L
L
(2)Import <module>
(1)from …import
Avec (2), il faut refaire un reload pour récupérer la valeur initiale.
Avec (1), il suffit donc de refaire « from…import » pour récupérer
la valeur qui n’a pas été modifiée dans sa table ( du module appelé)
Légende: L= local, G= global, B= built-in.
Scope : Le modèle LGB
Exemple
• Illustration de la remarque
#contenu du module mon_module
num=12
#fin du module mon_module (.py)
#on est dans l’invite interactive
>>>from mon_module import num
>>> print num
12
>>>num=24
>>>print num
24
>>>from mon_module import num #équivalent du reload
>>>print num
12
# ne fonctionne pas avec les types modifiables
CHAPITRE VI :
LES EXCEPTIONS
1. Définition
Comme en Ada ou en Java, il existe un mécanisme de contrôle des erreurs
d’exécution , les exeptions.Le traitement d’une exception permet de passer
par dessus un bout de programme.
Dans Python , il existe deux types d’exception :
- celles présentent dans la table des exceptions de Python
- celles créées par l’utilisateur
2. Comment gérer ces exceptions ???
Il est possible d’écrire des programmes qui prennent en charges des
exceptions spécifiques.
Ex : try:
print 1.0 / 0
except ZeroDivisionError:
print '*** n'a pas d'inverse ***
else : pass
Lorsque l’instruction « try » est rencontrée, on execute d’abord la
« clause d’essai ».
Si une exception se produit, le reste de la clause try est ignorée.
Dans le cas contraire, on ignore la clause d’exception.
Si une exception se produit qui ne correspond pas à l’exception
dans la clause except, elle est renvoyée aux instructions « try »
extérieures. S’il n’y a pas de prise en charge, Python affichera un
message d’erreur.
L’instruction « else » est une clause par défaut qui doit suivre toutes les
clauses d’exeptions. Elle permet d’executer la suite du programme dans le cas
où aucune exception ne serait survenue.
Quand une exception survient, elle peut avoir une valeur associée, appelé
argument de l’exeption.
Ex : try :
spam()
except NameError, x:
print ‘nom’, x,’non défini’
ce qui affichera : nom spam non défini.
3. Comment déclencher une exception??
L’instruction « raise » permet à l’utilisateur de déclencher une
exception.
Par exemple :
def myfunc() :
raise EOFError
try:
myfunc()
except EOFError :
print « erreur d’i/O !! »
Else :
print « Et voilà »
4. Créer ma propre exception… C’est possible ???
Oui !!!!
Il suffit d’affecter une chaîne de caractères à une variable…
Ex : MonErreur = « Une erreur »
def mafunc() :
raise MonErreur, « survenue »
try :
mafunc()
except MonErreur, value :
print « mon erreur est %s! »%value
else:
pass
5. Actions de nettoyage…
L’instruction « try » contient une autre clause exceptionnelle
qui permet de définir les actions de nettoyage qui doivent être
éxecutées impérativement.
Ex : def divise(a,b):
return a/b
for x in range(1.0,5.0,1.0):
try:
result = divise(x,x-4)
print « Le résultat est %f »% result
finally :
print « cette ligne est exécutée quoi qu’il se passe »
rem : La clause de finalisation est éxecutée qu’une exception
est executée ou non..
CHAPITRE VII :
LES CLASSES
1. introduction
Python offre la possibilité de programmer en Orienté objet.
Le mécanisme de classe en Python est un mélange des mécanismes
de classes de C++ et de Modula-3.
Ex : Comme en c++, tous les membres d’une classe sont publics, et
toutes les fonctions membres sont virtuelleS.Il n’y a pas de
constructeur ni de destructeur particulier.
Comme en Modula-3, il n’y a pas de raccourcis pour faire
référence aux membres d’un objet à partir de ses méthodes.
2. La synthaxe…
La forme la plus simple de définition de classe ressemble à ceci :
class Nomclasse:
<instruction1>
…
<instructionN>
Dans la pratique, les instructions à l’intérieur de la définition de classe
seront souvent des définitions de fonctions, mais d’autres
instructions sont acceptées.
L’objet classe permet deux types d’opération : La réferenciation des attributs
et l’instanciation.
La réference d’attributs : Nomclasse.i où i est un attribut de Nomclasse est
une réferences d’attribut valide.
L’instanciation(création d’une instance (objet) Nomclasse):
x=Nomclasse() affecte la nouvelle instance à la variable x
3. A l’intérieur de la classe…
On trouve deux types d’attributs :
-
données (idem que les données membre en C)
-
Les méthodes (idem que fonction membre en C)
1)
Les données
Les données n’ont pas besoin d’être déclarée; Comme les
variable locale, elles apparaissent lorsqu’on leur affecte une
valeur la première fois.
ex : class MaClasse :
def f(x):
print « hello World »
i=123456
x= MaClasse()
x.compteur = 1 #creation de l’attribut compteur
2) Les méthodes
Une méthode est appelée comme en C++ :
x.f()
Vous avez surement remarqué que la fonction f définie dans MaClasse a
été appelée sans paramètre alors que la définition en contenait un. Ca devrait
normalement déclencher une exception. Mais il n’en est rien car la
particularité des méthodes est que l’objet est passé comme premier argument
de la fonction. Le plus souvent par convention appelé « self » pour amélioré
la lisibilité du programme .
L’appel x.f() est donc équivalent à MaClasse.f(x).
Il n’est pas nécessaire que la définition de la méthode soit
comprise dans la définition de la classe.
Ex : def f1 (self,x,y):
return min(x,x+y)
class C:
f=f1
Méthodes prédefinies…
Python contient une liste de méthodes dites spéciales :
En particulier, la méthode __init__(self)…
Lorsqu’une class définit la méthode spéciale __init__(), l’instantation de la
classe appelle automatiquement cette méthode.
Il s’agit en fait de ce qu’on appel en C/C++ un constructeur.
Bien sûr, la méthode __init__() peut prendre autant de paramètre qu’on le
vaut, pour une flexibilité accrue…
Ex : class Complexe:
def __init__(self, partiereelle, partieimaginaire):
self.r = partiereelle
self.i = partieimaginaire
x = Complexe(3.0,-4.5)
x.r, x.i donne: (3.0, -4.5)
4. L’héritage
La syntaxe pour définir une classe dérive est la suivante :
Class Nomclassedérivée (NomClassedeBase):
<instruction1>
…
<instructionN>
Rem : A la place de d’un nom de classe de base, une expression est
acceptée. Ce qui est utile lorsque le définition de la classe de base se
trouve dans un autre module..
Ex : class NomClasseDerivee(nommod.NomClasseDeBase):
L’exécution d’une définition de classe dérivée se déroule
comme une classe de base. Quand l’objet classe est construit, la
classe de base est mémorisée.C’est ce qui permet de trouver
facilement un attribut. Lorsqu’un attributs est réferencé, il est
recherché dans la classe dérivée s’il ne s’y trouve pas on le
recherchera dans la classe de base.
5. L’héritage multiple
Python supporte également l’héritage multiple.
Une définition de classe avec plusieurs classes de base ressemble à :
Class NomClasseDerivee (Base1,Base2,..,BaseN)
<instruction1>
…
<instructionN>
Lorsqu’on référence un attribut, la recherche s’effectue en
profondeur càd de gauche à droite? Donc si un attribut n’est pas
trouvé dans ClasseDerivee, on le cherchera d’abord dans base1, puis
dans base2, et ainsi de suite jusqu’à ce qu’on le trouve…
Rem : Il faut faire attention aux conflits accidentelles!!
Par exemple, si on crée une classe dérivée de deux autres
classes dérivées de la même classe de base…risque de problèmes!!!!
CHAPITRE VIII :
LES OUTILS DE PYTHON
1.Quelques librairies
2. Exemple d’utilisation de GUI
•
•
•
file: hello
#!/usr/local/bin/python
from Tkinter import *
•
•
•
•
•
class Hello(Frame):
def __init__(self, parent=None):
Frame.__init__(self, parent)
self.pack()
self.make_widgets()
(Graphic User Interface)
# get widget classes
# container subclass
# do superclass init
•
•
•
•
•
def make_widgets(self):
widget = Button(self,
text='Hello world',
command = self.onPress)
widget.pack(side=LEFT)
•
•
def onPress(self):
print "Hi."
•
if __name__ == '__main__':
•
% hello
•
Hello().mainloop()