SlideShare une entreprise Scribd logo
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 2/2
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écution
L’interprétation : Chaque ligne source est analysée et exécutée.
Avantage : Pas de code objet , pas d’édition de lien
Inconvénient : Plus lent car on doit interpréter à chaque fois
Technique 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 Mac
Pour 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/2011
Lors de l'installation vous pouvez sélectionner le répertoire où sera
installé Python, pour ma part je l'installe dans le répertoire /GNU
La documentation (sous Windows) se trouve dans le répertoire
/Doc de l'installation, on trouve un fichier avec l'extension .chm
Vous 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 Path
Ceci 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 sources
win32com 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 : ==, !=, <, <=, >, >=

1 > 5        # False
9 <= 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 que
deux valeurs : False et True
Code source : le type entier 1/2

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)


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

2 ** 50                  # 1125899906842624L
2 ** 80L                 # 1208925819614629174706176L
2 ** long(80)            # 1208925819614629174706176L
Code source : le type entier 2/2

Opérations sur les bases

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

Pour un flottant on peut utiliser la notation point décimal ou
exponentielle
1.368
5e9
3.59871e-10

•Supporte les mêmes opérations que les entiers à l’exception de :
22.0 / 3        # 7.333333333333333
22.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 valeur
Du point de vue informatique c’est la référence à une adresse
mémoire
Par 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 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

 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 flottant
f = float(raw_input("Entrez une valeur flottante : "))
Code source : et les sorties

 Pour effectuer une sortie on utilise l'instruction print :
x = 5
y = 3
print   x                                #   5
print   "somme: ", x + y                 #   8
print   "différence : ", x – y           #   2
print   "produit : ", x * y              #   15
print   "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
entier
En Python il existe trois types de séquences prédéfinis
les chaînes (normales, brutes ou Unicodes)
les listes
les 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, 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.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


%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] = 7
print couleurs # ['rouge', 7, 'bleu', 'jaune'])




list1   = [1, 2, 5.0]
list2   = ['a', 'b', 'c']
list3   = [list1, list2] # une liste de liste
print   list3 # [[1, 2, 5.0], ['a', 'b', 'c']]
Code source : les listes, méthodes et accès


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]


L'indiçage d'une liste s'effectue de la même manière qu'une chaîne
de caractères
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 vide
trucMuch = [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"


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
bois = ['chêne', 'acacia', 'peuplier']
bois[2:2] = ['platane']        # insertion en 3iéme position
bois[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']
Code source : les tuples


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


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

•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


Un dictionnaire est un couple clef : valeur entouré d'accolades
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'}
Code source : les dictionnaires, les méthodes


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

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



•Les dictionnaires ne sont pas ordonnés
•On ne peut donc pas les indicer
Code source : les dictionnaires, les itérateurs


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

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')
Code source : les ensembles


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


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

•Les opérations :


'c'   in x # True :   appartenance
x –   y # set(['a',   'c']) : différence
x |   y # set(['a',   'c', 'b', 'd', 'x']) : union
x &   y # set(['b',   'd']) : intersection
Le problème de référence
Code source : le problème des références 1/3


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

i = 1
message = "mon message"

•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 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]

Contrôler une alternative

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)

n = input('Entrez un entier [1..10] : ')
while (n < 1) or (n > 10) :
       n = input('Entrez un entier [1..10] S.V.P. : ')
Code source : for… [else]

Parcourir une séquence

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
Code source : Les listes compréhension 1/2

Une liste compréhension est une expression permettant de générer
de manière très compacte une liste
Elle revient à une boucle for qui construirait la même liste en
utilisant 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)
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)
Code source : break

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


for 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
Code source : continue

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


for 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
Le traitement des exceptions en
            Python
Code source : gestion des exceptions, try … except … [else]

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


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
Code source : gestion des exceptions, try … finally …

•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


f = open(unFichier, "r")

try :
        traitementFichier(f)
finally:
        f.close()
Code source : gestion des exceptions, raise

•L'instruction raise permet de lever volontairement une exception



if not 0 <= x <= 1 :
        raise ValueError, "x n'est pas dans l'interval [0 .. 1]"
Les fonctions en Python
Code source : fonctions, déclaration

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


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



•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

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


def maFonction(x, y, z) :
        pass

maFonction(3, 'e', 5.6) # x=3, y='e', z=5.6
Code source : fonctions, paramètres par défaut

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

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

maFonction(3, 'e', 5.6) # x=3, y='e', z=5.6
maFonction(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.6
maFonction(3, y='e') # x=3, y='e', z=0.0
Code source : fonctions, paramètres passage par tuple



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


def 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 z


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


def maFonc(y) : # y et z sont affectés dans maFonc: locaux
          global x # permet de modifier x
          x += 5
          z = x + y
          return z


x = 99
print 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és
    d'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   lecture
f2   =   open("monFichier",   'w')    #   ouverture   en   écriture
f3   =   open("monFichier",   'a')    #   ouverture   en   ajout
f4   =   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 f1
l1 = ["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 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

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é class
Un objet class s'appel de la même manière qu'une fonction.
L'objet créé, appelé instance, sait à quelle classe il appartient
Une classe possède des attributs, des données et des
fonctions, ces dernières s'appellent des méthodes
Python définit des méthodes spéciales
Une 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 corps
La classe comporte un nom, la liste des classes dont elle hérite et
éventuellement d'une docstring associée
Le 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 CMaClasse
print dir(o1)    # affiche les attributs de l'objet o1
print 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 '__wea
kref__' 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 = 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

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 soulignement
Elles permettent :
d'initialiser un objet instancier
de modifier son affichage
de 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 n
print 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 + 3
s = "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 = 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)

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 2/3

class D(object) :
          def methode(self) :
                                      x = A()
                    print
                                      x.methode()
"D.methode"
                                      # Affiche :
                                      # A.methode
class 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)
la programmation OO : problème d'héritage 3/3

class D(object) :
          def methode(self) :
                                   x = A()
                    print
                                   x.methode()
"D.methode"
                                   # Affiche :
                                   # A.methode
class 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()
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) 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

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ère
Les caractères alphabétiques et numériques correspondent à eux-
mêmes
Certains 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
re
Pour 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. l'expression 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)
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 recherche
c.endpos : l'indice de s de la fin de la recherche
c.lastgroup : le nom du dernier groupe de correspondance
c.lastindex : l'indice du dernier groupe qui a correspondu
c.re : l'expression rationnelle r utilisée
c.string : la chaîne s passée
c.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 groupes
c.groups([default=None]) : renvoie un tuple de sous-chaînes
des différents groupes. None au contenu de default si le groupe
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 stderr
 fd.close()
Programme externe : module wx

Lancer un programme externe dans un GUI est très simple en
utilisant 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() :
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
 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
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

GuiBuilder (Tkinter) http://sourceforge.net/projects/spectcl/files/
       nécessite Pmw http://sourceforge.net/projects/pmw/files/
IDE
PyScripter éditeur/débogueur version 32/64bits
PyDev plugin pour Eclipse
IDLE éditeur fourni avec Python
SciTE éditeur
Komodo Edit éditeur écrit en Java
Leo éditeur écrit en Python et Tkinter
SPE é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’indentation
Tabulation : Préférez les espaces. Espaces/Tabulation ne pas les
mélanger dans un même projet
Limitez vos lignes à 80 caractères
Quand 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 # 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).

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

Contenu connexe

Tendances

Formation python micro club.net
Formation python micro club.netFormation python micro club.net
Formation python micro club.net
Zakaria SMAHI
 
Développement informatique : Programmation fonctionnelle, décorateur et génér...
Développement informatique : Programmation fonctionnelle, décorateur et génér...Développement informatique : Programmation fonctionnelle, décorateur et génér...
Développement informatique : Programmation fonctionnelle, décorateur et génér...
ECAM Brussels Engineering School
 
Développement informatique : Programmation graphique
Développement informatique : Programmation graphiqueDéveloppement informatique : Programmation graphique
Développement informatique : Programmation graphique
ECAM Brussels Engineering School
 
Johnny-Five : Robotique et IoT en JavaScript
Johnny-Five : Robotique et IoT en JavaScriptJohnny-Five : Robotique et IoT en JavaScript
Johnny-Five : Robotique et IoT en JavaScript
ECAM Brussels Engineering School
 
Interception de signal avec dump de la pile d'appel
Interception de signal avec dump de la pile d'appelInterception de signal avec dump de la pile d'appel
Interception de signal avec dump de la pile d'appel
Thierry Gayet
 
Python avancé : Qualité de code et convention de codage
Python avancé : Qualité de code et convention de codagePython avancé : Qualité de code et convention de codage
Python avancé : Qualité de code et convention de codage
ECAM Brussels Engineering School
 
Algorithmique_et_programmation_part3_V2
Algorithmique_et_programmation_part3_V2Algorithmique_et_programmation_part3_V2
Algorithmique_et_programmation_part3_V2Emeric Tapachès
 
Atelier Python 2eme partie par Achraf Kacimi El Hassani
Atelier Python 2eme partie par Achraf Kacimi El HassaniAtelier Python 2eme partie par Achraf Kacimi El Hassani
Atelier Python 2eme partie par Achraf Kacimi El HassaniShellmates
 
C2 - Langage C - ISIMA 1 - Deuxieme partie
C2 - Langage C - ISIMA 1 - Deuxieme partieC2 - Langage C - ISIMA 1 - Deuxieme partie
C2 - Langage C - ISIMA 1 - Deuxieme partie
Loic Yon
 
Les fondamentaux du langage C
Les fondamentaux du langage CLes fondamentaux du langage C
Les fondamentaux du langage C
Abdoulaye Dieng
 
Développement informatique : Chaines de caractères et expressions regulières
Développement informatique : Chaines de caractères et expressions regulièresDéveloppement informatique : Chaines de caractères et expressions regulières
Développement informatique : Chaines de caractères et expressions regulières
ECAM Brussels Engineering School
 
C++ 11/14
C++ 11/14C++ 11/14
C++ 11/14
Alexandre Hamez
 
Programmation orientée objet : Object, classe et encapsulation
Programmation orientée objet : Object, classe et encapsulationProgrammation orientée objet : Object, classe et encapsulation
Programmation orientée objet : Object, classe et encapsulation
ECAM Brussels Engineering School
 
Cours de C++ / Tronc commun deuxième année ISIMA
Cours de C++ / Tronc commun deuxième année ISIMACours de C++ / Tronc commun deuxième année ISIMA
Cours de C++ / Tronc commun deuxième année ISIMA
Loic Yon
 
Python après 15 ans de JAVA
Python après 15 ans de JAVAPython après 15 ans de JAVA
Python après 15 ans de JAVA
Pierre-Alban DEWITTE
 
Développement informatique : Programmation concurrente
Développement informatique : Programmation concurrenteDéveloppement informatique : Programmation concurrente
Développement informatique : Programmation concurrente
ECAM Brussels Engineering School
 
cpp1 : Quelques elements de base du C++
cpp1 : Quelques elements de base du C++cpp1 : Quelques elements de base du C++
cpp1 : Quelques elements de base du C++
Abdoulaye Dieng
 
Python For Data Science - French Course
Python For Data Science - French CoursePython For Data Science - French Course
Python For Data Science - French Course
Haytam EL YOUSSFI
 

Tendances (19)

Formation python micro club.net
Formation python micro club.netFormation python micro club.net
Formation python micro club.net
 
Développement informatique : Programmation fonctionnelle, décorateur et génér...
Développement informatique : Programmation fonctionnelle, décorateur et génér...Développement informatique : Programmation fonctionnelle, décorateur et génér...
Développement informatique : Programmation fonctionnelle, décorateur et génér...
 
Développement informatique : Programmation graphique
Développement informatique : Programmation graphiqueDéveloppement informatique : Programmation graphique
Développement informatique : Programmation graphique
 
Johnny-Five : Robotique et IoT en JavaScript
Johnny-Five : Robotique et IoT en JavaScriptJohnny-Five : Robotique et IoT en JavaScript
Johnny-Five : Robotique et IoT en JavaScript
 
Interception de signal avec dump de la pile d'appel
Interception de signal avec dump de la pile d'appelInterception de signal avec dump de la pile d'appel
Interception de signal avec dump de la pile d'appel
 
Python avancé : Qualité de code et convention de codage
Python avancé : Qualité de code et convention de codagePython avancé : Qualité de code et convention de codage
Python avancé : Qualité de code et convention de codage
 
Algorithmique_et_programmation_part3_V2
Algorithmique_et_programmation_part3_V2Algorithmique_et_programmation_part3_V2
Algorithmique_et_programmation_part3_V2
 
Atelier Python 2eme partie par Achraf Kacimi El Hassani
Atelier Python 2eme partie par Achraf Kacimi El HassaniAtelier Python 2eme partie par Achraf Kacimi El Hassani
Atelier Python 2eme partie par Achraf Kacimi El Hassani
 
C2 - Langage C - ISIMA 1 - Deuxieme partie
C2 - Langage C - ISIMA 1 - Deuxieme partieC2 - Langage C - ISIMA 1 - Deuxieme partie
C2 - Langage C - ISIMA 1 - Deuxieme partie
 
Les fondamentaux du langage C
Les fondamentaux du langage CLes fondamentaux du langage C
Les fondamentaux du langage C
 
Développement informatique : Chaines de caractères et expressions regulières
Développement informatique : Chaines de caractères et expressions regulièresDéveloppement informatique : Chaines de caractères et expressions regulières
Développement informatique : Chaines de caractères et expressions regulières
 
C++ 11/14
C++ 11/14C++ 11/14
C++ 11/14
 
Programmation orientée objet : Object, classe et encapsulation
Programmation orientée objet : Object, classe et encapsulationProgrammation orientée objet : Object, classe et encapsulation
Programmation orientée objet : Object, classe et encapsulation
 
Cours de C++ / Tronc commun deuxième année ISIMA
Cours de C++ / Tronc commun deuxième année ISIMACours de C++ / Tronc commun deuxième année ISIMA
Cours de C++ / Tronc commun deuxième année ISIMA
 
Python après 15 ans de JAVA
Python après 15 ans de JAVAPython après 15 ans de JAVA
Python après 15 ans de JAVA
 
Développement informatique : Programmation concurrente
Développement informatique : Programmation concurrenteDéveloppement informatique : Programmation concurrente
Développement informatique : Programmation concurrente
 
cpp1 : Quelques elements de base du C++
cpp1 : Quelques elements de base du C++cpp1 : Quelques elements de base du C++
cpp1 : Quelques elements de base du C++
 
Python For Data Science - French Course
Python For Data Science - French CoursePython For Data Science - French Course
Python For Data Science - French Course
 
Cours php
Cours phpCours php
Cours php
 

En vedette

Expo universelle-1900
Expo universelle-1900Expo universelle-1900
Expo universelle-1900catavrio
 
Pauvres petits-vieux
Pauvres petits-vieuxPauvres petits-vieux
Pauvres petits-vieuxcatavrio
 
Grand père qui a 80 ans ans bien sonné
Grand père qui a 80 ans ans bien sonnéGrand père qui a 80 ans ans bien sonné
Grand père qui a 80 ans ans bien sonnécatavrio
 
Propriã©tã©s du corps
Propriã©tã©s du corpsPropriã©tã©s du corps
Propriã©tã©s du corpscatavrio
 
L’impact des médias sociaux et des usages numériques sur la conduite de l’act...
L’impact des médias sociaux et des usages numériques sur la conduite de l’act...L’impact des médias sociaux et des usages numériques sur la conduite de l’act...
L’impact des médias sociaux et des usages numériques sur la conduite de l’act...
regiosuisse
 
Examen Final - Slideshare
Examen Final - SlideshareExamen Final - Slideshare
Examen Final - Slideshare
nataliacherres
 
Pour mariaetjosep
Pour mariaetjosepPour mariaetjosep
Pour mariaetjosep
brunochaumontet
 
Curso de posgrado peris jose
Curso de posgrado peris joseCurso de posgrado peris jose
Curso de posgrado peris jose
José Peris
 
Référencer son blog
Référencer son blogRéférencer son blog
Référencer son blog
Ernesto Hane
 
Quel est le_prix_de_la_beaute
Quel est le_prix_de_la_beauteQuel est le_prix_de_la_beaute
Quel est le_prix_de_la_beautecatavrio
 
Bloq1.Act3. Versión En el mercado
Bloq1.Act3. Versión En el mercadoBloq1.Act3. Versión En el mercado
Bloq1.Act3. Versión En el mercado
tutoresaa
 
Presentación personal 02
Presentación personal 02Presentación personal 02
Presentación personal 02
IsaCas1995
 
Exposicion de analisis de los componentes
Exposicion de analisis de los componentesExposicion de analisis de los componentes
Exposicion de analisis de los componentes
Mane_Rex
 
Dossier De Presse Fdl Mouans Sartoux 2007
Dossier De Presse Fdl Mouans Sartoux 2007Dossier De Presse Fdl Mouans Sartoux 2007
Dossier De Presse Fdl Mouans Sartoux 2007brichardcaroline
 
Teoria de la información
Teoria de la informaciónTeoria de la información
Teoria de la información
Erick Contreras
 
Check up de_vieux..
Check up de_vieux..Check up de_vieux..
Check up de_vieux..catavrio
 
Diapocitiba grado 9
Diapocitiba grado 9Diapocitiba grado 9
Diapocitiba grado 9
ANAERCIRA
 

En vedette (20)

Expo universelle-1900
Expo universelle-1900Expo universelle-1900
Expo universelle-1900
 
Pauvres petits-vieux
Pauvres petits-vieuxPauvres petits-vieux
Pauvres petits-vieux
 
Grand père qui a 80 ans ans bien sonné
Grand père qui a 80 ans ans bien sonnéGrand père qui a 80 ans ans bien sonné
Grand père qui a 80 ans ans bien sonné
 
Letimbre
LetimbreLetimbre
Letimbre
 
Propriã©tã©s du corps
Propriã©tã©s du corpsPropriã©tã©s du corps
Propriã©tã©s du corps
 
L’impact des médias sociaux et des usages numériques sur la conduite de l’act...
L’impact des médias sociaux et des usages numériques sur la conduite de l’act...L’impact des médias sociaux et des usages numériques sur la conduite de l’act...
L’impact des médias sociaux et des usages numériques sur la conduite de l’act...
 
Examen Final - Slideshare
Examen Final - SlideshareExamen Final - Slideshare
Examen Final - Slideshare
 
Pour mariaetjosep
Pour mariaetjosepPour mariaetjosep
Pour mariaetjosep
 
Nostalgie
NostalgieNostalgie
Nostalgie
 
Curso de posgrado peris jose
Curso de posgrado peris joseCurso de posgrado peris jose
Curso de posgrado peris jose
 
Référencer son blog
Référencer son blogRéférencer son blog
Référencer son blog
 
Quel est le_prix_de_la_beaute
Quel est le_prix_de_la_beauteQuel est le_prix_de_la_beaute
Quel est le_prix_de_la_beaute
 
Bloq1.Act3. Versión En el mercado
Bloq1.Act3. Versión En el mercadoBloq1.Act3. Versión En el mercado
Bloq1.Act3. Versión En el mercado
 
Presentación personal 02
Presentación personal 02Presentación personal 02
Presentación personal 02
 
Exposicion de analisis de los componentes
Exposicion de analisis de los componentesExposicion de analisis de los componentes
Exposicion de analisis de los componentes
 
Dossier De Presse Fdl Mouans Sartoux 2007
Dossier De Presse Fdl Mouans Sartoux 2007Dossier De Presse Fdl Mouans Sartoux 2007
Dossier De Presse Fdl Mouans Sartoux 2007
 
Teoria de la información
Teoria de la informaciónTeoria de la información
Teoria de la información
 
Diaporama IUT GTE Poitiers
Diaporama IUT GTE PoitiersDiaporama IUT GTE Poitiers
Diaporama IUT GTE Poitiers
 
Check up de_vieux..
Check up de_vieux..Check up de_vieux..
Check up de_vieux..
 
Diapocitiba grado 9
Diapocitiba grado 9Diapocitiba grado 9
Diapocitiba grado 9
 

Similaire à Formation python

Formation python
Formation pythonFormation python
Formation python
j_lipaz
 
Chapitre1: Langage Python
Chapitre1: Langage PythonChapitre1: Langage Python
Chapitre1: Langage Python
Aziz Darouichi
 
Introduction au langage python notion de base
Introduction au langage python notion de baseIntroduction au langage python notion de base
Introduction au langage python notion de base
mohamedAitomar1
 
Introduction au langage python (Notion de base)
Introduction au langage python (Notion de base)Introduction au langage python (Notion de base)
Introduction au langage python (Notion de base)
mohamedAitomar1
 
C1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partieC1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partie
Loic Yon
 
Code Week 2014 - atelier d'initiation à la programmation avec python
Code Week 2014 - atelier d'initiation à la programmation avec pythonCode Week 2014 - atelier d'initiation à la programmation avec python
Code Week 2014 - atelier d'initiation à la programmation avec python
bbourgois
 
Cours langage c
Cours langage cCours langage c
Cours langage c
coursuniv
 
Cours programmation en langage C.pdf
Cours  programmation  en  langage  C.pdfCours  programmation  en  langage  C.pdf
Cours programmation en langage C.pdf
khalidmoussaid4
 
ESGAE_C#_2021-2024 Cours Avancé (('.pptx
ESGAE_C#_2021-2024 Cours Avancé (('.pptxESGAE_C#_2021-2024 Cours Avancé (('.pptx
ESGAE_C#_2021-2024 Cours Avancé (('.pptx
LagloireSouamounou
 
cours lanagage c avec des exemples d'application
cours lanagage c avec des exemples d'applicationcours lanagage c avec des exemples d'application
cours lanagage c avec des exemples d'application
kamalomari2
 
Langage C
Langage CLangage C
Langage C
mohamednacim
 
Cours_C_for_Etudiant.pdf
Cours_C_for_Etudiant.pdfCours_C_for_Etudiant.pdf
Cours_C_for_Etudiant.pdf
Hailisara
 
COURS_PYTHON_22.ppt
COURS_PYTHON_22.pptCOURS_PYTHON_22.ppt
COURS_PYTHON_22.ppt
IbtissameAbbad1
 
Technologies du Web - Architectures matérielles et logicielles
Technologies du Web - Architectures matérielles et logiciellesTechnologies du Web - Architectures matérielles et logicielles
Technologies du Web - Architectures matérielles et logicielles
Frédéric Simonet
 
Chap 1 Initiation.pptx
Chap 1 Initiation.pptxChap 1 Initiation.pptx
Chap 1 Initiation.pptx
olfaharrabi2
 
01 - Introduction à Python chaines de caractères.pdf
01 - Introduction à Python chaines de caractères.pdf01 - Introduction à Python chaines de caractères.pdf
01 - Introduction à Python chaines de caractères.pdf
MARYAM510573
 
Support Formation Samsung - Python - Session 1 - 2022.pptx
Support Formation Samsung - Python - Session 1 - 2022.pptxSupport Formation Samsung - Python - Session 1 - 2022.pptx
Support Formation Samsung - Python - Session 1 - 2022.pptx
bpmana
 
cours fortran.pptx
cours fortran.pptxcours fortran.pptx
cours fortran.pptx
MED B
 
OSIS18_IoT: L'approche machine virtuelle pour les microcontrôleurs, le projet...
OSIS18_IoT: L'approche machine virtuelle pour les microcontrôleurs, le projet...OSIS18_IoT: L'approche machine virtuelle pour les microcontrôleurs, le projet...
OSIS18_IoT: L'approche machine virtuelle pour les microcontrôleurs, le projet...
Pôle Systematic Paris-Region
 
Présentation Arduino par Christian, F5HOD
Présentation Arduino par Christian, F5HODPrésentation Arduino par Christian, F5HOD
Présentation Arduino par Christian, F5HOD
webmasterref68
 

Similaire à Formation python (20)

Formation python
Formation pythonFormation python
Formation python
 
Chapitre1: Langage Python
Chapitre1: Langage PythonChapitre1: Langage Python
Chapitre1: Langage Python
 
Introduction au langage python notion de base
Introduction au langage python notion de baseIntroduction au langage python notion de base
Introduction au langage python notion de base
 
Introduction au langage python (Notion de base)
Introduction au langage python (Notion de base)Introduction au langage python (Notion de base)
Introduction au langage python (Notion de base)
 
C1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partieC1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partie
 
Code Week 2014 - atelier d'initiation à la programmation avec python
Code Week 2014 - atelier d'initiation à la programmation avec pythonCode Week 2014 - atelier d'initiation à la programmation avec python
Code Week 2014 - atelier d'initiation à la programmation avec python
 
Cours langage c
Cours langage cCours langage c
Cours langage c
 
Cours programmation en langage C.pdf
Cours  programmation  en  langage  C.pdfCours  programmation  en  langage  C.pdf
Cours programmation en langage C.pdf
 
ESGAE_C#_2021-2024 Cours Avancé (('.pptx
ESGAE_C#_2021-2024 Cours Avancé (('.pptxESGAE_C#_2021-2024 Cours Avancé (('.pptx
ESGAE_C#_2021-2024 Cours Avancé (('.pptx
 
cours lanagage c avec des exemples d'application
cours lanagage c avec des exemples d'applicationcours lanagage c avec des exemples d'application
cours lanagage c avec des exemples d'application
 
Langage C
Langage CLangage C
Langage C
 
Cours_C_for_Etudiant.pdf
Cours_C_for_Etudiant.pdfCours_C_for_Etudiant.pdf
Cours_C_for_Etudiant.pdf
 
COURS_PYTHON_22.ppt
COURS_PYTHON_22.pptCOURS_PYTHON_22.ppt
COURS_PYTHON_22.ppt
 
Technologies du Web - Architectures matérielles et logicielles
Technologies du Web - Architectures matérielles et logiciellesTechnologies du Web - Architectures matérielles et logicielles
Technologies du Web - Architectures matérielles et logicielles
 
Chap 1 Initiation.pptx
Chap 1 Initiation.pptxChap 1 Initiation.pptx
Chap 1 Initiation.pptx
 
01 - Introduction à Python chaines de caractères.pdf
01 - Introduction à Python chaines de caractères.pdf01 - Introduction à Python chaines de caractères.pdf
01 - Introduction à Python chaines de caractères.pdf
 
Support Formation Samsung - Python - Session 1 - 2022.pptx
Support Formation Samsung - Python - Session 1 - 2022.pptxSupport Formation Samsung - Python - Session 1 - 2022.pptx
Support Formation Samsung - Python - Session 1 - 2022.pptx
 
cours fortran.pptx
cours fortran.pptxcours fortran.pptx
cours fortran.pptx
 
OSIS18_IoT: L'approche machine virtuelle pour les microcontrôleurs, le projet...
OSIS18_IoT: L'approche machine virtuelle pour les microcontrôleurs, le projet...OSIS18_IoT: L'approche machine virtuelle pour les microcontrôleurs, le projet...
OSIS18_IoT: L'approche machine virtuelle pour les microcontrôleurs, le projet...
 
Présentation Arduino par Christian, F5HOD
Présentation Arduino par Christian, F5HODPrésentation Arduino par Christian, F5HOD
Présentation Arduino par Christian, F5HOD
 

Dernier

Les écrans informatiques au fil du temps.pptx
Les écrans informatiques au fil du temps.pptxLes écrans informatiques au fil du temps.pptx
Les écrans informatiques au fil du temps.pptx
abderrahimbourimi
 
Le Comptoir OCTO - Qu’apporte l’analyse de cycle de vie lors d’un audit d’éco...
Le Comptoir OCTO - Qu’apporte l’analyse de cycle de vie lors d’un audit d’éco...Le Comptoir OCTO - Qu’apporte l’analyse de cycle de vie lors d’un audit d’éco...
Le Comptoir OCTO - Qu’apporte l’analyse de cycle de vie lors d’un audit d’éco...
OCTO Technology
 
Le Comptoir OCTO - Équipes infra et prod, ne ratez pas l'embarquement pour l'...
Le Comptoir OCTO - Équipes infra et prod, ne ratez pas l'embarquement pour l'...Le Comptoir OCTO - Équipes infra et prod, ne ratez pas l'embarquement pour l'...
Le Comptoir OCTO - Équipes infra et prod, ne ratez pas l'embarquement pour l'...
OCTO Technology
 
PRESENTATION DE L'ACTIVE DIRECTORY SOUS WINDOWS SERVEUR.pptx
PRESENTATION DE L'ACTIVE DIRECTORY SOUS WINDOWS SERVEUR.pptxPRESENTATION DE L'ACTIVE DIRECTORY SOUS WINDOWS SERVEUR.pptx
PRESENTATION DE L'ACTIVE DIRECTORY SOUS WINDOWS SERVEUR.pptx
AlbertSmithTambwe
 
COURS D'ADMINISTRATION RESEAU SOUS WINDOWS
COURS D'ADMINISTRATION RESEAU  SOUS WINDOWSCOURS D'ADMINISTRATION RESEAU  SOUS WINDOWS
COURS D'ADMINISTRATION RESEAU SOUS WINDOWS
AlbertSmithTambwe
 
De l'IA comme plagiat à la rédaction d'une « charte IA » à l'université
De l'IA comme plagiat à la rédaction d'une « charte IA » à l'universitéDe l'IA comme plagiat à la rédaction d'une « charte IA » à l'université
De l'IA comme plagiat à la rédaction d'une « charte IA » à l'université
Université de Franche-Comté
 
Le support de présentation des Signaux 2024
Le support de présentation des Signaux 2024Le support de présentation des Signaux 2024
Le support de présentation des Signaux 2024
UNITECBordeaux
 
Ouvrez la porte ou prenez un mur (Agile Tour Genève 2024)
Ouvrez la porte ou prenez un mur (Agile Tour Genève 2024)Ouvrez la porte ou prenez un mur (Agile Tour Genève 2024)
Ouvrez la porte ou prenez un mur (Agile Tour Genève 2024)
Laurent Speyser
 
OCTO TALKS : 4 Tech Trends du Software Engineering.pdf
OCTO TALKS : 4 Tech Trends du Software Engineering.pdfOCTO TALKS : 4 Tech Trends du Software Engineering.pdf
OCTO TALKS : 4 Tech Trends du Software Engineering.pdf
OCTO Technology
 

Dernier (9)

Les écrans informatiques au fil du temps.pptx
Les écrans informatiques au fil du temps.pptxLes écrans informatiques au fil du temps.pptx
Les écrans informatiques au fil du temps.pptx
 
Le Comptoir OCTO - Qu’apporte l’analyse de cycle de vie lors d’un audit d’éco...
Le Comptoir OCTO - Qu’apporte l’analyse de cycle de vie lors d’un audit d’éco...Le Comptoir OCTO - Qu’apporte l’analyse de cycle de vie lors d’un audit d’éco...
Le Comptoir OCTO - Qu’apporte l’analyse de cycle de vie lors d’un audit d’éco...
 
Le Comptoir OCTO - Équipes infra et prod, ne ratez pas l'embarquement pour l'...
Le Comptoir OCTO - Équipes infra et prod, ne ratez pas l'embarquement pour l'...Le Comptoir OCTO - Équipes infra et prod, ne ratez pas l'embarquement pour l'...
Le Comptoir OCTO - Équipes infra et prod, ne ratez pas l'embarquement pour l'...
 
PRESENTATION DE L'ACTIVE DIRECTORY SOUS WINDOWS SERVEUR.pptx
PRESENTATION DE L'ACTIVE DIRECTORY SOUS WINDOWS SERVEUR.pptxPRESENTATION DE L'ACTIVE DIRECTORY SOUS WINDOWS SERVEUR.pptx
PRESENTATION DE L'ACTIVE DIRECTORY SOUS WINDOWS SERVEUR.pptx
 
COURS D'ADMINISTRATION RESEAU SOUS WINDOWS
COURS D'ADMINISTRATION RESEAU  SOUS WINDOWSCOURS D'ADMINISTRATION RESEAU  SOUS WINDOWS
COURS D'ADMINISTRATION RESEAU SOUS WINDOWS
 
De l'IA comme plagiat à la rédaction d'une « charte IA » à l'université
De l'IA comme plagiat à la rédaction d'une « charte IA » à l'universitéDe l'IA comme plagiat à la rédaction d'une « charte IA » à l'université
De l'IA comme plagiat à la rédaction d'une « charte IA » à l'université
 
Le support de présentation des Signaux 2024
Le support de présentation des Signaux 2024Le support de présentation des Signaux 2024
Le support de présentation des Signaux 2024
 
Ouvrez la porte ou prenez un mur (Agile Tour Genève 2024)
Ouvrez la porte ou prenez un mur (Agile Tour Genève 2024)Ouvrez la porte ou prenez un mur (Agile Tour Genève 2024)
Ouvrez la porte ou prenez un mur (Agile Tour Genève 2024)
 
OCTO TALKS : 4 Tech Trends du Software Engineering.pdf
OCTO TALKS : 4 Tech Trends du Software Engineering.pdfOCTO TALKS : 4 Tech Trends du Software Engineering.pdf
OCTO TALKS : 4 Tech Trends du Software Engineering.pdf
 

Formation python

  • 1.
  • 2. 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
  • 4.
  • 6.
  • 7. 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écution L’interprétation : Chaque ligne source est analysée et exécutée. Avantage : Pas de code objet , pas d’édition de lien Inconvénient : Plus lent car on doit interpréter à chaque fois Technique 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
  • 8. 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
  • 9. Installation de Python et des modules complémentaires
  • 10. Installation de Python 1/2 Python peut s'installer sur des machines Unix, Windows et Mac Pour 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/2011 Lors de l'installation vous pouvez sélectionner le répertoire où sera installé Python, pour ma part je l'installe dans le répertoire /GNU La documentation (sous Windows) se trouve dans le répertoire /Doc de l'installation, on trouve un fichier avec l'extension .chm Vous prouvez trouver cette documentation sous python.org/doc
  • 11. 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 Path Ceci vous permet dans une fenêtre de commande de lancer l'application Python et de rentrer directement dans l'interpréteur Python.
  • 12. 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 sources win32com 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
  • 14. 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
  • 15. 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 : ==, !=, <, <=, >, >= 1 > 5 # False 9 <= 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 que deux valeurs : False et True
  • 16. Code source : le type entier 1/2 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) •Les entiers longs, limités par la taille de la RAM 2 ** 50 # 1125899906842624L 2 ** 80L # 1208925819614629174706176L 2 ** long(80) # 1208925819614629174706176L
  • 17. Code source : le type entier 2/2 Opérations sur les bases 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
  • 18. Code source : le type flottant Pour un flottant on peut utiliser la notation point décimal ou exponentielle 1.368 5e9 3.59871e-10 •Supporte les mêmes opérations que les entiers à l’exception de : 22.0 / 3 # 7.333333333333333 22.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
  • 19. 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
  • 20. Code source : les données et les variables Variable : C’est le nom donné à une valeur Du point de vue informatique c’est la référence à une adresse mémoire Par 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
  • 21. Code source : les mots réservés de Python
  • 22. 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)
  • 23. Code source : autres formes d’affectation On peut rencontrer d’autres formes comme : 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
  • 24. 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 flottant f = float(raw_input("Entrez une valeur flottante : "))
  • 25. Code source : et les sorties Pour effectuer une sortie on utilise l'instruction print : x = 5 y = 3 print x # 5 print "somme: ", x + y # 8 print "différence : ", x – y # 2 print "produit : ", x * y # 15 print "produit : %d" % (x * y) # 15 •Le séparateur virgule (,) permet d'éviter de retourner à la ligne
  • 26. Code source : les séquences Une séquence est un conteneur ordonné d'éléments indicé par un entier En Python il existe trois types de séquences prédéfinis les chaînes (normales, brutes ou Unicodes) les listes les tuples
  • 27. 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"
  • 28. 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 ! '
  • 29. 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
  • 30. 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'
  • 31. 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'
  • 32.
  • 33. 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.141592655897931 print "%4.2f" % (pi) # 3.14 print "%.4e" % (pi) # 3.1415e+000 print "%g" % (pi) # 3.14159
  • 34. 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.
  • 35. 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
  • 36. 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] = 7 print couleurs # ['rouge', 7, 'bleu', 'jaune']) list1 = [1, 2, 5.0] list2 = ['a', 'b', 'c'] list3 = [list1, list2] # une liste de liste print list3 # [[1, 2, 5.0], ['a', 'b', 'c']]
  • 37. Code source : les listes, méthodes et accès 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] L'indiçage d'une liste s'effectue de la même manière qu'une chaîne de caractères nombres[1:3] # [18, 9] nombres[:2] # [10, 18] nombres[:] # [10, 18, 9, 5, 1] nombres[-1] # 1
  • 38. Code source : les listes, initialisation chose = [] # une liste vide trucMuch = [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
  • 39. Code source : les listes, le découpage "slicing" 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 bois = ['chêne', 'acacia', 'peuplier'] bois[2:2] = ['platane'] # insertion en 3iéme position bois[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']
  • 40. Code source : les tuples 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 unTuple = ('chêne', 15, ["plaine", 1200]) •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
  • 41. Code source : les dictionnaires Un dictionnaire est un couple clef : valeur entouré d'accolades 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'}
  • 42. Code source : les dictionnaires, les méthodes Les méthodes suivantes sont spécifiques aux dictionnaires : dico.keys() # ['quatre', 'trois', 'deux'] dico.values() # ['four', 'three', 'two'] dico.iterkeys() # itérateur sur les clefs dico.itervalues() # itérateur sur les valeurs associées dico.iteritems() # itérateur clef, valeur [('quatre','four'), ('trois','three'), ('deux','two')] dico.has_key('un') # False dico.has_key('quatre') # True •Les dictionnaires ne sont pas ordonnés •On ne peut donc pas les indicer
  • 43. Code source : les dictionnaires, les itérateurs Les itérateurs sont des objets spécifiques permettant de parcourir un dictionnaire : 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')
  • 44. Code source : les ensembles Les ensembles sont gérés par la fonction set() : x = set ('abcd') y = set('bdx') •Les opérations : 'c' in x # True : appartenance x – y # set(['a', 'c']) : différence x | y # set(['a', 'c', 'b', 'd', 'x']) : union x & y # set(['b', 'd']) : intersection
  • 45. Le problème de référence
  • 46. Code source : le problème des références 1/3 L'opération d'affectation est plus complexe qu'il n'y parait i = 1 message = "mon message" •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
  • 47.
  • 48. 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]
  • 49. Les instructions de branchement
  • 50. Code source : if … [elif] … [else] Contrôler une alternative 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'
  • 51. 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) n = input('Entrez un entier [1..10] : ') while (n < 1) or (n > 10) : n = input('Entrez un entier [1..10] S.V.P. : ')
  • 52. Code source : for… [else] Parcourir une séquence 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
  • 53. Code source : Les listes compréhension 1/2 Une liste compréhension est une expression permettant de générer de manière très compacte une liste Elle revient à une boucle for qui construirait la même liste en utilisant 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)
  • 54. 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)
  • 55. Code source : break •Le break permet d'interrompre immédiatement le traitement d'une boucle for ou d'un while for 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
  • 56. Code source : continue •Le continue permet de reprendre immédiatement à la ligne de l'en-tête d'une boucle for ou d'un while for 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
  • 57. Le traitement des exceptions en Python
  • 58. Code source : gestion des exceptions, try … except … [else] •Permet de traiter des erreurs levées par Python en cours d'exécution 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
  • 59. Code source : gestion des exceptions, try … finally … •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 f = open(unFichier, "r") try : traitementFichier(f) finally: f.close()
  • 60. Code source : gestion des exceptions, raise •L'instruction raise permet de lever volontairement une exception if not 0 <= x <= 1 : raise ValueError, "x n'est pas dans l'interval [0 .. 1]"
  • 62. Code source : fonctions, déclaration •Une fonction est un groupe d'instructions regroupé sous un nom et s'exécutant à la demande def nomDeLaFontion(<paramétres>) : <blocInstructions> •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
  • 63. Code source : fonctions, passage des paramètres •Chaque argument dans la définition d'une fonction correspond, dans l'ordre, à un paramètre de l'appel def maFonction(x, y, z) : pass maFonction(3, 'e', 5.6) # x=3, y='e', z=5.6
  • 64. Code source : fonctions, paramètres par défaut •Dans une fonction il est possible d'avoir des paramètres par défaut def maFonction(x, y, z=0.0) : pass maFonction(3, 'e', 5.6) # x=3, y='e', z=5.6 maFonction(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.6 maFonction(3, y='e') # x=3, y='e', z=0.0
  • 65. Code source : fonctions, paramètres passage par tuple 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
  • 66. 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}
  • 67. La portée des objets
  • 68. 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 …
  • 69. 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 def 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 z x = 99 print maFonc(1) # affiche : 6 def maFonc(y) : # y et z sont affectés dans maFonc: locaux global x # permet de modifier x x += 5 z = x + y return z x = 99 print maFonc(1) # affiche : 105
  • 71. 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és d'effectuer la partition de l'espace de noms la documentation et les tests peuvent être intégrés aux modules.
  • 72. 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
  • 73. 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"
  • 75. 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 lecture f2 = open("monFichier", 'w') # ouverture en écriture f3 = open("monFichier", 'a') # ouverture en ajout f4 = open("monFichier", 'br') # ouverture en lecture binaire f1.close() # fermeture du fichier
  • 76. 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 f1 l1 = ["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
  • 77. Code source : Manipulation des fichiers, lecture •Les méthodes de lecture 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 f1.close() # fermeture du fichier
  • 79. 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é class Un objet class s'appel de la même manière qu'une fonction. L'objet créé, appelé instance, sait à quelle classe il appartient Une classe possède des attributs, des données et des fonctions, ces dernières s'appellent des méthodes Python définit des méthodes spéciales Une classe peut hériter d'une au plusieurs autres classes
  • 80. 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 corps La classe comporte un nom, la liste des classes dont elle hérite et éventuellement d'une docstring associée Le 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
  • 81. la programmation OO : instanciation Pour créer un objet on appel le nom de sa classe o1 = CMaClasse() # o1 est un objet de CMaClasse print dir(o1) # affiche les attributs de l'objet o1 print 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>
  • 82. 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 '__wea kref__' 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
  • 83. 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 = 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)
  • 84. 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 soulignement Elles permettent : d'initialiser un objet instancier de modifier son affichage de surcharger des opérateurs …
  • 85. 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 n print o1.x # 10
  • 86. 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 + 3 s = "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__…)
  • 87. 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 = 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) print v1 + v2 # affiche : vecteur(6.700000, 9.100000)
  • 88. 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.
  • 89.
  • 90. la programmation OO : problème d'héritage 2/3 class D(object) : def methode(self) : x = A() print x.methode() "D.methode" # Affiche : # A.methode class 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)
  • 91. la programmation OO : problème d'héritage 3/3 class D(object) : def methode(self) : x = A() print x.methode() "D.methode" # Affiche : # A.methode class 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()
  • 92. 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.
  • 93. 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"
  • 95. 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ère Les caractères alphabétiques et numériques correspondent à eux- mêmes Certains 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 ()
  • 96. Les expressions rationnelles : définition 2/3
  • 97. Les expressions rationnelles : définition 3/3
  • 98. Les expressions rationnelles : module re 1/2 En Python les expressions rationnelles sont traitées par le module re Pour 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. l'expression 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)
  • 99. 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 recherche c.endpos : l'indice de s de la fin de la recherche c.lastgroup : le nom du dernier groupe de correspondance c.lastindex : l'indice du dernier groupe qui a correspondu c.re : l'expression rationnelle r utilisée c.string : la chaîne s passée c.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 groupes c.groups([default=None]) : renvoie un tuple de sous-chaînes des différents groupes. None au contenu de default si le groupe
  • 100. 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
  • 102. 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 stderr fd.close()
  • 103. Programme externe : module wx Lancer un programme externe dans un GUI est très simple en utilisant 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() :
  • 104. 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 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
  • 105. 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
  • 106. Les interfaces utilisateurs graphiques (GUI)
  • 107. 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
  • 108. 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/
  • 109. IDE PyScripter éditeur/débogueur version 32/64bits PyDev plugin pour Eclipse IDLE éditeur fourni avec Python SciTE éditeur Komodo Edit éditeur écrit en Java Leo éditeur écrit en Python et Tkinter SPE éditeur puissant écrit en Python et wxPython par le développeur de Blender animation graphique 2D/3D
  • 111. règles d'écritures : Forme du code Indentation : Utilisez 4 espaces pour l’indentation Tabulation : Préférez les espaces. Espaces/Tabulation ne pas les mélanger dans un même projet Limitez vos lignes à 80 caractères Quand 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 # oui 2 un_long_calcul = variable + 3 taux * 100 4 5 # non 6 un_long_calcul = variable 7 + taux * 100
  • 112. 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
  • 113. 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)
  • 114. 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}}''' ...
  • 115. The Zen of Python
  • 116. PEP 20 The Zen of Python 1/2
  • 117. PEP 20 The Zen of Python 2/2
  • 118. FIN