Cours Python

Introduction, installation et prise en

main
Présentation de Python - Historique
Python est un langage de programmation créé en 1989 par Guido Van Russum.
En 2001 la Python Software Foundation a été créée, organisation à but non lucratif.

Version Année d’apparition Fonctionnalités supplémentaires

Python 1989 Inspiré du langage ABC

Python 0.9 1991 Première diffusion du code python

Python 2 2001 Support d’Unicode

Python 3 2009 Nombreuses fonctionnalités ajoutées ou modifiées.

Suppression d’éléments obsolètes.

Python est sous licence GPL depuis 2001

Présentation de Python - Caractéristiques
 Langage interprété
Python est un langage interprété, il n’a pas besoin d’être compilé. (Mais existe une compilation
partielle)
 Langage orienté objet
Python implémente le paradigme objet, cela permet de développer des applications structurée.
Cependant il permet également une programmation impératif (du type C) sans recours à la
programmation objet.
 Portabilité
Python s’exécute sur pratiquement toutes les plateformes utilisées actuellement : Unix, Windows,
MacOS, BSD…
 Puissant et diversifié
Python préserve la facilité d’utilisation des langages de scripts (Shell, Tcl…) tout en fournissant de
nombreux outils avancés typiques des langages de programmation objet (C++, Java…)
Langage interprété

Source : http://www.ukonline.be/programmation/java/tutoriel/intro.php
Domaines d'application
 Python couteau Suisse
 Un module pour toute utilisation

 Langage de script
 Remplace des langages de script tel que Shell
 Accès ressources
 Script de maintenance

 Projet
 Langage objet structuré, peut remplacer C++ ou Java

 Calcul scientifique
 Une bonne alternative à Matlab
 Modules : SciPy, NumPy, Mathplot (C)
 Calcul mathématique : sagemath
Forces et faiblesses

Force Faiblesse
 Stable  Non compilé
 Apprentissage : très simple  Donc plus lent

 Développement rapide  Diffusion plus restreinte qu’un

 Des modules pour presque langage type Java (Mais en
toutes les applications très net évolution)
 Grande communauté
 Utilisateurs : Google,
DropBox…
Développement projet : coût
12

10

0
C/C++ Java Php Python
Les différents Interpréteur de Python
 Python/CPython
 Il existe une API d’intégration Python/C qui permet d’étendre les programmes Python par des
composants écrits en C
 Ceci permet d’implémenter un système afin de réduire le temps de développement puis, sis besoin,
les éléments qui le nécessitent peuvent être réécrits en C
 Jython
 Permet la communication entre les programmes Python est des composants Java. Il peut être utile
pour fédérer des applications web en Java.
 IronPython
 Pour la plateforme .Net
 PythonWin
 PythonWin a été conçu pour le plateformes MS-Wiondows. Il rend possible l’interaction entre les
programmes python et des composants écrits avec l’API COM.
Les différentes versions de Python

V 2.7 V 3.4

 La plus utilisée  Utilisation d’itérateurs

 Nombre important de  Nombreuse
modules tiers fonctionnalités ajoutées
 Evolution maintenue ou modifiées
 Suppression d’éléments
obsolètes
 Moins de modules tiers,
en développement
Idle
 Présentation idle
L'interpréteur Python ipython
 IPython est un terminal interactif pour le langage de programmation Python qui
propose des fonctionnalités telles que l'introspection, une syntaxe additionnelle, la
complétion et un historique riche.
 Objectif : proposer une interface simple aux non-développeurs
 Spyder : interface intégrant IPython
L'interpréteur Python bpython
 N’existe pas en Windows
Eclipse & PyDev

 http://pydev.org/download.html
 http://pydev.org/manual_101_install.html
Initiation à la syntaxe Python
Syntaxe en bloc
 La plupart des structures en Python s’organisent sous la forme de blocs
d’instruction.
 La différence entre Python et C, par exemple, est que les blocs ne sont pas
délimités par des caractères spéciaux mais seulement en fonction de
l’indentation.
 Exemple:
Exécutable Python
 Un programme python est un ensemble
d’instructions
 Extension : .py
 Exécution : python test.py
Commentaires
#ceci est notre premier programme

a=2 #affectation de la variable a

if a>1: #vérifie si a est supérieur à 1

print 'vrai' #affiche vrai
else:
print 'faux' #affiche faux

print 'fin programme' #affiche fin de programme

Encodage
 Le programme au dessus ne fonctionnera pas
 Le texte contient des accents
 Il faut spécifier l’encodage :

# -*- coding : utf-8 -*-

Variables
 Nom de variables
 Il ne peut être composé que de lettres (non accentuées), de chiffres et du symbole
souligné « _ »
 Il ne peut commencer par un chiffre
 Python est sensible à la casse: les lettres majuscules et minuscules ne constituent
pas le même variable(NOM est différent de nom)
 Par convention les variables commencent par une minuscule ( les majuscules sont
réservés pour les classes)
 Typage dynamique: Lors de l’affectation, la variable prend automatiquement le type
correspondant.

>>>a = 2 #a est de type int

>>>b = 3.50 #b est de type float
>>>chaine = ‘Bonjour’ #chaine est de type string
>>>x = y = 10
>>>x,y,chaine = 2,3.5,’bonjour’
Manipuler les nombres
 Trois types de nombres: >>>5+3
>>>5*3
 Entiers
>>>5.*3
 Réels
>>>5/3
 Complexes
>>>5/3.
>>>5./3
>>>5.//3
 L’interpréteur de Python peut être >>>5%2
utilisé en tant que calculatrice.
>>>(1+5)*3
>>>(1+1j)*2
>>>(1+1j)*(1-1j)
Manipuler les chaînes
 Les chaînes de caractères sont de type String
 Elles s’écrivent de 4 façons différents
'ceci est une chaîne de caractères '
"ceci est une chaîne de caractères "
''' ceci est une chaîne de caractères'''
" " " ceci est une chaîne de caractères " " "
 Le symbole \ permet d’insérer des caractères spéciaux
Print 'c\'est\tun script python\n'
Print ('\'Ceci est une citation \
très longue\', Auteur')
 Découpage de chaîne:
chaine[position]
>>> chaine = 'Bonjour'
>>> chaine[1]
>>> chaine[1:3]
>>> chaine[n:m:p]
Application
 En utilisant la fonction raw_input, écrire un programme qui propose
de saisir un nom et renvoie « Bonjour nom ! »
 Ajouter au programme précédant la prise en compte du genre et
renvoyer « Bonjour genre Nom »
 Limiter le choix du genre en proposant de choisir 0 pour madame ou
1 pour monsieur.
 Prendre en compte l’heure, pour afficher bonjour ou bonsoir.
Les opérateurs
 Priorité
 Lorsqu’il y a plus d’un opérateur dans une expression, l’ordre dans lequel les
opérations doivent être effectuées dépend de règles de priorité, identique aux
règles mathématique. Si deux opérateurs ont la même priorité, l’évaluation se fait
de gauche à droite.
 Associativité
 Lorsque deux opérateurs ont la même précédente c’est l’associativité qui
détermine l’ordre d’exécution des opération
 Les opérateur s sont en général associés de gauche à droite. Cependant certains
opérateurs comme les opérateurs d’assignation ont une associativité de droite à
gauche
 2+3+4 est évalué comme (2+3)+4
 Par contre a=b=c est trait é comme a=(b=c)
Les opérateurs
 Opérateurs d’affectation
 Exemples :
 a, b, c = 2, 5, 10
 a += 3 # équivaut à a = a + 3, donc a vaut maintenant 5
 b *= 4 # b vaut maintenant 20
 c /= 2 # c vaut maintenant 5

 Opérateurs logiques
 a and b : ET logique booléen, si a est faux, retourne a et b non évalué, sinon
retourne b
 a or b : OU logique booléen, si a est vrai, retourne a et b non évalué, sinon
retourne b
 not a : NON logique, si a est faux, retourne 'True', sinon retourne 'False’

 Opérateurs de comparaison
 a = 1<3 # a vaut 'True' car 1 est inférieur à 3.
Les opérateurs
 Quelques opérateurs classiques
Les types de données standard
Types numériques
 Conversion
>>>int(3.5)
>>>float(3)
>>>int(‘3’)
>>>int(1+1j) #erreur
Séquences
 Dans python, le type séquence correspond à une collection ordonnée d’objet
 Non modifiables
 Str (chaîne de caractères)
 Tuple
>>>tuple1=1,2,3.5,’coucou’
>>>tuple2=(1,2,3.6,’coucou’)
 Modifiables
 Liste
>>>liste1=[1,’Bonjour’, 3.5]
Chaînes de caractères
 Les méthodes de la classe String
 >>>str.__doc__

 Quelques exemples:
 >>>chaine=‘Bonjour, ceci est du Python’

 >>>print chaine # dans python 3.x >>>print(chaine)

 >>>chaine.upper()
 >>>chaine.lower()
 >>>chaine.title()
 >>>chaine.isupper()
 Concaténation
 >>>chaine1,chaine2 = ‘Bonjour’, ‘tout le monde’
 >>>chaine1+’ ‘+chaine2
 Test d’appartenance
 >>>‘our’ in chaine #retourne un booléen
Application : manipulation de chaînes
 Affecter une variable avec une chaîne de caractères
 Mettre tout en majuscule
 A-t-on modifié la variable?
 Définir une autre variable contenant le chaîne en
majuscule.
Chaînes de caractères
 Remplacement d’une séquence dans une chaîne
 chaine.replace(texte1, texte2[,nbmax])
 Exemples:
 >>>chaine1=‘Bonjour tout le monde’
 >>>print chaine1.replace(‘jour’,soir’)
 >>>chaine2 = chaine1.replace(‘jour’,soir’)
 >>> print chaine1, chaine2
 Convertion
 Str ->int
 Exemple
 >>>chaine=‘123’

 >>>print chaine+1

 >>>print int(chaine)+1
Découpage de chaînes
Il est possible d'extraire une partie d'une chaîne de caractères :

nom_chaine[début:fin:pas]
# Donne les caractères d'indice i tel que 'debut <= i < fin', le caractère d'indice égal à fin
n'est donc pas pris en compte

Exemples :
chaine = "voici un exemple"
print(chaine[:3]) # renvoie 'voi', équivalent à chaine[0:3]
print(chaine[2:5]) # renvoie 'ici'
print(chaine[7:]) # renvoie 'n exemple', tout ce qui est après l'indice 7
Listes
Définition
Une liste se définit avec la syntaxe suivante:
nom_liste=[element1, element2,element3]
Les éléments peuvent être de types différents
Accès à un élément
>>>liste=[1,2,’texte’]
>>>liste[1]
>>>liste[1] += 2
Les références
Les références : lors d’une affectation d’une variable à une autre, python effectue une
référence et non une copie :
L= [1,2,3]
M=['x',L,'y']
print(M) # Renvoie ['x', [1, 2, 3], 'y']
L[1]=0
print(M) # Renvoie ['x', [1, 0, 3], 'y']
# M contient une référence vers les données de L, donc modifier L
modifie aussi M
# Pour créer une véritable copie de la liste, si M ne devait pas
être modifiée,
# il faudrait utiliser L[:]
L= [1,2,3]
M=['x',L[:],'y']
print(M) # Renvoie ['x', [1, 2, 3], 'y']
L[1]=0
print(M) # Renvoie ['x', [1, 2, 3], 'y']
print(L) # Renvoie [1,0,3]
Liste de compréhension
 Syntaxe : [f(x) for x in seq if cdt(x)]
 Exemple :
 L = [‘Toto’, ‘titi’, ‘TaTa’]
 Retourner la liste des chaînes de L qui commencent par
une majuscule tout en les mettant en miniscule
Application : recherche pdfs
 Soit une liste de fichiers d’extension différentes ( .txt,
.pdf, .py…)
 Ecrire un programme qui retourne la liste des pdfs,
leur nombre
 2 solutions :
 En utilisant append
 En créant une nouvelle liste à partir de la première
Tuples
 Un tuple est une séquence dans laquelle il n’est pas possible de modifier les
éléments. C’est une séquence non modifiable.
 Pas de suppression
 Pas d’ajout d’élément
 Pas de modification d’élément
 Exemple :
unTuple = tuple("Ok !")
print(unTuple) # Renvoie ('O', 'k', ' ', '!')
tuple2 = ('Ok !', 23, 34, 45, True)
print(tuple2) # Renvoie ('Ok !', 23, 34, 45, True)>
Exemple de tuple utilisé implicitement : l'affectation multiple
a,b = 3,4 # Équivaut à (a,b) = (3,4)

 Remarque : pour définir un tuple à un élément il est nécessaire d'ajouter une virgule,
sinon Python considère l'élément comme un nombre. tupleUnElement = (1,)
Dictionnaires
 Définition
 En python, un dictionnaire permet de stocker un ensemble de données tout comme
le fait une liste ou un tuple. La différence est que les données ne sont pas
ordonnées
 Chaque donnée est associée à une clé et non à un indice. Chaque ajout de
donnée consiste à ajouter un couple (clé, valeur)
 Les dictionnaires sont de la catégorie maps
 Caractéristique
 Les dictionnaires sont délimités par des accolades {}
 Les clés doivent être de type non modifiables (entier, chaîne, tuple) : elles ne
doivent donc pas être des variables
 Un dictionnaire ne peut pas contenir deux clés identique. En revanche, rien
n’empêche d’avoir deux valeurs identiques.
 Création directe
 nomDictionnaire = { cle : valeur, cle2 : valeur2, cle3 : valeur3 }
 Exemple :
 dictionnaire = {"Hello !" : "Bonjour !", " Thanks !" : "Merci !", "Bye !" : "Au revoir !« }
Manipulation de dictionnaires
 Ajout & modification
 dictionnaire = {}
 dictionnaire["pseudo"] = "user"
 dictionnaire["mot de passe"] = "*"
 Accès à une valeur
 print(dictionnaire["mot de passe"])
 Update() : Méthode qui permet d’ajouter au dictionnaire tous les couples (clé, valeur)
passés en arguments:
 dico1 = dict([('abcdef'[i], i) for i in range(6)])
 dico2 = dict(clé1=1,clé2=2,clé3=3)
 dico1.update(dico2)
 print(dico1)
 Clear() : effacer tous les couples du dictionnaire
 dico1 = dict([('abcdef'[i], i) for i in range(6)])
 dico1.clear()
 print(dico1)
Manipulation de dictionnaires
 Pop() : supprimer le couple précisé par la clé et renvoie la valeur associée à la clé

 Del() : supprime le couple associé

 Values() : renvoie la liste des valeurs contenues dans le dictionnaire

 Keys(): renvoie la liste des clés contenus dans le dictionnaire

Manipulation de dictionnaire
 Accès au clé:

 Accès aux clé et valeurs

Dictionnaires et fonctions
 Les dictionnaires peuvent servir à stocker des fonctions

 Application
Ensembles
 Définition
 Un ensemble est une collection non ordonnée d’objets unique
 Il n’y a donc pas de relation d’ordre et il est impossible de retrouver deux éléments
identique
 Déclaration
>>>e1 = set((1,1,2,3))
>>>e2 = set([3,4])
>>>{1,2,3} # attention ceci est différent d’un dictionnaire
>>>liste = [1,1,1,2,2,3]
>>>ensemble = set(liste)
>>>print ensemble
>>>liste2 = list(ensemble)
>>>e1&e2
>>>e1|e2
>>>e1-e2
>>>e1^e2
Les structures de contrôle
Structures de test
 Structure de test: if
Structures de test : elif
Structures de boucle: while
Mot clé : break
Mot clé : continue
Boucle For
 Syntaxe:
 For element in liste:
Executer instruction
 Exemple:

 En principe for s’applique sur tout itérateur, plus loin l’exemple sur la lecture des
fichiers.

 Itérateur : objet qui possède deux méthodes, __iter__ et __next__.

Application
 Ecrire un programme qui renvoi la liste des nombres
premiers inférieurs à n.
 On pourra utiliser:
 2 boucles for
 Range
 %
 Break
 Append pour remplir la liste
Les fonctions
Fonctions prédéfinies et originales
 print/ print()
 La fonction print permet d’afficher des données dans la console.

 input(), raw_input()
 La fonction input permet de récupérer une valeur rentrer par l’utilisateur
 Cette fonction peut prendre en paramètre une chaine de caractères indiquant à l’utilisateur ce
qu’il doit entrer
Les fonctions
 Définition
 Une fonction est composé de :
 Son nom
 Ses paramètres ou arguments: données ou variables passées à la fonctions
 Sa sortir: la ou les valeurs retournées par la fonction

 Avantages
 Le code est réutilisable. S’il est nécessaire de faire la même démarche plusieurs fois, la
fonction permet de définir la démarche puis de l’utiliser par un simple appel
 Décomposition du code. Les fonctions permettent de décomposer le code en morceaux qui ont
des rôles bien définis
Les fonctions
 Déclaration

 Appel

 Fonction sans paramètres

 Fonction avec paramètres

Les procédures
 Les fonctions qui ne renvoient rien sont appelé des procédures
 En voici une qui affiche un texte dans la console mais ne renvoie aucune valeur

 Lorsqu’une fonction n’utilise pas l’instruction return, alors elle renvoie None.
Portée des variables
 Les variables définies dans une fonction ont une portée limitée à la fonction. A
contrario, une variable définie dans le programme générale peut être utilisée dans une
fonction
 Lorsqu’une variable est utilisée, elle est d’abord cherchée localement puis ensuite si
elle n’est pas trouvée, elle est cherchée globalement
Mot clé global
 Le mot clé global permet de préciser qu’une variable appartient à l’espace mémoire
général et non à celui de la fonction. Cependant l’utilisation de ce mot clé n’est pas
toujours recommandé
Passage d’arguments
 Les arguments sont passés aux fonctions par affectation
 Les arguments non modifiables ne sont pas affecté

 Les arguments modifiables peuvent être affectés par la fonction

 Pour modifier un nombre il faut alors, soit utiliser une liste à un élément soit utiliser la syntaxe
suivante
Arguments par défaut
 Il est possible de donner une valeur par défaut à certains paramètres. Ainsi si la fonction est
appelée sans donner de valeur à ce paramètre, c’est la valeur par défaut qui est utilisée.
 Contraintes: les arguments avec valeur par défaut doivent être déclarés après les autres
arguments

 Appel désordonné : les arguments de la fonction peuvent être passés sans ordre. Cependant il faut
bien utiliser l’étiquette de l’argument (étiquette : le nom qui est associé à l’argument lors de la
déclaration de la fonction)
Nombre indéfini d’arguments
 Il est possible de définir une fonction avec un nombre d’arguments arbitraires.
 Pour préciser cela il faut ajouter le symbole ‘*’ devant l’étiquette du tuple
Applications : Arguments
 Ecrire une fonction qui prend en argument une liste,
vérifie que c'est bien une liste de int et affiche la
moyenne, la somme , le max et le min
 Aide :[x for x in Liste if cdt] pour créer une liste des
éléments de la Liste qui vérifient la condition cdt.
 Définir la fonction cap(‘ chaine test, Ok’)->’ Chaine
test, ok’ et la fonction iscap(‘ Chaine’)->booléen
(prendre en compte les points)
Récursivité
 Les fonctions peuvent faire appel à elle-même
 Les fonctions récursives ont besoin d’un cas d’arrêt, plus explicitement cela correspond au cas où
la fonction ne va plus s’appeler. Sans cela la fonction rentre dans une boucle infinie
Application récursivité
 Réécrire la fonction cap() pour prendre en compte
les points.
 Exemple : cap(‘test. un Test’)->’Test. Un test’
 Utiliser la récursivité
La fonction Lambda
 Définition : fonction simple et anonyme déclarée au milieu de code, stockée dans une variable.
>>> g = lambda x: x*2
>>> g(3)
 Utilisation :
 Exemple1 : on utilise la fonction filtrer(fonction, séquence), elle permet de filtrer une
séquence en ne gardant que les éléments renvoyant True.

 Exemple2 : on utilise la fonction map(fonction, liste), elle permet d’appliquer une opération à
l’ensemble des éléments de la liste
Application lambda
 Ecrire une fonction qui prend en argument un entier
n et retourne la fonction puissance n
 Retourner les éléments d’une liste qui commencent
par une majuscule
 in : L=[‘test’, ‘ToTo’, ‘Titi’]
 out : M=[‘ToTo’, ‘’Titi’]
 Retourner la longueur des éléments d’une liste
 Retourner la longueur + 1 des éléments d’une liste

 L=[liste de chaines de caractères]

La fonction print()
 Présentation : permet d’afficher des données sur la console

 Formatage de variables:

%s : pour chaîne de caractère

%d : pour un entier
%f : pour un réel
Instruction yield
 L’instruction yield dans une fonction permet de retourner un générateur. A chaque itération, elle
agit comme un return.
 Le générateur permet de parcourir une liste à l’aide de la méthode next(). A chaque appel de
next(), la fonction reprend là où elle s’était arrêtée
 Exemple :
Application yield
 Définir un générateur qui retourne un suite
décroissante de valeurs
 rrange(n,m,p) -> [n,n-p,n-2*p,… (abs(m/p)+1)*p]
 Exemples:
 rrange(6) -> [6,5,4,3,2,1,0]
 rrange(6,2) -> [6,5,4,3]
 rrange(6,2,2) -> [6,4]
Application : calcul âge
 Définir une fonction qui prend en argument une date et
retourne l’âge.
 Aide:
 from datetime import date
 aujourdhui = date.today()
 date(1980,2,28)
 dateAnniversaire=dateNaissance.replace(year= aujourdhui.year)
 aujourdhui < dateAnniversaire
 aujourdhui.year
Manipulation de fichiers
Lecture et écriture séquentielle
 Pour ouvrir un fichier : fonction open()
 Chemin
 Mode
 Cette fonction renvoie un objet à stocker dans une variable.

 Mode d’ouverture

 Pour fermer un fichier (indispensable pour libérer la ressource ) : la fonction close()

Lecture contenu fichier
 Lecture intégrale : la fonction read()

 Liste des lignes: la fonction readlines()

 Lecture ligne par ligne

 Lecture d’une ligne : La méthode readline() retournera tout d’abord la première ligne. Puis la
seconde et ainsi de suite
Se déplacer dans un fichier
 Tell() : elle permet de déterminer la position actuelle du curseur.

 Seek() : permet de déplacer le curseur de lecture du fichier

Ajouter un argument à la méthode readline() permet d’indiquer le nombre d’octets à lire, ici 4.
Ecrire dans un fichier
 Write() : permet d’écrire une chaîne de caractères

 Utiliser une boucle

 Writelines() : permet d’écrire une liste de chaînes

Le mot clé with
 Fermeture de fichier: importante pour libérer la ressource (le fichier) pour qu’il puisse être
accessible par d’autres programmes.
 Problème: si une erreur survient, la ligne qui ferme le fichier n’est pas appelée.
 Il existe le mot clé with, il permet d’éviter ce genre de problème

 Avec with, le fichier est systématiquement fermé à la fin du bloc.

 Closed : permet de vérifier si un fichier est fermé, elle renvoi un booléen
Application (écrire/lire fichier)
 Écrire un programme qui permette de créer et de
relire aisément un fichier texte.
 Votre programme proposera un choix, soit
d’enregistrer de nouvelles lignes de texte, soit
d’afficher le contenu du fichier.
 L’utilisateur devra pouvoir entrer ses lignes de texte
successives en utilisant simplement la touche
<Enter> pour les séparer.
 Pour terminer les entrées, il lui suffira d’entrer une
ligne vide.
La Programmation
Orientée Objet
Pourquoi et quand développer en
modèle objet ?
 En principe : on peut réaliser avec la programmation objet la même chose qu’avec la
programmation impérative et vis versa.
 Mais par souci de :
 Clarté : une perception plus intuitive de l’univers des données à traiter
 Structuration de projet : modularité, séparation de couches, modèle UML
 Outils puissants : héritage, polymorphisme…
 Rapidité de développement
 Maintenance facile
 Contexte (exemple interface graphique)
Cas de figure

Animaux

Chasser()
Boire()

Point d’eau
Boire()

Brouter()

Croitre()
Cas de figure
proie Animal
Id Id
Nom Nom
Etat Etat
Brouter(herbe) Boire()
Eau

prédateur
Id
Nom
Etat
Chasser(proie)

Herbe
Taille

Croitre()
Classes, Méthodes et Attributs
 Classe : un modèle englobant des objets qui sont identifiables par les mêmes donnée
et ont les mêmes comportements
 Elle est ainsi définie par:
 Nom
 Attributs : données
 Méthode : comportements
Espaces de nom et instances
 Espace de nom : permettent de faire des
regroupements logiques et résoudre les Module
collisions de noms.
 Les différents espaces noms Classe
 De méthode
 De classe
Méthode 1
 De module
 Types
 Global
 Local
 Instance : un objet d’une classe
 Exemple : Soit une classe Personne dont les
attributs sont nom, prenom, age. Méthode 2
Personne1(‘Dupond’, ‘David’, 25) est une
instance, soit un objet, de la classe Personne.
Encapsulation
 L'encapsulation est un mécanisme consistant à rassembler les données et les
méthodes au sein d'une structure en cachant l'implémentation de l'objet, c'est-à-dire
en empêchant l'accès aux données par un autre moyen que les services proposés.
L'encapsulation permet donc de garantir l'intégrité des données contenues dans l'objet
 Elle permet également d’effectuer d’autres tâches que de déterminer une valeur ou la
modifier
Héritage et polymorphisme
 L’héritage entre classes  Polymorphisme est l'idée de
 Exemple : Les classes Herbivore et permettre à un même code d'être
Carnivore héritent de la classe utilisé avec différents types
Animal, en l’occurrence la méthode (classes)
boire()

Animal

Source:http://www.commentcamarche.net/contents/8
11-poo-le-polymorphisme
proie prédateur
 Exemple : Addition (+) change
selon la classe.
 1+2
 ‘ceci est’ +’ un texte’
Les patrons de conception (motif de
conception/Design pattern)
 Un recueil de bonnes pratiques (dans le cadre de la programmation
objet) de conception pour un certain nombre de problèmes
récurrents en programmation basé sur les retours d’expériences.
 Exemple : MVC est une combinaison de patrons de conception

Motif d’architecture

Motif de conception

Syntaxe
Python Orienté Objet
Classes, Méthodes et Attributs
 En python tout est objet : les chaînes de caractères, les listes,…
 Par convention, les noms de classes commencent souvent par une majuscule et ne
comporte pas le caractère souligné ‘_’
 L’encapsulation des données : garder privées certains données de l’objet, il n’est pas
possible d’accéder directement à ces données. Il est nécessaire de créer des
accesseurs qui vont permettre d’obtenir la valeur d’un attribut et des mutateurs qui
vont permettre de modifier cette valeur.
 Eléments d’une classe:
 Nom de classe :
 Attributs : variables définies dans le corps de la classe
 Méthodes : des fonctions définies dans le corps de la classe
Les constructeurs
 Le constructeur (une méthode) sert à créer des instances de la classe. C’est une
méthode spéciale __init__. Elle est appelée lors de l’instanciation
 Syntaxe
def __init__(self, attribut1,atrribut2…):
self.attribut1=attribut1
self.attribut2=attribut2
self.methode(*)

 Le mot clé self : représente l’instance qui va être créée.

 Exemple :
class Personne(object):
def __init__(self, nom, prenom, age):
self.nom=nom
self.prenom=prenom
self.age=age instanciation
personne1=Personne(‘Dupond’, ‘Pierre’, 30)
#L’argument self correspond à personne1

 Application: afficher le nom de personne1

Méthodes
 Définition : une fonction qui s’applique à une instance de la classe.
 Le premier paramètre d’une méthode est toujours l’objet, défini par self.

class Personne(object):
def __init__(self, nom, prenom, age):
self.nom=nom
self.prenom=prenom
self.age=age

def afficher(self):
print "Je m'appelle %s %s et j'ai %d ans" %(self.nom,
self.prenom, self.age)

personne1=Personne('dupond', 'david',25)
# personne1.adresse='nice'
# print personne1.adresse
personne1.afficher()
Application
 Dans la classe, modifier l’attribut âge par date de
naissance de type date et implémenter la méthode
calculAge()
Espaces de noms
 Globals() : liste de variables Module
globales
 Locals() : liste des variables Classe
locales
 Lors d’un appel de variable, Python
Méthode 1
cherche dans :
1. Espace de noms local,
spécifique à la fonction/méthode
en cours.
2. Espace de nom, spécifique au
module en cours Méthode 2
3. Espace de noms prédéfini,
global à tous les modules

Source:http://python.developpez.com/cours/DiveIntoPython/p
hp/frdiveintopython/html_processing/locals_and_globals.php
Encapsulation
 __age vs _age

class Personne(object):

def __init__(self, nom): Accesseur

self.__nom=nom

def _get_age(self):
return self.__age
Mutateur
def _set_age(self, n):
self.__age = age

nom=property(_get_age, _set_age)
Méthodes spéciales
 __init__ : constructeur
 __repr__ : affecte la façon dont est affiché l’objet
 __str__ : converti l’objet en chaîne de caractères
 __add__ : appelée lorsque le symbole + est utilisé
 __eq__(self,objet2) : opérateur d’égalité
 …
Exemples de classes : String
 La classe string est la classe qui correspond aux chaînes de caractères
 Quelques méthodes
Exemples de classes : listes
Héritage et polymorphisme
 Exemple héritage
Application héritage
 Définir la classe STR qui hérite de la classe str
 Définir les méthodes
 cap(self) : qui prend en argument self et retourne la même chaine
avec une majuscule au début de chaîne et après chaque ‘.’.
 iscap(self) : vérifie si une chaîne de caractères est sous format
cap.
 Polymorphisme
 __add__(self,autre) : concatène deux chaînes en mettant la
deuxième chaîne en cap.
Test de classes
 Issubclass() : vérifie si une classe est une sous-classe d’une autre classe

 Isinstance() : permet de vérifier si un objet est une instance d’une classe

L'introspection
 l’introspection consiste à >>> liste = [1,2,3]
considérer des modules et des >>> dir(liste)
fonctions en mémoire comme des >>> liste.append.__doc__
objets, à en obtenir des >>> help(liste.append)
informations et à les manipuler

 dir(objet) : retourne la liste des

méthodes et attributs de objet
 objet.__doc__ : retourne la
documentation de objet
 help(objet) : même résultat que
__doc__ représenté différemment.
Utilisation de la Librairie
standard
Arguments passés en ligne de commande.
 Pour lancer un script depuis une console

Test.py
print 'ok'

 Si cela ne fonctionne pas, il faut ajouter le lien vers python.exe dans la liste des
variables d’environnement.
Arguments passés en ligne de commande.
 Pour passer des arguments en ligne de commende

Test.py
import sys
for arg in sys.argv:
print arg
Application
 Ecrire un programme qui permet de prendre des
arguments en ligne de commande, vérifie que c’est
bien des entiers et calcule leur somme.
Solution

import sys
sum=0
for arg in sys.argv[1:]:
sum+=int(arg)
print sum

import sys
try:
print sum(map(int,sys.argv[1:]))
except:
print 'Le script prend uniquement des arguments entiers'
Expressions régulières
 Les expressions régulières sont un moyen de rechercher, extraire ou remplacer des expressions
dans une chaîne de caractères.
 Exemple d'utilisation : Les expressions régulières peuvent servir à vérifier la syntaxe de données
entrées par l'utilisateur dans un formulaire : le numéro de téléphone comporte bien 10 chiffres,
l'adresse e-mail a la bonne syntaxe...
 Caractères spéciaux
Expressions régulières
 Classes de caractères: groupement de caractères placés entre crochets

 Groupes de caractères: groupement de caractères placés entre parenthèses afin

d’appliquer les caractères spéciaux à l’ensemble du groupe.
Le module re
 Module spécialement conçu pour travailler avec les expressions régulières, il permet de :
 chercher dans une chaîne de caractères
 remplacer des expressions
 compiler des expressions : stocker une expression régulière dans une variable
 Search(expression, chaine):permet de rechercher dans une chaîne de caractères
Application : Re
 Ecrire un programme qui permet de retrouver toutes les adresses mail dans
un fichier texte
Le module re
 Sub(expression, remplaçant, chaine) : permet de remplacer une expression dans une chaîne
Manipulation du système de fichiers.
 La manipulation du système de fichiers est triviale et puissante en Python.
 Modules importants : os, shutil…
 os.listdir(path) : renvoie liste des fichiers et répertoire
 os.path.exists(path) : vérifie si un dossier existe
 os.chdir(path) : change le répertoire courant au path donné
 os.path.isfile(fichier) : vérifie si c’est un fichier
 os.rename(src, dst)
 os.remove(fichier) : supprime le fichier
 os.walk(path) : retourne dirname, dirnames, filnames
 os.path.getsize(path) : retourne la taille d’un fichier
 os.rmdir(path) : supprime un répertoire vide
 shutil.rmtree(path) : supprime le répertoire et contenu
 shutil.copy2(file,dirout) : copie file dans le répertoire
dirout
 …
Application : manipulation système de fichiers
in out
nom nom2

Nom_prenom
prenom

Nom_prenom_date.pdf
Date

Nomprenom.pdf
Présentation de quelques modules
importants de la bibliothèque standard.
 datetime
 os, shutil
 sqlite3
 Pickle (sérialisation)
 Csv
 Dom
Datetime
 Module python standard pour gérer des objet de type datetime

from datetime import date

def calculerAge(dateNaissance):
today = date.today()
anniversaire = dateNaissance.replace(year=today.year)
if anniversaire > today:
return today.year - dateNaissance.year - 1
else:
return today.year - dateNaissance.year

print calculerAge(date(1980,2,29))
 Pickle
 Persistance d’objet
exo_pickle.py Test_pickle.p exo_depickle.py

import pickle ccopy_reg import pickle

_reconstructor from exo_pickle import Test
class Test(object): p0
def __init__(self, valeur): (c__main__
self.valeur=valeur Test fichier=open('test_pickle.p','
def imprimer(self): p1 r')
print 'test ok' c__builtin__ obj=pickle.load(fichier)
object obj.imprimer()
if __name__=='__main__': p2 print obj.valeur
test=Test('valeur1') Ntp3 fichier.close()
test.imprimer() Rp4
fichier=open('test_pickle.p','w') (dp5
pickle.dump(test,fichier) S'valeur'
fichier.close() p6
S'valeur1'
p7
sb.
Accès aux bases de données
relationnelles (survol)
 Il existe plusieurs modules pour accéder à une base
de données depuis le code Python
 Psycopg2 : pour accéder à une base PostgresSQL
 MysqlDB : pour accéder à une base Mysql
 sqlite3 : un moteur de base de données , contrairement à
mysql ou postgres (modèle client-serveur), sqlite utilise
un système de fichier pour simuler un client-serveur
(module sqlite3)
Les exceptions
Présentation
 Les exceptions sont les messages que l'interpréteur affiche lorsque le programme
rencontre une erreur. Les informations comprises dans une exception sont
généralement le lieu et la cause de l'erreur.
 La gestion des exceptions consiste à proposer au programme une suite d'instructions
à exécuter en cas d'erreur afin qu'il ne sorte pas du flux d'instructions.
 Exemples d'exceptions :
 Accéder à une clé non-existante d'un dictionnaire déclenche une exception
KeyError
 Chercher une valeur non-existante dans une liste déclenche une exception
ValueError.
 Utiliser un indice qui n'existe pas dans une séquence déclenche une exception
IndexError.
 Appeler une méthode non-existante déclenche une exception AttributeError.
 Mélanger les types de données sans conversion déclenche une exception
TypeError.
 Tenter de diviser par zéro déclenche une exception ZeroDivisionError
 Utiliser une mauvaise syntaxe (problème de parenthèses,...) déclenche une
exception SyntaxError.
 Essayer de lire un fichier qui n'existe pas déclenche une exception I0Error.
Utilisation de try et except :
 La structure minimale pour gérer les exceptions est l'utilisation des mots clés try et except. Le mot
try permettra de définir le bloc d'instructions à tester, le mot except correspond aux instructions à
exécuter en cas d'erreur. Voici la syntaxe :

try:
# bloc à essayer
except:
# bloc qui sera exécuté en cas d'erreur

 Exemple :
try :
nombre = input("Entrez un nombre : ")
nombre = int(nombre)
print("Vous avez bien tapé un nombre !")
except :
print("Vous auriez dû taper un nombre...")

 Inconvénients de cette structure :

 Dans l'exemple, le problème n'est pas totalement résolu, le message d'erreur est affiché mais
la suite du programme ne pourra pas utiliser d'entier 'nombre‘
 Cette syntaxe ne différencie pas les exceptions qui pourront être levées dans le bloc try, les
exceptions peuvent être de plusieurs types, ici rien n'est précisé.
Préciser le type d’exception
 Dans de nombreux cas, il n'existe pas seulement une exception possible lors d'une opération. Il est
alors possible d'utiliser une syntaxe qui permet de définir les instructions en fonction de l'exception.

try:
 instructions
except typeException :
instructions2

 Exemple d'application Instruction à tester : resultat = numerateur / denorninateur. Tout d'abord, il

est nécessaire de déterminer les exceptions possibles :
 NameError : l'une des variables numérateur ou dénominateur ria pas été définie (elle n'existe pas).
 TypeError : l’une des variables numérateur ou dénominateur ne peut diviser ou être divisée (les
chaînes de caractères ne peuvent être divisées, ni diviser d'autres types, par exemple).
 ZeroDivisionError : si la variable dénominateur est égale à O.

try:
resultat = numerateur / denominateur
except NameError:
print(*La variable numerateur ou denominateur n'a pas été définie.')
except TypeError:
print("La variable numerateur ou denominateur possède un type
incompatible avec la division.')
except ZeroDivisionError:
print(*La variable denominateur est égale à O.‘)
Préciser le type d’exception
 Autres syntaxes possibles
 Il est possible d'effectuer les même instructions pour plusieurs types d'exceptions.
try:
resultat = numerateur / denominateur
except ZeroDivisionError:
print("La variable denominateur est égale à O.")
except (NameError.TypeError) :
print("Une erreur est survenue.")

 Si vous ne connaissez pas toutes les exceptions possibles, alors le dernier bloc except ne doit pas
contenir de type d'exception
try:
resultat = numerateur / denominateur
except NameError:
print("La variable numerateur ou denominateur n'a pas été définie.")
except ZeroDivisionError:
print("La variable denominateur est égale à O.")
except : print("Une erreur est survenue.")

 Renvoyer le message fourni par Python :

try:
# bloc de test
except type_de_l_exception as exception_retournee:
print "Voici l'erreur : ", exception_retournee
Mot clé else
 Dans un bloc try, le mot clé else va permettre d'exécuter une action si aucune erreur
n'est trouvée dans le bloc. Il permet de continuer le programme après la recherche
d'erreurs.

try:
resultat = numerateur / denominateur
except NameError :
print("La variable numerateur ou denominateur n'a pas été définie.")
except ZeroDivisionError:
print("la variable denominateur est égale à O.")
else:
print("le résultat obtenu est: ", resultat)
Mot clé finally
 Le mot clé finally permet d'exécuter du code après un bloc try, dans tous les cas de
figure, quelle que soit l'exécution du bloc try. Même s'il existe une instruction return
dans votre bloc except par exemple, le bloc finally sera exécuté.

try:
resultat = numerateur / denominateur
except ZeraivisionError:
print("La variable denominateur est égale à 0.")
else:
print("Le résultat obtenu est", resultat)
finally:
print("Fin du programme ! ")
Mot clé pass
 Imaginons que vous souhaitiez tester un bloc d'instructiorts mais ne faire aucune
action lorsque ce bloc amène une erreur. Ceci pose un problème car un bloc try ne
peut pas exister sans au moins un bloc except.
 Il existe alors un mot clé pass qui permet de gérer ce problème, il est utilisé avec la
syntaxe suivante :
try:
# test d'instruction(s)
except type_de_l_exception:
pass # rien ne doit se passer en cas d'erreur

 Ce mot clé permet de passer le bloc except sans effectuer aucune action.
 Le mot clé pass n'est pas propre aux exceptions, il peut aussi être utilisé dans des
conditions, ou dans des fonctions que vous voulez laisser vide
 Exemple : try:
fsock = open(filename, "rb", 0)
try:
fsock.seek(-128, 2)
tagdata = fsock.read(128)
finally:
fsock.close()
except IOError:
pass
Les assertions
 Les assertions sont un moyen simple de s'assurer qu'une condition est respectée avant de
poursuivre l'exécution du programme.
 En général, les assertions sont utilisées dans des blocs try except. Pour écrire une assertion, il faut
utiliser le mot clé assert suivi d'une expression qui renvoie True ou False. Si l'expression renvoie
faux, rien ne se pages, sinon un exception AssertionError est levée.
 Exemple:
var = 5
assert var == 5
assert var == 8 # Renvoie une exception AssertionError

 Les assertions permettent de lever des erreurs là où Python n'en trouve pas lui même. Par
exemple, l'utilisateur doit entrer une année, il est préférable de s'assurer que celle-ci n'est pas
négative :

annee = input("Entrez une année supérieure à 0 :"

try:
annee = int(annee) # conversion de l'année en entier
assert annee > 0
except ValueError:
print("Vous n'avez pas entré un nombre")
except AssertionError:
print("L'année entrée est inférieure ou égale à 0.")
Lever une exception
 Il est possible de lever soi-même une exception avec le mot clé raise.
 La syntaxe est la suivante :
raise TypeException("message à afficher)

 Exemple :

annee = input() # l'utilisateur entre l'année

try:
annee = int(annee) # on tente de convertir l'année
if annee<=0:
raise ValueError("l'année entrée est négative ou nulle")
except ValueError:
print("La valeur entrée est invalide (l'année est peut-être
négative).")
Créer une exception
 Pour créer une exception, il suffit de définir une classe qui dérive de la classe
Exception telle que :

class MonException(Exception):
pass

 Vous pouvez maintenant lancer et récupérer votre exception :

try:
raise MonException("Mon message d'erreur")
except MonException, (instance):
print "Le message d'erreur : " + instance.message
Application : calcul d’âge
 Dans la classe Personne prendre en compte les
années bissextiles en utilisant les exceptions
 Dans la class STR : interdire l’opération de
multiplication par un entier
Importation de module
Création IHM
Principes de programmation des interfaces
graphiques.
 Une interface graphique est un dispositif de dialogue Homme-Machine (au même titre
qu’une console)
 Les éléments
 Fenêtres
 Conteneurs
 Widgets (outils)
 Evénements (équivalent de commande en console)
 Souris
 Clavier
Présentation de la bibliothèque wxPython.
 WxWidgets
 Bibliothèque graphique libre
 Multi-plateforme
 S’adapte à l’environement
 Ecrire en C++
 WxPthon : binding vers WxWidgets
 Particulièrement complète
 N’existe pas en Python3, en développement
 Dispose d’une interface de démo
 wysiwyg
Une fenêtre
 Premier pas
#!/usr/bin/python
# simple.py

import wx

app = wx.App()
frame = wx.Frame(None, -1, 'simple.py')

frame.Show()
app.MainLoop()

 app = wx.App() : tout programme wxpython doit avoir un objet

application
 frame = wx.Frame(None, -1, 'simple.py') : définition d’une
fenêtre de la class Frame(parent, id, title)
 frame.Show(): affichage de la fenêtre
 app.MainLoop() : cycle interminable qui guète les événements
Exemple
 Ecrire le même programme en utilisant:
 Une classe qui hérite de la classe Frame
 En instanciant notre fenêtre comme objet de cette
classe
Menus et barre d’outils

 Un outil:
 Présentation graphique
 Capture d’événement
 Méthode en cas de capture
Menu
import wx

class Example(wx.Frame):
def __init__(self, parent,id,title,newsize):
super(Example, self).__init__(parent,id,title,size=newsize)
menubar = wx.MenuBar()
fileMenu = wx.Menu()
fitem = fileMenu.Append(wx.ID_EXIT, 'Quit', 'Quit application')
menubar.Append(fileMenu, '&File')
self.SetMenuBar(menubar)
self.Bind(wx.EVT_MENU, self.OnQuit, fitem)
self.SetSize((300, 200))
self.SetTitle('Simple menu')
self.Centre()
self.Show(True)

def OnQuit(self, e):

self.Close()

if __name__ == '__main__':
ex = wx.App()
Example(None,-1,’ma fenetre’, (500,300))
ex.MainLoop()
Sous menu

imp = wx.Menu()
imp.Append(wx.ID_ANY, 'Import newsfeed list...')
imp.Append(wx.ID_ANY, 'Import bookmarks...')
imp.Append(wx.ID_ANY, 'Import mail...')
fileMenu.AppendMenu(wx.ID_ANY, 'I&mport', imp)
Toolbar
import wx

class Example(wx.Frame):

def __init__(self, *args):

super(Example, self).__init__(*args)
toolbar = self.CreateToolBar()
qtool = toolbar.AddLabelTool(wx.ID_ANY, 'Quit', wx.Bitmap('texit.png'))
toolbar.Realize()
self.Bind(wx.EVT_TOOL, self.OnQuit, qtool)
self.SetTitle('Simple toolbar')
self.Centre()
self.Show(True)

def OnQuit(self, e):

self.Close()

def main():

ex = wx.App()
Example(None)
ex.MainLoop()

if __name__ == '__main__':
main()
Conteneur wx.Panel
 Ajouter un conteneur au code de la Frame
panel = wx.Panel(self, -1)
wx.TextCtrl(self, pos=(30, 3), size=(120, 20))

 Pour utiliser le conteneur panel en dehors de la

classe frame
self.panel = wx.Panel(self, -1)
Présentation des Widgets disponibles (liste
non exsaustive).
 wx.Button
 wx.BitmapButton
 wx.StaticLine
 wx.StaticText
 wx.StaticBox
 wx.ComboBox
 wx.CheckBox
 wx.StatusBar
 wx.RadioButton
 wx.Gauge
 wx.Slider
 wx.SpinCtrl
wx.Button

cbtn = wx.Button(self, label=‘Afficher', pos=(20, 30), size=(100,20))

cbtn.Bind(wx.EVT_BUTTON, self.Afficher)
wx.BitmapButton

cbtn = wx.BitmapButton(pnl,-1, wx.Bitmap('../imgs/boutton.png'), pos=(20, 30))

cbtn.Bind(wx.EVT_BUTTON, self.OnQuit)

 La méthode OnQuit à définir

wx.StaticLine

wx.StaticLine(pnl, pos=(25, 50), size=(220,1))

wx.StaticText

wx.StaticText(pnl, label='Ceci est un texte', pos=(25, 30))

wx.StaticBox

wx.StaticBox(pnl,label='Texte', pos=(20, 20), size=(220,50))

wx.ComboBox
distros = [‘option1‘, ‘option2‘, ‘option3']

self.st = wx.StaticText(pnl, label='', pos=(50, 140))

cb = wx.ComboBox(pnl, pos=(50, 30), choices=distros,

style=wx.CB_READONLY)

cb.Bind(wx.EVT_COMBOBOX, self.OnSelect)

def OnSelect(self, e):

i = e.GetString()
self.st.SetLabel(i)
wx.CheckBox

cb = wx.CheckBox(pnl, label='Show title', pos=(20, 20))

cb.SetValue(True)

cb.Bind(wx.EVT_CHECKBOX, self.ShowOrHideTitle)
wx.StatusBar

self.sb = self.CreateStatusBar()
wx.RadioButton

self.rb1 = wx.RadioButton(pnl, label='Value A', pos=(10, 10),style=wx.RB_GROUP)

self.rb2 = wx.RadioButton(pnl, label='Value B', pos=(10, 30))
self.rb3 = wx.RadioButton(pnl, label='Value C', pos=(10, 50))

self.rb1.Bind(wx.EVT_RADIOBUTTON, self.SetVal)
self.rb2.Bind(wx.EVT_RADIOBUTTON, self.SetVal)
self.rb3.Bind(wx.EVT_RADIOBUTTON, self.SetVal)

def SetVal(self, e):

state1 = str(self.rb1.GetValue())
state2 = str(self.rb2.GetValue())
state3 = str(self.rb3.GetValue())

self.sb.SetStatusText(state1, 0)
self.sb.SetStatusText(state2, 1)
self.sb.SetStatusText(state3, 2)
wx.Gauge

self.gauge = wx.Gauge(pnl, range=TASK_RANGE, size=(250, 25))

self.gauge.SetValue(self.count)
Les sizers
 Conteneur qui permet de calibrer les widgets
 wx.BoxSizer
 wx.StaticBoxSizer
 wx.GridSizer
 wx.FlexGridSizer
 wx.GridBagSizer
wx.BoxSizer
 Ce sizer permet de mettre plusieurs widgets dans
une ligne ou une colonne. Nous pouvons mettre un
sizer dans un sizerexistant. De cette façon, nous
pouvons créer des modèles très complexes.
vbox = wx.BoxSizer(wx.VERTICAL)
vbox.Add(bouton, 1, wx.EXPAND | wx.ALL, 20)
Vbox.Add(self.st)
self.SetSizer(vbox) )
wx.GridSizer
 Le wx.GridSizer
permet de créer des
widgets dans une
table à 2 dimentions.
Chaque cellule dans
la table a la même
taille.
vbox = wx.BoxSizer(wx.VERTICAL)
vbox.Add(bouton, 1, wx.EXPAND | wx.ALL, 20)
Vbox.Add(self.st)
self.SetSizer(vbox) )
gs=wx.GridSizer(ligne, colonne)
gs.AddMany( [(wx.Button(self, label='Cls'), 0, wx.EXPAND),
(wx.Button(self, label='Bck'), 0, wx.EXPAND),
(wx.StaticText(self), wx.EXPAND),
(wx.Button(self, label='Close'), 0, wx.EXPAND)])
vbox.Add(gs, proportion=1, flag=wx.EXPAND)
self.SetSizer(gs)
Application : Calculatrice
 Boutons: 0 à 9, C et ‘=‘, x, …
 Self.Fit() : center et retirer espace d’un fenêtre
 Wx.BoxSizer(vertical)
 evt.GetEventObject().GetLabel()
 Wx.Gridsizer
 Eval(chaine)->effectue le calcul contenu dans chaine
import wx def OnButton(self, evt):
import math vbtn = evt.GetEventObject().GetLabel() # la valeur du bouton
class Calculatrice(wx.Frame): if vbtn == "=": # calcul
def __init__(self):
chaine = self.barresaisi.GetValue()
wx.Frame.__init__(self, None, -1, "Calculatrice basic")
# ignorer lorsque la chaine est vide
sizer = wx.BoxSizer(wx.VERTICAL)
if not chaine.strip():
return
self.barresaisi = wx.TextCtrl(self, -1) # barre d'affichage
# on effectue le calcul
sizer.Add(self.barresaisi, 0, wx.EXPAND) # ajout barre affichage a
sizer if chaine[:3]=='rac':
gsizer = wx.GridSizer(5,4) # un sizer de type tableau pour contenir les result = eval(str(math.sqrt(float(chaine[3:]))))
boutons autre que =
else:
for ligne in ["7", "8", "9", "./’ ,"4", "5", "6", "*,"1", "2", "3", "-’ ,"0", ".", "C",
"+’ ,"rac", "**", "", ""]: result = eval(chaine)
for ele in ligne: # Show result
btn = wx.Button(self, -1, ele) self.barresaisi.SetValue(str(result))
gsizer.Add(btn) elif vbtn == "C": # effacer
self.Bind(wx.EVT_BUTTON, self.OnButton, btn) self.barresaisi.SetValue("")
sizer.Add(gsizer, 1, wx.EXPAND)
# bouton egale
else: # ajout chaine dans la barre de saisie
btnegal = wx.Button(self, -1, "=")
self.barresaisi.SetValue(self.barresaisi.GetValue() + vbtn)
self.Bind(wx.EVT_BUTTON, self.OnButton, btnegal)
self.equal.SetFocus() # Set the [=] button in focus
sizer.Add(btnegal, 0, wx.EXPAND)
self.equal = btnegal
if __name__ == "__main__":
# ajout sizer
# Run the application
self.SetSizer(sizer)
# retrait espace app = wx.App()

sizer.Fit(self) dlg = Calculatrice()

dlg.Show()
app.MainLoop()
Manipulation CSV
Présentation
writer
writer
Exemple writer
Résultat writer
reader
Exemple reader
Les « bonnes pratiques »
Documentation avec DocStrings
 La DocString est une chaîne de caractères que l’on n’assigne pas, et qui est placée à un endroit
spécifique du code pour décrire ce dernier.
 Fonction
 Exemple # -*- coding: cp1252 -*-
def ajouter(a,b):
"""Ajoute deux nombres l'un à l'autre et retourne
le résultat.
"""
return a + b

 help >>> help(ajouter)

Help on function ajouter in module __main__:

ajouter(a, b)
Ajoute deux nombres l'un à l'autre et retourne
le résultat.

 Ou (pour appeler uniquement la doc)

Documentation : DocStrings
 Classe
class MaClasse(object):
"""
Ceci est une documentation de ma classe
"""

def methode(self):
"""
Retourne un objet univers, prêt
à être impitoyable.
"""
pass
 Module
"""Ceci est la documentation de mon module"""

class MaClasse(object):
"""
Ceci est une documentation de ma classe
"""

def methode(self):
"""
Retourne un objet univers, prêt
à être impitoyable.
"""
pass
Documentation avec PyDoc
 Pydoc :Module python pour générer automatiquement de la documentation en ligne
 Exemple

 Commande : python <chemin absolu \pydoc.py> -w votreModule (cela génère un

fichier votreModule.html)
 Exemple : python c:\python27\lib\pydoc.py –w module
Tests unitaires
 La fonction carré
def carre(x):
return x**2

 Un test sur cette fonction

def testcarre():
for x, r in {0:0,1:1,-2:4}.items():
if carre(x) !=r:
print 'erreur de test: la valeur attendue pour le carre de %d\
est %d. la valeur retournee est %d' %(x,r,carre(x))
break
else:
print 'test reussi'
Tests unitaires avec DocTest
 Doctest : module Python qui utilise la docstring pour définir des tests
 Syntaxe:
 Dans le corps du module ou dans la fonction à tester
 Dans la docstring

"""
…
>>> carre(2)
4
>>> [carre(long(n)) for n in range(6)]
[0,1,4,9,16,25]

…
"""

 Appel
if __name__ == "__main__":
import doctest
doctest.testmod()
""" >>> factorial(30.1)
This is the "example" module. Traceback (most recent call last):
...
The example module supplies one function, factorial(). For ValueError: n must be exact integer
example,
>>> factorial(30.0)
265252859812191058636308480000000L
>>> factorial(5)
120
It must also not be ridiculously large:
"""
>>> factorial(1e100)
Traceback (most recent call last):
def factorial(n):
...
"""Return the factorial of n, an exact integer >= 0.
OverflowError: n too large
"""
If the result is small enough to fit in an int, return an
int.
Else return a long. import math
if not n >= 0:

>>> [factorial(n) for n in range(6)] raise ValueError("n must be >= 0")

[1, 1, 2, 6, 24, 120] if math.floor(n) != n:

>>> [factorial(long(n)) for n in range(6)] raise ValueError("n must be exact integer")

[1, 1, 2, 6, 24, 120] if n+1 == n: # catch a value like 1e300

>>> factorial(30) raise OverflowError("n too large")

265252859812191058636308480000000L result = 1

>>> factorial(30L) factor = 2

265252859812191058636308480000000L while factor <= n:

>>> factorial(-1) result *= factor

Traceback (most recent call last): factor += 1

... return result

ValueError: n must be >= 0

Factorials of floats are OK, but the float must be an exact
integer: if __name__ == "__main__":
import doctest
doctest.testmod()
Débugger avec PyLint
 Pylint est un outil qui vérifie les erreurs dans le code Python, tente de faire appliquer
une norme de codage et détecte les mauvais codes.
 Install: pip install pylint
 Appel : pylint nom_module
Installation PIP
 Un outil pour installer et gérer les packages python
 Téléchargement : pip-installer.org (get-pip.py)
 Installation : python get-pip.py
Conventions de nommage
 Les conventions de nommage d’une librairie Python sont un peu en désordre, ce qui fait que nous
n'auront jamais un ensemble complètement cohérent -- néanmoins, voici quelques lignes
directrices.
 Descriptif: Styles de Nommage
 Prescription: Conventions de Nommage
 Les Noms de Modules : module.py

 Les Noms de Classes : class MaClasse(object):

 Les Noms de Fonctions/méthodes : def maFonction() ou def ma_fonction()
 Les Noms de variables Globales : attention ‘_’
 http://lapagearegis.free.fr/guidedestyle.html

 NB : Les modules qui sont prévus pour être utilisés via "from M import *" devraient préfixer leurs
variables globales (et leurs fonctions et classes internes) avec un souligné, pour empêcher leur
exportation.
Structuration projet
 Nommage : des nom de variables, classes et fonctions/méthodes implicites
 Éviter from module import * , utiliser plutôt from module import e1,e2,e3,
mieux encore import module
 _VAR pour les variables globales non importées
 Éviter l’usage du typage dynamique:
 A=0
 A=‘chaine’
Les Modules de Python
Philosophie Python avec les modules
(standard, tiers)
 Built-in Modules:
>>import sys
>>sys.builtin_module_names
 Modules standard : https://docs.python.org/2.7/py-
modindex.html
Les modules os et subprocess (survol)

os subprocess
 Diverses interfaces de système d'exploitation  Diverses interfaces de système d'exploitation
– bas niveau – haut niveau
 module vous permet de frayer de nouveaux
 Ce module fournit un moyen d'utiliser la procédés, connectez à leurs tuyaux d'entrée /
fonctionnalité portable dépendant du système sortie / erreur, et d'obtenir leurs codes de
d'exploitation retour.
 Exemple utilisation:  Ce module remplace plusieurs anciens
modules et fonctions:
 import os  os.system
 os.popen(commande)  os.spawn*
 os.popen*
 popen2.*
 commands.*
 Exemple utilisation
 Import subprocess
 subprocess.Popen(commande)
 subprocess.call(commande)
Le module threading (survol)
 Ce module fournit des primitives de haut niveau pour travailler avec plusieurs threads
 Exemple:
 threading.current_thread() : retourne le thread courant
 threading.enumerate() : retourne les threads en vie
 threading.active_count() : compte le nombre de threads en vie

 En CPython, en raison de l'interprète de verrouillage global, un seul thread peut

exécuter du code Python à la fois (même si certaines bibliothèques orientées vers la
performance pourraient surmonter cette limitation). Si vous souhaitez que votre
application fasse un meilleur usage des ressources informatiques des machines multi-
core, il est conseiller d'utiliser le module multithreading.