Formation python
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

Formation python

on

  • 1,120 views

Formation python

Formation python

Statistics

Views

Total Views
1,120
Views on SlideShare
1,120
Embed Views
0

Actions

Likes
1
Downloads
63
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Formation python Presentation Transcript

  • 1. Le menuIntroduction 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
  • 2. Introduction au langage Python
  • 3. Historique 2/2
  • 4. Techniques de production des programmesLa compilation : on effectue la traduction d’un code source en unlangage objet puis on assemble les différents objets pour obtenirun 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 codeintermé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’estportable au niveau du bytecode
  • 5. La technique de production de PythonUtilise la technique mixte : Interprétation du bytecode compiléLe bytecode qui est une forme intermédiaire est portable sur toutemachine muni d’une machine virtuelle Python Code source Compilateur ByteCode Interpréteur Résultat
  • 6. Installation de Python et des modules complémentaires
  • 7. Installation de Python 1/2Python peut sinstaller sur des machines Unix, Windows et MacPour chaque système dexploitation on trouve des paquetagespermettant linstallation.Sous Windows ou a des paquetages .msi ou .exe et on trouve desversions pour des OS 32bits ou 64bits. Pour effectuer linstallationvous devez avoir les droits dadministration sur la machine.Le site officiel est python.org deux versions sont disponibles labranche 2.7.x et la branche 3.2.x, au 01/02/2012 nous avons :La version 2.7.2 du 11/06/2011La version 3.2.2 su 04/09/2011Lors de linstallation vous pouvez sélectionner le répertoire où serainstallé Python, pour ma part je linstalle dans le répertoire /GNULa documentation (sous Windows) se trouve dans le répertoire/Doc de linstallation, on trouve un fichier avec lextension .chmVous prouvez trouver cette documentation sous python.org/doc
  • 8. Installation de Python 2/2Une fois installé, il faut penser à ajouter le chemin daccès delinstallation dans la variable denvironnement PATH pour quepython soit accessible.Sous Windows vous sélectionnez les propriétés de la machine estallez dans Paramètres systèmes avancés, variable denvironnementet vous modifiez ou créez la variable PathCeci vous permet dans une fenêtre de commande de lancerlapplication Python et de rentrer directement dans linterpréteurPython.
  • 9. Installation de Python, autres paquetagesEn plus de linstallation de base de Python il est possible dinstallerdes paquetages spécifiques pour bénéficier de nouveaux modules.epydoc pour lextraction de la documentation des sourceswin32com pour utiliser COM/DCOM (spécifique Windows)py2exe pour générer une application sous la forme dun exécutable…Linstallation des paquetages supplémentaires seffectuent soitselon le standard Python qui consiste à disposer dun fichiersetup.py dans le répertoire où se trouve le paquetage à installersoit sous la forme dun exécutable à lancer.Pour linstallation standard on lance la commande suivante enétant positionné dans le répertoire où se trouve le fichier setup.py:python setup.py install
  • 10. Les instructions du langage
  • 11. Code source : les commentairesLe 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, enPython 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
  • 12. Code source : Les expressions booléennesOn distingue deux possibilités True et False. Attention la premièrelettre est en majuscule.Avec les opérateurs de comparaison : ==, !=, <, <=, >, >=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•Les opérateur logiques et de comparaison ne peuvent prendre quedeux valeurs : False et True
  • 13. Code source : le type entier 1/2Opérations arithmétiques20 + 3 # 2320 – 3 # 1720 * 3 # 6020 ** 3 # 800020 / 3 # 6 (division entière)20 % 3 # 2 (modulo)•Les entiers longs, limités par la taille de la RAM2 ** 50 # 1125899906842624L2 ** 80L # 1208925819614629174706176L2 ** long(80) # 1208925819614629174706176L
  • 14. Code source : le type entier 2/2Opérations sur les bases06 + 02 # 8oct(6+2) # ’010’ (dix en octal)0x6 + 0x4 # 10hex(6+4) # 0xa’ (en hexadécimal)int(10110’,2) # 22int(10110’,3) # 93
  • 15. Code source : le type flottantPour un flottant on peut utiliser la notation point décimal ouexponentielle1.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 modulemath) :cos(pi/4) # 0.7071067811865476
  • 16. Code source : le type complexeOn écrit les complexes en notation cartésienne,ils sont constitués de deux flottants : la partie réelleet la partie imaginaire, la partie imaginaire étant suffixée par lalettre j1j(5+3j) + (6-8j) # (11-5j)(5+3j).real # 5.0(5.3j).imag # 3.0
  • 17. Code source : les données et les variablesVariable : C’est le nom donné à une valeurDu point de vue informatique c’est la référence à une adressemé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 dePython
  • 18. Code source : les mots réservés de Python
  • 19. Code source : l’affectationPour affecter une valeur à une variable on utilise le signe =Le membre de gauche reçoit le membre de droitex = 2 # x reçoit la valeur 2•La valeur d’une variable peut évoluée dans le temps•la valeur précédente est perduex = x + 1 # 3 (incrémentation)x = x - 1 # 2 (décrémentation)
  • 20. Code source : autres formes d’affectationOn 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
  • 21. Code source : les entrées Pour effectuer une entrée au clavier on peut utiliser input() Elle effectue un typage dynamique Et 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 : "))
  • 22. Code source : et les sorties Pour effectuer une sortie on utilise linstruction 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
  • 23. Code source : les séquencesUne séquence est un conteneur ordonné déléments indicé par unentierEn Python il existe trois types de séquences prédéfinisles chaînes (normales, brutes ou Unicodes)les listesles tuples
  • 24. Code source : les chaînes de caractères différentes notationsc1 = "Linformation de la chaîne"c2 = avec des "apostrophes" !!c3 = """Usage : -h : aide -q : quitter"""r1 = rune chaîne en mode rawu1 = u"une chaîne unicode"
  • 25. Code source : les chaînes de caractères, les opérationsLa longueur dune chaînec1 = "abcdef"len(c1) # 6•Concaténation de deux chaînesc2 = "ghijkl"c3 = c1 + c2 # abcdefghijkl•La répétition de chaînesc4 = "help! "c5 = c4 * 3 # help ! help ! help !
  • 26. Code source : les chaînes de caractères, les méthodes 1/3Le découpage dune chaînec1 = "une ligne à découper"c1.split( ) # [une, ligne, à, découper]•la concaténation de deux chaînes-.join([cest, à, dire]) # "cest-à-dire"•la recherche de position dans une chaîneabracadabra.find(bra) # 1 (premier indice à 0)•le nombre doccurence dans une chaîneabracadabra.count(bra) # 2
  • 27. Code source : les chaînes de caractères, les méthodes 2/3Convertir en minuscule"MINUSCULE".lower() # minuscule•Convertir en majusculesmajuscule.upper() # MAJUSCULE•La première lettre en majusculebruno.capitalize() # Bruno•Toutes les premières lettres en majusculececi est un titre.title() # Ceci Est Un Titre•Linversion de la cassefRANK.swapcase() # Frank
  • 28. Code source : les chaînes de caractères, les méthodes 3/3Linversion de la cassefRANK.swapcase() # Frank•La suppression de caractères en début et fin" Trop despaces ".strip( ) # "Trop despace"•Le remplacement dune chaîne par une autreabracadabra.replace(a, o) # obrocodobro
  • 29. Code source : les chaînes de caractères, le formatageLe formatage dune chaîne ressemble au format du langage Cx = 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 : 19pi = 3.141592655897931print "%4.2f" % (pi) # 3.14print "%.4e" % (pi) # 3.1415e+000print "%g" % (pi) # 3.14159
  • 30. 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 longueurIl est possible de contrôler laffichage en spécifiant le nombre decaractères désiré, "%3d" affiche un entier sous la forme de 3caractères, "%03d" même chose mais en complétant devant pardes zéro, "%7.2f" un flottant sur 7 caractères avec 2 chiffres aprèsle point décimal.
  • 31. Code source : les chaînes de caractères, brutes et UnicodeEn Python il existe dautres méthodes pour coder des chaînes decaractères :Les chaîne brutes, ce sont des chaînes précédées de la lettre r ouR, les caractères déchappement comme ou n ne sont pasinterprétés.Les chaînes en Unicode sont précédées de u ou ULes chaînes en Unicode brut sont précédées de ur
  • 32. Code source : les listesUne liste est une collection hétérogène déléments ordonnés etmodifiables séparés par une virgule et entourée de crochetscouleurs = [rouge, vert, bleu, jaune ]print couleurs # [rouge, vert, bleu, jaune]print couleurs[1] # vertcouleur[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]]
  • 33. Code source : les listes, méthodes et accèsnombres = [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) # 2nombres.remove(30) # [10, 18, 9, 5, 1]Lindiçage dune liste seffectue de la même manière quune chaînede caractèresnombres[1:3] # [18, 9]nombres[:2] # [10, 18]nombres[:] # [10, 18, 9, 5, 1]nombres[-1] # 1
  • 34. Code source : les listes, initialisationchose = [] # 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
  • 35. Code source : les listes, le découpage "slicing"Pour insérer ou supprimer des éléments, le membre de gauche doitobligatoirement indiquer une tranche,Le membre de droite doit aussi être une listebois = [chêne, acacia, peuplier]bois[2:2] = [platane] # insertion en 3iéme positionbois[4:4] = [bouleau] # insertion en 5iéme positionprint bois # [chêne, acacia, platane, peuplier, bouleau]bois[2:4] = [] # effacement par liste videprint 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]
  • 36. Code source : les tuplesUn tuple est une collection hétérogène déléments ordonnés etimmuable séparés par une virgule et entourée de parenthèsesunTuple = (chêne, 15, ["plaine", 1200])•Un tuple sutilise comme une liste, mais son parcours est plusrapide•Généralement on utilise le tuple pour définir des constantes•Un tuple nest pas modifiable
  • 37. Code source : les dictionnairesUn dictionnaire est un couple clef : valeur entouré daccoladesdico= {} # dictionnaire videdico[un] = onedico[deux] = twodico[trois] = threeprint dico # {un:one, trois:three, deux:two}print dico[un] # onedel dico[un]print dico # {trois:three, deux:two}dico[quatre] = fourprint dico # {quatre: four, trois: three, deux: two}
  • 38. Code source : les dictionnaires, les méthodesLes méthodes suivantes sont spécifiques aux dictionnaires :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 dictionnaires ne sont pas ordonnés•On ne peut donc pas les indicer
  • 39. Code source : les dictionnaires, les itérateursLes itérateurs sont des objets spécifiques permettant de parcourirun dictionnaire :for key in dico.iterkeys() : print key # quatre trois deuxfor value in dico.itervalues() : print value # four three twofor keyValue in dico.iteritems() print keyValue #(quatre,four), (trois,three), (deux,two)
  • 40. Code source : les ensemblesLes ensembles sont gérés par la fonction set() :x = set (abcd)y = set(bdx)•Les opérations :c in x # True : appartenancex – y # set([a, c]) : différencex | y # set([a, c, b, d, x]) : unionx & y # set([b, d]) : intersection
  • 41. Le problème de référence
  • 42. Code source : le problème des références 1/3Lopération daffectation est plus complexe quil ny paraiti = 1message = "mon message"•Laffectation réalise en fait plusieurs opérations : 1.crée et mémorise un nom de variable dans lespace 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 ladresse de la valeur correspondante
  • 43. Code source : le problème des références 3/3Il faut utiliser le module copy pour obtenir une vraie copie dunobjetimport 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 lobjet ac.append(5)print a # [1, 2, 3, 4]print b # [1, 2, 3, 4]print c # [1, 2, 3, 4, 5]
  • 44. Les instructions de branchement
  • 45. Code source : if … [elif] … [else]Contrôler une alternativeif x < 0 : print "x est négatif"elif x % 2 : print "x est positif et pair"else : print "x nest ni négatif ni pair"# pour un booléenif x : # if s is True ou if x == True
  • 46. Code source : while … [else]Répéter du codecpt = 0while x > 0 : x = x // 2 # division avec troncature cpt += 1print "lapproximation 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. : )
  • 47. Code source : for… [else]Parcourir une séquencefor c in Hello : print c, # H e l l ofor x in [1, H, 5.269] : print x, # 1 H 5.269for x in xrange(5) : print x, # 0 1 2 3 4
  • 48. Code source : Les listes compréhension 1/2Une liste compréhension est une expression permettant de générerde manière très compacte une listeElle revient à une boucle for qui construirait la même liste enutilisant la méthode append()•Forme 1 :result = [x+1 for x in uneSequence]# donne le même résultat que :result = []for x in uneSequence : result.append(x+1)
  • 49. Code source : Les listes compréhension 2/2•Forme 2 :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 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)
  • 50. Code source : break•Le break permet dinterrompre immédiatement le traitement duneboucle for ou dun whilefor x in xrange(1, 11) : if x == 5 : break print x,print "nBoucle for interrompue pour x = %d" % (x)# affiche# 1 2 3 4# Boucle for interrompue pour x = 5
  • 51. Code source : continue•Le continue permet de reprendre immédiatement à la ligne delen-tête dune boucle for ou dun whilefor x in xrange(1, 11) : if x == 5 : continue print 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
  • 52. Le traitement des exceptions en Python
  • 53. Code source : gestion des exceptions, try … except … [else]•Permet de traiter des erreurs levées par Python en coursdexécutionfrom math import sinfor x in xrange(-3, 4) : try : print %.3f % (sin(x)/x) except : print 1.0, # gère lexception en 0
  • 54. Code source : gestion des exceptions, try … finally …•Permet deffectuer un traitement quil y ait eu ou non la levéedune exception.•La clause finally met en place un gestionnaire de nettoyage•Il ne peut y avoir quune clause finally et pas de clause elsef = open(unFichier, "r")try : traitementFichier(f)finally: f.close()
  • 55. Code source : gestion des exceptions, raise•Linstruction raise permet de lever volontairement une exceptionif not 0 <= x <= 1 : raise ValueError, "x nest pas dans linterval [0 .. 1]"
  • 56. Les fonctions en Python
  • 57. Code source : fonctions, déclaration•Une fonction est un groupe dinstructions regroupé sous un nom etsexécutant à la demandedef nomDeLaFontion(<paramétres>) : <blocInstructions>•le <blocInstruction> est obligatoire, sil ne fait rien on doit utiliserlinstruction passdef carre(x) : return x*xprint carre(4) # 16 : appel de la fonction carre
  • 58. Code source : fonctions, passage des paramètres•Chaque argument dans la définition dune fonctioncorrespond, dans lordre, à un paramètre de lappeldef maFonction(x, y, z) : passmaFonction(3, e, 5.6) # x=3, y=e, z=5.6
  • 59. Code source : fonctions, paramètres par défaut•Dans une fonction il est possible davoir des paramètres par défautdef maFonction(x, y, z=0.0) : passmaFonction(3, e, 5.6) # x=3, y=e, z=5.6maFonction(3, e) # x=3, y=e, z=0.0•Les appels peuvent se faire par paramètre nommémaFonction(3, y=e, z=5.6) # x=3, y=e, z=5.6maFonction(3, y=e) # x=3, y=e, z=0.0
  • 60. Code source : fonctions, paramètres passage par tupledef somme(*args) : resultat = 0 for x in args : resultat += x return resultatprint somme(5) # 5print somme(5, 10, 15) # 30def somme(a, b, c ) : return a+b+cx = [5, 10, 15]print somme(*x) # 30
  • 61. Code source : fonctions, paramètres passage dun dictionnairedef unDic(**kargs) : return kargsprint 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}
  • 62. La portée des objets
  • 63. 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édergrâce à linstruction globals() qui fournit les couples variable :valeur.•La portée locale, ce sont les objets internes aux fonctions et auxclasses. Linstruction locals() fournit le couples variable : valeur.•Les objets globaux ne sont pas modifiables dans les portéeslocales•La portée interne correspond aux noms prédéfinis de Python.•La recherche seffectue dans lordre suivant : Local (fonction) les noms définis dans le def dune fonction Globale (module) les noms affectés à la base dun module et les noms déclarés global dans une fonction Interne (Python) les noms prédéfinis comme open, close, len …
  • 64. 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 + y return zx = 99print maFonc(1) # affiche : 100def maFonc(y) : # x, y et z sont affectés dans maFonc: locaux x = 5 # nouvel x local, masque le x global z = x + y return zx = 99print maFonc(1) # affiche : 6def maFonc(y) : # y et z sont affectés dans maFonc: locaux global x # permet de modifier x x += 5 z = x + y return zx = 99print maFonc(1) # affiche : 105
  • 65. Les Modules
  • 66. Code source : Les modules•Un module est un fichier indépendant qui permet de créer desbibliothè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és deffectuer la partition de lespace de noms la documentation et les tests peuvent être intégrés aux modules.
  • 67. Code source : Les modules, import•Il existe deux méthodes pour effectuer limportation dun moduledans un programme import <nomDeModule> qui effectue limportation de la totalité des objets du moduleimport wx from <nomDeModule> import obj1, … qui effectue limportation des objets spécifiés du modulefrom math import pi, sin, cos
  • 68. Code source : Fichier ou modules ?•Nimporte quel fichier python est considéré comme un module•Un module peut être importé et lancé par lui mêmeif __main__ == __main__ : print "Ce programme est lancé par lui-même"else : print "Je suis importé par un autre module"
  • 69. Manipulation des fichiers
  • 70. 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 lattribut b pour traiter le fichier en mode binairef1 = open("monFichier", r) # ouverture en lecturef2 = open("monFichier", w) # ouverture en écrituref3 = open("monFichier", a) # ouverture en ajoutf4 = open("monFichier", br) # ouverture en lecture binairef1.close() # fermeture du fichier
  • 71. Code source : Manipulation des fichiers, écriture•Les méthodes décrituresf1 = open("monFichier", w)s1 = foof1.write(s) # on écrit la chaîne s1 dans f1l1 = ["x", "y", "z"]f1.writlines(l1) # on écrit les chaînes de l1 dans f1print >> f1, "ajout de la chaîne" # écrit dans f1 en mode ajoutf1.close() # fermeture du fichier
  • 72. Code source : Manipulation des fichiers, lecture•Les méthodes de lecturef1 = 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 duneliste# lecture et affichage des lignes dun fichierfor s in f1 : print sf1.close() # fermeture du fichier
  • 73. La programmation objet en Python
  • 74. la programmation Orientée ObjetPython est non seulement un langage procédurale, mais aussi unlangage objet.En fait, pour Python, tout est objetEn Python on défini un objet au travers du mot réservé classUn objet class sappel de la même manière quune fonction.Lobjet créé, appelé instance, sait à quelle classe il appartientUne classe possède des attributs, des données et desfonctions, ces dernières sappellent des méthodesPython définit des méthodes spécialesUne classe peut hériter dune au plusieurs autres classes
  • 75. la programmation OO : classEn Python il existe une classe de base nommée object.Toute classe créée, si elle nhérite pas dautres classes devrait aumoins hériter de la classe object.On dit que object est lancêtre de tous les autres types.Une classe est constituée dun en-tête et dun corpsLa classe comporte un nom, la liste des classes dont elle hérite etéventuellement dune 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 classedébute par une majuscule, pour ma part je débute toujours mesclasses par un C majuscule.•INFO est un attribut de la classe CMaClasse, il est local àCMaClasse
  • 76. la programmation OO : instanciationPour créer un objet on appel le nom de sa classeo1 = CMaClasse() # o1 est un objet de CMaClasseprint dir(o1) # affiche les attributs de lobjet o1print o1.INFO # affiche (5,)o1.INFO = 10 # modification de lattribut dinstance !!!print CMaClasse.INFO # affiche (5,), lattribut de classe nest pas changéo1.x = 55 # création dun nouvel attribut dinstanceo2 = CMaClasse() # o2 est un nouvel objet de CMaClasseprint o2.INFO # affiche (5,)print o2.x # AttributeError: type object CMaClasse has no attribute xprint o1 # <__main__.CMaClasse object at 0x025A3BF0>print o2 # <__main__.CMaClasse object at 0x025A35F0>
  • 77. la programmation OO : espace de nomsLes espaces de noms son implémentés par des dictionnaires pourles modules, les classes et les instancesprint CMaClasse.__dict__ # {INFO: (5,), __dict__: <attribute __dict__ ofCMaClasse 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
  • 78. la programmation OO : Les méthodesUne méthode se déclare comme une fonction dans le corps duneclasse.Elle dispose toujours dun premier paramètre obligatoire quireprésente lobjet sur lequel la méthode sera appliquée.Par convention ce premier paramètre sappel self. Le nom estarbitraire, vous pouvez lui en donner un autreclass 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 linstance print CMaClasse.x, # lattribut de la classe print self.yo1 = CMaClasse()o1.affiche() # 45 12 (affiche reçoit o1 comme valeur pour le paramètre self)
  • 79. la programmation OO : méthodes spécialesUn certain nombre de méthodes ont des noms prédéfinis, ellessont précédées et suivis de deux caractères de soulignementElles permettent :dinitialiser un objet instancierde modifier son affichagede surcharger des opérateurs…
  • 80. la programmation OO : __init__Cette méthode est appelée lors de linstanciation dun objet, ellepermet deffectuer certaines opérations dinitialisation nécessairesà lobjetclass CMaClasse(object) : def __init__(self, n) : self.x = n # initialisation de lattributdinstance xo1 = CMaClasse(10) # paramètre obligatoire affecté au paramètre nprint o1.x # 10
  • 81. la programmation OO : surchargeLa surcharge permet à un opérateur de posséder un sensdifférents suivant le type des opérandes.Quand on effectue :x = 1 + 3s = "azerty" + "qwerty"•on utilise la surcharge de lopérateur + qui effectue une additionentière pour le premier cas et une concaténation de chaîne decaractè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__…)
  • 82. la programmation OO : Exemple de surchargeOn veut gérer des vecteurs et effectuer de opérations.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 dun vecteur return "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)
  • 83. la programmation OO : Héritage et polymorphismeLhéritage est un mécanisme permettant de se servir dune ouplusieurs classes existantes pour créer une nouvelle classe. Cettenouvelle classe disposant de fonctionnalités supplémentaires oudifférentes.Le polymorphisme est la capacité pour une méthode portant lemême nom et appartenant à des classes différentes héritéesdeffectuer un travail différent. Cest ce que lon appel la surcharge.
  • 84. la programmation OO : problème dhéritage 2/3class D(object) : def methode(self) : x = A() print x.methode()"D.methode" # Affiche : # A.methodeclass B(D) : # B.methode def methode(self) : # D.methode print # C.methode"B.methode" # D.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)
  • 85. la programmation OO : problème dhéritage 3/3class D(object) : def methode(self) : x = A() print x.methode()"D.methode" # Affiche : # A.methodeclass B(D) : # B.methode def methode(self) : # C.methode print # D.methode"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()
  • 86. la programmation OO : objets privés 1/2En python il nexiste pas la même notion quen C++ ou Java surles attributs privés, publiques, protégésLes objets dune classe qui commence par un simple sous-lignésont, par convention, des objets protégés, mais aucun contrôlenest effectué par le langage, ils sont en fait aussi publiques quedes objets sans sous-ligné.Pour être privé, un objet doit commencé par deux sous-lignés, àlexception des objets qui commencent et se terminent par deuxsous-lignésCeci est valable aussi bien pour les attributs dune classe que pourles méthodes.
  • 87. la programmation OO : objets privés 2/2class CMaClasse(object) : def __init__(self) :# méthode publique self.x = None # objet (attribut) publique self._y = "" # objet (attribut) protégé parconvention 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 # lattribut x de linstance prend lavaleur 4print o1 # CMaClasse x=4, _y=, __z=10o1._y = "ma chaîne"
  • 88. Les expressions rationnelles
  • 89. Les expressions rationnelles : définition 1/3Une expression rationnelle (ou expression régulière qui est unterme impropre) est une chaîne représentant un motif recherché.Python offre le module re pour manipuler les expressionsrationnelles.Ici on effectuera un survol des possibilités des expressionsrationnelles, pour plus dinformations sur leur utilisations vouspouvez vous référer au livre de Jeffrey Friedl (ed OReilly) Maîtrisedes 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 significationparticulière, ils sont désactivés sils sont précédés dun anti-slash()Certains caractères alphabétiques ont une signification particulièresils sont précédés dun anti-slash ()Le caractère anti-slash est représenté par deux anti-slashes ()
  • 90. Les expressions rationnelles : définition 2/3
  • 91. Les expressions rationnelles : définition 3/3
  • 92. Les expressions rationnelles : module re 1/2En Python les expressions rationnelles sont traitées par le modulerePour faciliter lécriture des expressions rationnelles on les déclaredans 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 demanipuler lexpression rationnelle. lexpression rationnelle compilée :•soit r = re.compile(motif[, flags]) 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)
  • 93. Les expressions rationnelles : module re 2/2Lobjet de correspondance (c) retourné par match, searchdisposent des attributs :c.pos : lindice de s de début de la recherchec.endpos : lindice de s de la fin de la recherchec.lastgroup : le nom du dernier groupe de correspondancec.lastindex : lindice du dernier groupe qui a corresponduc.re : lexpression 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 bornesdans c.string de la sous-chaîne capturée par groupid, sic.string[i:j], c.start retourne i, c.end retourne j et c.spanretourne (i,j)c.expand(template) : équivalent à sub()c.group([groupid[,*groupids]]) : renvoie la sous-chaînecapturée par groupid, ou un tuple si plusieurs groupesc.groups([default=None]) : renvoie un tuple de sous-chaînesdes différents groupes. None au contenu de default si le groupe
  • 94. Les expressions rationnelles : exemplesimport rer = re.compile(r(w+) (w+))s = "Bruno Normand, consultant"m = r.match(s)m.group() # Bruno Normandm.group(1) # Brunom.group(2) # Normandm.group(1,2) # (Bruno, Normand)r = re.compile(r(?P<firstName>w+) (?P<lastName>w+))m = r.match(s)m.group(firstName) # Brunom.group(lastName) # Normandemail = "tony@tiremove_thisger.net"m = re.search("remove_this", email)email[:m.start()] + email[m.end():] # tony@tiger.net
  • 95. Programme externe, et thread
  • 96. Programme externe : module subprocessLancer un programme externe seffectue avec Popen du modulesubprocess. 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 stderr fd.close()
  • 97. Programme externe : module wxLancer un programme externe dans un GUI est très simple enutilisant les interfaces fournis par wx. 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() :
  • 98. Les threads 1/2Python offre la possibilité de gérer des thread au travers dumodule threadUn thread est en fait une fonction qui sexécute "en parallèle" devotre programme principal.On se défini une fonction ou une méthode dune classe qui seraexécutée par le thread en utilisant la fonction suivantethread.start_new_thread(fonction,(p1,…))Vous pouvez aussi utiliser le module threading qui est unesurcouche au module thread et offrant des fonctionnalitéspermettant de créer des threads timer, lancer un thread, gérer dessémaphores, des locks …Pour lancer un thread on doit le créer avec la classe Thread : import threading Thread(groupe=None, target=None, name=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
  • 99. Les threads 2/2Un thread sexécute "en parallèle" cela implique non seulementquon doit lui laisser du temps pour quil sexécute, mais quil doitaussi laisser du temps aux autres threads et au programmeprincipal pour quils sexé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
  • 100. Les interfaces utilisateurs graphiques (GUI)
  • 101. GUIPar défaut lors de linstallation 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 linterface Tkinter est faible.Il existe dautres GUI :wxPython (33.33%): interface de wx, écrit en C++, avec Python(celui que jutilise) http://wxpython.org/download.phppyGtk (14.94%): interface de GTK, écrit en C, avec Pythonhttp://www.pygtk.org/downloads.htmlpyQt (14,94%): interface de QT, écrit en C++, avec Pythonhttp://www.riverbankcomputing.co.uk/software/pyqt/downloadLes autres interfaces sont plus lutilisation de Python dans dautreslangagesPythonForDelphi (1,72%)interface avec DelphiJython interface avec JavaIronPython interface avec .NetLes pourcentages sont ceux du site Developpez.com sur lutilisation des GUI en Python
  • 102. RADBoaConstructor (wxPython) http://boa-constructor.sourceforge.net/Download.htmlPythonCard (wxPython)http://sourceforge.net/projects/pythoncard/files/Visualwx (wxPython) wxGlade (wxPython)http://wxglade.sourceforge.net/WxDesigner (wxPython) payant http://www.wxdesigner-software.de/download.htmlGuiBuilder (Tkinter) http://sourceforge.net/projects/spectcl/files/ nécessite Pmw http://sourceforge.net/projects/pmw/files/
  • 103. IDEPyScripter é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 ledéveloppeur de Blender animation graphique 2D/3D
  • 104. Quelques règles décritures
  • 105. règles décritures : Forme du codeIndentation : Utilisez 4 espaces pour l’indentationTabulation : Préférez les espaces. Espaces/Tabulation ne pas lesmélanger dans un même projetLimitez vos lignes à 80 caractèresQuand c’est possible découpez vos lignes après un séparateurplutôt que l’antislash 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
  • 106. règles décritures : Forme du codeLa définition dune 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 lapremière lettre de chaque mot commence par une majuscule.Dans les classes cachez les méthodes et les objets que vous nevoulez pas exporter en les précédents dun double souligné.Dans les classes pensez à définir la méthode __str__ qui retourneune image des objets de la classe, utile quand on effectue unprint dun objet qui par défaut affiche instance de la classe Cx àladresse yyyyy
  • 107. règles décritures : documentationLes modules doivent disposer dune entête et dune docstringassociée.Pour chaque fonction, classe et méthode utilisez les docstring pourdonner des explications sur le rôle des ces différents éléments.Pour chaque fonction et méthode de classe formater la docstringpour quelle soit interprétable par epydoc, ceci vous permettra degénérer la documentation de vos projets de manière simple (voirexemple page suivante)
  • 108. 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 deffectuer lanalyse de fichiers ADA pour en déterminer les fonctions etprocé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: Lobjet retourné de la recherche @type rule: I{B{_sre.SRE_Pattern}} @param ignoreCase: Indicateur à I{B{True}} si lon ignore la case lors des comparaisons. @type ignoreCase: I{B{bool}}...
  • 109. The Zen of Python
  • 110. PEP 20 The Zen of Python 1/2
  • 111. PEP 20 The Zen of Python 2/2
  • 112. FIN