Formation Python

Le menu

Introduction au langage PythonInstallation de Python et des modules complémentairesLes instructions du langageLe traitement des exceptionsLes fonctions en PythonLa portée des objetsLes modulesLa manipulation des fichiersLa programmation objet en PythonLes expressions rationnellesProgramme externe, et threadLes interfaces utilisateurs graphiques (GUI) Quelques règles d'écritureThe Zen of Python

Introduction au langage Python

Historique 1/2

L’auteur Guido van Rossum, employé au CWI1989 Ecriture de la première version du langage durant ses vacances des fêtes de Noël. 1991 sortie de la version 0.9.01995 il est employé au CNRI1999 le CNRI et DARPA lance le projet Computer Programming for Everybody (CP4E), Python est utilisé pour enseigner la programmationTravail ensuite à BeOpen2000 création de l’ équipe PythonLab2001 création de la Python Sofware Foundation (PSF)Décembre 2008 version 3.0Guido van Rossum est nommé « Dictateur bienveillant à vie »Depuis 2005 il travail pour Google

Historique 2/2

Les langages ayant influencés Python

Techniques de production des programmes

La compilation : on effectue la traduction d’un code source en un langage objet puis on assemble les différents objets pour obtenir un exécutable sur une machine au travers d’un éditeur de lien. Inconvénient : il faut refaire le processus à chaque modification. Avantage : c’est rapide à l’exécutionL’interprétation : Chaque ligne source est analysée et exécutée.Avantage : Pas de code objet , pas d’édition de lienInconvénient : Plus lent car on doit interpréter à chaque foisTechnique mixe : On traduit le langage source en un code intermédiaire et on exécute de code intermédiaire (bytecode)Inconvénient : c’est toujours de l’interprétéAvantage : c’est plus rapide que l’interprétation du source, c’est portable au niveau du bytecode

La technique de production de Python

Utilise la technique mixte : Interprétation du bytecode compilé

Le bytecode qui est une forme intermédiaire est portable sur toute machine muni d’une machine virtuelle Python

Code source Compilateur ByteCode Interpréteur Résultat

Installation de Python et des modules complémentaires

Installation de Python 1/2

Python peut s'installer sur des machines Unix, Windows et MacPour chaque système d'exploitation on trouve des paquetages permettant l'installation.Sous Windows ou a des paquetages .msi ou .exe et on trouve des versions pour des OS 32bits ou 64bits. Pour effectuer l'installation vous devez avoir les droits d'administration sur la machine.Le site officiel est python.org deux versions sont disponibles la branche 2.7.x et la branche 3.2.x, au 01/02/2012 nous avons :La version 2.7.2 du 11/06/2011 La version 3.2.2 su 04/09/2011Lors de l'installation vous pouvez sélectionner le répertoire où sera installé Python, pour ma part je l'installe dans le répertoire /GNULa documentation (sous Windows) se trouve dans le répertoire /Doc de l'installation, on trouve un fichier avec l'extension .chmVous prouvez trouver cette documentation sous python.org/doc

Installation de Python 2/2

Une fois installé, il faut penser à ajouter le chemin d'accès de l'installation dans la variable d'environnement PATH pour que python soit accessible.Sous Windows vous sélectionnez les propriétés de la machine est allez dans Paramètres systèmes avancés, variable d'environnement et vous modifiez ou créez la variable PathCeci vous permet dans une fenêtre de commande de lancer l'application Python et de rentrer directement dans l'interpréteur Python.

Installation de Python, autres paquetages

En plus de l'installation de base de Python il est possible d'installer des paquetages spécifiques pour bénéficier de nouveaux modules.epydoc pour l'extraction de la documentation des sourceswin32com pour utiliser COM/DCOM (spécifique Windows)py2exe pour générer une application sous la forme d'un exécutable… L'installation des paquetages supplémentaires s'effectuent soit selon le standard Python qui consiste à disposer d'un fichier setup.py dans le répertoire où se trouve le paquetage à installer soit sous la forme d'un exécutable à lancer.Pour l'installation standard on lance la commande suivante en étant positionné dans le répertoire où se trouve le fichier setup.py :python setup.py install

Les instructions du langage

Code source : les commentaires

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

On distingue deux possibilités True et False. Attention la première lettre est en majuscule.Avec les opérateurs de comparaison : ==, !=, <, <=, >, >=

• Les opérateur logiques et de comparaison ne peuvent prendre que deux valeurs : False et True

1 > 5 # False9 <= 15 < 20 # True

• Opérateurs logiques : and, or et not

(9 == 9) or (10> 100) # True dès le premier membre(6 > 9) and (4 == 4) # False dès le premier membre

Code source : le type entier 1/2

Opérations arithmétiques

• Les entiers longs, limités par la taille de la RAM

20 + 3 # 2320 – 3 # 1720 * 3 # 6020 ** 3 # 800020 / 3 # 6 (division entière)20 % 3 # 2 (modulo)

2 ** 50 # 1125899906842624L2 ** 80L # 1208925819614629174706176L2 ** long(80) # 1208925819614629174706176L

Code source : le type entier 2/2

Opérations sur les bases

06 + 02 # 8oct(6+2) # ’010’ (dix en octal)0x6 + 0x4 # 10hex(6+4) # '0xa’ (en hexadécimal)int('10110’,2) # 22int('10110’,3) # 93

Code source : le type flottant

Pour un flottant on peut utiliser la notation point décimal ou exponentielle1.3685e93.59871e-10

• Supporte les mêmes opérations que les entiers à l’exception de :

22.0 / 3 # 7.33333333333333322.0 // 3 # 7.0 (division entière forcée)

• Les opérations mathématique usuelles (au travers du module math) :cos(pi/4) # 0.7071067811865476

Code source : le type complexe

On écrit les complexes en notation cartésienne, ils sont constitués de deux flottants : la partie réelle et la partie imaginaire, la partie imaginaire étant suffixée par la lettre j

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

Variable : C’est le nom donné à une valeurDu point de vue informatique c’est la référence à une adresse mémoirePar convention les noms des variables sont écrites en minuscule, elles commencent par une lettre ou le caractère souligné, et éventuellement par des lettres, chiffres ou caractère soulignéElles doivent évidemment être différents des mots réservés de Python

Code source : les mots réservés de Python

Code source : l’affectation

Pour affecter une valeur à une variable on utilise le signe =Le membre de gauche reçoit le membre de droite

x = 2 # x reçoit la valeur 2

• La valeur d’une variable peut évoluée dans le temps • la valeur précédente est perdue

x = x + 1 # 3 (incrémentation)x = x - 1 # 2 (décrémentation)

Code source : autres formes d’affectation

On peut rencontrer d’autres formes comme :

x = 2 # la forme de basex += 2 # idem à x = x + 2 si x existe déjàx = y = 5 # cibles multiples de droite à gauchex, 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

Pour effectuer une entrée au clavier on peut utiliser input()Elle effectue un typage dynamiqueEt permet d’afficher une invite :

x = input("Entrez une valeur entière : ")

• Ou utiliser raw_input() pour forcer la saisie en mode texte :

x = raw_input("Entrez une valeur flottante : ")f = float(x) # conversion en flottantf = float(raw_input("Entrez une valeur flottante : "))

Code source : et les sorties

Pour effectuer une sortie on utilise l'instruction print :

x = 5y = 3print x # 5print "somme: ", x + y # 8print "différence : ", x – y # 2print "produit : ", x * y # 15print "produit : %d" % (x * y) # 15

• Le séparateur virgule (,) permet d'éviter de retourner à la ligne

Code source : les séquences

Une séquence est un conteneur ordonné d'éléments indicé par un entierEn Python il existe trois types de séquences prédéfinisles chaînes (normales, brutes ou Unicodes)les listesles tuples

Code source : les chaînes de caractères différentes notations

c1 = "L'information de la chaîne"c2 = 'avec des "apostrophes" !!'c3 = """Usage : -h : aide -q : quitter"""

r1 = r'une chaîne en mode raw'

u1 = u"une chaîne unicode"

Code source : les chaînes de caractères, les opérations

La longueur d'une chaîne

c1 = "abcdef"len(c1) # 6

• Concaténation de deux chaînes

c2 = "ghijkl"c3 = c1 + c2 # abcdefghijkl

• 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

Le découpage d'une chaîne

c1 = "une ligne à découper"c1.split(' ') # ['une', 'ligne', 'à', 'découper']

• la concaténation de deux chaînes

'-'.join(['c'est', 'à', 'dire']) # "c'est-à-dire"

• la recherche de position dans une chaîne

'abracadabra'.find('bra') # 1 (premier indice à 0) • le nombre d'occurence dans une chaîne

'abracadabra'.count('bra') # 2

Code source : les chaînes de caractères, les méthodes 2/3

Convertir en minuscule

"MINUSCULE".lower() # 'minuscule'

• Convertir en majuscules

'majuscule'.upper() # 'MAJUSCULE'

• La première lettre en majuscule

'bruno'.capitalize() # 'Bruno' • Toutes les premières lettres en majuscule

'ceci est un titre'.title() # 'Ceci Est Un Titre' • 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"

• Le remplacement d'une chaîne par une autre

'abracadabra'.replace('a', 'o') # 'obrocodobro'

Code source : les chaînes de caractères, l'indiçage

La position dans une chaîne s'effectue en donnant entre crochet la position en commençant à zéro

c1 = 'abcdefg'c1[0] # 'a' c1[3] # 'd' c1[-1] # 'g' (si négatif on commence par la fin)

• On peut effectuer l'extraction d'une partie de la chaîne

c1[1:4] # 'bcd'c1[3:] # 'defg'c1[:3] # 'abc'

• Une chaîne de caractères n'est pas modifiable

a b c d e f g

0 1 2 3 4 5 6 7

c1 =

Code source : les chaînes de caractères, le formatage

Le formatage d'une chaîne ressemble au format du langage C

x = 25"%d en base 10 : %d" % (x, x) # '25 en base 10 : 25' "%d en base 8 : %o" % (x, x) # '25 en base 8 : 31' "%d en base 16 : %x" % (x, x) # '25 en base 8 : 19'

pi = 3.141592655897931print "%4.2f" % (pi) # 3.14print "%.4e" % (pi) # 3.1415e+000print "%g" % (pi) # 3.14159

Code source : les chaînes de caractères, les principaux formats

%d : un entier signé%u : un entier non-signé%o : un octal (non-signé)%x : un hexadécimal (non-signé)%s : une chaîne de caractères%f : un flottant%e : un flottant, sous forme exponentiel%g : un flottant, sous forme 'optimal' suivant sa longueur

Il est possible de contrôler l'affichage en spécifiant le nombre de caractères désiré, "%3d" affiche un entier sous la forme de 3 caractères, "%03d" même chose mais en complétant devant par des zéro, "%7.2f" un flottant sur 7 caractères avec 2 chiffres après le point décimal.

Code source : les chaînes de caractères, brutes et Unicode

En Python il existe d'autres méthodes pour coder des chaînes de caractères :

Les chaîne brutes, ce sont des chaînes précédées de la lettre r ou R, les caractères d'échappement comme \ ou \n ne sont pas interprétés.

Les chaînes en Unicode sont précédées de u ou U

Les chaînes en Unicode brut sont précédées de ur

Code source : les listes

Une liste est une collection hétérogène d'éléments ordonnés et modifiables séparés par une virgule et entourée de crochets

couleurs = ['rouge', 'vert', 'bleu', 'jaune' ]print couleurs # ['rouge', 'vert', 'bleu', 'jaune'] print couleurs[1] # 'vert' couleur[1] = 7print couleurs # ['rouge', 7, 'bleu', 'jaune'])

list1 = [1, 2, 5.0]list2 = ['a', 'b', 'c']list3 = [list1, list2] # une liste de listeprint list3 # [[1, 2, 5.0], ['a', 'b', 'c']]

Code source : les listes, méthodes et accès

L'indiçage d'une liste s'effectue de la même manière qu'une chaîne de caractères

nombres = [5, 1, 9 ,30, 18]nombres.sort() # [1, 5, 9 , 18, 30] nombres.append(10) # [1, 5, 9 , 18, 30, 10] nombres.reverse() # [10, 30, 18, 9, 5, 1] nombres.index(18) # 2 nombres.remove(30) # [10, 18, 9, 5, 1]

nombres[1:3] # [18, 9]nombres[:2] # [10, 18]nombres[:] # [10, 18, 9, 5, 1]nombres[-1] # 1

Code source : les listes, initialisation

chose = [] # une liste videtrucMuch = [2]*4 # [2, 2, 2, 2]

range(5) # crée la liste [0, 1, 2, 3 , 4] range(5,8) # crée la liste [5, 6, 7] range(2, 11, 2) # crée la liste [2, 4, 6, 8, 10]

chose = range(7) # [0, 1, 2, 3 , 4, 5, 6]

print 3 in chose # True

Code source : les listes, le découpage "slicing"

bois = ['chêne', 'acacia', 'peuplier']bois[2:2] = ['platane'] # insertion en 3iéme positionbois[4:4] = ['bouleau'] # insertion en 5iéme position print bois # ['chêne', 'acacia', 'platane', 'peuplier', 'bouleau']bois[2:4] = [] # effacement par liste vide print bois # ['chêne', 'acacia', 'bouleau']bois[1:3] = ['sapin'] print bois # ['chêne', 'sapin']bois[1:] = ['châtaigné', 'pommier', 'poirier']print bois # ['chêne', 'châtaigné', 'pommier', poirier']

Pour insérer ou supprimer des éléments, le membre de gauche doit obligatoirement indiquer une tranche,Le membre de droite doit aussi être une liste

Code source : les tuples

unTuple = ('chêne', 15, ["plaine", 1200])

Un tuple est une collection hétérogène d'éléments ordonnés et immuable séparés par une virgule et entourée de parenthèses

• 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= {} # dictionnaire vide

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'}

Un dictionnaire est un couple clef : valeur entouré d'accolades

Code source : les dictionnaires, les méthodes

dico.keys() # ['quatre', 'trois', 'deux']dico.values() # ['four', 'three', 'two']dico.iterkeys() # itérateur sur les clefsdico.itervalues() # itérateur sur les valeurs associéesdico.iteritems() # itérateur clef, valeur [('quatre','four'), ('trois','three'), ('deux','two')]dico.has_key('un') # Falsedico.has_key('quatre') # True

Les méthodes suivantes sont spécifiques aux dictionnaires :

• Les dictionnaires ne sont pas ordonnés• On ne peut donc pas les indicer

Code source : les dictionnaires, les itérateurs

for key in dico.iterkeys() : print key # 'quatre' 'trois' 'deux'

for value in dico.itervalues() : print value # 'four' 'three' 'two'

for keyValue in dico.iteritems() print keyValue # ('quatre','four'), ('trois','three'), ('deux','two')

Les itérateurs sont des objets spécifiques permettant de parcourir un dictionnaire :

Code source : les ensembles

x = set ('abcd')y = set('bdx')

Les ensembles sont gérés par la fonction set() :

'c' in x # True : appartenancex – y # set(['a', 'c']) : différencex | y # set(['a', 'c', 'b', 'd', 'x']) : unionx & y # set(['b', 'd']) : intersection

• Les opérations :

Le problème de référence

Code source : le problème des références 1/3

i = 1message = "mon message"

L'opération d'affectation est plus complexe qu'il n'y parait

• L'affectation réalise en fait plusieurs opérations :1.crée et mémorise un nom de variable dans l'espace de noms

courant (une adresse)2.lui attribut dynamiquement un type bien déterminé3.crée et mémorise une valeur (le membre de droite)4.établi un lien entre le nom de la variable et l'adresse de la

valeur correspondante

Code source : le problème des références 2/3

a = [1, 2, 3]b = a # une référence sur ab.append(4)print a # [1, 2, 3, 4]

Si un objet modifiable est affecté, tout changement sur un objet modifiera l'autre

a

b1, 2, 3

b.append(4)

a

b1, 2, 3, 4

Code source : le problème des références 3/3

import copya = [1, 2, 3]b = a # une référence sur ab.append(4)print a # [1, 2, 3, 4]c = copy.copy(a) # une copie de l'objet ac.append(5)print a # [1, 2, 3, 4]print b # [1, 2, 3, 4]print c # [1, 2, 3, 4, 5]

Il faut utiliser le module copy pour obtenir une vraie copie d'un objet

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éenif x : # 'if s is True' ou 'if x == True'

Contrôler une alternative

Code source : while … [else]

cpt = 0while x > 0 :

x = x // 2 # division avec troncaturecpt += 1

print "l'approximation de log2(x) est %d" % (cpt)

n = input('Entrez un entier [1..10] : ')while (n < 1) or (n > 10) :

n = input('Entrez un entier [1..10] S.V.P. : ')

Répéter du code

Code source : for… [else]

for c in 'Hello' :print c, # H e l l o

for x in [1, 'H', 5.269] :print x, # 1 H 5.269

for x in xrange(5) :print x, # 0 1 2 3 4

Parcourir une séquence

Code source : Les listes compréhension 1/2

result = [x+1 for x in uneSequence]# donne le même résultat que :result = []for x in uneSequence :

result.append(x+1)

Une liste compréhension est une expression permettant de générer de manière très compacte une listeElle revient à une boucle for qui construirait la même liste en utilisant la méthode append()

• Forme 1 :

Code source : Les listes compréhension 2/2

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)

result = [x+1 for x in uneSequence if x > 12]# donne le même résultat que :result = []for x in uneSequence :

if x > 12 : result.append(x+1)

• Forme 2 :

• Forme 3 :

Code source : break

for x in xrange(1, 11) :if x == 5 :

breakprint x,

print "\nBoucle for interrompue pour x = %d" % (x)# affiche# 1 2 3 4# Boucle for interrompue pour x = 5

• Le break permet d'interrompre immédiatement le traitement d'une boucle for ou d'un while

Code source : continue

for x in xrange(1, 11) :if x == 5 :

continueprint x,

print "\nLa boucle for a sauté la valeur 5"# affiche# 1 2 3 4 6 7 8 9 10# Boucle for a sauté la valeur 5

• Le continue permet de reprendre immédiatement à la ligne de l'en-tête d'une boucle for ou d'un while

Le traitement des exceptions en Python

Code source : gestion des exceptions, try … except … [else]

from math import sin

for x in xrange(-3, 4) :try :

print '%.3f' % (sin(x)/x) except :

print 1.0, # gère l'exception en 0

• Permet de traiter des erreurs levées par Python en cours d'exécution

Code source : gestion des exceptions, try … finally …

f = open(unFichier, "r")

try :traitementFichier(f)

finally:f.close()

• Permet d'effectuer un traitement qu'il y ait eu ou non la levée d'une exception.

• La clause finally met en place un gestionnaire de nettoyage• Il ne peut y avoir qu'une clause finally et pas de clause else

Code source : gestion des exceptions, raise

if not 0 <= x <= 1 :raise ValueError, "x n'est pas dans l'interval [0 .. 1]"

• L'instruction raise permet de lever volontairement une exception

Les fonctions en Python

Code source : fonctions, déclaration

def nomDeLaFontion(<paramétres>) :<blocInstructions>

• Une fonction est un groupe d'instructions regroupé sous un nom et s'exécutant à la demande

• le <blocInstruction> est obligatoire, s'il ne fait rien on doit utiliser l'instruction pass

def carre(x) :return x*x

print carre(4) # 16 : appel de la fonction carre

Code source : fonctions, passage des paramètres

def maFonction(x, y, z) :pass

maFonction(3, 'e', 5.6) # x=3, y='e', z=5.6

• Chaque argument dans la définition d'une fonction correspond, dans l'ordre, à un paramètre de l'appel

Code source : fonctions, paramètres par défaut

def maFonction(x, y, z=0.0) :pass

maFonction(3, 'e', 5.6) # x=3, y='e', z=5.6maFonction(3, 'e') # x=3, y='e', z=0.0

• Dans une fonction il est possible d'avoir des paramètres par défaut

maFonction(3, y='e', z=5.6) # x=3, y='e', z=5.6maFonction(3, y='e') # x=3, y='e', z=0.0

• Les appels peuvent se faire par paramètre nommé

Code source : fonctions, paramètres passage par tuple

def somme(*args) :resultat = 0for x in args : resultat += xreturn resultat

print somme(5) # 5print 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 fonctionGlobale (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 : globauxdef maFonc(y) : # y et z sont affectés dans maFonc : locaux

z = x + yreturn z

x = 99print maFonc(1) # affiche : 100

def maFonc(y) : # x, y et z sont affectés dans maFonc: locauxx = 5 # nouvel x local, masque le x globalz = x + yreturn z

x = 99print maFonc(1) # affiche : 6

def maFonc(y) : # y et z sont affectés dans maFonc: locauxglobal x # permet de modifier xx += 5z = x + yreturn z

x = 99print maFonc(1) # affiche : 105

Les Modules

Code source : Les modules

• Un module est un fichier indépendant qui permet de créer des bibliothèques de fonctions ou de classes

• Le fait de créer des modules permet :La réutilisation du code la réalisation de services et de données partagésd'effectuer la partition de l'espace de noms la documentation et les tests peuvent être intégrés aux

modules.

Code source : Les modules, import

• Il existe deux méthodes pour effectuer l'importation d'un module dans un programme

import <nomDeModule> qui effectue l'importation de la totalité des objets du module

import wx

from <nomDeModule> import obj1, … qui effectue l'importation des objets spécifiés du module

from math import pi, sin, cos

Code source : Fichier ou modules ?

• N'importe quel fichier python est considéré comme un module• Un module peut être importé et lancé par lui même

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

• Le type fichier est connu du langage Python• Par défaut les fichiers sont ouverts en mode texte• Il faut préciser l'attribut 'b' pour traiter le fichier en mode binaire

f1 = open("monFichier", 'r') # ouverture en lecturef2 = open("monFichier", 'w') # ouverture en écrituref3 = open("monFichier", 'a') # ouverture en ajoutf4 = open("monFichier", 'br') # ouverture en lecture binaire

f1.close() # fermeture du fichier

Code source : Manipulation des fichiers, écriture

• Les méthodes d'écritures

f1 = open("monFichier", 'w')s1 = 'foo'f1.write(s) # on écrit la chaîne s1 dans f1l1 = ["x", "y", "z"]f1.writlines(l1) # on écrit les chaînes de l1 dans f1

print >> f1, "ajout de la chaîne" # écrit dans f1 en mode ajout

f1.close() # fermeture du fichier

Code source : Manipulation des fichiers, lecture

• Les méthodes de lecture

f1 = open("monFichier", 'r')s = f1.read() # lit tous le fichiers = f1.read(n) # lit au plus n octetss = f1.readline() # lit la ligne suivantes = f1.readlines() # lit toutes les lignes sous forme d'une liste# lecture et affichage des lignes d'un fichierfor s in f1 :

print s

f1.close() # fermeture du fichier

La programmation objet en Python

la programmation Orientée Objet

Python est non seulement un langage procédurale, mais aussi un langage objet.En fait, pour Python, tout est objet

En Python on défini un objet au travers du mot réservé classUn objet class s'appel de la même manière qu'une fonction. L'objet créé, appelé instance, sait à quelle classe il appartientUne classe possède des attributs, des données et des fonctions, ces dernières s'appellent des méthodesPython définit des méthodes spécialesUne classe peut hériter d'une au plusieurs autres classes

la programmation OO : class

En Python il existe une classe de base nommée object.Toute classe créée, si elle n'hérite pas d'autres classes devrait au moins hériter de la classe object.On dit que object est l'ancêtre de tous les autres types.Une classe est constituée d'un en-tête et d'un corpsLa classe comporte un nom, la liste des classes dont elle hérite et éventuellement d'une docstring associéeLe corps est obligatoirement indenté

class CMaClasse(object) :'''Documentation de CMaClasse'''INFO = (5,)

• CMaClasse est le nom de la classe, par convention une classe débute par une majuscule, pour ma part je débute toujours mes classes par un C majuscule.

• INFO est un attribut de la classe CMaClasse, il est local à CMaClasse

la programmation OO : instanciation

Pour créer un objet on appel le nom de sa classe

o1 = CMaClasse() # o1 est un objet de CMaClasseprint dir(o1) # affiche les attributs de l'objet o1print o1.INFO # affiche (5,)o1.INFO = 10 # modification de l'attribut d'instance !!!print CMaClasse.INFO # affiche (5,), l'attribut de classe n'est pas changéo1.x = 55 # création d'un nouvel attribut d'instance

o2 = CMaClasse() # o2 est un nouvel objet de CMaClasse print o2.INFO # affiche (5,)print o2.x # AttributeError: type object 'CMaClasse' has no attribute 'x'

print o1 # <__main__.CMaClasse object at 0x025A3BF0>print o2 # <__main__.CMaClasse object at 0x025A35F0>

la programmation OO : espace de noms

Les espaces de noms son implémentés par des dictionnaires pour les modules, les classes et les instances

print CMaClasse.__dict__ # {'INFO': (5,), '__dict__': <attribute '__dict__' of 'CMaClasse' objects>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'CMaClasse' objects>, '__doc__': 'La documentation de CMaClasse'}

print dir(o2) # ['INFO', '__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__','__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']

• En premier on affiche le dictionnaire lié à la classe CMaClasse• Puis les attributs liés à une instance de CMaClasse

la programmation OO : Les méthodes

Une méthode se déclare comme une fonction dans le corps d'une classe.Elle dispose toujours d'un premier paramètre obligatoire qui représente l'objet sur lequel la méthode sera appliquée.Par convention ce premier paramètre s'appel self. Le nom est arbitraire, vous pouvez lui en donner un autre

class CMaClasse(object) :'''Documentation de CMaClasse'''INFO = (5,)x = 45def affiche(self) : # déclaration de la méthode affiche

self.y = 12 # un nouvel attribut de l'instanceprint CMaClasse.x, # l'attribut de la classeprint 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

Un certain nombre de méthodes ont des noms prédéfinis, elles sont précédées et suivis de deux caractères de soulignementElles permettent :d'initialiser un objet instancierde modifier son affichagede surcharger des opérateurs…

la programmation OO : __init__

Cette méthode est appelée lors de l'instanciation d'un objet, elle permet d'effectuer certaines opérations d'initialisation nécessaires à l'objet

class CMaClasse(object) :def __init__(self, n) :

self.x = n # initialisation de l'attribut d'instance x

o1 = CMaClasse(10) # paramètre obligatoire affecté au paramètre nprint o1.x # 10

la programmation OO : surcharge

La surcharge permet à un opérateur de posséder un sens différents suivant le type des opérandes.Quand on effectue :

x = 1 + 3s = "azerty" + "qwerty"

• on utilise la surcharge de l'opérateur + qui effectue une addition entière pour le premier cas et une concaténation de chaîne de caractères pour le deuxième cas

• Python dispose de méthodes de surcharges pour : tous les types (__call__, __str__, __cmp__, …) tous les nombres (__add__, __mul__, __div__, …) les séquences (__len__, __iter__, __delitem__…)

la programmation OO : Exemple de surcharge

On veut gérer des vecteurs et effectuer de opérations.

class CVecteur(object) :def __init__(self, x, y) :

self.x = xself.y = y

def __add__(self, autre) : # addition vectoriellereturn CVecteur(self.x + autre.x, self.y + autre.y)

def __str__(self) : # affichage d'un vecteurreturn "vecteur(%f, %f)" % (self.x, self.y)

v1 = CVecteur(2.2, 3.3)v2 = CVecteur(4.5, 5.8)

print v1 + v2 # affiche : vecteur(6.700000, 9.100000)

la programmation OO : Héritage et polymorphisme

L'héritage est un mécanisme permettant de se servir d'une ou plusieurs classes existantes pour créer une nouvelle classe. Cette nouvelle classe disposant de fonctionnalités supplémentaires ou différentes.

Le polymorphisme est la capacité pour une méthode portant le même nom et appartenant à des classes différentes héritées d'effectuer un travail différent. C'est ce que l'on appel la surcharge.

la programmation OO : problème d'héritage 1/3

Exemple, si A hérite de B et C, dans cet ordre, et que B et C héritent de D.La résolution classique recherche dans l'ordre A, B, D, C, D.D est recherché avant C donc si une méthode de D est redéfinie dans C elle ne sera jamais vue. C'est l'héritage en diamant

A

CB

D

A

CB

D

object

Méthode classique Nouvelle Méthode

la programmation OO : problème d'héritage 2/3

class D(object) :def methode(self) :

print "D.methode"

class B(D) :def methode(self) :

print "B.methode"

D.methode(self)

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)

x = A()x.methode()# Affiche : # A.methode# B.methode# D.methode# C.methode# D.methode

la programmation OO : problème d'héritage 3/3

class D(object) :def methode(self) :

print "D.methode"

class B(D) :def methode(self) :

print "B.methode"

super(B,self).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()

x = A()x.methode()# Affiche : # A.methode# B.methode# C.methode# D.methode

la programmation OO : objets privés 1/2

En python il n'existe pas la même notion qu'en C++ ou Java sur les attributs privés, publiques, protégés

Les objets d'une classe qui commence par un simple sous-ligné sont, par convention, des objets protégés, mais aucun contrôle n'est effectué par le langage, ils sont en fait aussi publiques que des objets sans sous-ligné.

Pour être privé, un objet doit commencé par deux sous-lignés, à l'exception des objets qui commencent et se terminent par deux sous-lignés

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) publiqueself._y = "" # objet (attribut) protégé par

conventionself.__z = 10 # objet (attribut) privé

def __uneMethode(self, a): # méthode privéeself.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 4print o1 # CMaClasse x=4, _y='', __z=10o1._y = "ma chaîne"print o1 # CMaClasse x=4, _y='ma chaîne', __z=10 print o1.__z # AttributeError: 'CMaClasse' object has no attribute '__z' o1.__z = 15 # nouvel attribut __z de o1print o1 # CMaClasse x=4, _y'=ma chaîne', __z=10 print o1.__z # 15 o1.__uneMethode(15) # AttributeError: 'CMaClasse' object has no attribute '__uneMethode'

Les expressions rationnelles

Les expressions rationnelles : définition 1/3

Une expression rationnelle (ou expression régulière qui est un terme impropre) est une chaîne représentant un motif recherché.Python offre le module re pour manipuler les expressions rationnelles.Ici on effectuera un survol des possibilités des expressions rationnelles, pour plus d'informations sur leur utilisations vous pouvez vous référer au livre de Jeffrey Friedl (ed O'Reilly) Maîtrise des expressions régulières.

Un motif doit respecter une syntaxe particulièreLes caractères alphabétiques et numériques correspondent à eux-mêmesCertains caractères de ponctuation ont une signification particulière, ils sont désactivés s'ils sont précédés d'un anti-slash (\)Certains caractères alphabétiques ont une signification particulière s'ils sont précédés d'un anti-slash (\)Le caractère anti-slash est représenté par deux anti-slashes (\\)

Les expressions rationnelles : définition 2/3

Les expressions rationnelles : définition 3/3

Les expressions rationnelles : module re 1/2

En Python les expressions rationnelles sont traitées par le module rePour faciliter l'écriture des expressions rationnelles on les déclare dans des chaînes brutes r' ', r" " ou r""" """Une expression rationnelle doit être compilée avant d'être utilisée ; re.compile, cette fonction retourne un objet permettant de manipuler l'expression rationnelle.• soit r = re.compile(motif[, flags]) l'expression rationnelle compilée :

r.findall(s[,pos[,endpos]]) : renvoie une liste de chaînes représentant chacune des sous chaînes de s, r ne doit pas contenir de groupe

r.match(s[,pos[,endpos]]) : renvoie un objet correspondance si une sous-chaîne de s correspond au motif

r.search(s[,pos[,endpos]]) : renvoie un objet correspondance pour la sous-chaîne la plus à gauche de s

r.split(s[,maxsplit]) : renvoie une liste des division de s par r r.sub(repl,s[,count]) : renvoie une copie de s où les

correspondances avec r sont remplacées par repl r.subn(repl,s[,count]) :renvoie une paire (nouvelleChaîne,n)

Les expressions rationnelles : module re 2/2

L'objet de correspondance (c) retourné par match, search disposent des attributs :c.pos : l'indice de s de début de la recherchec.endpos : l'indice de s de la fin de la recherchec.lastgroup : le nom du dernier groupe de correspondancec.lastindex : l'indice du dernier groupe qui a corresponduc.re : l'expression rationnelle r utiliséec.string : la chaîne s passéec.start (groupid=0), c.end (groupid=0), c.span (groupid=0) : méthodes retournant les indices des bornes dans c.string de la sous-chaîne capturée par groupid, si c.string[i:j], c.start retourne i, c.end retourne j et c.span retourne (i,j)c.expand(template) : équivalent à sub() c.group([groupid[,*groupids]]) : renvoie la sous-chaîne capturée par groupid, ou un tuple si plusieurs groupesc.groups([default=None]) : renvoie un tuple de sous-chaînes des différents groupes. None au contenu de default si le groupe n'a pas participé à la reconnaissance.c.groupdict ([default=None]) : renvoie un dictionnaire des groupes nommés (la clef) de sous-chaînes trouvées.

Les expressions rationnelles : exemples

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

Lancer un programme externe s'effectue avec Popen du module subprocess.

from subprocess import Popen, PIPE

cmd = ["diff", repNew, repOld]fd = open(TMP_FILE, "w")pipe = Popen(cmd, stdout=fd, stderr=PIPE, universal_newlines=True)print pipe.communicate()[1] # récupérer la sortie de stderrfd.close()

Programme externe : module wx

Lancer un programme externe dans un GUI est très simple en utilisant les interfaces fournis par wx.

import wximport 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() : self.__appendMessage(stream.read()) def __del__(self): if self.__process is not None : self.__process.Detach() self.__process.CloseOutput() self.__process = None

Les threads 1/2

Python offre la possibilité de gérer des thread au travers du module threadUn 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 : Thread(groupe=None, target=None, name=None, args=(), kwargs=None, verbose=None)

import threadingdef maFonction(p1,…) :...monThread = threading.Thread(target=maFonction, args=(p1,...)) # création du threadmonThread.start() # lancement du threadmonThread.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, BalloonAuxquels 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.phppyGtk (14.94%): interface de GTK, écrit en C, avec Python http://www.pygtk.org/downloads.htmlpyQt (14,94%): interface de QT, écrit en C++, avec Python http://www.riverbankcomputing.co.uk/software/pyqt/downloadLes autres interfaces sont plus l'utilisation de Python dans d'autres langagesPythonForDelphi (1,72%)interface avec DelphiJython interface avec JavaIronPython 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

GuiBuilder (Tkinter) http://sourceforge.net/projects/spectcl/files/ nécessite Pmw http://sourceforge.net/projects/pmw/files/

IDE

PyScripter éditeur/débogueur version 32/64bitsPyDev plugin pour EclipseIDLE éditeur fourni avec PythonSciTE éditeurKomodo Edit éditeur écrit en JavaLeo éditeur écrit en Python et TkinterSPE éditeur puissant écrit en Python et wxPython par le développeur de Blender animation graphique 2D/3D

Quelques règles d'écritures

règles d'écritures : Forme du code

Indentation : Utilisez 4 espaces pour l’indentationTabulation : Préférez les espaces. Espaces/Tabulation ne pas les mélanger dans un même projetLimitez vos lignes à 80 caractèresQuand c’est possible découpez vos lignes après un séparateur plutôt que l’antislash \

1 appel_d_une_fonction(parametre_1, parametre_2,2 parametre_3, parametre_4):3 ...

1 # oui2 un_long_calcul = variable + \3 taux * 1004 5 # non6 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).

Les méthodes et fonctions commencent par une minuscule et la première lettre de chaque mot commence par une 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é.

Dans les classes pensez à définir la méthode __str__ qui retourne une image des objets de la classe, utile quand on effectue un print d'un objet qui par défaut affiche instance de la classe Cx à l'adresse yyyyy

règles d'écritures : documentation

Les modules doivent disposer d'une entête et d'une docstring associée.Pour chaque fonction, classe et méthode utilisez les docstring pour donner des explications sur le rôle des ces différents éléments.Pour chaque fonction et méthode de classe formater la docstring pour qu'elle soit interprétable par epydoc, ceci vous permettra de générer la documentation de vos projets de manière simple (voir exemple page suivante)

règles d'écritures : exemple

# -*- coding: ISO-8859-15 -*-#-------------------------------------------------------------------------------# Name: AnalAda.py# Author: Bruno NORMAND# RCS-ID: $Id$# Copyright: (c) 2011 Bruno NORMAND# Licence: GPL#-------------------------------------------------------------------------------'''Ce module se charge d'effectuer l'analyse de fichiers ADA pour en déterminer les fonctions et procédures contenues dans les paquetages.'''class CAdaCapture(): '''Cette classe se charge de mémoriser les informations capturées'''

def __init__(self, typeAda, index, rule, ignoreCase=False): '''Cette méthode initialise les objets de la classe. @param typeAda: Le nom du type donné @type typeAda: I{B{unicode}} @param index: Le numéro de la ligne dans le fichier où a été trouvée la correspondance @type index: I{B{int}} @param rule: L'objet retourné de la recherche @type rule: I{B{_sre.SRE_Pattern}} @param ignoreCase: Indicateur à I{B{True}} si l'on ignore la case lors des comparaisons. @type ignoreCase: I{B{bool}}'''...

The Zen of Python

PEP 20 The Zen of Python 1/2

PEP 20 The Zen of Python 2/2

FIN