Professional Documents
Culture Documents
Le menu
Introduction au langage Python
Installation de Python et des modules complémentaires
Les instructions du langage
Le traitement des exceptions
Les fonctions en Python
La portée des objets
Les modules
La manipulation des fichiers
La programmation objet en Python
Les expressions rationnelles
Programme externe, et thread
Les interfaces utilisateurs graphiques (GUI)
Quelques règles d'écriture
The Zen of Python
Introduction au langage Python
Historique 1/2
Le bytecode qui est une forme intermédiaire est portable sur toute
machine muni d’une machine virtuelle Python
Le code source est destiné à être lu par un être humain donc doit
être écrit de manière à faciliter la lecture.
Les parties de code non triviales doivent être commentés, en
Python un commentaire commence par un# et ce qui suit jusqu’à
la fin de la ligne est ignoré par le compilateur
#----------------------------------------------
# un commentaire
#----------------------------------------------
5 * 4 # un autre commentaire
Code source : Les expressions booléennes
1 > 5 # False
9 <= 15 < 20 # True
Opérations arithmétiques
20 + 3 # 23
20 – 3 # 17
20 * 3 # 60
20 ** 3 # 8000
20 / 3 # 6 (division entière)
20 % 3 # 2 (modulo)
2 ** 50 # 1125899906842624L
2 ** 80L # 1208925819614629174706176L
2 ** long(80) # 1208925819614629174706176L
Code source : le type entier 2/2
06 + 02 # 8
oct(6+2) # ’010’ (dix en octal)
0x6 + 0x4 # 10
hex(6+4) # '0xa’ (en hexadécimal)
int('10110’,2) # 22
int('10110’,3) # 93
Code source : le type flottant
22.0 / 3 # 7.333333333333333
22.0 // 3 # 7.0 (division entière forcée)
1j
(5+3j) + (6-8j) # (11-5j)
(5+3j).real # 5.0
(5.3j).imag # 3.0
Code source : les données et les variables
x = 2 # x reçoit la valeur 2
x = x + 1 # 3 (incrémentation)
x = x - 1 # 2 (décrémentation)
Code source : autres formes d’affectation
x = 2 # la forme de base
x += 2 # idem à x = x + 2 si x existe déjà
x = y = 5 # cibles multiples de droite à gauche
x, y = 3.5, 8.7 # affectation par position (tuple)
x, y = [3.5, 8.7] # affectation par position (liste)
x, y = y, x # échange des valeurs de x et y
Code source : les entrées
c1 = "L'information de la chaîne"
c2 = 'avec des "apostrophes" !!'
c3 = """Usage :
-h : aide
-q : quitter"""
• La répétition de chaînes
c4 = "help! "
c5 = c4 * 3 # 'help ! help ! help ! '
Code source : les chaînes de caractères, les méthodes 1/3
Convertir en minuscule
"MINUSCULE".lower() # 'minuscule'
• Convertir en majuscules
'majuscule'.upper() # 'MAJUSCULE'
• L'inversion de la casse
'fRANK'.swapcase() # 'Frank'
Code source : les chaînes de caractères, les méthodes 3/3
L'inversion de la casse
'fRANK'.swapcase() # 'Frank'
• La suppression de caractères en début et fin
" Trop d'espaces ".strip(' ') # "Trop d'espace"
c1 = a b c d e f g
0 1 2 3 4 5 6 7
pi = 3.141592655897931
print "%4.2f" % (pi) # 3.14
print "%.4e" % (pi) # 3.1415e+000
print "%g" % (pi) # 3.14159
Code source : les chaînes de caractères, les principaux formats
• Un tuple s'utilise comme une liste, mais son parcours est plus
rapide
• Généralement on utilise le tuple pour définir des constantes
• Un tuple n'est pas modifiable
Code source : les dictionnaires
dico['un'] = 'one'
dico['deux'] = 'two'
dico['trois'] = 'three'
print dico # {'un':'one', 'trois':'three', 'deux':'two'}
print dico['un'] # 'one'
del dico['un']
print dico # {'trois':'three', 'deux':'two'}
dico['quatre'] = 'four'
print dico # {'quatre': 'four', 'trois': 'three', 'deux': 'two'}
Code source : les dictionnaires, les méthodes
x = set ('abcd')
y = set('bdx')
• Les opérations :
i = 1
message = "mon message"
a
1, 2, 3
b
b.append(4)
a
1, 2, 3, 4
b
Code source : le problème des références 3/3
Il faut utiliser le module copy pour obtenir une vraie copie d'un
objet
import copy
a = [1, 2, 3]
b = a # une référence sur a
b.append(4)
print a # [1, 2, 3, 4]
c = copy.copy(a) # une copie de l'objet a
c.append(5)
print a # [1, 2, 3, 4]
print b # [1, 2, 3, 4]
print c # [1, 2, 3, 4, 5]
Les instructions de branchement
Code source : if … [elif] … [else]
if x < 0 :
print "x est négatif"
elif x % 2 :
print "x est positif et pair"
else :
print "x n'est ni négatif ni pair"
# pour un booléen
if x : # 'if s is True' ou 'if x == True'
Code source : while … [else]
Répéter du code
cpt = 0
while x > 0 :
x = x // 2 # division avec troncature
cpt += 1
print "l'approximation de log2(x) est %d" % (cpt)
for c in 'Hello' :
print c, # H e l l o
for x in xrange(5) :
print x, # 0 1 2 3 4
Code source : Les listes compréhension 1/2
• Forme 1 :
• Forme 2 :
• Forme 3 :
result = [x+y for x in uneSequence for y in uneAutre]
# donne le même résultat que :
result = []
for x in uneSequence :
for y in uneAutre :
result.append(x+y)
Code source : break
for x in xrange(-3, 4) :
try :
print '%.3f' % (sin(x)/x)
except :
print 1.0, # gère l'exception en 0
Code source : gestion des exceptions, try … finally …
f = open(unFichier, "r")
try :
traitementFichier(f)
finally:
f.close()
Code source : gestion des exceptions, raise
def nomDeLaFontion(<paramétres>) :
<blocInstructions>
def carre(x) :
return x*x
def maFonction(x, y, z) :
pass
def somme(*args) :
resultat = 0
for x in args : resultat += x
return resultat
print somme(5) # 5
print somme(5, 10, 15) # 30
def somme(a, b, c ) :
return a+b+c
x = [5, 10, 15]
print somme(*x) # 30
Code source : fonctions, paramètres passage d'un dictionnaire
def unDic(**kargs) :
return kargs
print unDic(a=5, b=58) # affiche : {'a':5, 'b':58}
nombres = {'un':1, 'deux':2, 'trois':3}
print unDic(**nombres) # affiche : {'un': 1, 'trois': 3, 'deux':
2}
La portée des objets
Code source : La portée des objets
• Les noms des objets sont créés lors de leur première affectation.
• Leur portée dépend où ils sont déclarés
• On distingue la portée globale correspondant au module
__main__ qui maintient un dictionnaire des objets globaux, on
peut y accéder grâce à l'instruction globals() qui fournit les
couples variable : valeur.
• La portée locale, ce sont les objets internes aux fonctions et aux
classes. L'instruction locals() fournit le couples variable :
valeur.
• Les objets globaux ne sont pas modifiables dans les portées
locales
• La portée interne correspond aux noms prédéfinis de Python.
• La recherche s'effectue dans l'ordre suivant :
Local (fonction) les noms définis dans le def d'une fonction
Globale (module) les noms affectés à la base d'un module et
les noms déclarés global dans une fonction
Interne (Python) les noms prédéfinis comme open, close, len
…
Code source : exemples de portées
# x et maFonc sont affectés dans le module : globaux
def maFonc(y) : # y et z sont affectés dans maFonc : locaux
z = x + y
return z
x = 99
print maFonc(1) # affiche : 100
x = 99
print maFonc(1) # affiche : 6
x = 99
print maFonc(1) # affiche : 105
Les Modules
Code source : Les modules
import wx
if __main__ == '__main__' :
print "Ce programme est lancé par lui-même"
else :
print "Je suis importé par un autre module"
Manipulation des fichiers
Code source : Manipulation des fichiers
f1 = open("monFichier", 'w')
s1 = 'foo'
f1.write(s) # on écrit la chaîne s1 dans f1
l1 = ["x", "y", "z"]
f1.writlines(l1) # on écrit les chaînes de l1 dans f1
f1 = open("monFichier", 'r')
s = f1.read() # lit tous le fichier
s = f1.read(n) # lit au plus n octets
s = f1.readline() # lit la ligne suivante
s = f1.readlines() # lit toutes les lignes sous forme d'une
liste
# lecture et affichage des lignes d'un fichier
for s in f1 :
print s
class CMaClasse(object) :
'''Documentation de CMaClasse'''
INFO = (5,)
class CMaClasse(object) :
'''Documentation de CMaClasse'''
INFO = (5,)
x = 45
def affiche(self) : # déclaration de la méthode affiche
self.y = 12 # un nouvel attribut de l'instance
print CMaClasse.x, # l'attribut de la classe
print self.y
o1 = CMaClasse()
o1.affiche() # 45 12 (affiche reçoit o1 comme valeur pour le paramètre self)
la programmation OO : méthodes spéciales
class CMaClasse(object) :
def __init__(self, n) :
self.x = n # initialisation de l'attribut d'instance x
class CVecteur(object) :
def __init__(self, x, y) :
self.x = x
self.y = y
def __add__(self, autre) : # addition vectorielle
return CVecteur(self.x + autre.x, self.y + autre.y)
def __str__(self) : # affichage d'un vecteur
return "vecteur(%f, %f)" % (self.x, self.y)
v1 = CVecteur(2.2, 3.3)
v2 = CVecteur(4.5, 5.8)
object
D D
B C B C
class D(object) :
def methode(self) :
x = A()
print "D.methode"
x.methode()
# Affiche :
class B(D) :
# A.methode
def methode(self) :
# B.methode
print "B.methode"
# D.methode
D.methode(self)
# C.methode
# D.methode
class C(D) :
def methode(self) :
print "C.methode"
D.methode(self)
class A(B, C) :
def methode(self) :
print "A.methode"
B.methode(self)
C.methode(self)
la programmation OO : problème d'héritage 3/3
class D(object) :
def methode(self) :
x = A()
print "D.methode"
x.methode()
# Affiche :
class B(D) :
# A.methode
def methode(self) :
# B.methode
print "B.methode"
# C.methode
super(B,self).methode()
# D.methode
class C(D) :
def methode(self) :
print "C.methode"
super(C,self).methode()
class A(B, C) :
def methode(self) :
print "A.methode"
super(A,self).methode()
la programmation OO : objets privés 1/2
Ceci est valable aussi bien pour les attributs d'une classe que pour
les méthodes.
la programmation OO : objets privés 2/2
class CMaClasse(object) :
def __init__(self) : # méthode publique
self.x = None # objet (attribut) publique
self._y = "" # objet (attribut) protégé par
convention
self.__z = 10 # objet (attribut) privé
def __uneMethode(self, a): # méthode privée
self.x = a # autorisé
self._y += "%s" %(a) # autorisé
self.__z += 2 # autorisé
def __str__(self):
return "CMaClasse x=%s, _y='%s', __z=%s" %
(self.x, self._y, self.__z)
o1 = CMaClasse()
o1.x = 4 # l'attribut x de l'instance prend la
valeur 4
print o1 # CMaClasse x=4, _y='', __z=10
o1._y = "ma chaîne"
Les expressions rationnelles
Les expressions rationnelles : définition 1/3
import re
r = re.compile(r'(\w+) (\w+)')
s = "Bruno Normand, consultant"
m = r.match(s)
m.group() # 'Bruno Normand'
m.group(1) # 'Bruno'
m.group(2) # 'Normand'
m.group(1,2) # ('Bruno', 'Normand')
r = re.compile(r'(?P<firstName>\w+) (?P<lastName>\w+)')
m = r.match(s)
m.group('firstName') # 'Bruno'
m.group('lastName') # 'Normand'
email = "tony@tiremove_thisger.net"
m = re.search("remove_this", email)
email[:m.start()] + email[m.end():] # tony@tiger.net
Programme externe, et thread
Programme externe : module subprocess
import wx
import time
...
class CPanelShell(wx.Panel):
...
def startShell(self):
if self.__process is not None :
self.__process = wx.Process(self)
self.__shellPid = wx.execute("/bin/bash", wx.EXEC_ASYNC,
self.__process)
time.sleep(0.001)
def execCommande(self, cmd):
self.__process.GetOutputStream().write(str(cmd) + '\n')
def __inIdle(self, evt):
if self.__process is not None :
stream = self.__process.GetInputStream()
if stream.CanRead() :
self.__appendMessage(stream.read())
stream = self.__process.GetErrorStream()
if stream.CanRead() :
Les threads 1/2
Python offre la possibilité de gérer des thread au travers du module
thread
Un thread est en fait une fonction qui s'exécute "en parallèle" de
votre programme principal.
On se défini une fonction ou une méthode d'une classe qui sera
exécutée par le thread en utilisant la fonction suivante
thread.start_new_thread(fonction,(p1,…))
Vous pouvez aussi utiliser le module threading qui est une
surcouche au module thread et offrant des fonctionnalités
permettant de créer des threads timer, lancer un thread, gérer des
sémaphores, des locks …
Pour lancer un thread on doit le créer avec la classe Thread :
import threading target=None, name=None,
Thread(groupe=None, args=(), kwargs=None,
def maFonction(p1,…) :
verbose=None)
...
monThread = threading.Thread(target=maFonction, args=(p1,...)) # création
du thread
monThread.start() # lancement du thread
monThread.join() # attendre la fin du thread
Les threads 2/2
Un thread s'exécute "en parallèle" cela implique non seulement
qu'on doit lui laisser du temps pour qu'il s'exécute, mais qu'il doit
aussi laisser du temps aux autres threads et au programme
principal pour qu'ils s'exécutent.
import threading
import time
def threadTest():
global i
while not stop:
i = i**2+1
print i
time.sleep(0.01)
stop = False
i = 0
thread=threading.Thread(target=threadTest)
thread.start()
stop = True
thread.join()
print i
Les interfaces utilisateurs graphiques (GUI)
GUI
Par défaut lors de l'installation de Python un GUI est installé :
Tkinter, et Tix (22,41%)
Tix ajoute la gestion des Combobox, Notebook, Metter, Balloon
Auxquels on peut rajouter Pmw, car l'interface Tkinter est faible.
Il existe d'autres GUI :
wxPython (33.33%): interface de wx, écrit en C++, avec Python
(celui que j'utilise) http://wxpython.org/download.php
pyGtk (14.94%): interface de GTK, écrit en C, avec Python
http://www.pygtk.org/downloads.html
pyQt (14,94%): interface de QT, écrit en C++, avec Python
http://www.riverbankcomputing.co.uk/software/pyqt/download
Les autres interfaces sont plus l'utilisation de Python dans d'autres
langages
PythonForDelphi (1,72%)interface avec Delphi
Jython interface avec Java
IronPython interface avec .Net
Les pourcentages sont ceux du site Developpez.com sur l'utilisation des GUI en Python
RAD
BoaConstructor (wxPython)
http://boa-constructor.sourceforge.net/Download.html
PythonCard (wxPython)
http://sourceforge.net/projects/pythoncard/files/
Visualwx (wxPython) wxGlade (wxPython)
http://wxglade.sourceforge.net/
WxDesigner (wxPython) payant
http://www.wxdesigner-software.de/download.html
1 appel_d_une_fonction(parametre_1, parametre_2,
2 parametre_3, parametre_4):
3 ...
1 # oui
2 un_long_calcul = variable + \
3 taux * 100
4
5 # non
6 un_long_calcul = variable \
7 + taux * 100
règles d'écritures : Forme du code
La définition d'une classe commence par une majuscule
(personnellement je la précède de la lettre C en majuscule).
Dans les classes cachez les méthodes et les objets que vous ne
voulez pas exporter en les précédents d'un double souligné.