FAQPython

FAQ Python
Date de publication : 24/05/2005
Dernière mise à jour : 23/05/2009
Cette FAQ a été réalisée à partir des questions posées sur le forum Python complétées
par d'autres questions qui pouvaient nous sembler intéressantes de traiter. Toutefois
il se peut que les réponses apportées contiennent des erreurs, imprécisions ... Vous
pouvez dans ce cas contacter un des membres de la rédaction pour lui faire part de
vos remarques.
L'équipe Python de Developpez.
Ont contribué à cette FAQ :
Guigui_ - oiffrig - Miksimus - naxelas -

Onarap - Choupi - THE_VIP - Wormus -
DiGiTAL_MiDWAY - airod - jean-jacques varvenne -
FAQ Python
1. Introduction (5) .......................................................................................................................................................................... 5

2. IDLE (3) .................................................................................................................................................................................... 7
3. Généralités (13) ......................................................................................................................................................................... 8
4. Mode console (4) .....................................................................................................................................................................16
5. Type de données (31) ..............................................................................................................................................................18
5.1. Les nombres (4) ..............................................................................................................................................................19
5.2. Les chaînes de caractères (17) ....................................................................................................................................... 22
5.2.1. String (10) .............................................................................................................................................................. 23
5.2.2. Les chaînes Unicode (5) ........................................................................................................................................27
5.2.3. Expressions régulières (2) ..................................................................................................................................... 29
5.3. Listes (6) ......................................................................................................................................................................... 30
5.4. Dictionnaire (4) ...............................................................................................................................................................33
6. Les fonctions (2) ......................................................................................................................................................................35
7. Programmation objet (5) ..........................................................................................................................................................37
8. Gestion Fichier/Répertoire (21) ...............................................................................................................................................40
8.1. Prérequis (1) ....................................................................................................................................................................41
8.2. Fichier (7) ....................................................................................................................................................................... 42
8.3. Répertoire (5) ..................................................................................................................................................................46
8.4. Fichiers de configuration (6) .......................................................................................................................................... 48
8.4.1. Fichiers variable=valeur (2) ...................................................................................................................................49
8.4.2. ConfigParser (4) .....................................................................................................................................................50
8.5. Compression/Archive (2) ................................................................................................................................................52
9. Base de registre sous Windows (4) .........................................................................................................................................54
10. Thread (3) .............................................................................................................................................................................. 56
11. Réseau / Web (9) ................................................................................................................................................................... 59
11.1. FTP (5) ..........................................................................................................................................................................61
12. Les erreurs (5) ....................................................................................................................................................................... 64
13. GUI (64) .................................................................................................................................................................................67
13.1. Tkinter / Tix / Pmw (55) .............................................................................................................................................. 68
13.1.1. Prérequis (4) .........................................................................................................................................................69
13.1.2. Tkinter (45) .......................................................................................................................................................... 71
13.1.2.1. Widget (4) ................................................................................................................................................... 72
13.1.2.2. Fenêtre (7) ...................................................................................................................................................74
13.1.2.3. Entry (5) ......................................................................................................................................................77
13.1.2.4. Button (2) ....................................................................................................................................................79
13.1.2.5. Label (1) ......................................................................................................................................................81
13.1.2.6. Listbox (3) ...................................................................................................................................................82
13.1.2.7. Canvas (3) ................................................................................................................................................... 84
13.1.2.8. Text (4) ....................................................................................................................................................... 86
13.1.2.9. Menu (3) ..................................................................................................................................................... 88
13.1.2.10. tkMessageBox (3) ..................................................................................................................................... 90
13.1.2.11. tkFileDialog (2) .........................................................................................................................................91
13.1.2.12. Gestion de la géométrie (1) ...................................................................................................................... 92
13.1.2.13. Evènements (5) ......................................................................................................................................... 93
13.1.2.13.1. Evènements Clavier (1) ................................................................................................................... 94
13.1.2.13.2. Evènements Souris (2) .....................................................................................................................95
13.1.2.14. Divers (2) .................................................................................................................................................. 96
13.1.3. Tix (6) .................................................................................................................................................................. 97
13.1.3.1. Widget (1) ................................................................................................................................................... 98
13.1.3.2. Tix.Combobox (2) .......................................................................................................................................99
13.1.3.3. Tix.Notebook (1) .......................................................................................................................................101
13.1.3.4. Tix.Meter (1) .............................................................................................................................................102
13.1.3.5. Tix.Balloon (1) ..........................................................................................................................................103
13.2. wxPython (6) ...............................................................................................................................................................104
-3-
Les sources présentées sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation de ces sources
constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2005-2009 Developpez LLC. Tout droits réservés Developpez LLC. Aucune
reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez
LLC. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://python.developpez.com/faq/
FAQ Python
13.3. pyGTK (2) .................................................................................................................................................................. 107

14. Optimisation (2) ...................................................................................................................................................................109
15. Déploiement (7) ................................................................................................................................................................... 111
15.1. Py2exe (6) ................................................................................................................................................................... 112
16. Autres bibliothèques (10) .................................................................................................................................................... 116
16.1. Pil - Python Image Library (7) ...................................................................................................................................117
16.2. Matplotlib (3) ..............................................................................................................................................................119
-4-
FAQ Python
Sommaire > Introduction

Qu'est-ce que Python ?
Auteurs : Guigui_ ,
Une présentation du langage Python est faite dans la première partie du cours de Swinnen qui vous montrera les
caractéristiques du langage: Apprendre à programmer avec Python. En voici un résumé
# Python est portable sur de nombreux OS (Unix, Mac, Windows, ...)
# Python est gratuit et utilisable sans restriction dans des projets commerciaux.
# La syntaxe de Python est très simple, l'indentation du code (plutôt que l'usage d'accolades) permet d'avoir des
programmes très lisibles et plus compactes
# Python détruit lui-même les objets créés lorsque plus aucune référence ne pointe sur eux
# Il n'y a pas de pointeurs explicites en Python.
# Python est orienté-objet. Il supporte l'héritage multiple et la surcharge des opérateurs.
# Python est dynamiquement typé.
# Python est extensible : On peut l'interfacer avec d'autres langages (C, C++, Delphi, Java, ...)
# La bibliothèque standard de Python est très riches et de nombreuses bibliothèques gratuites peuvent être facilement
ajoutées
Où trouver de l'aide pour Python ?

Auteurs : Guigui_ ,
La documentation en anglais est très importante, en français un peu moins.
Documentation officielle
Python Library Reference
The Python Language Reference
Global Module Index
Cours et tutoriel de Développez.com
Quelle implémentation de Python choisir ?

Auteurs : Guigui_ ,
Il existe plusieurs implémentations du langage Python:
• CPython, codée en C, la plus utilisée et appelée plus simplement Python

• Jython codée en Java et fonctionnant sur les machines virtuelles Java
• IronPython codée en C# et fonctionnant sur les plateformes .Net
Vous pouvez les télécharger à partir de notre rubrique Outils Python et avoir plus de détails sur leur fonctionnement.
-5-
FAQ Python
Si vous débutez en Python, téléchargez de préférence CPython. Toute la documentation du site ainsi que le forum sont
consacrés presque exclusivement à cette implémentation.
Quel éditeur utiliser ?

Auteurs : Guigui_ ,
Il est important d'utiliser un éditeur qui gère Python car le formatage du code est primordiale sous peine d'avoir des
erreurs de syntaxe (notamment au niveau de l'indentation)
Si vous faites uniquement de la programmation en mode console, l'éditeur IDLE proposé à l'installation de Python est
un bon choix avec en particulier l'indentation automatique et la coloration syntaxique.
Si vous aimez aussi l'auto-complétion, vous pouvez optez pour d'autres IDE que vous pouvez télécharger dans la
rubrique Outils Python
Si vous programmez des interfaces graphiques, vous pouvez également être aidés par des éditeurs spécialement conçus
pour cela tels que Boa Constructor téléchargeables depuis la même rubrique. En revanche, si vous voulez rester
complètement maître de votre code, il est peut-être préférable de tout programmer, ce qui n'est pas si difficile que
cela avec l'habitude. Vous trouverez quelques tutoriels pour programmer intégralement vos IHMs dans la rubrique
Tutoriels Python
A quelle version de Python se rapporte cette FAQ ?

Auteurs : Guigui_ ,
La FAQ Python se rapporte à la dernière release de Python. Actuellement, nous assurons que les codes source proposés
dans cette FAQ sont compatibles avec la version 2.6 de Python (ainsi que dans les versions ultérieures de la branche
2.x) mais dans la majorité des cas, ils fonctionneront également sans problème avec des versions antérieures. Lors de
nouvelles releases de Python, les pages seront mise à jour pour être conforme à cette release. Lorsque nécessaire, la
version utile de Python sera mentionnée.
-6-
FAQ Python
Sommaire > IDLE

Comment éditer un script python avec IDLE ?
Auteurs : Guigui_ ,
Pour ouvrir IDLE, distribué dans la distribution standart de Python, il suffit d'exécuter le fichier <PYTHONHOME>/
lib/idlelib/idle.pyw (typiquement sous Windows c:/python25/lib/idlelib/idle.pyw ). Une fois IDLE ouvert, il vous faut vous
mettre en mode éditeur si cela n'est pas fait par défaut (menu File -> New Window ). Vous n'avez alors plus qu'à charger
votre fichier (menu File -> Open... ).
Une autre solution est d'éditer directement votre script par un clic droit sur votre fichier puis Edit with IDLE.
lien : Comment configurer IDLE en mode Editeur ou Shell au démarrage ?
Comment configurer IDLE en mode Editeur ou Shell au démarrage ?

Auteurs : Guigui_ ,
Dans le menu Options, cliquez sur l'option Configure IDLE.... Cliquez ensuite sur l'onglet General. Vous pouvez alors
sélectionner l'option Open Edit Window si vous voulez ouvrir IDLE uniquement en mode éditeur ou bien Open Shell
Window si vous voulez ouvrir IDLE en mode interactif. A la prochaine ouverture de IDLE, l'option sera prise en compte.
Pourquoi j'obtiens le message d'erreur IndentationError:

unindent does not match any outer indentation level ?
Auteurs : Guigui_ ,
L'erreur IndentationError intervient lorsqu'il y a un problème d'indentation dans votre code. Dans IDLE, la première
ligne contient les caractères du prompt (>>>). Mais au niveau de l'alignement des blocks, il faut faire abstraction de
ce prompt.
>>> nb = input("Choisissez un nombre :")

Choisissez un nombre :5
>>> if nb > 0:
print "positif"
else: print "négatif"
File "<pyshell#18>", line 3

^
IndentationError: unindent does not match any outer indentation level
>>> if nb > 0:
print "positif"
positif
>>> if nb > 0:
print "positif"
positif
-7-
FAQ Python
Sommaire > Généralités

Comment exécuter un programme Python ?
Auteurs : Guigui_ ,
Les fichiers Python que vous pouvez utiliser portent les extensions .py, .pyc ou .pyo.
Sous Windows:
Les scripts Python sont exécutés par l'application python.exe ou pythonw.exe (si on ne veut pas que la console soit
affichée), fichiers que l'on retrouve dans le répertoire d'installation de Python (typiquement c:/python25). En général,
à l'installation de Python, cette association est faite d'elle-même et un double-clic sur votre script Python suffit pour
l'exécuter. Vous pouvez également l'exécuter à partir de la console DOS en tapant directement c:/python25/python.exe
monscript.py ou bien simplement python monscript.py si le répertoire c:/python25/ a été ajouté auparavant à la variable
d'environnement PATH de windows (Panneau de Configuration->Système->Avancé->Variables d'environnement).
Sous linux:
en début de script, il vous suffit d'insérer en première ligne #!/usr/bin/env python. Cette ligne permet au système Unix de
trouver quel logiciel doit être utilisé pour interpréter la suite du fichier. Donnez ensuite l'attribut exécutable au fichier
(soit en ligne de commande avec chmod+x monscript.py soit à partir d'un gestionnaire de fichier) et exécutez le fichier
à partir la ligne de commande python monscript.py
Certains éditeurs permettent également d'exécuter ses scripts. Par exemple sous IDLE, un simple F5 exécute votre
source.
lien : Comment ne pas afficher la fenêtre DOS à l'exécution du programme ?

lien : Comment empêcher la fermeture de la fenêtre DOS à l'exécution d'un programme ?
Comment obtenir des informations utiles sur l'utilisation d'un objet/module/fonction ?

Auteurs : Guigui_ ,
Avant même de rechercher dans une quelconque documentation (cours, tutoriel, FAQ, ...), vous pouvez obtenir
facilement des informations sur tout objet, module ou fonction que vous souhaitez utiliser. Pour cela, il suffit à partir
d'un interpréteur python, d'utiliser les fonctions dir([object]), help([object]) ou encore les docstrings avec l'attribut
__doc__.
dir([object]) retourne la liste des attributs de l'objet object. Ces attributs peuvent être par exemple le nom des classes ou
fonctions d'un module, le nom des attributs ou fonctions d'une classe, ... La liste obtenue n'est cependant pas forcément
complète.
help([object]) invoque le système d'aide intégré. Si aucun argument n'est donné, le système d'aide interactif démarre
sur la console de l'interpréteur. Si l'argument est une chaîne de caractères, celle-ci est considérée comme le nom d'un
module, fonction, classe, méthode, mot clé et la page d'aide détectée est donnée sur la console. Si l'argument est un autre
type d'objet, la page d'aide de cet objet est alors générée.
Enfin vous pouvez aussi visualiser les docstrings en appelant le paramètre __doc__ sur un objet.
Quelques exemples
## code pour obtenir des informations sur les string:
dir(str)
help(str)
str.__doc__
## code pour obtenir des informations sur le module math:

import math
dir(math)
help(math) ## ou help("math")
math.__doc__
## code pour obtenir des informations sur la fonction math.cos:

import math
dir(math.cos)
-8-
FAQ Python
Quelques exemples
help(math.cos) ## ou help("math.cos")
math.cos.__doc__
Comment obtenir des informations sur son système (d'exploitation, plateforme, python) ?
Auteurs : Guigui_ ,
Python propose 2 modules principaux pour obtenir un maximum d'informations sur le système sur lequel est installé
Python et sur Python lui-même, ce qui peut-être utile nécessaire si on développe une application multi-plateforme ou
devant être compatible avec différentes versions de Python. Ces 2 modules sont sys et platform. Il vous suffira
de parcourir les différents liens pour découvrir toutes les fonctions disponibles.
Par exemple, pour connaître le système d'exploitation, vous pouvez faire:
>>> import platform

>>> platform.platform()
'Windows-XP-5.1.2600-SP2'
>>> platform.system()
'Windows'
>>> platform.uname()
('Windows', 'ordiguigui', 'XP', '5.1.2600', '', '')
Pour connaître la plateforme sur lequel tourne Python:
>>> import sys

>>> sys.platform
'win32'
Pour connaître la version de Python:
>>> import sys

>>> import platform
>>> sys.version_info
(2, 5, 1, 'final', 0)
>>> sys.version
'2.5.1 (r251:54863, Apr 18 2007, 08:51:08) [MSC v.1310 32 bit (Intel)]'
>>> platform.python_version()
'2.5.1'
>>> platform.python_version_tuple()
['2', '5', '1']
Comment procéder à une installation silencieuse de Python sous windows ?

Auteurs : Guigui_ ,
La version 2.4 de Python est distribué sur Windows avec l'installateur de Microsoft (MSI). Vous pouvez ainsi en lui
appliquant les paramètres adéquats opter pour une installation silencieuse. La commande à utiliser est:
msiexec /i python<version>.msi /q
où python<version>.msi correspond au fichier à installer , msiexec est le l'installateur de microsoft (fichier msiexec.exe
qui doit se trouver dans <Windows>\System32\ si non reconnu)
-9-
FAQ Python
et q est un paramètre qui peut prendre les valeurs suivantes:
• qn: Pas d'interface

• qb: Affichage d'une simple barre de progression
• qb!: Comme qb mais sans le bouton Annuler
• qr: Affiche les boîtes de dialogue mais sans interaction avec l'utilisateur
• qn+: Comme qn avec affichage à la fin de la boîte de dialogue de fin d'installation
• qb+: Comme qb avec affichage à la fin de la boîte de dialogue de fin d'installation
On peut également rajouter un paramètre TARGETDIR si on veut changer le répertoire de destination
msiexec /i python<version>.msi TARGETDIR=d:\Python24
Pour une installation pour tous les utilisateurs, il est nécessaire de spécifier un autre paramètres ALLUSERS=1.
En résumé, pour faire une installation sans interaction de l'utilisateur mais avec affichage complet du processus
d'installation, il suffit d'utiliser la commander suivante
msiexec /i python-2.4.2.msi ALLUSERS=1 /qr
D'autres paramètres peuvent être utiliser. Pour plus d'information, vous pouvez consulter la documentation
officielle
Comment importer des modules/fonctions/fichiers ?

Auteurs : Guigui_ ,
Lors de l'importation d'un module, le programme va tout d'abord vérifier si le module à importer se trouve dans le
dictionnaire sys.modules (module de bases + les modules d'autres bibliothèques que vous avez installés). Si le module
n'est pas trouvé, le programme le cherchera à partir de la liste définie par sys.path (qui contient le répertoire courant,
la variable d'environnement PYTHONPATH entre autres)
Voici les syntaxes que vous pouvez utiliser:
import MonModule
import MonModule as MonAlias
from MonModule import *
from MonModule import MonObjet1 as MonAlias1, MonObjet2 as MonAlias2
import Tkinter
root=Tkinter.Tk()
import Tkinter as Tk
root=Tk.Tk()
from Tkinter import *
root=Tk()
On utilise régulièrement un alias lorsque le nom du module est long (genre Tk pour Tkinter). Pour les modules courts
(os, re), on se contente d'un import simple.
On déconseille l'utilisation de l'instruction from même si le programme est plus concis. Le code sera moins lisible car
on ne saura pas à priori d'où viennent les fonctions utilisées. De plus, cela pourra entraîner des conflits de noms.
f=open('test.txt', 'w') ## la fonction open est celle des objets prédéfinies de Python
- 10 -
FAQ Python
from os import *
f=open('test.txt',
O_CREAT) ## la fonction open est celle du module os, la définition de la fonction open du __builtin__ a été
## écrasée par celle de l'os lors lors de son import
Quid des importations circulaires ?

Auteurs : Guigui_ ,
L'importation circulaire typique est quand 2 modules s'importent mutuellement. Leur utilisation est en général
déconseillée et peut parfois introduire des erreurs à cause de variables non définies au moment des importations. Evitez
donc au maximum l'importation circulaire. Il y a en général presque toujours moyen de le programmer autrement. Si
pour vous, l'importation circulaire est inévitable, il vous faut simplement comprendre le fonctionnement de l'exécution
d'un programme afin de placer les instructions dans le bon ordre.
Nous allons partir sur un exemple simple. Nous avons 2 modules a.py et b.py qui effectueront respectivement un import
b et un import a et nous exécutons le script main.py qui lui même importe le module a.
Lorsque main.py tombe sur l'instruction import a, un objet sys.modules['a'] est alors créé et initialisé à vide. Le corps
du module a est alors exécuté jusqu'à ce qu'il tombe sur l'instruction import b. Un nouvel objet sys.modules['b'] est
alors créé et initialisé à vide; le corps du module b est alors exécuté. Lorsqu'il tombe sur l'instruction import a, comme
l'objet sys.modules['a'] existe déjà, une variable globale a est alors liée dans le module b à cet objet; l'exécution du corps
du module b se poursuit alors jusqu'à la fin. Cependant, le module a n'ayant pas été entièrement chargée, le corps
du module b n'aura donc accès qu'aux objets déjà chargés dans le module a et des erreurs seront générés pour tout
accès à d'autres objets du module a. C'est pourquoi, dans ce cas précis, il est important de bien maîtriser l'ordre des
déclarations des objets dans chacun de vos modules.
Une fois que les 2 modules a et b auront été entièrement importés, il n'y aura bien entendu plus aucune erreur de ce type.
Comment importer un module qui n'est pas dans le répertoire courant ?

Auteurs : Guigui_ ,
Si vous voulez structurer vos projets en ayant des fichiers dans différents répertoires, vous aurez parfois des problèmes
au moment de l'importation des modules parce que Python ne saura pas où chercher vos modules. Il vous est
néanmoins proposé plusieurs solutions pour que l'importation se fasse sans erreur. Python cherche en premier lieu
le module à importer dans le répertoire courant. Il ira ensuite dans chercher dans les chemins définis par la variable
d'environnement PYTHONPATH. Cette variable d'environnement permet d'initialiser la liste sys.path à partir de
laquelle Python effectuera les importations. Vous pouvez modifier dynamiquement cette liste de chemins (liste qui ne
sera donc valable qu'à l'exécution de votre programme) en ajoutant les répertoires supplémentaires dans lesquels vous
voulez que Python cherchent les modules à importer.
import sys
sys.path.append(monchemin)
Depuis Python 2.5, il est également possible d'effectuer des importations relatives. Pour cela, il vous faut d'abord créer
un fichier __init__.py dans le répertoire contenant les modules à importer. Ce fichier peut être vide. Par exemple,
considérons un répertoire locale qui contient un répertoire A lui même contenant un fichier __init__.py vide et un fichier
testA.py. Depuis votre répertoire locale, vous pouvez importer testA par l'instruction import A.testA, from A import testA
ou from A.testA import *.
lien : What's New in Python: 4 PEP 328: Absolute and Relative Imports
- 11 -
FAQ Python
lien : Comment importer des modules/fonctions/fichiers ?
Comment déclarer une variable à partir d'une chaine de caractères ?

Auteurs : Guigui_ ,
Il arrive parfois qu'il nous faille déclarer des attributs à partir de la chaînes de caractères représentant leur nom, par
exemple lors de la lecture d'un fichier de configuration contenant le nom des variables et leur valeurs. Le nom de toutes
les variables (fonctions, classes ou simples attributs) sont conservés en Python dans des dictionnaires. Il suffit d'ajouter
un élément à ces dictionnaires pour créer une nouvelle variable.
Dans le cas d'un attribut: Pour récupérer l'ensemble des noms de variables globales, il suffit d'appler la méthode
globals()
>>> globals()['mavariable']=5
>>> mavariable
5
Dans le cas d'une classe, pour créer de nouveaux attributs, on peut utiliser l'appel au dictionnaire __dict__
>>> class maclasse:

def __init__(self):
self.__dict__['variable1']=[1,2,3]
print self.__dict__['variable1']
>>> a=maclasse()
[1, 2, 3]
Une autre façon, est d'utiliser la méthode global setattr(obj, name, value) qui aura le même effet
>>> setattr(a, 'variable2', (5,6))

>>> a.variable2
(5, 6)
Une autre méthode est d'utiliser directement la fonction exec(unstr) qui exécute la chaîne de caractères passé en
argument
>>> exec('mavariable=5')
>>> mavariable
5
>>> exec("mavariable=['5','6']")
>>> mavariable
['5', '6']
Dans le cas d'une fonction: il n'est pas possible d'utiliser directement l'ajout d'un élément en passant directement par
le dictionnaire. Il faudra passer par la méthode exec
>>> exec("def plus(x,y): print x+y")

>>> plus(3,5)
- 12 -
FAQ Python
Comment empêcher les messages d'avertissement lors de l'utilisation de caractères non-ASCII ?

Auteurs : naxelas ,
Quand vous lancez votre script Python, si celui-ci contient des caractères non-ASCII, vous pouvez avoir le message
d'avertissement suivant:
sys:1: DeprecationWarning: Non-ASCII character ... in file ... on line ..., but no encoding
declared;
see http://www.python.org/peps/pep-0263.html for details
Par défaut l'interpréteur s'attend à ne devoir traiter que des caractères ascii. L'encodage ascii ne contient que 256
caractères, n'incluant pas les caractères accentués et spéciaux du français. Pour que l'interpréteur reconnaisse les
caractères non ascii, vous devez déclarer l'encodage que vous utilisez au début du fichier source. Pour le français, les
encodages iso-8859-1, Latin-1, cp1252 ainsi que utf-8 fonctionneront.
La déclaration se fait comme ceci:
# -*- coding: iso8859-1 -*-
Pour plus de détails: http://www.python.org/peps/pep-0263.html
Comment quitter son application ?

Auteurs : Guigui_ ,
import sys
sys.exit()
Comment récupérer les paramètres passés à un programme ?

Auteurs : Guigui_ ,
Vous pourrez récupérer les paramètres passés à votre programme par l'attribut sys.argv qui contient la liste des
paramètres et où sys.argv[0] est le nom complet du programme appelé.
Comment lancer un programme externe ?

Auteurs : Guigui_ ,
Il existe de multiples façon pour exécuter un programme externe qui dépendront de plusieurs facteurs (si il y a ou
non des paramètres, si vous voulez attendre la fin du programme externe ou non avant de poursuivre le programme
principal, ...). Vous trouverez dans la Python Library Reference toutes les informations pour exploiter au mieux les
différentes méthodes exposées à la suite.
- 13 -
FAQ Python
Toutes ses fonctions sont obtenues à partir du module os ou subprocess. Tout d'abord, vous pouvez utilisez la fonction
os.startfile( path[, operation]) qui exécute le fichier path avec l'application associée par défaut et rend immédiatement
la main.
import os
os.startfile('c:/windows/notepad.exe')
os.startfile('MonImage.bmp')
Une deuxième méthode est la fonction os.system( command) qui exécute command, ne rend la main que lorsque
l'application lancée prend fin. Vous pouvez lancer l'application externe avec des paramètres.
import os
os.system("c:/windows/notepad.exe monfichier.log")
os.system('MonImage.bmp')
Une troisième méthode est la fonction os.spawnl(...) ou os.spawnv(...) ainsi que leurs variantes qui permet d'exécuter un
programme dans un nouveau processus. Le premier paramètre attendu peut prendre comme valeur os.P_WAIT pour
attendre la fermeture de l'application avant de poursuivre le programme principal ou os.P_NOWAIT pour rendre la
main immédiatement.
import os
os.spawnl(os.P_NOWAIT, "c:/windows/notepad.exe")
Une quatrième méthode est la fonction os.popen( command[, mode[, bufsize]]) qui exécute command dans un processus
enfant et rend immédiatement la main en retournant un descripteur du fichier.
import os
os.popen("c:/windows/notepad.exe monfichier.log")
Vous pouvez également regarder du côté du module subprocess ( Python Library Reference: Subprocess
management ) qui aura pour but de remplacer les 3 dernières méthodes.
lien : Python Library Reference: File Object Creation

lien : Python Library Reference: Process Management
lien : Python Library Reference: Subprocess management
Comment n'instancier qu'une seule fois un programme ?

Auteurs : jean-jacques varvenne ,
Pour n'instancier qu'une fois un programme, une solution simple peut être de créer un fichier au moment de l'exécution
du programme et de le supprimer à la fin de l'exécution. Il vous suffit alors de vérifier l'existence ou non de ce fichier pour
poursuivre l'exécution du programme. Le problème de cette solution peut cependant être l'absence de droit d'écriture
ou bien un plantage de l'application (ou bien une fermeture de l'application non prévu) qui empêcherait la suppression
de ce fichier.
Une deuxième solution consiste à créer un mini-serveur sur un port défini qui se contente de simplement exister. La
deuxième exécution d'un même programme générera une erreur lors de la tentative de création de ce mini-serveur sur
ce même port.
- 14 -
FAQ Python
#!/usr/bin/python
# -*- coding: iso-8859-1 -*-
from asyncore import dispatcher

import sys, time, socket
class Server( dispatcher ):

def __init__(self):
dispatcher.__init__(self)
self.create_socket( socket.AF_INET, socket.SOCK_STREAM )
self.bind( ( '', 50000 ) )
self.listen(1)
try:
Server()
except:
print 'Déjà en service !'
sys.exit()
print 'START'
time.sleep(10)
print 'STOP'
- 15 -
FAQ Python
Sommaire > Mode console

Comment ne pas afficher la fenêtre DOS à l'exécution du programme ?
Auteurs : Guigui_ ,
Si vous ne voulez pas que la fenêtre DOS s'ouvre, vous devez appeler votre programme par l'interpréteur pythonw (situé
dans le même répertoire que l'interpréteur python). En général, il suffit de changer l'extension de votre programme de
.py en .pyw. Si la fenêtre DOS s'ouvre encore, il vous faut alors associer manuellement les fichiers .pyw à pythonw.
Comment empêcher la fermeture de la fenêtre DOS à l'exécution d'un programme ?

Auteurs : Guigui_ ,
# Si votre programme ne présente aucun bogue, vous pouvez utilisez en fin de programme la fonction
raw_input(prompt='') qui attend l'entrée d'une chaine de caractères avant de poursuivre l'exécution du programme.
raw_input("Appuyer sur une touche pour quitter le programme")
.
# Si vous êtes sous Windows et que vous voulez exécuter un programme test.py, vous pouvez procéder de la manière
suivante:
créer un fichier test.bat (qui n'est autre qu'un fichier texte renommée avec l'extension bat) dans lequel vous tapez:
c:/python24/python.exe test.py
pause
ou si le programme python.exe est le programme par défaut pour l'exécution d'un fichier .py
test.py
pause
Comment effacer le contenu de la console Dos/Shell ?

Auteurs : Onarap ,
Sous Linux:
import os
os.system('clear')
Sous Windows:
import os
- 16 -
FAQ Python
os.system('cls')
Comment afficher un texte sans aller à la ligne

Auteurs : Guigui_ ,
Pour afficher un texte dans la console Python sans qu'il y ait un retour à la ligne, vous pouvez, soit à la fin de l'instruction
print ajouter
une virgule (mais cela ajoutera néanmoins un espace avec le prochain élément écrit sur la console, soit utilisez
l'instruction
sys.stdout.write(unstr) qui écrit unstr à la position courante du curseur. Avec cette méthode, pour retourner à la ligne,
il suffira
d'écrire le caractère "\n"
import sys
print "un texte sur la 1er ligne",
print "un autre texte toujours sur la 1er ligne"
sys.stdout.write("on est sur la 2ème ligne")
print "on est toujours sur la 2ème ligne",
sys.stdout.write("on est sur toujours sur la 2ème ligne\n")
print "on est sur la 3ème ligne"
- 17 -
FAQ Python
Sommaire > Type de données
- 18 -
FAQ Python
Sommaire > Type de données > Les nombres

Comment convertir un nombre d'une base quelconque en base 10 ?
Auteurs : Guigui_ ,
Pour convertir un nombre X (écrit sous forme d'une chaîne de caractères) d'une base quelconque en base 10 (ou nombre
entier), on utilise la fonction int(x [,base]) où base représente la base sous laquelle est écrit le nombre.
>>> int('AA', 16) ## Conversion de AA de la base 16 à la base 10

170
>>> int('0xAA', 16) ## Conversion de OxAA de la base 16 à la base 10
170
>>> int('71', 8) ## Conversion de 71 de la base 8 à la base 10
57
>>> int('071', 8) ## Conversion de 071 de la base 8 à la base 10
57
>>> int('AA', 11) ## Conversion de 11 de la base 11 à la base 10
120
Si base=0, la base est déterminée automatiquement en fonction de l'écriture du nombre sous forme de chaîne. Par
exemple, un nombre hexadécimale est écrit sous forme d'une chaîne commençant par 0x, un nombre octale sous forme
d'une chaîne commençant par 0. Dans ces cas-là, on n'est pas obligé de spécifier la base de départ en lui donnant la
valeur 0.
>>> int('0x15',0)
21
>>> int('071', 0)
57
Comment convertir un nombre entier dans une autre base ?

Auteurs : Guigui_ ,
Pour convertir un nombre entier (ou en base 10) en un nombre octal, on utilise la fonction oct(N)
>>> oct(21)
'025'
Pour convertir un nombre entier (ou en base 10) en un nombre hexadécimal, on utilise la fonction hex(N)
>>> hex(21)
'0x15'
A partir de la version 2.6 de Python, pour convertir un nombre entier (ou en base 10) en un nombre binaire, on utilise
la fonction bin(N)
>>> bin(21)
'0b10101'
- 19 -
FAQ Python
Pour convertir dans d'autres bases, vous devrez programmer vos propres fonctions
Comment convertir un nombre entier en binaire ?

Auteurs : oiffrig , Guigui_ ,
Il n'existe pas de fonctions dans la distribution de Python pour convertir un nombre entier en binaire. Vous devez donc
écrire votre propre fonction.
Voici une fonction qui construit une chaîne binaire à partir d'un nombre. Elle est basé sur l'algorithme d'Euclide.
def bin(n):
"""Convertit un nombre en binaire"""
q = -1
res = ''
while q != 0:
q = n // 2
r = n % 2
res = `r` + res
n = q
return res
>>> bin(109323)
'11010101100001011'
On peut accélérer le processus avec un code sur le même algorithme mais beaucoup plus concis (suppression de toutes
les variables intermédiaires); ce qui peut être utile si on a besoin de convertir beaucoup de nombres
def bin_optimise(n):
"""Convertit un nombre en binaire"""
if n == 0: return '0'
res = ''
while n != 0: n, res = n >> 1, `n & 1` + res
return res
Un petit test pour vérifier le gain en temps
import time
n = 1000000
a = time.clock()
for i in range(n): bin(i)
b = time.clock()
for i in range(n): bin_optimise(i)
c = time.clock()
print b-a, ',', c-b
>>> 15.9132169033 , 12.7892307542
A partir de la version 2.6 de Python, les nombres binaires font leur apparition et commence par 0b. Pour convertir un
nombre entier en binaire, il suffit alors de passer par la fonction bin
>>> print (0bbb)

7
>>> bin(7)
- 20 -
FAQ Python
'0b111'
Comment obtenir le code Ascii ou Unicode d'un caractère ?

Auteurs : Guigui_ ,
Pour obtenir le code ascii d'une caractère, il suffit d'appliquer la méthode ord(c) où c est le caractère en question. ord
renvoie un nombre entre 0 et 65535. S'il s'agit d'un caractère ascii, le code sera compris entre 0 et 255.
>>> ord("é")
233
>>> ord("a")
97
>>> ord(" ")
32
>>> ord(u'\u9000')
36864
Si vous voulez l'ensemble des codes ascii d'une chaîne de caractères, il suffit d'utiliser la fonction map( ord, machaîne)
ou bien d'utiliser une liste en intention.
>>> map(ord, "abcde")

[97, 98, 99, 100, 101]
>>> [ord(i) for i in "abcde"]
[97, 98, 99, 100, 101]
la méthode inverse est unichr(i) pour obtenir le caractère unicode de i ou chr(i) pour obtenir le caractère ascii de i. Dans
ce dernier ça, i doit être compris entre 0 et 255, une erreur est retournée sinon.
>>> unichr(63000)
u'\uf618'
>>> unichr(97)
u'a'
>>> chr(97)
'a'
- 21 -
FAQ Python
Sommaire > Type de données > Les chaînes de caractères
- 22 -
FAQ Python
Sommaire > Type de données > Les chaînes de caractères > String
Où trouver de l'aide ?
Auteurs : Guigui_ ,
un grand nombre de fonctions sur les strings accessibles directement sur les chaines de caractères sans importation
de nouveau module: string. Ainsi, vous pourrez trouver une explication complète (avec l'utilisation des paramètres
optionels) aux différentes fonctions présentées par la suite.
Comment extraire une sous-chaîne d'un string ?

Auteurs : Guigui_ ,
Comme pour tous les objets de type séquence, vous pouvez extraire une sous-séquence par la forme x[start:end:step] où
start est l'index de départ, end l'index de fin non inclu et step le pas. start et end peuvent être négatifs. Dans ce cas-là,
l'index est considéré comme relatif à la fin du string et len(x)+start ou len(x)+end leur sont substitués. De plus si start
est omis, il est considéré comme valant 0, si end est omis, il est considéré comme len(x). Si step est omis, il est traité
comme valant 1.
Ainsi, pour récupérer les permiers caractères (les plus à gauche) d'un string, il suffit d'utiliser la syntaxe x[:nb] où nb
représente le nombre de caractères à récupérer.
Pour récupérer les derniers caractères (les plus à droite) d'un string, il suffit d'utiliser la syntaxe x[-nb:] où nb représente
le nombre de caractères à récupérer.
>>> x = "0123456789"
>>> x[3:5]
'34'
>>> x[::2]
'02468'
>>> x[1::2]
'13579'
>>> x[:3]
'012'
>>> x[-3:]
'789'
Comment remplacer une chaine de caractères par une autre ?

Auteurs : Guigui_ ,
s.replace(old, new, maxsplit=sys.maxint) renvoit une copie de s où les occurences de la sous-chaine old est remplacée par
la sous-chaine new
>>>'tapadaca'.replace('a','i',2)
'tipidaca'
- 23 -
FAQ Python
Comment découper un string selon une chaine de caractères ?

Auteurs : Guigui_ ,
s.split(sep=None, maxsplit=sys.maxint) renvoit une liste L de strings où chaque élément de L est un mot de s, où la chaîne
sep sépare les mots. Si sep=None, les mots sont séparés par une suite quelconque d'espaces
>>>'a = b'.split('=')
['a ',' b']
>>>'a b c d'.split()
['a', 'b', 'c', 'd']
Comment supprimer une chaine de caractères en tête/fin d'un string ?

Auteurs : Guigui_ ,
s.strip(x=None) renvoit une copie de s où la chaine x en début/fin de s est supprimé. si x=None, ce sont les espaces qui
seront supprimés. lstrip et rstrip sont utilisées respectivement pour la suppresion à gauche et à droite
>>> 'aaaaabbbbbaaaaa'.strip('aaa')
'bbbbb'
>>> ' a '.rstrip()
' a'
Comment compter le nombre d'occurences d'une sous-chaine dans un string ?

Auteurs : Guigui_ ,
s.count(sub, start=0, end=sys.maxint) renvoie le nombre d'occurences de la souschaine sub dans s[start:end]
>>> 'tapadaca'.count('a')
4
Comment renverser une chaîne de caractères ?

Auteurs : Guigui_ ,
On peut utiliser les tranches de séquences de syntaxe s[i:j:k] qui retourne la sous-séquence de s comprise entre le ième
élément compris et le jème non compris de pas k
s[::-1] renvoie les éléments de s dans l'ordre inverse.
>>> mystr='abcde'
>>> mystr[::-1]
- 24 -
FAQ Python
'edcba'
Qu'est-ce qu'un raw string ?

Auteurs : Guigui_ ,
Un raw string est simplement une chaîne de caractères dont les séquences d'échappement avec le caractère \ (backslash
ou antislash) ne sont pas interprétées. Cela est particulièrement utile avec les chaînes de caractères représentant les
chemin d'accès à un fichier ou à un répertoire qui peuvent s'utiliser avec des / ou des \ et ainsi parfois entraîner
des erreurs si vous oubliez de doubler les backslash. Les raw string sont aussi très utiles pour améliorer la lisibilité
des expressions régulières friantes de backslash. Dans vos programmes, un raw string est simplement une chaîne de
caractères précédée de la lettre r. Vous pouvez voir les caractères spéciaux dans le Python Reference Manual qui
nécessiteront une attention particulière.
>>> a = "c:\python25\tcl\reg1.1\tclreg11.dll"
>>> a
'c:\\python25\tcl\reg1.1\tclreg11.dll'
>>> print a
c:\python25 cl
eg1.1 clreg11.dll
>>> a = r"c:\python25\tcl\reg1.1\tclreg11.dll"
>>> a
'c:\\python25\\tcl\\reg1.1\\tclreg11.dll'
>>> print a
c:\python25\tcl\reg1.1\tclreg11.dll
lien : Pourquoi j'obtiens une erreur lorsque mon string contient le caractère \ (backslash) ?
Pourquoi j'obtiens une erreur lorsque mon string contient le caractère \ (backslash) ?
Auteurs : Guigui_ ,
Le caractère \ (backslash) est en Python un caractère spécial qui peut donner un sens spécial au caractère le succédant.
Par exemple, '\t' est le caractère de tabulation. Vous trouverez la liste des caractères spéciaux dans le Python
Reference Manual.
Ainsi, lorsque vous travaillez avec des chaînes de caractères, si celle-ci contient un \, une erreur ou une mauvaise
interprétation de la chaîne peut apparaître, notamment lorsque vous manipulez sous windows des path de fichiers ou
répertoires.
Si vous avez besoin du caractère \ dans une de vos chaînes, dédoublez-le (\\) ou bien utilisez les raw string qui ne
considèrent pas le caractère \ comme spécial.
Dans le cas de fichiers ou répertoires sous windows, on peut aussi utiliser le caractère / (slash) à la place qui est reconnu
de la même façon.
>>> import os
>>> os.path.isdir('c:\python24\bin')
False
>>> os.path.isdir('c:\\python24\\bin')
True
>>> os.path.isdir(r'c:\python24\bin')
True
>>> os.path.isdir('c:/python24/bin')
- 25 -
FAQ Python
True
Comment gérer un compteur avec un nombre de chiffres constant ?

Auteurs : Guigui_ ,
Problèmatique: vous souhaitez gérer un compteur avec nombre de chiffres constants (donc en affichant des "0" à gauche
des nombres ne possédant pas assez de chiffres).
Pour cela, il vous suffit d'utiliser la fonction s.zfill( width) qui rajoute des caractères '0' devant la chaînes de caractères
jusqu'à ce que celle-ci ait une longueur égale à width. Si la chaînes de caractère a une longueur inférieure à width, celle-
ci est retournée telle quelle.
Vous pouvez également utiliser la fonction s.rjust( width[, fillchar]) qui permet d'ajuster une chaîne de caractères en
ajoutant à gauche le nombre de caractères fillchar nécessaires pour que la nouvelle chaîne de caractères est une longueur
égale à width
for i in range(1000): print str(i).zfill(3)

for i in range(1000): print str(i).rjust(3, '0')
La fonction s.ljust( width[, fillchar]) permet d'ajuster une chaîne de caractères en ajoutant à droite le nombre de
caractères fillchar nécessaires pour que la nouvelle chaîne de caractères ait une longueur égale à width
- 26 -
FAQ Python
Sommaire > Type de données > Les chaînes de caractères > Les chaînes Unicode
Quel est la différence entre une chaîne unicode et une chaîne normale ?
Auteurs : Guigui_ ,
Les chaînes normales décrites par le type str sont des chaînes d'octets qui peuvent être interprétées en connaissant leur
encodage. Ils en existent de nombreux comme l'ascii (7 bits) qui est l'encodage par défaut de Python, ISO-8859-1 (ou
latin_1 sur 8 bits) pour les langues occidentales, utf-8, utf-16, ...
Les chaînes unicode décrites par le type unicode permette de définir tout caractère existant où chaque caractère
nécessite plusieurs octets pour être codées (2 octets pour Python qui utilise unicode UCS2). Les chaînes unicode sont
reconnaissables par la présence du caractère u devant la chaîne.
Vous pouvez transformer une chaîne normale en chaîne unicode et vice versa.
Comment savoir si une chaîne de caractères est de type str ou unicode ?

Auteurs : Guigui_ ,
La méthode isinstance( object, classinfo) renvoie True si l'objet object est une instance de la classe classinfo ou d'une
classe dérivée.
a = u'a\xe2'
print isinstance(a, unicode) ## True
Comment convertir une chaîne normale en chaîne unicode ?

Auteurs : Guigui_ ,
Si vous avez une chaîne normale dont vous connaissez l'encodage, vous pouvez la transformer en chaîne unicode par la
fonction unicode( [object[, encoding [, errors]]]) où object est la chaîne à convertir et encoding, l'encodage d'interprétation
de object. Vous pouvez également utiliser la méthode decode( [encoding[, errors]]) appliquée à un objet de type str
strutf8 = '\xc3\xa2\xc3\xa4\xc3\xa0\xc3\xa9\xc3\xa8\xc3\xab\xc3\xaa'
## chaîne "âäàéèëê" encodée en utf-8
uni = unicode(strutf8, 'utf-8') ## uni = u'\xe2\xe4\xe0\xe9\xe8\xeb\xea'
uni2 = strutf8.decode('utf-8') ## uni2 = u'\xe2\xe4\xe0\xe9\xe8\xeb\xea'
Si vous utilisiez un autre encodage, vous pourriez obtenir une erreur (unicode(strutf8, 'ascii') génèrera une erreur) ou
bien une chaîne unicode ne décrivant par la chaîne spécifiée (unicode(strutf8, 'latin_1') ). Si vous voulez convertir une
chaîne de caractères non contenue dans une variable en chaîne unicode, vous pouvez directement le faire en rajoutant
en ajoutant le caractère u devant la chaîne
- 27 -
FAQ Python
uni = u"âäàéèëê" ## u'\xe2\xe4\xe0\xe9\xe8\xeb\xea'
Comment convertir une chaîne unicode en chaîne normale ?

Auteurs : Guigui_ ,
Si vous avez une chaîne unicode, vous pouvez facilement la convertir en chaîne normale sous n'importe quel encodage
(capable d'interpréter la chaîne unicode) avec la méthode appliquée à une chaîne unicode encode( [encoding[,errors]])
où encoding est l'encodage souhaité pour la chaîne normale créée.
a = u'\xe2\xe4\xe0\xe9\xe8\xeb\xea'
a.encode('utf-8') ## '\xc3\xa2\xc3\xa4\xc3\xa0\xc3\xa9\xc3\xa8\xc3\xab\xc3\xaa'
Comment connaître l'encodage par défaut des chaînes de caractères ?

Auteurs : Guigui_ ,
Les problèmes viennent souvent du fait que l'on définit des chaînes contenant des caractères spéciaux sans que l'on
écrive ses caractères spéciaux avec un encodage spécifique (par exemple 'ä' au lieu de '\x84' dans l'encodage cp850). Vous
pouvez connaître l'encodage par défaut dans lequel Python encodera vos chaînes contenant des caractères spéciaux par
l'attribut sys.stdin.encoding et ainsi facilement la convertir en chaîne unicode.
import sys
print sys.stdin.encoding ## cp1252 sous IDLE, cp850 sous la console Python
machaine = 'äâ' ## machaine est une chaîne encodée selon l'encodage sys.stdin.encoding
unicode(machaine, sys.stdin.encoding) ## u'\xe4\xe2'
Ainsi la fenêtre interactive d'IDLE utilise l'encodage cp1252, la console interactive Python l'encodage cp850
- 28 -
FAQ Python
Sommaire > Type de données > Les chaînes de caractères > Expressions régulières
Comment tester la validité de son expression régulière ?
Auteurs : Miksimus ,
Le logiciel Kodos permet de tester vos expressions régulières. Il est disponible sous Linux et Windows. Son utilisation
est très simple et les quelques exemples disponibles vous permettront de comprendre rapidement son fonctionnement.
Comment remplacer un motif d'une chaîne de caractères par un autre string ?

Auteurs : Guigui_ ,
Les chaînes de caractères possèdent une méthode replace qui permettent de remplacer une sous-chaîne par une autre.
Mais il arrive souvent que l'on veuille plutôt traiter un motif plutôt qu'une sous-chaîne prédéfinie. Pour cela, il convient
alors d'utiliser le module re et la fonction re.sub( pattern, repl, string[, count]) . pattern est le motif en question dont vous
pouvez retrouver la syntaxe dans la Python Library Reference. repl est la sous-chaîne qui sera substituée au motif
rencontré, string est la chaîne à traiter. Enfin, count, qui est un paramètre facultatif, indique le nombre d'occurences
du motif qui seront substitués (les count premiers). Si ce paramètre est omis ou égal à 0, toutes les occurences seront
substituées.
>>> import re
>>> a = "Phrase test avec des nombres comme 500 ou 2487"
>>> re.sub("\d", "*", a)
'Phrase test avec des nombres comme *** ou ****'
>>> re.sub("\d+", "*", a)
'Phrase test avec des nombres comme * ou *'
lien : Comment remplacer une chaine de caractères par une autre ?
- 29 -
FAQ Python
Sommaire > Type de données > Listes

Quelles sont les méthodes basiques de l'objet list ?
Auteurs : Guigui_ ,
Les listes sont des objets qui possèdent quelques méthodes très pratiques pour les manipuler:
l.append(x) : ajoute l'occurence x en fin de liste.
l.extend(x) : ajoute chaque élement de la séquence x en fin de liste.
l.count(x) : renvoie le nombre d'occurences x de la liste.
l.index(x[, i[, j]]) : retourne le plus petit k tel que s[k] = x et i<=k<=j. retourne une erreur si l'élément n'est pas présent
dans la liste. Si i et j sont omis, l'ensemble de la liste est considéré.
l.insert(i, x) : insère l'occurence x à la position i.
l.pop([i]) : retourne l'élément de la position i et le supprime de la liste. Si i est omis, le dernier élément de la liste est
retourné et supprimé
l.remove(x) : supprime la première occurence de x de la liste. retourne une erreur si cette valeur n'est pas présente.
l.reverse() : renverse la liste sur place.
l.sort([cmp[, key[, reverse]]]) : trie les éléments de la liste sur place. Vous pouvez définir votre propre fonction de
comparaison en définissant le paramètre cmp. Le booléan reverse permet de retourner ou non la liste triée dans l'ordre
croissant ou décroissant. Si ces paramètres sont omis, la liste est triée dans l'ordre alphanumérique croissant.
>>> a = [5, 0, 3, 9, 4, 3, 7]
>>> a.append(15) ## a = [5, 0, 3, 9, 4, 3, 7, 15]
>>> a.extend((45, 12, 35)) ## a = [5, 0, 3, 9, 4, 3, 7, 15, 45, 12, 35]
>>> a.extend('abcdef') ## a = [5, 0, 3, 9, 4, 3, 7 ,15, 45, 12 ,35, 'a', 'b', 'c', 'd', 'e', 'f']
>>> a.count(3)
2
>>> a.index(3)
2
>>> a.insert(8, 6) ## a = [5, 0, 3, 9, 4, 3, 7 ,15, 6, 45, 12 ,35, 'a', 'b', 'c', 'd', 'e', 'f']
>>> a.pop() ## a = [5, 0, 3, 9, 4, 3, 7 ,15, 6, 45, 12 ,35, 'a', 'b', 'c', 'd', 'e']
'f'
>>> a.remove(3) ## a = [5, 0, 9, 4, 3, 7 ,15, 6, 45, 12 ,35, 'a', 'b', 'c', 'd', 'e']
>>> a.reverse() ## a = ['e', 'd', 'c', 'b', 'a', 35, 12, 6, 45, 7, 3, 4, 9, 0, 5]
>>> a.sort() ## a = [0, 3, 4, 5, 6, 7, 9, 12, 35, 45, 'a', 'b', 'c', 'd', 'e']
Comment supprimer une occurence dans une liste ?

Auteurs : Guigui_ ,
Vous avez plusieurs manières de supprimer une occurence dans une liste
La première façon est d'utiliser la méthode l.remove(x) qui supprime la première occurence x dans la liste l et qui
retourne une erreur si l'occurence x n'existe pas dans l.
l = [1,5,4,1,23,1,2,1]
try:
while True: l.remove(1)
except: pass
print l ## [5,4,23,2]
Si vous voulez supprimer toutes les occurences d'une valeur dans une liste, ne passer pas par la méthode remove qui
est lente mais reconstruisez plutôt entièrement votre liste en omettant les éléments qui ne vous intéressent plus. Cela
se fait très facilement avec une liste en intension.
Suppression de la valeur 0 dans une liste
- 30 -
FAQ Python
Suppression de la valeur 0 dans une liste

l = 5 * range(4) ## [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
l = [x for x in l if x!=0]
print l ## [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
Pour ne conserver qu'une seule occurence pour chaque élement de la liste, utilisez le type set qui représente les objets
ensembles et qui conserve donc une unique occurence de chaque élément d'une séquence.
l = [1,5,4,1,23,1,2,1]
s = set(l)
l = list(s)
print l ## [1,2,4,5,23]
Comment concaténer les éléments d'une liste dans une string ?

Auteurs : Guigui_ ,
Si votre liste ne contient que des string, il suffira d'utiliser la méthode ''.join(l) où l représente une séquence.
Si votre liste contient autre chose que des string, vous pouvez utilisez toujours cette méthode join tout en traitant chaque
élément de la séquence
exemple:
l1 = ['toto',' ','part',' ','en',' ','voyage']

strl1 = ''.join(l1)
l2 = [116, 111, 116, 111, 32, 112, 97, 114, 116, 32, 101, 110, 32, 118, 111, 121, 97,
103, 101]
str2 = ''.join(chr(i) for i in l2)
Comment mélanger les éléments d'une liste ?

Auteurs : Guigui_ , Choupi ,
Le module random propose la fonction random.shuffle( x[, random]) qui permet de mélanger une séquence en place.
>>> import random

>>> l = range(100)
>>> random.shuffle(l)
Niveau algorithmique, voici une méthode pour mélanger une liste d'une complexité linéaire (par rapport au nombre
d'éléments de la liste). On va simplement parcourir tous les élements de la liste et à chaque fois en choisir un autre au
hasard et faire l'échange des 2 éléments. Cette méthode sera de toute façon beaucoup plus longue que l'utilisation de
la fonction précédente.
import random
l = range(1000)
count = len(l)
randint = random.randint
for i in range(count):
j = randint(0,count-1) ## Selection au hasard de l'index d'un element de la liste
## Echange des 2 elements
- 31 -
FAQ Python
l[i], l[j] = l[j], l[i]
Comment vider une liste ?

Auteurs : Guigui_ ,
L'objet list ne possède pas de méthode pour vider complètement ses éléments.
Si vous affecter la liste vide à votre liste ( mylist = [] ), vous créer en faite un nouvel objet, ce qui peut poser problème
si d'autres références pointent sur ce même objet et que cette particularité est importante dans votre programme. La
méthode la plus simple si vous souhaitez toujour travailler sur la même liste est d'utiliser directement la fonction comme
suit:
del(mylist[:])
une autre méthode beaucoup moins rapide est d'utiliser la méthode pop dans une boucle while
while mylist: mylist.pop()
Comment créer une liste de listes de nombres (ou tableau à 2 dimensions) ?

Auteurs : Guigui_ ,
Supposons que nous voulions créer un tableau d'entiers de 5 cases par 5. La méthode intuitive serait la suivante:
>>> l = 5 * [5*[0]]
>>> l[0][0] = 1
>>> print l
[[1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0]]
Cependant en tenant de modifier un élément de la liste, on s'aperçoit que l'affectation s'est faite à plusieurs endroits.
Ceci vient simplement du fait que lors de la création de notre liste de listes, la sous-liste 5*[0] n'a en fait été créée qu'une
seule fois et que chaque sous-liste l[i] (0<=i<=4) pointe ainsi sur la même zone mémoire.
Pour créer une liste de listes (contenant des éléments initialisés), il vous faudra donc passer par 2 étapes:
>>> l = 5*[0] ## peu importe ce que l'on met dans cette liste
>>> for i in range(len(l)): l[i] = 5*[0]
>>> l[0][0]=1
>>> print l
[[1, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
Il est à noter que cette méthode ne fonctionne qu'avec des types ou objets immuables (nombres ou chaînes de caractères)
mais pas avec des objets.
- 32 -
FAQ Python
Sommaire > Type de données > Dictionnaire

Quelles sont les opérations de base sur l'objet dict ?
Auteurs : oiffrig ,
dic[cle]: Retourne la valeur associée à la clé cle
dic.get(cle, val): Retourne la valeur associée à la clé cle, ou val si la clé n'existe pas
dic[cle] = val: Assigne la valeur val à cle (si la clé n'existe pas, elle est créée)
del dic[cle]: Supprime la clé cle
dic.clear(): Vide le dictionnaire
dic1.update(dic2): Assigne à dic1 les éléments de dic2
>>> dic = {'prenom': 'Jean', 'nom': 'Dupond'}

>>> print dic['nom']
Dupond
>>> print dic.get('mail', 'a@a.com')
a@a.com
>>> dic['tel'] = '0123456789' # dic = {'nom': 'Dupond', 'tel': '0123456789', 'prenom': 'Jean'}
>>> dic2 = {'prenom': 'Jean-Pierre', 'mail': 'jp@dupond.com'}
>>> dic.update(dic2) # dic = {'nom': 'Dupond', 'tel': '0123456789', 'prenom': 'Jean-
Pierre', 'mail': 'jp@dupond.com'}
>>> del dic['mail'] # dic = {'nom': 'Dupond', 'tel': '0123456789', 'prenom': 'Jean-Pierre'}
>>> dic.clear() # dic = {}
Comment tester si une clé existe dans un dictionnaire ?

Auteurs : oiffrig ,
Un dictionnaire permet l'utilisation de la syntaxe x in dic
dic = {'prenom': 'Jean', 'nom': 'Dupond'}

if 'tel' in dic:
print 'Téléphone:', dic['tel']
Comment obtenir la liste des éléments d'un dictionnaire ?

Auteurs : oiffrig ,
Il y a trois méthodes permettant de lister les éléments :
• dic.keys() donne la liste des clés

• dic.values() donne la liste des valeurs
• dic.items() donne la liste des couples (clé, valeur)
Attention: Avec Python 3.0, ces méthodes ne renvoient plus des listes mais des vues, pour obtenir une liste, il faut utiliser
list(dict.items()) par exemple
On peut aussi itérer sur les clés :
for cle in dic:

print cle, ":", dic[cle]
- 33 -
FAQ Python
Quels sont les types de clés que l'on peut utiliser ?

Auteurs : oiffrig ,
Les clés d'un dictionnaire doivent être hashables :
• Tous les types immuables de python (numériques, chaînes de caractères, tuples, etc. mais pas les listes ni les
dictionnaires !)
• Tous les types disposant des méthodes __hash__ et __eq__ ou __cmp__
- 34 -
FAQ Python
Sommaire > Les fonctions

Comment effectuer une surcharge de fonctions (ou polymorphisme paramétrique) ?
Auteurs : Guigui_ ,
Comme tout langage à typage dynamique, il n'est pas possible d'effectuer une surchage de fonctions. On peut toutefois
contourner le problème de plusieurs façons dépendant du paramétrage des fonctions que vous souhaitez écrire.
par exemple, pour une fonction proposant un paramètre nécessitant un traitement spécial suivant son type, on peut
simplement tout d'abord tester le type du paramètre avant d'appeler une autre fonction privée adéquate.
def _testint(data): print "traitement d'un entier ", data

def _teststr(data): print "traitement d'un string ", data
def _testlist(data): print "traitement d'une liste ", data
def fonctiontest(data):
if type(data) == int: _testint(data)
elif type(data) == str: _teststr(data)
elif type(data) == list: _testlist(data)
else: raise AttributeError, "aucun traitement pour le type "+str(type(data))
>>> fonctiontest(1)
traitement d'un entier 1
>>> fonctiontest("1")
traitement d'un string 1
>>> fonctiontest({})
AttributeError: aucun traitement pour le type <type 'dict'>
S'il s'agit d'une surcharge de fonctions dont le nombre de paramètres peut varier, on peut utiliser la syntaxe *args qui
permet de passer autant de paramètres supplémentaires par position que l'on veut
def somme(*args):
return sum(args)
>>> print somme(5,3,2)

10
>>> print somme(1,2,3,4)
10
S'il s'agit d'une surcharge de fonctions dont le nombre de paramètres peut varier ainsi que leur type (ou leur sens), on
peut dans ce cas utiliser soit un paramètre dictionnaire soit un paramètre de la forme **keys qui permet de passer des
paramètres par la syntaxe nomparametre = valeurparametre
def calcul(**keys):
score = keys['value']
if 'somme' in keys: score += keys['somme']
if 'produit' in keys: score *= keys['produit']
return score
>>> print calcul(value = 5, somme = 2, produit = 7)

49
>>> print calcul(value = 4, produit = 9)
36
- 35 -
FAQ Python
On peut bien évidemment mélanger les différentes syntaxe. La syntaxe général étant def mafonction(param1, param2, ...,
*args, **keys): ...
Comment récupérer le prototype d'une fonction ?

Auteurs : Guigui_ ,
Si vous avez besoin d'utiliser une fonction et que vous ne connaissez pas les paramètres qu'elle prend, vous pouvez
tout de même récupérer le prototype complet de la fonction. Pour cela, il vous faudra passer par le module inspect. Ce
module propose la fonction inspect.getargspec( func) qui renvoie le nom et les valeurs par défaut des arguments de la
fonction func. Un tuple de 4 valeurs est retourné de la forme (args, varargs, varkw, defaults). args est la liste des noms
des paramètres spécifiés. varargs et varkx correspondent aux noms des arguments * et ** ou bien à None si ceux-ci ne
sont pas présents. Enfin defaults est un tuple des valeurs par défaut des arguments ou bien None si il n'y a aucune valeur
par défaut de spécifier. Si ce tuple a n éléments, ils correspondent aux n derniers éléments listés dans args
import inspect
def TestInspectFonction(p1, p2, **kwarg): pass
class TestInspect:
def MaFonction(self, p1, p2 = 'PPP2', p3 = 'PPP3', *arg , **kwarg ): pass
inspect.getargspec(TestInspectFonction) ## (['p1', 'p2'], None, kwarg, None)

inspect.getargspec(TestInspect.MaFonction)
## (['self', 'p1', 'p2', 'p3'], 'arg', 'kwarg', ('PPP2', 'PPP3'))
lien : Python Library Reference: inspect # Inspect live objects

lien : Comment obtenir des informations utiles sur l'utilisation d'un objet/module/fonction ?
- 36 -
FAQ Python
Sommaire > Programmation objet

Comment sauvegarder une instance Python dans un fichier ?
Auteurs : Guigui_ ,
Vous pouvez sauvegarder de manière très simples dans des fichiers des objets python basiques ou même des objets que
vous auriez vous-mêmes définis.
S'il s'agit de nombres (int, float, ...), chaînes de caractères, conteneurs (tuples, listes, dictionnaires) contenant
uniquement des objets de types élémentaires, vous pouvez utiliser le module marshal. Sinon, s'il s'agit d'instances de
classe que vous avez vous-mêmes définis, utilisez le module pickle ou cPickle (qui est beaucoup plus rapide que pickle)
La fonction dump(value, file) où value est l'objet élémentaire à sauvegarder et file est un fichier ouvert en écriture.
La focntion load(fileobj) permet de lire un fichier et retourne l'objet enregistré; fileobj étant un fichier ouvert en lecture.
import marshal
import cPickle
dico = {}
dico['toto'] = [23,'53453',{'a':5}]
marshal.dump(dico, open("mondico", 'wb')) ## Sauvegarde du dictionnaire
print marshal.load(open("mondico", "rb")) ## Rechargement du dictionnaire
class toto:
def __init__(self):
self.x = 5
tutu = toto()
cPickle.dump(tutu, open("toto2", "wb")) ## Sauvegarde de l'objet tutu
print cPickle.load(open("toto2")).x ## Rechargement de l'objet tutu
Comment sauvegarder une instance Python contenant des images dans un fichier ?
Auteurs : Guigui_ ,
Vous pouvez avoir besoin de travailler sur des objets contenant directement le contenu d'images ou bien de transférer
des objets devant travailler sur des images. Vous devez tout d'abord récupérer et installer la bibliothèque Pil. Au
lieu de devoir ainsi fournir un fichier contenant l'objet et chacune des images dans des fichier séparés ou dans un
fichier .zip, vous pouvez alors décider d'utiliser un unique fichier qui peut ainsi faciliter la procédure. En revanche, si
vous travaillez avec des images compressées, le fichier que nous allons créer sera beaucoup plus gros que l'ensemble
des fichiers images le constituant.
Pour cela, il suffit tout d'abord d'ouvrir chaque image en tant fichier binaire grâce à la commande open et le paramètre
'rb' et de les conserver dans une variable ou un autre conteneur (comme une liste ou un dictionnaire).
la méthode seek(0) vous permet de vous placer au début du fichier et la méthode read() de lire le contenu entier du
fichier ouvert.
Sauvegarde dans un fichier une instance Python contenant 2 images

import cPickle
img1 = open('first.jpg', 'rb')
img1.seek(0)
w1 = img1.read()
img1.close()
img2 = open('second.jpg', 'rb')
img2.seek(0)
w2 = img2.read()
img2.close()
dic = {'img1' : w1, 'img2': w2}
cPickle.dump(dic, open("monfichier", "wb"))
- 37 -
FAQ Python
Une fois que vous avez récupérer le fichier créé avec cPickle, vous pouvez récupérer en connaissant la structure du
fichier les 2 images transmises. Pour cela, on va utiliser le module cStringIO qui permet de lire et de créer des fichiers
en mémoire. Par la méthode write, nous allons écrire le contenu de nos variables, se repositionner avec seek(0) au début
du fichier. Enfin, nous allon récréer une image grâce à Pil et la fonction Image.open.
Recréation des 2 images à partir d'une instance créée avec cPickle

import Image, cPickle, cStringIO
monobjet = cPickle.load(open("monfichier"))
img1 = cStringIO.StringIO()
img1.write(monobjet['img1'])
img1.seek(0)
im1 = Image.open(img1)
im1.save('first.jpg')
img2 = cStringIO.StringIO()
img2.write(monobjet['img2'])
img2.seek(0)
im2 = Image.open(img2)
im2.save('second.jpg')
Comment récupérer le nom de la classe d'un objet ?

Auteurs : Guigui_ ,
Vous pouvez récupérer le nom de la classe d'un objet en appliquant à cet objet l'attribut .__class__.__name__
>>> a = 5
>>> a.__class__.__name__
'int'
>>> class toto: pass
>>> b = toto()
>>> b.__class__.__name__
'toto'
Comment hériter d'un objet immuable ?

Auteurs : Guigui_ ,
Les objets immuables que l'on utilise traditionnellement sont les nombres et les chaînes de caractères. Pour ces objets,
on ne peut effectuer un héritage traditionnelle qui utilise la méthode __init__ qui n'a aucune influence sur la valeur
retournée par le constructeur dans ce cas-là. Vous devez alors utiliser la méthode __new__(...) comme sur l'exemple
suivant. Si vous redéfinissez ensuite des fonctions que la classe parente possède déjà, n'oubliez pas d'utiliser si nécessaire
la fonction super(cls, obj) qui permet d'appeler les fonctions de la classe mère sous peine parfois d'obtenir des erreurs
de récursion infinie. Etudiez ainsi l'exemple suivant où la classe angle dérive de la classe int en redéfinissant quelques
fonctions basiques.
Construction d'une classe angle qui donne l'angle principale entre 0 et 360°
class angle(int):
def __new__(self, n):
## On retourne l'angle principale dans l'intervalle [0;360]
return int.__new__(self, n % 360)
def __sub__(self, n):
## On calcule la différence de 2 angles en retournant l'angle principal
return angle(super(angle, self).__sub__(n))
def __add__(self, n):
- 38 -
FAQ Python
Construction d'une classe angle qui donne l'angle principale entre 0 et 360°
## On calcule la somme de 2 angles en retournant l'angle principal
return angle(super(angle, self).__add__(n))
A = angle(540)
B = angle(- 460)
print A, B, type(A), type(B) ## 180 260 <class '__main__.angle'> <class '__main__.angle'>
print A - B, type(A - B) ## 280 <class '__main__.angle'>
print A + B, type(A - B) ## 80 <class '__main__.angle'>
Comment effectuer une surchage d'opérateur ?

Auteurs : Guigui_ ,
En Python, on peut surcharger tous les opérateurs. L'ensemble de ces opérateurs est identique à ceux que l'on
retrouve dans le module operator. Ces opérateurs se redéfinissent donc dans une classe de la manière suivante def
__operateur__(self, ...): ...
Dans l'exemple suivant, nous allons créer une classe Vecteur et définir les opérations habituelles sur un vecteur
# -*- coding: cp1252 -*-

import math
class Vector:
def __init__(self, x=0, y=0):
self.x=x
self.y=y
def __eq__(self, vB): return (self.x==vB.x) and (self.y==vB.y)
## test l'égalité de 2 vecteurs
def __add__(self, vB): return Vector(self.x+vB.x,self.y+vB.y) ## retourne le vecteur somme
def __sub__(self, vB): return Vector(self.x-vB.x,self.y-vB.y) ## retourne le vecteur différence
def __mul__(self, c):
if isinstance(c,Vector): return self.x*c.x+self.y*c.y ## retourne le produit scalaire
else: return Vector(c*self.x,c*self.y) ## retourne le vecteur multiplé par un scalaire
def __div__(self, c): return Vector(self.x/c,
self.y/c) ## retourne le vecteur ayant subi une division scalaire
def __abs__(self): return math.hypot(self.x, self.y) ## retourne la norme2 du vecteur
def __str__(self): return '('+str(self.x)+','+str(self.y)+')' ## retourne la réprésentation du vecteur sous fo
>>> a = Vector(4,5)
>>> b = Vector(6,7)
>>> print a==b
False
>>> print a+b
(10,12)
>>> print a-b
(-2,-2)
>>> print a*b
59
>>> print abs(a)
6.40312423743
- 39 -
FAQ Python
Sommaire > Gestion Fichier/Répertoire
- 40 -
FAQ Python
Sommaire > Gestion Fichier/Répertoire > Prérequis

Où trouver de l'aide ?
Auteurs : Guigui_ ,
un grand nombre de fonctions sur les fichiers/répertoires sont proposées par les module os, module os.path et
module shutil
- 41 -
FAQ Python
Sommaire > Gestion Fichier/Répertoire > Fichier

Comment lister les fichiers/répertoires d'un répertoire ?
Auteurs : Guigui_ ,
os.listdir(path) renvoie une liste contenant les noms de tous les fichiers et répertoires de path
>>> import os
>>> os.listdir('c:/python24')
['DLLs', 'Doc', 'include', 'kinterbasdb-wininst.log', 'Lib', 'libs', 'LICENSE.txt', 'matplotlib-wininst.log',
'msvcp71.dll', 'msvcr71.dll', 'MySQL-python.exe-wininst.log', 'NEWS.txt', 'numarray-wininst.log',
'Numeric-wininst.log', 'PIL-wininst.log', 'psycopg-wininst.log', 'py.ico', 'pyc.ico', 'python.exe',
'python.exe.manifest', 'pythonw.exe', 'pythonw.exe.manifest', 'pywin32-wininst.log', 'README.txt',
'Removekinterbasdb.exe', 'Removematplotlib.exe', 'RemoveMySQL-python.exe.exe', 'Removenumarray.exe',
'RemoveNumeric.exe', 'RemovePIL.exe', 'Removepsycopg.exe', 'Removepywin32.exe', 'Scripts', 'share', 'tcl',
'Tools', 'w9xpopen.exe']
On peut également utiliser la fonction glob.glob(path) qui renvoie une liste contenant le chemin complet des fichiers ou
répertoire contenu dans path
>>> import glob

>>> glob.glob('c:/python24/*')
['c:\\python24\\boa-constructor-wininst.log', 'c:\\python24\\DLLs', 'c:\\python24\\Doc',
'c:\\python24\\egenix-mx-base-wininst.log', 'c:\\python24\\include', 'c:\\python24\
\kinterbasdb-wininst.log',
'c:\\python24\\Lib', 'c:\\python24\\libs', 'c:\\python24\\LICENSE.txt', 'c:\\python24\
\matplotlib-wininst.log',
'c:\\python24\\msvcp71.dll', 'c:\\python24\\msvcr71.dll', 'c:\\python24\
\MySQL-python.exe-wininst.log',
'c:\\python24\\NEWS.txt', 'c:\\python24\\numarray-wininst.log', 'c:\\python24\\PIL-wininst.log',
'c:\\python24\\psycopg2-wininst.log', 'c:\\python24\\py.ico', 'c:\\python24\\py2exe-wininst.log',
'c:\\python24\\pyc.ico', 'c:\\python24\\python.exe', 'c:\\python24\\python.exe.manifest', 'c:\
\python24\\pythonw.exe',
'c:\\python24\\pythonw.exe.manifest', 'c:\\python24\\README.txt', 'c:\\python24\
\Removeboa-constructor.exe',
'c:\\python24\\Removeegenix-mx-base.exe', 'c:\\python24\\Removekinterbasdb.exe', 'c:\\python24\
\Removematplotlib.exe',
'c:\\python24\\RemoveMySQL-python.exe.exe', 'c:\\python24\\Removenumarray.exe', 'c:\\python24\
\RemovePIL.exe',
'c:\\python24\\Removepsycopg2.exe', 'c:\\python24\\Removepy2exe.exe', 'c:\\python24\\Scripts', 'c:\
\python24\\share',
'c:\\python24\\tcl', 'c:\\python24\\Tools', 'c:\\python24\\unins000.dat', 'c:\\python24\
\unins000.exe',
'c:\\python24\\w9xpopen.exe']
Comment lister l'arborescence d'un répertoire ?

Auteurs : Guigui_ ,
Voici 2 façons de faire. Chacune des fonctions retournera la liste des fichiers (avec chemin complet) contenus dans un
répertoire ou dans un de ses sous-répertoires.
La première méthode utilise la fonction glob.glob(path) qui va lister le contenu d'un répertoire avec appel récursif aux
sous-répertoires
Lister l'aborescence d'un répertoire grâce à la fonction glob.glob(path)

import glob
import os.path
- 42 -
FAQ Python
Lister l'aborescence d'un répertoire grâce à la fonction glob.glob(path)

def listdirectory(path):
fichier=[]
l = glob.glob(path+'\\*')
for i in l:
if os.path.isdir(i): fichier.extend(listdirectory(i))
else: fichier.append(i)
return fichier
La fonction os.walk(path) crée un générateur de triplets (root, dirs, files) dans l'arborescence de path. Un triplet est
généré par répertoire visité. root représente le chemin d'accès du répertoire visité. dirs est la liste des sous-répertoires
du répertoire root et files est la liste des fichiers du répertoire root.
Lister l'aborescence d'un répertoire grâce à la fonction os.walk(path)

import os.path
def listdirectory2(path):
fichier=[]
for root, dirs, files in os.walk(path):
for i in files:
fichier.append(os.path.join(root, i))
return fichier
On peut en profiter pour tester la rapidité des 2 fonctions.
Utilisation des fonctions
import time
def compare(path):
a = time.clock()
listdirectory(path)
b = time.clock()
listdirectory2(path)
c = time.clock()
return b-a, c-b
>>>print compare('c:/python24')
- 43 -
FAQ Python
Utilisation des fonctions

(1.0782314512039937, 1.0392410208560028) ## les 2 fonctions se valent...
Comment savoir si un chemin représente un fichier ?

Auteurs : Guigui_ ,
os.path.isfile(path) renvoie True si path désigne un fichier existant
Comment connaître la taille d'un fichier ?

Auteurs : Guigui_ ,
os.path.getsize(path) renvoie la taille du fichier path
Comment supprimer un fichier ?

Auteurs : Guigui_ ,
Pour supprimer un fichier, il suffit d'utiliser la fonction os.remove(path) où path réprésente le chemin d'accès au fichier.
Comment renommer/déplacer un fichier ?

Auteurs : Guigui_ ,
os.rename(src, dst) permet de renommer le fichier de chemin src en le fichier de chemin dst, le répertoire contenant le
fichier de destination doit cependant déjà exister, une erreur étant sinon retournée.
os.renames(src, dst) permet de renommer le fichier src en dst tout en créant si nécessaire les répertoires contenant le
fichier de destination.
Enfin shutil.move(src, dst) renomme exactement comme os.renames le fichier src en dst si le fichier de destination est sur
le même système de fichiers. Autrement elle copie simplement src sur dst puis efface src
Si le fichier de destination se trouve sur le même système de fichiers, vous pouvez utiliser aussi bien les fonctions
os.rename, os.renames que shutil.move sinon préférez shutil.move, les 2 autres fonctions pouvant échouer à leur tâche.
lien : Comment renommer/déplacer un répertoire ?

lien : Python Library Reference: Files and Directories
lien : Python Library Reference: shutil -- High-level file operations
Comment manipuler les différentes parties d'un nom de fichier ?

Auteurs : Guigui_ ,
Le module os.path propose plusieurs fonctions simples d'utilisation pour récupérer les parties d'un nom de fichier:
Fonctions pour récupérer des les différentes parties d'un nom de fichier
• dirname(path): retourne le répertoire associé au path
• basename(path): retourne le nom simple du fichier (extension comprise)
• split(path): retourne le couple (répertoire, nom du fichier)
• splitdrive(path): retourne le couple (lecteur, chemin du fichier sans le lecteur)
- 44 -
FAQ Python
• splitext(path): retourne le couple (chemin du fichier sans l'extension, extension)

• splitunc(path): retourne le couple (unc, rest) où unc est du type \\host\répertoire partagé et rest le reste du path
(cette fonction n'est valable que sous Windows)
>>> import os.path

>>> os.path.dirname('c:\\python24\\python.exe')
'c:\\python24'
>>> os.path.basename('c:\\python24\\python.exe')
'python.exe'
>>> os.path.split('c:\\python24\\python.exe')
('c:\\python24', 'python.exe')
>>> os.path.splitdrive('c:\\python24\\python.exe')
('c:', '\\python24\\python.exe')
>>> os.path.splitext('c:\\python24\\python.exe')
('c:\\python24\\python', '.exe')
>>> os.path.splitunc(r'\\host\python24\lib\ftplib.py')
('\\\\host\\python24', '\\lib\\ftplib.py')
- 45 -
FAQ Python
Sommaire > Gestion Fichier/Répertoire > Répertoire

Comment savoir si un chemin représente un répertoire ?
Auteurs : Guigui_ ,
os.path.isdir(path) renvoit True si path désigne un répertoire existant
Comment créer un répertoire ?

Auteurs : Guigui_ ,
os.mkdir(path, mode=0777) créé un répertoire le plus à droite dans path
os.makedirs(path, mode=0777) crée tous les répertoires de path n'existant pas
Comment supprimer un répertoire ?

Auteurs : Guigui_ ,
os.rmdir(path) supprime le répertoire path si celui-ci est vide
Pour supprimer un répertoire non vide, on utilise la fonction shutil.rmtree(path)
Comment renommer/déplacer un répertoire ?

Auteurs : Guigui_ ,
os.rename(src, dst) permet de renommer le répertoire src en le répertoire dst, tous les répertoire parent de dst doivent
cependant déjà exister, une erreur étant sinon retournée.
os.renames(src, dst) permet de renommer le répertoire src en dst tout en créant si nécessaire les répertoires parent du
répertoire de destination.
Enfin shutil.move(src, dst) renomme exactement comme os.renames le répertoire src en dst si le répertoire de destination
est sur le même système de fichiers. Autrement elle copie simplement src sur dst puis efface src
Si le répertoire de destination se trouve sur le même système de fichiers, vous pouvez utiliser aussi bien les fonctions
os.rename, os.renames que shutil.move sinon préférez shutil.move, les 2 autres fonctions pouvant échouer à leur tâche.
lien : Comment renommer/déplacer un fichier ?

lien : Python Library Reference: Files and Directories
lien : Python Library Reference: shutil -- High-level file operations
Comment connaître la taille d'un répertoire ?

Auteurs : Guigui_ ,
Pour connaître la taille d'un répertoire, il suffit de le parcourir son arborescence en ajoutant la taille de chaque fichier
rencontré.
import os.path
def sizedirectory(path):
size = 0
for root, dirs, files in os.walk(path):
- 46 -
FAQ Python
for fic in files:

size += os.path.getsize(os.path.join(root, fic))
return size
print sizedirectory("c:/python25")
lien : Comment connaître la taille d'un fichier ?

lien : Comment lister l'arborescence d'un répertoire ?
- 47 -
FAQ Python
Sommaire > Gestion Fichier/Répertoire > Fichiers de configuration
- 48 -
FAQ Python
Sommaire > Gestion Fichier/Répertoire > Fichiers de configuration > Fichiers variable=valeur
Quel est la structure d'un fichier variable=valeur ?
Auteurs : Guigui_ ,
La manière la plus simple de créer un fichier de configuration est la suivante: une suite de lignes "variable = valeur.
On permet d'utiliser des commentaires (##). Ceux si peuvent être soit placés en début de ligne soit après une ligne
variable=valeur.
## Commentaire
variable1 = value1 ## commentaire1
variable2 = value2 ## commentaire2
...
Comment récupérer le contenu d'un fichier variable=valeur ?

Auteurs : Guigui_ ,
Dans le cas d'un tel type de fichiers, nous sommes obligés de lire le contenu entier du fichier. Le principe est de lire le
contenu entier du fichier puis de traiter ligne par ligne.
conf.txt
## Voici un exemple d'un fichier de configuration
variable1 = 10 ## un integer
variable2 = Guigui ## un string
Voici un exemple pour récupérer les variables/valeurs. Celles-ci sont introduit dans un dictionnaire. Libre à vous ensuite
de passer d'un dictionnaire à une liste de variables
dicoval={} ## dictionnaire dans lequel on introduit les paires variables/valeurs

path = open('conf.txt','rb') ## Ouverture du fichier de configuration en mode lecture
lignes = path.readlines() ## Récupération du contenu du fichier
## Traitement ligne par ligne

for lig in lignes:
sp = lig.split('#')[0] ## Elimination des commentaires potentiels
sp = sp.split('=') ## Séparation variable / valeur
## on teste la longueur de sp; si elle n'est pas égale à 2, c'est qu'il s'agit d'une ligne vide ou qu'avec des
if len(sp)==2: dicoval[sp[0].strip()]=sp[1].strip()
path.close() ## Fermeture du fichier de configuration
On peut ensuite traiter le dictionnaire pour pouvoir accéder directement aux variables sans passer par le dictionnaire
## pour un traitement automatique ou si on ne connaît pas à l'avance le nom des variables

for i in dicoval:
exec(i + '=' + str(dicoval[i]))
## si on connaît le nom des variables

variable1 = dicoval['variable1']
variable2 = dicoval['variable2']
- 49 -
FAQ Python
Sommaire > Gestion Fichier/Répertoire > Fichiers de configuration > ConfigParser

Où trouver de l'aide pour ConfigParser ?
Auteurs : Guigui_ ,
La documentation officielle est largement suffisante pour utiliser ce module: ConfigParser
Quelle est la structure des fichiers .cfg gérés par ConfigParser ?

Auteurs : Guigui_ ,
La structure des fichiers est la suivante:
[Section1]
NomDeClé1 : Valeur1
NomDeClé2 = Valeur2
[Section2]
NomDeClé3 : Valeur3
...
Les lignes commençants par le caractère # ou ; sont ignorées.
Comment créer la structure d'un fichier .cfg ?

Auteurs : Guigui_ ,
La fonction ConfigParser.ConfigParser permet de déclarer notre objet
La fonction cp.add_section(section) permet de rajouter une section à notre structure
La fonction cp.set(section, option, value) permet de rajouter la clé option à la section existante section avec la valeur value
La fonction cp.write(fileobject) permet de sauvegarder la structure
import ConfigParser
config = ConfigParser.ConfigParser()
config.add_section('Section String')
config.set('Section String', 'str1', 'MonString')
config.add_section('Section Integer')
config.set('Section String', 'int1', 100)
config.write(open('conf.cfg','w'))
Comment lire une clé d'un fichier .cfg ?

Auteurs : Guigui_ ,
On peut utiliser 4 méthodes dépendantes du type de la clé:
• cp.get( section, option) pour les clés de type string

• cp.getint( section, option) pour les clés de type integer
• cp.getfloat( section, option) pour les clés de type float
• cp.getboolean( section, option) pour les clés de type boolean
- 50 -
FAQ Python
config.read('conf.cfg')
monint = config.getint('Section Integer', 'int1')
monstring = config.get('Section String', 'str1')
- 51 -
FAQ Python
Sommaire > Gestion Fichier/Répertoire > Compression/Archive

Comment compresser un répertoire dans une archive ZIP ?
Auteurs : Guigui_ ,
Pour manipuler les archives ZIP, il vous faudra passer par le module zipfile. Vous utiliserez 2 fonctions de ce module.
La première fonction zipfile.ZipFile( file[, mode[, compression[, allowZip64]]]) où file est le nom du fichier de l'archive à
créer, mode, le mode d'ouverture du fichier, donc ici 'w' (ou 'a' si l'archive existe déjà et que vous voulez la compléter),
compression représente le mode de compression ZIP et aura pour valeur ZIP_STORED ou ZIP_DEFLATED.
La deuxième fonction est la méthode z.write( filename[, arcname[, compress_type]]) où filename est le chemin du fichier
à compresser, arcname le chemin d'accès du fichier lors de la décompression (par défaut identique à filename).
Il vous faudra également parcourir l'arborescence du répertoire afin d'ajouter chaque fichier dans l'archive.
Zip du répertoire c:/python25/

import zipfile
import os.path
import glob
def zipdirectory(filezip, pathzip):

lenpathparent = len(pathzip)+1 ## utile si on veut stocker les chemins relatifs
def _zipdirectory(zfile, path):
for i in glob.glob(path+'\\*'):
if os.path.isdir(i): _zipdirectory(zfile, i )
else:
print i
zfile.write(i,
i[lenpathparent:]) ## zfile.write(i) pour stocker les chemins complets
zfile = zipfile.ZipFile(filezip,'w',compression=zipfile.ZIP_DEFLATED)
_zipdirectory(zfile, pathzip)
zfile.close()
zipdirectory('python25.zip', 'c:/python25')
lien : Comment lister l'arborescence d'un répertoire ?

lien : Python Library Reference
Comment dézipper une archive ZIP ?

Auteurs : Guigui_ ,
Pour décompresser une archive ZIP, il suffit de parcourir l'ensemble des fichiers de l'archive donnée par z.namelist() et
de copier chaque fichier de cette archive dans un nouveau fichier que l'on crée. zipfile.ZipFile(file, 'r') permet d'ouvrir
une archive ZIP en mode lecture. La méthode z.read(name) permet de lire le contenu du fichier name de l'archive
import zipfile
import os.path
import os
import glob
def dezip(filezip, pathdst = ''):

if pathdst == '': pathdst = os.getcwd() ## on dezippe dans le repertoire locale
zfile = zipfile.ZipFile(filezip, 'r')
for i in zfile.namelist(): ## On parcourt l'ensemble des fichiers de l'archive
print i
if os.path.isdir(i): ## S'il s'agit d'un repertoire, on se contente de creer le dossier
try: os.makedirs(pathdst + os.sep + i)
except: pass
else:
- 52 -
FAQ Python
try: os.makedirs(pathdst + os.sep + os.path.dirname(i))

except: pass
data = zfile.read(i) ## lecture du fichier compresse
fp = open(pathdst + os.sep + i, "wb") ## creation en local du nouveau fichier
fp.write(data)
## ajout des donnees du fichier compresse dans le fichier local
fp.close()
zfile.close()
dezip('python25.zip', 'python25')
- 53 -
FAQ Python
Sommaire > Base de registre sous Windows

Où trouver de l'aide pour accéder aux bases de registre ?
Auteurs : Guigui_ ,
Le module _winreg permet d'accéder aux bases de registre sous Windows. Vous trouverez dans la Python Library
reference l'aide suffisante pour manipuler la base de registre.
Comment créer une clef ?

Auteurs : Guigui_ ,
Pour créer une nouvelle clé au registre on utilise la méthode _winreg.CreateKey( key, sub_key) où key est une clé déjà
ouverte ou une constante HKEY_* prédéfinie et sub_key représente la sous-clé qui sera créée. Cette fonction retourne
le handle de la clé ouverte.
import _winreg
key = _winreg.CreateKey(_winreg.HKEY_CURRENT_USER, 'Software\\MonProg')
Comment supprimer une clef ?

Auteurs : Guigui_ ,
Pour supprimer une clé au registre on utilise la méthode _winreg.DeleteKey( key, sub_key) où key est une clé déjà ouverte
ou une constante HKEY_* prédéfinie et sub_key représente la sous-clé qui sera supprimée. Cette fonction ne peut pas
supprimer une clé qui possède des sous-clés
import _winreg
_winreg.DeleteKey(_winreg.HKEY_CURRENT_USER, 'Software\\MonProg')
Comment ouvrir une clef et lire/modifier/supprimer une valeur ?

Auteurs : Guigui_ ,
Pour ouvrir une clé, on utilise la fonction _winreg.OpenKey( key, sub_key[, res = 0][, sam = KEY_READ]) où key est une
clé déjà ouverte où une constante du type HREF_*, sub_key, la sous-clé à ouvrir, res un entier qui doit rester à 0 et sam
un entier qui définit le masque d'accès. La constante KEY_SET_VALUE permettra de modifier la clé en question alors
que KEY_READ ne permettra d'accéder à cette clé qu'en lecture seule. Cette fonction retourne le handle de la clé.
Pour lire une valeur, on utilise la fonction _winreg.QueryValueEx( key, value_name) où key est une clé déjà ouverte et
value_name le nom de la valeur à lire. Cette fonction retourne un couple où le premier élément est la valeur de la donnée
et le deuxième un entier donnant le type de la donnée.
import _winreg
key = _winreg.OpenKey( _winreg.HKEY_CURRENT_USER, 'Software\\MonProg',0, _winreg.KEY_READ)
(valeur,typevaleur) = _winreg.QueryValueEx(key,'MaDonnee')
_winreg.CloseKey(key)
print valeur, typevaleur
- 54 -
FAQ Python
Pour modifier une valeur, on applique la fonction SetValueEx( key, value_name, reserved, type, value) sur la key
précédente où value_name représente le nom de la valeur, reserved peut être n'importe quoi (c'est toujours 0 qui est
transmis), type est un entier (dont les valeurs possibles sont données dans le tableau ci-dessous) représentant le type de
la donnée et value la valeur de la donnée en question.
import _winreg
key = _winreg.OpenKey( _winreg.HKEY_CURRENT_USER, 'Software\\MonProg',0, _winreg.KEY_SET_VALUE)
_winreg.SetValueEx(key, 'MaDonnee', 0, _winreg.REG_DWORD, 5)
Constante Description
REG_BINARY Donnée binaire de n'importe quel forme
REG_DWORD Un nombre sur 32 bits
REG_DWORD_LITTLE_ENDIAN Un nombre sur 32 bits au format little-
endian
REG_DWORD_BIG_ENDIAN Un nombre sur 32 bits au format big-endian
REG_EXPAND_SZ String référençant une variable
d'environnement
REG_LINK Un lien symbolique
REG_MULTI_SZ Une séquence de string
REG_NONE Type sans valeur définie
REG_RESOURCE_LIST Une liste de ressources
REG_SZ Un string
Pour supprimer une valeur, on exécute la fonction _winreg.DeleteValue( key, value)
import _winreg
key = _winreg.OpenKey( _winreg.HKEY_CURRENT_USER, 'Software\\MonProg',0, _winreg.KEY_SET_VALUE)
_winreg.DeleteKey(key, 'MaDonnee')
- 55 -
FAQ Python
Sommaire > Thread

Comment utiliser simplement les Thread ?
Auteurs : Guigui_ ,
Les Thread en Python s'utilisent très facilement. Pour cela, il suffit de déclarer une instance par le constructeur
threading.Thread( group=None, target=None, name=None, args=(), kwargs={}) où :
• group doit rester à None, en attendant que la classe ThreadGroup soit implantée.
• target est la fonction appelée par le Thread.
• name est le nom du Thread.
• args est un tuple d'arguments pour l'invocation de la fonction target
• kwargs est un dictionnaire d'argumens pour l'invocation de la fonction target
il suffit ensuite pour exécuter le Thread d'appliquer la méthode start()
import threading
def affiche(nb, nom = ''):

for i in range(nb): print nom, i
a = threading.Thread(None, affiche, None, (200,), {'nom':'thread a'})

b = threading.Thread(None, affiche, None, (200,), {'nom':'thread b'})
a.start()
b.start()
Comment arrêter définitivement un Thread ?

Auteurs : Guigui_ , Wormus ,
Nous allons ici simplement nous intéresser aux threads ne présentant pas d'accès concurrent à des ressources. L'objectif
est donc simplement de tuer le thread lancé. Il existe pour cela plusieurs méthodes. Une première est d'appeler
simplement la méthode MonThread._Thread__stop() qui termine l'instruction en cours et tue ensuite le thread.
Une deuxième méthode plus propre est de définir un paramètre Terminated initialisé à False et dand la méthode run
de lancer une boucle infinie testant le booléen Terminated. Enfin, définissez une méthode stop qui met simplement
le paramètre Terminated à True. Vous pouvez ajouter ou non un timer dans la méthode run pour que le thread ne
monopolise pas toutes les ressources CPU. Vous retrouvez un tel exemple avec la classe Affiche. Pour arrêter le thread,
on appelle simplement la méthode stop et une fois la boucle while entièrement parcourue, le thread se termine.
import threading
import time
class Affiche(threading.Thread):
def __init__(self, nom = ''):
threading.Thread.__init__(self)
self.nom = nom
self.Terminated = False
def run(self):
i = 0
while not self.Terminated:
print self.nom, i
i += 1
time.sleep(2.0)
print "le thread "+self.nom +" s'est termine proprement"
def stop(self):
self.Terminated = True
- 56 -
FAQ Python
Le problème de la méthode précédente est donc le fait qu'il peut y avoir un laps de temps important entre le moment
de la demande de l'arrêt du thread et celui où le thread est réèllement terminé dû à la durée du timer. En utilisant la
classe Event, on peut ainsi accélérer l'arrêt du thread car la méthode monevent.wait(timeout) bloque le thread pendant
la durée timeout où jusqu'au moment où la méthode monevent.set() est appelée. La classe Affiche2 présente un exemple
sur ce principe.
class Affiche2(threading.Thread):
def __init__(self, nom = ''):
threading.Thread.__init__(self)
self.nom = nom
self._stopevent = threading.Event( )
def run(self):
i = 0
while not self._stopevent.isSet():
print self.nom, i
i += 1
self._stopevent.wait(2.0)
print "le thread "+self.nom +" s'est termine proprement"
def stop(self):
self._stopevent.set( )
a = Affiche('Thread A')
b = Affiche('Thread B')
c = Affiche2('Thread C')
a.start()
b.start()
c.start()
time.sleep(6.5)
a._Thread__stop()
b.stop()
c.stop()
Comment créer un Timer ?

Auteurs : Guigui_ ,
A ma connaissance, il n'existe pas d'objet intrinsèque permettant de gérer un timer afin d'exécuter périodiquement un
bout de code. Il est cependant possible avec la classe threading.Timer( interval, function, args=[], kwargs={}) de simuler
ce comportement. Vous pouvez alors créer une fonction qui lancera un objet threading.Timer sur elle-même, ce qui aura
pour effet de répéter périodiquement cette fonction. A la création de l'objet, vous devez fournir un flottant interval
indiquant le temps d'attente (après le lancement de la méthode start()) avant l'exécution de la fonction function lancée
avec les arguments args et kwargs.
import threading
import time
def MyTimer(tempo = 1.0):

threading.Timer(tempo, MyTimer, [tempo]).start()
## verification de la proprete du timer
print time.clock()
## Reste du traitement
MyTimer(2.0)
L'exemple précédent très simple ne permet pas de stopper et de relancer le Timer à votre guise.
- 57 -
FAQ Python
Voici un exemple d'une classe gérant un Timer avec possibilité de l'arrêter et de le relancer. Ce Timer prend en
paramètre la période du Timer (tempo), la fonction à appeler (target) et les arguments à passer à la fonction (une liste args
et un dictionnaire kwargs). Vous pouvez alors lancer la fonction par la méthode start() et l'arrêter par la méthode stop()
# -*- coding: cp1252 -*-

import threading
import time
class MyTimer:
def __init__(self, tempo, target, args= [], kwargs={}):
self._target = target
self._args = args
self._kwargs = kwargs
self._tempo = tempo
def _run(self):
self._timer = threading.Timer(self._tempo, self._run)
self._timer.start()
self._target(*self._args, **self._kwargs)
def start(self):
self._timer = threading.Timer(self._tempo, self._run)
self._timer.start()
def stop(self):
self._timer.cancel()
def affiche(unstr):
print unstr, time.clock()
a = MyTimer(1.0, affiche, ["MyTimer"])

a.start()
time.sleep(5.5)
print u"Timer arrêté"
a.stop()
time.sleep(2.0)
print u"Timer relancé"
a.start()
Il existe d'autres implémentations de Timer, par exemple la bibliothèque wxPython fournit un objet wx.Timer
lien : Python Library Reference: Timer Object
- 58 -
FAQ Python
Sommaire > Réseau / Web

Comment ouvrir le navigateur internet par défaut ?
Auteurs : Guigui_ ,
import webbrowser
webbrowser.open('http://python.org')
Comment lire le contenu d'une page web ?

Auteurs : Guigui_ ,
import urllib
page=urllib.urlopen('http://python.org')
strpage=page.read()
Comment télécharger un fichier d'un site web ?

Auteurs : Guigui_ ,
Pour télécharger un fichier d'un site web, vous pouvez utiliser la fonction urllib.urlretrieve( url[, filename[, reporthook[,
data]]]) où url représente le chemin du fichier à télécharger, filename le nom du fichier sauvegardé en local,
>>> import urllib

>>>
urllib.urlretrieve('http://python.developpez.com/outils/PythonZope/images/cpython.gif', 'c:/cpython.gif')
('c:/cpython.gif', <httplib.HTTPMessage instance at 0x00B8DBC0>)
Comment connaître l'adresse IP de son ordinateur sur le réseau Internet ?

Auteurs : Guigui_ ,
il y a deux manières de procéder pour connaître l'adresse IP de son ordinateur sur le réseau Internet suivant que son
ordinateur est derrière un routeur ou non. Si vous êtes derrière un routeur, l'adresse IP visible depuis Internet est celui
du routeur.
Dans le cas où vous êtes derrière un routeur, vous pouvez interroger une page du type www.MonIP.com qui affiche votre
adresse IP externe et ensuite analyser cette page pour récupérer l'adresse IP en question ou bien également d'autres sites
qui proposent directement un fichier xml d'où l'on peut encore plus facilement extraire l'information. Cette solution
fonctionne aussi si vous êtes directement relié au réseau Internet (sans passer par un routeur).
Connaître son adresse IP externe en étant derrière un routeur

import xml.dom.minidom
import urllib
## On va ici simplement analyser un fichier xml disponible sur internet qui donne l'adresse IP
ipxml = xml.dom.minidom.parse(urllib.urlopen('http://www.showmyip.com/xml/'))
myIP = ipxml.getElementsByTagName('ip')[0].childNodes[0].nodeValue
print myIP
- 59 -
FAQ Python
Pour connaître l'adresse IP interne de votre ordinateur (si vous êtes derrière un routeur) ou l'IP externe (si vous
n'êtes pas derrière un routeur), vous pouvez récupérer très facilement récupérer cette information. Par la fonction
socket.gethostname(), vous récupérer le nom de votre ordinateur puis la fonction socket.getaddrinfo( host, port[, family[,
socktype[, proto[, flags]]]]) retourne une liste d'informations utiles pour la manipulation de socket dont on peut extraire
facilement l'adresse IP que l'on recherche.
import socket
info = socket.getaddrinfo(socket.gethostname(), None)
print info
- 60 -
FAQ Python
Sommaire > Réseau / Web > FTP

Comment gérer les déconnexions intempestives du serveur FTP ?
Auteurs : Guigui_ ,
Quand vous manipulez un objet FTP et que vous vous connectez à un serveur FTP, il arrive parfois qu'une déconnexion
survienne (commandé par le serveur ou non), ce qui arrive souvent lorsque l'on reste trop longtemps connecté à un
serveur sans rien faire. Ceci peut être gênant notamment lorsqu'on veut exécuter de nombreuses actions sans maîtriser
le temps entre chaque. Une méthode serait de se reconnecter à chaque fois avant d'exécuter une requête sur le serveur.
Une autre façon de faire est de se créer une petite classe qui va gérer la reconnexion quand la connexion est perdu au
moment de l'exécution de la requête. Cette classe hérite de ftplib.FTP qui gère le client FTP. Nous avons ensuite la
fonction Reconnect qui permet la connexion au serveur et la fonction Command(self, command, *args) qui exécute la
requête command avec la liste de paramètres donnés par *args en se reconnectant si nécessaire au serveur.
import ftplib
class GDDFTP(ftplib.FTP):
def __init__(self, adresse, port, user, password):
ftplib.FTP.__init__(self, '')
self.adresse = adresse
self.port = port
self.user = user
self.password = password
def Reconnect(self):
self.connect(self.adresse, self.port) ## Recherche FTP
self.login(self.user, self.password) ## Connexion
def Command(self, command, *args):
try: return command(*args)
except:
self.Reconnect()
return command(*args)
ftp = GDDFTP(monadresse, monport, monlogin, monpassword)

print ftp.Command(ftp.size, monfichier)
ftp.close()
print ftp.Command(ftp.size, monfichier)
Comment savoir si un fichier représente un répertoire sur un serveur FTP ?

Auteurs : Guigui_ ,
Une instance ftplib.FTP ne possède pas de fonction permettant de savoir directement si un fichier est un répertoire
ou non. Il n'y a à ma connaissance non plus aucune commande FTP directe qui permettrait de nous l'indiquer. Une
méthode pour obtenir cette information consiste alors en la génération d'une erreur en fonction de la présence d'un
fichier ou répertoire avec certaines requêtes. Toutes ces méthodes ne fonctionnent aussi que si vous avez les droits
d'accès à ces dossiers ou fichiers.
Par exemple, vous pouvez demander la taille du fichier par la commande ftp.size(filename) qui renvoie la taille du fichier
filename ou bien une erreur si ce fichier n'existe pas ou n'est pas un répertoire.
try:
ftp.size(MyPath)
## Traitement si c'est un fichier
except:
## Traitement si c'est un répertoire
- 61 -
FAQ Python
On peut aussi tenter d'accéder au dossier ftp.cwd( pathname) qui générera une erreur si pathname ne représente pas
un répertoire. Il faudra cependant penser à retourner dans le répertoire parent ensuite.
try:
ftp.cwd(MyPath)
ftp.cwd("..")
except:
Comment se déplacer dans l'arborescence d'un serveur FTP ?

Auteurs : Guigui_ , DiGiTAL_MiDWAY ,
Vous pouvez changer le répertoire courant, il vous suffit d'utiliser la commande ftp.cwd( pathname) où pathname est
le chemin relatif ou absolu du répertoire souhaité.
Ainsi pour remonter d'un niveau dans l'arborescence des dossiers, il suffit d'appliquer la méthode ftp.cwd('..'). On peut
également utiliser directement une commande FTP avec la méthode ftp.sendcmd('CDUP')
Comment envoyer un fichier sur un serveur FTP ?

Auteurs : Guigui_ ,
Pour envoyer un fichier sur un serveur FTP, il vous faut tout d'abord vous connecter à se serveur puis appliquer la
fonction storbinary(command, file, blocksize = 8192) où command est une chaîne de caractères en général du type "STOR
CheminFichierSurServeur" (CheminFichierSurServeur étant le fichier (accompagné de son chemin d'accès) qui sera
créé sur le serveur), file le chemin d'accès du fichier à transférer ouvert en lecture binaire et blocksize la taille des blocks
transférés au serveur (on se contente généralement de la valeur par défaut).
import ftplib
ftp = ftplib.FTP('')
ftp.connect(monadresse, monport)
ftp.login(monlogin, monpassword)
ftp.storbinary('STOR fichiersurserveur', open(fichieratransferer, 'rb'))
Comment télécharger les fichiers d'une arborescence d'un répertoire?

Auteurs : Guigui_ ,
Si vous voulez télécharger tous les fichiers d'un répertoire et de ses sous-répertoires, il vous suffit de parcourir
récursivement chaque sous-dossier et de télécharger chaque fichier trouvé. La fonction ftp.nlst(path) renvoie la liste
des fichiers/répertoires de path. ftp.size(path) permet de savoir si le fichier path étudié est un fichier ou un répertoire.
ftp.retrbinary( command, callback[, maxblocksize[, rest]]) où command doit être du type 'RETR filename' et callback est
un fichier ouvert en écriture. La fonction suivante ne gère pas par contre les déconnexions au serveur. En suivant les
liens proposés, vous pourrez remédier à cela.
import os
import ftplib
def download(pathsrc, pathdst):
- 62 -
FAQ Python
lenpathsrc = len(pathsrc)
def _download(pathsrc):
l = ftp.nlst(pathsrc)
for i in l:
try:
ftp.size(i)
print i
ftp.retrbinary('RETR '+i, open(pathdst+os.sep+i[lenpathsrc:], 'wb').write)
except:
try: os.makedirs(pathdst+os.sep+os.path.dirname(i[lenpathsrc:]))
except: pass
_download(i)
_download(pathsrc)
ftp = ftplib.FTP('')
ftp.connect(monadresse, monport)
ftp.login(monlogin, monpassword)
download(cheminsource, chemindestination)
lien : Comment gérer les déconnexions intempestives du serveur FTP ?

lien : Comment savoir si un fichier représente un répertoire sur un serveur FTP ?
- 63 -
FAQ Python
Sommaire > Les erreurs

Pourquoi j'obtiens le message IndexError: ... index out of range ?
Auteurs : Guigui_ ,
L'erreur de type IndexError intervient lorsqu'on tente d'accéder à un élément d'une séquence n'existant pas. Les
séquences sont indexées de 0 (premier élément) à longueur(séquence) - 1 (dernier élément).
>>> l = [10, 3, 15]

>>> s = "abcde"
>>> print l[0], l[2]
10, 15
>>> print l[6]
Traceback (most recent call last):

File "<pyshell#2>", line 1, in <module>
print l[6]
IndexError: list index out of range
>>> print s[3]
'd'
>>> print s[len(s)]

print s[len(s)]
IndexError: string index out of range
Pourquoi j'obtiens le message AttributeError: 'NoneType' object has no attribute ... ?

Auteurs : Guigui_ ,
Ce message est obtenu lorsque vous essayer d'accéder à un attribut de type None. Souvent, il s'agit d'un objet que vous
aviez précédemment construit correctement mais auquel vous avez réaffecté une valeur None en lui appliquant une
fonction de retour None.
Vous pouvez également obtenir des erreurs de même type AttributeError: 'str' object has no attribute ... ou encore
AttributeError: 'int' object has no attribute ... qui résulteront de fonctions de retour une chaîne de caractères ou un entier.
Par exemple, les chaînes de caractères et les entiers sont des objets immuables, il est donc courant d'utiliser la syntaxe
monstring = monstring.mafonction() pour pouvoir réaffecter la valeur de retour de mafonction à monstring. Mais pour les
objets muables, ceux-ci possèdent parfois des fonctions qui les modifient directement sans avoir besoin de les réaffecter
(par exemple, pour une liste, la fonction malist.sort() va trier la liste malist en place et retourner une valeur de None)
>>> l = [5, 1, 4]
>>> l = l.sort() ## ici, on a en fait affecté None à l
>>> l.append(5)

l.append(5)
AttributeError: 'NoneType' object has no attribute 'append'
>>> l = [5, 1, 4]
>>> l.sort() ## ici, on trie en place l
>>> l
- 64 -
FAQ Python
[1, 4, 5]
lien : [Tkinter] Pourquoi j'obtiens le message AttributeError: 'NoneType' object has no attribute ... ?
Pourquoi j'obtiens le message AttributeError: 'module' object has no attribute ... ?

Auteurs : Guigui_ ,
Ce message peut intervenir pour deux raisons principales. La première est que vous essayer d'accéder à un attribut du
module qui n'existe pas. Python étant sensible à la casse, vérifiez alors que vous ne vous êtes pas trompé dans l'utilisation
des majuscules et minuscules. Avec un simple print dir(monmodule), vous aurez aussi accès à tous les attributs du module
monmodule et vous pourrez alors effectivement vérifier que l'attribut en question n'est pas présent (ou sous une autre
orthographe).
La deuxième possibilité est que le module où l'erreur a eu lieu n'est pas celui que vous pensiez avoir importé. Il suffit
que dans l'ensemble des répertoires dans lequel Python va rechercher les modules à importer, il en existe 2 ayant le
même nom, et vous n'êtes plus sûr de celui qui subsistera. Typiquement, si le nom de votre programme est le même
que celui d'un module de la bibliothèque standard, ce dernier ne sera pas importé. Choississez donc un nom pour vos
fichiers qui soit différent des autres modules existants.
Pourquoi j'obtiens le message ImportError: No module named ... ?

Auteurs : Guigui_ ,
Lorsque vous faite une importation d'un module, si celui-ci n'est pas installé sur votre ordinateur ou bien que Python
n'est pas capable de le trouver à partir des variables d'environnement, vous obtiendrez le message d'erreur ImportError:
No module named ... . S'il s'agit d'une bibliothèque externe, il vous faudra donc en général télécharger et installer la
bibliothèque en question. Vous trouverez bon nombres de liens sur notre page Outils Python.
S'il s'agit d'un de vos propres modules, cela signifie donc que Python ne cherche pas au bon endroit. Cela peut arriver
lorsque vous faites des importations directement depuis le shell Python (ou celui d'IDLE par exemple) où le répertoire
local n'est souvent pas celui auquel on pense.
Faites attention aussi à la casse, Python est sensible au majuscule/minuscule.
Pour un module standard, vérifier qu'il est bien présent selon la version de Python que vous utilisez.
Il peut enfin s'agir d'un module qui n'est pas disponible sous tous les systèmes d'exploitation. Référerez à la Python
Library Reference pour vérifier la disponibilité du module en question.
lien : Comment importer un module qui n'est pas dans le répertoire courant ?
Pourquoi j'obtiens le message TypeError: unsupported operand type(s) for ...: ... and ... ?
Auteurs : Guigui_ ,
Ce message d'erreur intervient lorsque vous essayer d'effectuer entre 2 objets une opération qui n'est pas supportée.
Cela intervient souvent lorsque les objets sont de types différents. Python est un langage fortement typé, c'est à dire
qu'il ne modifiera jamais le type d'un objet sauf si une conversion est demandée explicitement.
Ainsi, si vous voulez concaténer un nombre et une chaîne de caractères, il vous faudra tout d'abord convertir le nombre
en chaîne.
>>> 5 + 'e'

5 + 'e'
TypeError: unsupported operand type(s) for +: 'int' and 'str'
- 65 -
FAQ Python
>>> str(5) + 'e'

'5e'
- 66 -
FAQ Python
Sommaire > GUI

Quel GUI choisir pour ses interfaces graphiques ?
Auteurs : Guigui_ ,
Cette question est assez fréquente. Si vous voulez créer une interface graphique en Python pour programmer des
logiciels classiques (applications de gestion par exemple), vous avez le choix entre différentes bibliothèques qui vous
permettront de construire votre interface. Classiquement, on peut en dénombrer 4 qui sont portables sur Windows,
Linux et Mac, à savoir Tkinter, wxPython, pyGTK, et pyQt. Ces 4 bibliothèques sont des interfaces à respectivement Tcl/
Tk, wxWindows C++, GTK+ et Qt. En recherchant sur Internet, vous pourrez toujours en trouver d'autres mais qui sont
néanmoins beaucoup moins utilisées que ces quatre-ci. Vous pourrez les télécharger à partir de notre page Outils Python
Comment alors choisir sa bibliothèque ?
La plus simple à prendre en main est Tkinter, livrée dans la distribution Python et qui possède de nombreuses extensions
possibles (Pmw, Tix, ...). Tkinter est très bien pour débuter avec les interfaces graphiques en Python ou pour de petites
applications qui ne nécessitent pas une interface trop élaborée. De plus, la documentation sur Tkinter est très abondantes.
Tkinter reste cependant assez limité en composants graphiques et l'utilisation des widgets fournis n'est pas forcément
très habituelle par rapport à ce que l'on retrouve dans toutes les autres.
Ensuite on retrouve 2 bibliothèques open source et d'utilisation gratuite pour des projets commerciaux à savoir pyGTK
et wxPython. wxPython semble la plus portable des 2 et est à préférer pour une utilisation sous Windows.
Enfin, pyQt est gratuit pour les projets libres et payant pour les projets commerciaux. pyQt semble la plus élaborée des 4.
Pour des projets professionnels, si vous ne voulez pas vous acquitter d'une licence payante, choississez wxPython sinon
pyQt.
Enfin, Python s'interface bien avec d'autres langages. Il vous ait donc possible de créer votre interface dans un autre
langage tout en programmant en Python. par exemple, le composant PythonForDelphi permet de créer une interface
Delphi et de manipuler des objets Python. Jython permet de manipuler des objets Java ou encore IronPython permet
de s'interfacer avec .Net. Là, encore, vous retrouverez les liens sur la page Outils Python
lien : FAQ Tkinter

lien : Tutoriel wxPython
lien : Tutoriel pyGTK
lien : Débat: Quel GUI choisir ?
lien : Forum Python GUI
- 67 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw
- 68 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Prérequis

Où trouver de l'aide pour Tkinter ?
Auteurs : Guigui_ ,
Une documentation complète en anglais est disponible mais vous trouverez également de nombreux cours en français
qui vous permettront d'apprendre à construire une interface avec Tkinter.
•
Apprendre à programmer avec Python : chapitres 8, 13-15
•
Python Library Reference 2.6
•
Python Library Reference 3.0
•
An Introduction to Tkinter (1999) : documentation exhaustive de Tkinter
•
An Introduction to Tkinter (2005) : en cours de rédaction
Quels sont les changements pour Tkinter entre Python 2 et Python 3 ?

Auteurs : Guigui_ ,
Python 3 apporte une harmonisation au niveau des modules. Tous commencent maintenant par une minuscule. Au
niveau de Tkinter, ils sont maintenant tous regroupés dans un même paquetage nommé tkinter. Le changement majeur
entre Python 2 et Python 3 pour Tkinter apparaît donc lors de l'importation des modules. Attention, pour le moment,
la plupart des modules externes (Pmw, ...) dépendants de Tkinter n'ont pas encore été mis à jour et ne fonctionneront
qu'avec une version 2 de Python.
Importation avec Python 2

import Tkinter
import Tix
import ScrolledText
import tkColorChooser
import tkCommonDialog
import tkFileDialog
import tkFont
import tkMessageBox
import tkSimpleDialog
Importation avec Python 3

import tkinter
import tkinter.tix
import tkinter.scrolledtext
import tkinter.colorchooser
import tkinter.commondialog
import tkinter.filedialog
import tkinter.font
import tkinter.messagebox
import tkinter.simpledialog
Prérequis pour les questions suivantes

Auteurs : Guigui_ ,
- 69 -
FAQ Python
import tkMessageBox
import tkFileDialog
import Tix
root=Tk.Tk() ## Création de la fenêtre principale si vous n'utilisez que des objets Tkinter
root=Tix.Tk() ## Création de la fenêtre principale si vous utilisez des objets Tix
entry=Tk.Entry(root) ## Création d'un Entry
button=Tk.Button(root) ## Création d'un Button
label=Tk.Label(root) ## Création d'un Label
listbox=Tk.Listbox(root) ## Création d'une Listbox
canvas=Tk.Canvas(root) ## Création d'un Canvas
text=Tk.Text(root) ## Création d'un Text
Comment installer la bibliothèque Pmw ?

Auteurs : Guigui_ ,
L'installation est très simple. Vous devez tout d'abord récupérer le zip des sources qui se nomme Pmw.1.3.2.tar.gz. Il
suffit ensuite d'extraire les fichiers/répertoires dans le répertoire PythonPath/Lib/site-packages où PythonPath est le
répertoire d'installation de Python (par exemple, c:/python26 typiquement sous Windows).
Vous pourrez alors vérifier que la bibliothèque est bien installé en testant avec l'interpréteur Python la commande
import Pmw.
- 70 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tkinter
- 71 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tkinter > Widget
Comment donner le focus à un Widget ?
Auteurs : Guigui_ ,
w.focus_set() donne le focus au widget w
Comment modifier la fonte d'un Widget ?

Auteurs : Guigui_ ,
Le module tkFont fournit une classe Font qui permet de définir les caractéristiques des fontes de n'importe quel widget
avec les attributs suivants:
attributs de la classe Font

• family: 'courier', 'arial', ...
• size: integer
• slant: NORMAL ou ITALIC
• weight: NORMAL ou BOLD
• underline: True ou False
• overstrike: True ou False
La fonction font.config(**font_option) permet de configurer la fonte, les différents attributs étant optionnels.
import tkFont
fonte = tkFont.Font(root)
fonte.config(size=18, family='courier', slant=tkFont.ITALIC, weight=tkFont.BOLD, underline=True,
overstrike=True)
label.config(font = fonte)
Comment afficher une image sur un Widget ?

Auteurs : Guigui_ ,
La classe Tkinter PhotoImage reconnaît les images GIF et PPM. Le fait qu'elle soit utilisée comme option de
configuration image d'un widget ne suffit pas à maintenir une instance PhotoImage en vie. Il faut donc s'assurer de
conserver ces instances dans un objet conteneur de Python;
# -*- coding: cp1252 -*-

def imgaffiche():
img = Tk.PhotoImage(file = imgfile)
## Création d'un objet PhotoImage qui reconnait les extensions .gif et .ppm
gifsdict[imgfile] = img ## si on commente cette ligne, l'image ne s'affichera pas
button.configure(image=img) ## Ajout de l'image sur le bouton
## On pourrait aussi directement faire
## gifsdict[imgfile] = Tk.PhotoImage(file = imgfile)
## button.configure(image = gifsdict[imgfile])
root = Tk.Tk()
button = Tk.Button(text = "affiche image", command = imgaffiche)
imgfile = strchemin ## strchemin:str, chemin d'accès à l'image
- 72 -
FAQ Python
gifsdict={} ## Utilisation d'un dictionnaire pour conserver une référence sur la PhotoImage créée
button.pack()
root.mainloop()
Si vous voulez afficher une image autre que GIF ou PPM, il vous faudra passer par la bibliothèque PIL qui est
capable de lire tout type d'images. Il faudra également conserver l'image dans un objet conteneur Python pour les
mêmes raisons que précedemment.
from PIL import Image, ImageTk ## Importation des modules utiles dans PIL
root = Tk.Tk()
monimage = Image.open("lena.jpg") ## Chargement d'une image à partir de PIL

photo = ImageTk.PhotoImage(monimage) ## Création d'une image compatible Tkinter
label = Tk.Label(image=photo) ## Insertion de l'image de l

label.image = photo ## Maintient en vie de photo dans un objet non détruit par le garbage
## pour pas que l'image disparaisse du label
label.pack()
root.mainloop()
Comment changer la couleur de fond d'un widget ?

Auteurs : Guigui_ ,
Pour modifier la couleur de fond d'un widget, il suffit d'appliquer la méthode w.config(bg = NewColor) ou
w.config(background = NewColor) où NewColor est une chaîne représentant soit un nom de couleur (par exemple "red",
"green", ...) soit directement une couleur avec ses composantes RVB en ayant la forme "#RRVVBB" où RR, VV, BB
sont des valeur hexadécimales comprises entre 00 et FF
root = Tk.Tk()
root.config (bg = "red")
label = Tk.Label(root, text = "test")
label.configure(background = "#50A42D")
label.pack()
root.mainloop()
- 73 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tkinter > Fenêtre
Comment empêcher le redimensionnement d'une fenêtre par l'utilisateur ?
Auteurs : Guigui_ ,
root.resizable(width=False, height=False)
Remarque: en revanche, cela n'empêchera pas le redimensionnement automatique de votre fenêtre si vous utilisez le
gestionnaire de géométrie pack ou grid
Comment afficher une fenêtre en plein écran ?

Auteurs : Guigui_ ,
De manière très simple, en appliquant l'instruction root.wm_state(newstate="zoomed"), vous afficherez la fenêtre
principale en plein écran. Cette instruction ne fonctionne que sous windows
Comment forcer le rafraîchissement d'une fenêtre ?

Auteurs : Guigui_ ,
Tkinter ne rafraîchit l'interface graphique que lorsque le traitement de l'exécution de la fonction lancée est terminée
(par exemple lorsque l'on clique sur un bouton). Il arrive cependant parfois que la fonction exécutée dure un certain
temps qui empêche donc la fenêtre de se redessiner.
Si vous voulez éviter ce désagrément, vous pouvez rajouter dans votre programme des appels à root.update()
root = Tk.Tk()
lbl = Tk.Label(text=0)
def go():
for i in range(100000):
lbl.config(text=i)
root.update()
btn = Tk.Button(text='go', command=go)
lbl.pack()
btn.pack()
root.mainloop()
Comment intercepter la fermeture d'une fenêtre ?

Auteurs : Guigui_ ,
Tkinter supporte un mécanisme appelé protocol handlers dont le plus utilisé est le protcole WM_DELETE_WINDOW qui
définit ce qui doit se passer quand une fenêtre se ferme. Ce protocole doit être associé à un widget de type root ou Toplevel
de la manière suivante widget.protocol("WM_DELETE_WINDOW", handler) où handler est la fonction exécutée lors
de la fermeture de la fenêtre.
root = Tk.Tk()
def Intercepte():
- 74 -
FAQ Python
print "Interception de la fermeture de la fenetre"

root.destroy()
root.protocol("WM_DELETE_WINDOW", Intercepte)
root.mainloop()
Comment modifier le texte de la barre de titre d'une fenêtre ?

Auteurs : Guigui_ ,
Pour modifier le texte de la barre de titre d'un widget de type root ou Toplevel il suffit d'appliquer la fonction
w.title(mytitle) où mytitle est le nouveau texte en question.
root = Tk.Tk()
root.title('Main root')
def createframe():
toplevel = Tk.Toplevel(root)
toplevel.title('Subroot')
btn = Tk.Button(root, text = 'create a frame', command = createframe)

btn.pack()
root.mainloop()
Comment modifier l'icône de la barre de titre d'une fenêtre ?

Auteurs : Guigui_ ,
Pour modifier l'icône de la barre de titre d'une fenêtre root ou toplevel, il vous suffit d'appliquer la fonction
root.iconbitmap(myicon) où myicon représente le chemin d'accès de votre icône (testé uniquement avec des fichiers de
type .ico)
root = Tk.Tk()
root.iconbitmap("MyIcon.ico")
root.mainloop()
Comment créer une fenêtre sans barre de titre ni bordure ?

Auteurs : airod ,
Si vous avez besoin de créer des fenêtres root (Tk) ou TopLevel, vous pouvez lui appliquer la fonction
overrideredirect(flag=None) avec un flag ayant une valeur non nulle. Cela peut être utile par exemple pour afficher
une fenêtre contenant un message (une infobulle par exemple). Toutefois, vous ne pourrez ni déplacer ni détruire cette
fenêtre de manière ordinaire (il faudra donc prévoir dans votre code les fonctions nécessaires pour gérer cela).
root = Tk.Tk()
def affiche():
- 75 -
FAQ Python
top=Tk.Toplevel()
top.overrideredirect(1)
btn = Tk.Button(top, text = 'Fermer', command = top.destroy)
btn.pack()
btn = Tk.Button(root, text = 'Afficher message', command = affiche)

btn.pack()
root.mainloop()
lien : Création d'une classe InfoBulle
- 76 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tkinter > Entry
Comment effacer le contenu d'un Entry ?
Auteurs : Guigui_ ,
entry.delete(0,Tk.END)
Comment insérer un texte dans un Entry ?

Auteurs : Guigui_ ,
e.insert(index, text) insère le string text à la position index
e.insert(Tk.INSERT, text) insère le string text à la position du curseur
e.insert(Tk.END, text) insère le string text à la fin du widget
Comment utiliser la zone de texte comme une zone de saisie de mot de passe ?
Auteurs : Guigui_ ,
entry.configure(show='*')
Comment récupérer le contenu d'un Entry ?

Auteurs : Guigui_ ,
Il vous suffit simplement d'appliquer la méthode get() sur votre widget Entry pour récupérer son contenu (sous forme
d'un string).
Comment modifier l'état d'un Entry ?

Auteurs : Guigui_ ,
Pour modifier l'état d'un Entry, vous devez configurer l'option state par une des 3 options suivantes Tk.NORMAL,
Tk.DISABLED ou "readonly" de la manière suivante entry.config(state = NewState). Si vous optez pour Tk.DISABLED
ou "readonly", vous ne pourrez plus modifier le contenu de l'Entry (les fonctions insert et delete sont ignorées). De plus,
avec Tk.DISABLED, vous ne pourrez ni sélectionner ni copier le contenu de l'Entry, chose que vous pourrez encore
faire avec "readonly". Si vous voulez donc pouvoir modifier le contenu de l'Entry tout en interdisant à l'utilisateur de
le modifier manuellement, vous devrez avant d'appliquer une méthode insert/delete modifier l'état à Tk.NORMAL puis
le remettre à l'état Tk.DISABLED ou "readonly"
root = Tk.Tk()
entry = Tk.Entry(root, state=Tk.DISABLED)
i=0
def EntryStateModify():
global i
- 77 -
FAQ Python
entry.config(state=Tk.NORMAL)
entry.insert(Tk.END, str(i))
entry.config(state = Tk.DISABLED)
i += 1
btn = Tk.Button(root, text = 'Ajouter', command = EntryStateModify)
entry.pack()
btn.pack()
root.mainloop()
- 78 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tkinter > Button
Comment associer une fonction au clic gauche sur un bouton ?
Auteurs : Guigui_ ,
Une première méthode est de renseigner l'attribut command du widget Tk.Button. Cet attribut est associé à une fonction
sans paramètre. Il est important de ne pas mentionner les void () lors de cette association.
On peut également utiliser la fonction bind, cf Comment associer un évènement clavier/souris à un widget ?.
def clic():
print 'Clic gauche sur le bouton'
root = Tk.Tk()
button = Tk.Button(root, text = 'toto', command = clic)
button.pack()
root.mainloop()
Comment passer des paramètres à l'action associée à un Button ?

Auteurs : Guigui_ ,
Le passage d'arguments à l'action associée à un Tkinter.Button peut être utile si vous avez plusieurs Button qui pointent
sur la même fonction ou encore que la fonction appelée par le clic sur le bouton ait besoin d'un argument que celle-ci
ne peut connaître d'elle-même. Par défaut, le paramètre command d'un Button nécessite une fonction sans argument.
Vous pouvez cependant utiliser les fonctions lambdas pour passer des arguments supplémentaires. La syntaxe d'une
expression lambda est la suivante:
mafonction = lambda argument:expression où argument est la liste des arguments de ma fonction et expression
l'expression retournée par la fonction.
exemple:
f1 = lambda x: x + 5
print f1(9) ## 14
f2 = lambda x, y = 5: x * y
f2(6) ## 30
def multiplie(x, y): print x * y
f3 = lambda x, y:multiplie(x, y)
f3(7, 3) ## 21
Pour utiliser les expressions lambda avec un Button, les arguments devront obligatoirement avoir une valeur par défaut
vu que le clic sur un bouton ne peut apporter de valeurs aux paramètres de l'expression lambda. Si vous voulez pouvoir
modifier ces valeurs aux cours du programme il faudra soit utiliser des variables modifiables soit redéfinir le paramètre
command
def AfficheLabel(txt):
label.config(text = txt)
root = Tk.Tk()
label = Tk.Label(root, text = "Clic sur le bouton ")
label.grid(row = 0, column = 0, columnspan = 3)
svEntry = Tk.StringVar()
edit = Tk.Entry(root, textvariable = svEntry)
- 79 -
FAQ Python
edit.grid(row = 1, columnspan = 3)
btn1 = Tk.Button(root, text = "Button1", command = lambda
x=1:AfficheLabel("Clic sur le bouton "+str(x)))
x=2:AfficheLabel("Clic sur le bouton "+str(x)))
x=svEntry:AfficheLabel("valeur de l'entry: "+x.get()))
btn1.grid(row = 2, column = 0)
root.mainloop()
- 80 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tkinter > Label
Comment modifier le texte du label ?
Auteurs : Guigui_ ,
l.config(text=newstr) remplace le texte du label par newstr
- 81 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tkinter > Listbox
Comment récupérer un élément cliqué dans une Listbox ?
Auteurs : Guigui_ ,
def clic(evt):
i=listbox.curselection() ## Récupération de l'index de l'élément sélectionné
return listbox.get(i) ## On retourne l'élément (un string) sélectionné
listbox.bind('<ButtonRelease-1>',clic)
## on associe l'évènement "relachement du bouton gauche la souris" à la listbox
Comment associer un Scrollbar à une Listbox ?

Auteurs : Guigui_ ,
L'association d'un Scrollbar à une Listbox se fait très simplement. Pour cela, il suffit de créer un Scrollbar et la Listbox
associée avec un même parent (en général une Frame).
Ensuite, il faut configurer le Scrollbar et la Listbox pour que le déplacement dans la Listbox et le mouvement de
l'ascenseur se fasse simultanément, pour un Scrollbar vertical:
scrollbar.config(command = widget.yview)
listbox.config(yscrollcommand = scrollbar.set
Enfin, on les affiche à l'écran par l'intermédiaire du packer
listbox.pack(side = Tk.LEFT, fill = Tk.Y)
scrollbar.pack(side = Tk.RIGHT, fill = Tk.Y)
root = Tk.Tk()
f1 = Tk.Frame(root)
s1 = Tk.Scrollbar(f1)
l1 = Tk.Listbox(f1)
for i in range(20): l1.insert(i, str(i))
s1.config(command = l1.yview)
l1.config(yscrollcommand = s1.set)
l1.pack(side = Tk.LEFT, fill = Tk.Y)
s1.pack(side = Tk.RIGHT, fill = Tk.Y)
f1.pack()
root.mainloop()
Comment supprimer un élément dans une Listbox ?

Auteurs : Guigui_ ,
Pour supprimer un élement dans une listbox, il faut utiliser la fonction l.delete(first, last=None) où first représente l'index
du premier élement supprimé et last, l'index du dernier. Si ce dernier est omis, un seul élément (désigné par first) sera
supprimé.
Pour vider une listbox, il suffit d'appliquer la procédure l.delete(0,Tk.END)
Suppression de l'ensemble des éléments dans une listbox

root = Tk.Tk()
listbox = Tk.Listbox(root)
listbox.insert(0, 'element1')
- 82 -
FAQ Python
Suppression de l'ensemble des éléments dans une listbox

listbox.pack()
def clear():
listbox.delete(0, Tk.END)
btn = Tk.Button(root, text = 'Effacer la liste', command=clear)
btn.pack()
root.mainloop()
- 83 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tkinter > Canvas
Comment effacer le contenu d'un Canvas ?
Auteurs : Guigui_ ,
canvas.delete(Tk.ALL)
Comment insérer une image dans un Canvas ?

Auteurs : Guigui_ ,
Pour afficher une image autre que GIF ou PPM, il vous faudra passer par la bibliothèque PIL qui est capable de
lire tout type d'images.
Avec la fonction ImageTk.PhotoImage, vous créerez une image compatible Tkinter que vous pourrez afficher dans un
Canvas par la méthode create_image(position, **options) où position réprésente les 2 coordonnées du coin en haut à
gauche de l'image sachant que l'image sera aussi positionnée par rapport au paramètre anchor qui par défaut vaut
CENTER. Donc pour que l'image soit positionnée en haut à gauche du Canvas, vous devez utilisez la position 0, 0 et
rajouter le paramètre anchor = Tk.NW. Enfin le paramètre image représente l'image que vous voulez insérer.
Le Canvas ne s'adapte pas par défaut à la place que prennent les éléments que vous dessiner dedans. Donc si l'image que
vous insérez est trop grande, vous pouvez vous assurer qu'elle sera entièrement visible en renseignant les paramètres
width et height à la création du Canvas
from PIL import Image, ImageTk

root = Tk.Tk()
image = Image.open("lenna.jpg")
photo = ImageTk.PhotoImage(image)
canvas = Tk.Canvas(root, width = image.size[0], height = image.size[1])

canvas.create_image(0,0, anchor = Tk.NW, image=photo)
canvas.pack()
root.mainloop()
lien : Comment afficher une image sur un Widget ?
Comment modifier la couleur d'item d'un Canvas ?

Auteurs : Guigui_ ,
Pour modifier la couleur d'un item d'un Canvas, il faut tout d'abord que celui-ci supporte l'attribut fill. Ensuite vous
pouvez modifier cette attribut par la méthode canvas.itemconfigure(item, fill = NewColor) où item réprésente l'identifiant
de l'item à modifier et NewColor la nouvelle couleur.
root = Tk.Tk()
canvas = Tk.Canvas(root, height=100, width=200)

canvas.pack()
oval = canvas.create_oval(20,20,70,70,width=2,fill='red')
rect = canvas.create_rectangle(90,20,140,70,width=2,fill='green')
poly = canvas.create_polygon([160,45,175,20,190,45,175,70 ], width =2, fill = 'blue')
- 84 -
FAQ Python
def ColorChange():
canvas.itemconfigure(oval, fill = "blue")
canvas.itemconfigure(rect, fill = "#67A12B")
canvas.itemconfigure(poly, fill = "#001020")
btn = Tk.Button(root, text = "Changer la couleur des objets", command = ColorChange)

btn.pack()
root.mainloop()
- 85 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tkinter > Text
Comment modifier le mode de coupure du texte ?
Auteurs : Guigui_ ,
text.config(wrap=Tk.CHAR) ## Découpe des mots selon les caractères

text.config(wrap=Tk.NONE) ## pas de découpe des mots
text.config(wrap=Tk.WORD) ## Découpe des mots selon un mot entier
Comment mettre le texte en lecture seule ?

Auteurs : Guigui_ ,
text.config(state=Tk.DISABLED)
text.config(state=Tk.NORMAL) ## Remet le texte en mode normal
Comment récupérer le contenu d'un widget Text ?

Auteurs : Guigui_ ,
Pour récupérer le contenu d'un widget Text, il suffit d'utiliser la fonction text.get(start, end=None) où start et end sont
deux flottants.
start: Le nombre avant le "." décimal correspond à la première ligne à récupérer et le nombre après le "." correspond
au premier caractère à récupérer de la ligne en question.
end: Le nombre avant le "." décimal correspond à la dernière ligne à récupérer et le nombre après le "." correspond
au dernier caractère à récupérer de la ligne en question sachant que celui-ci est non inclu.
Remarque: le première caractère de la première ligne est d'index 1.0
Exemple:
text.get(1.0, Tk.END) ## Récupération du contenu entier d'un widget Text

text.get(5.0, 6.0) ## Récupération du contenu de la 5ème ligne
text.get(2.3, 4.11) ## Récupération du contenu du caractère 3 de la 2ème ligne jusqu'au caractère
## 11 (non inclu) de la 4ème ligne
Comment associer un Scrollbar à un Text ?

Auteurs : Guigui_ ,
Pour le widget Text, on peut associer un Scrollbar horizontal ou/et un Scrollbar vertical.
L'option orient permet de définir si la Scrollbar est horizontale ou verticale. Le fonctionnement est quasiment similaire
à celui pour la Listbox excepté que dans le cas de l'utilisation d'un double Scrollbar, on utilisera plutôt le gridder que
la packer.
root = Tk.Tk()
## Déclaration des différents widgets

f1 = Tk.Frame(root)
s1 = Tk.Scrollbar(f1, orient=Tk.VERTICAL)
s2 = Tk.Scrollbar(f1, orient=Tk.HORIZONTAL)
- 86 -
FAQ Python
t1 = Tk.Text(f1, wrap=Tk.NONE)
## association du déplacement de la glissière des scrollbar avec la position visible dans

## le widget Text et inversement.
s1.config(command = t1.yview)
s2.config(command = t1.xview)
t1.config(yscrollcommand = s1.set, xscrollcommand = s2.set)
## Placement du widget Text et des Scrollbar associés

t1.grid(column=0, row=0)
s1.grid(column=1, row=0, sticky=Tk.S+Tk.N)
s2.grid(column=0, row=1, sticky=Tk.W+Tk.E)
f1.pack()
root.mainloop()
lien : Comment associer un Scrollbar à une Listbox ?
- 87 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tkinter > Menu
Comment insérer une barre de menu ?
Auteurs : Guigui_ ,
le widget Menu peut être utiliser pour créer une barre de menu dans une fenêtre. Pour cela, vous devez tout d'abord
définir un premier Menu de parent une fenêtre ( mainmenu = Tk.Menu(root) ) puis associé ce menu à la fenêtre (
root.config(menu = mainmenu) ).
Pour ajouter des menus à la barre de menu, vous créerez de nouveaux Menu ayant pour parent le premier
menu crée ( menuExample = Tk.Menu(mainmenu) ) et sera insérée à la barre par la fonction add_cascade (
mainmenu.add_cascade(label = "Exemple", menu=menuExample) ). La fonction add_cascade(**options) peut recevoir
une liste de paramètres où les principaux sont label pour le titre du menu fils et menu représentant l'indentifiant du
menu fils en question.
Pour ajouter des options à un menu fils, vous utilisez la fonction add_command(**options) qui peut recevoir une liste
de paramètres et où les principaux sont label pour le titre de l'option et command qui représente la fonction associée
au clic sur l'option.
Exemple de création d'un Menu

# -*- coding: cp1252 -*-
import tkMessageBox
root = Tk.Tk() ## Fenêtre principale
def Affiche(): tkMessageBox.showinfo("Exemple d'un Menu Tkinter")

def About(): tkMessageBox.showinfo("A propos", "Version 1.0")
mainmenu = Tk.Menu(root) ## Barre de menu

menuExample = Tk.Menu(mainmenu) ## Menu fils menuExample
menuExample.add_command(label="Affiche", command=Affiche)
## Ajout d'une option au menu fils menuFile
menuExample.add_command(label="Quitter", command=root.quit)
menuHelp = Tk.Menu(mainmenu) ## Menu Fils

menuHelp.add_command(label="A propos", command=About)
mainmenu.add_cascade(label = "Exemple", menu=menuExample)

mainmenu.add_cascade(label = "Aide", menu=menuHelp)
root.config(menu = mainmenu)
root.mainloop()
Comment ajouter un séparateur dans un menu ?

Auteurs : THE_VIP ,
La méthode add_separator() permet de rajouter une ligne de séparation dans un menu.
- 88 -
FAQ Python
# -*- coding: cp1252 -*-

import tkMessageBox
root = Tk.Tk()
def Affiche(): tkMessageBox.showinfo("Exemple d'un Menu Tkinter")

def About(): tkMessageBox.showinfo("A propos", "Version 1.0")
mainmenu = Tk.Menu(root)
menuExample = Tk.Menu(mainmenu)
menuExample.add_command(label="Affiche", command=Affiche)
menuExample.add_separator() ## Ajout d'une ligne séparatrice
menuExample.add_command(label="Quitter", command=root.quit)
mainmenu.add_cascade(label = "Exemple", menu = menuExample)

root.mainloop()
Comment permettre ou non qu'un menu soit détachable de son parent ?

Auteurs : THE_VIP ,
Le widget Menu admet un paramètre booléen tearoff qui indique si le menu en question peut être détaché de son parent
ou non; par défaut, tearoff = 1 et le menu est détachable. Un menu détachable est caractérisé par la présence d'une
ligne pointillée en son début.
root = Tk.Tk()
mainmenu = Tk.Menu(root)
menunondetachable = Tk.Menu(mainmenu, tearoff = 0)
menudetachable = Tk.Menu(mainmenu, tearoff = 1)
mainmenu.add_cascade(label="Menu1", menu = menunondetachable)
mainmenu.add_cascade(label="Menu2", menu = menudetachable)
menunondetachable.add_command(label="Quit", command = fenetre.quit)
menudetachable.add_command(label="Quit", command = fenetre.quit)
root.mainloop ()
- 89 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tkinter > tkMessageBox
Comment afficher une boîte de dialogue Information ?
Auteurs : Guigui_ ,
tkMessageBox.showinfo(strTitel, strMessage) ouvre une boite d'Information avec le message strMessage et le caption de
la boite strTitel
Comment afficher une boîte de dialogue Warning ?

Auteurs : Guigui_ ,
tkMessageBox.showwarning(strTitel, strMessage) signale un warning avec le message strMessage et le caption de la boite
strTitel
Comment afficher une boîte de dialogue Error ?

Auteurs : Guigui_ ,
tkMessageBox.showerror(strTitel, strMessage) signale une erreur avec le message strMessage et le caption de la boite
strTitel
- 90 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tkinter > tkFileDialog
Comment afficher une boîte de dialogue pour sélectionner un fichier ?
Auteurs : Guigui_ ,
Il suffit d'utiliser la fonction tkFileDialog.askopenfilename(filetypes= tuplelist)
le paramètre facultatif filetypes est une list de tuple de strings de la forme (Nom du groupe des extensions, liste des
extensions). Cette fonction renvoie le chemin du fichier sélectionné si vous appuyez sur le bouton Ouvrir et '' si vous
appuyez sur le bouton Annuler
## exemple:
tkFileDialog.askopenfilename(filetypes = [("All", "*"),("Fichiers Python","*.py;*.pyw")])
Comment afficher une boîte de dialogue pour sélectionner un répertoire ?

Auteurs : Guigui_ ,
Il suffit d'utiliser la fonction tkFileDialog.askdirectory(initialdir= strDirectory) où le paramètre facultatif initialdir
indique le répertoire initiale d'ouverture
## Exemple:
tkFileDialog.askdirectory(initialdir='c:/Python24')
- 91 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tkinter > Gestion de la géométrie
Quel gestionnaire de mise en place choisir ?
Auteurs : Guigui_ ,
Tkinter offre 3 gestionnaires différents de mise en place des widgets à savoir le packer, le gridder et la placer:
- Le packer permet de positionner des objets les uns par rapport aux autres en spécifiant simplement s'ils sont au-dessus,
en-dessous à gauche ou à droite dans leur conteneur (Frame ou Toplevel) respectif ou par rapport à un autre objet placé
précédemment. Dès que l'interface graphique est assez compliqué, pour ne pas avoir de surprise lors de la visualisation
à l'écran, ce gestionnaire nécessite l'utilisation abondante de sous-conteneurs.
- Le gridder permet de positionner des objets directement dans une grille en spécifiant la colonne et la rangée où se situera
l'objet. Ce gestionnaire est donc utile quand l'interface graphique propose une grille de widgets avec volonté d'avoir
des alignements respectés. - Le placer permet de positionner des objets dans leur conteneur en spécifiant directement
leur position au pixel près.
L'avantage des 2 premiers gestionnaires est que ceux-ci gèrent directement le redimensionnement des objets lorsque la
fenêtre conteneur est elle-même redimensionnée par l'utilisateur ou bien modifiée par l'ajout d'un nouvel objet.
Il est fortement conseillé d'utiliser le même gestionnaire de mise en place dans un même conteneur. Il est par contre tout
à fait possible pour une même interface graphique d'utiliser plusieurs gestionnaires de mise en place. Généralement,
le packer et le gridder sont les 2 gestionnaires que l'on conserve et que l'on retrouve simultanément dans une même
interface graphique.
- 92 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tkinter > Evènements
Comment associer un évènement clavier/souris à un widget ?
Auteurs : Guigui_ ,
Il suffit d'appeler la fonction w.bind(event_name, callable) où le string event_name représente l'évènement et callable
la fonction à appeler
## Exemple: Affichage dans un label du numéro du bouton de la souris sur le clic sur button
def updatelabel(evt):
label.configure(text=evt.num)
button.bind('<Button-1>', updatelabel)
Comment associer un évènement à toute l'application ?

Auteurs : Guigui_ ,
Pour associer un évènement à toute l'application (évènement qui se réalisera donc quelquesoit le widget qui aura le
focus), il suffit d'appliquer la méthode bind_all à n'importe quel widget de l'application.
## Exemple simple: on affiche la touche entrée au clavier quelquesoit le widget qui a le focus
root = Tk.Tk()
e1 = Tk.Entry(root)
e2 = Tk.Entry(root)
e1.pack()
e2.pack()
def affiche(evt):
print evt.char
e1.bind_all('<Key>', affiche) ## ou e2.bind_all('<Key>', affiche) ou root.bind_all('<Key>', affiche)
root.mainloop()
- 93 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tkinter > Evènements > Evènements Clavier
Quels sont les noms des évènements associés au clavier ?
Auteurs : Guigui_ ,
L'utilisateur a pressé une touche quelconque: Key
L'utilisateur a pressé une touche spéciale:
- Touches de fonction: F1, F2, ..., F12
- Touches du curseur: Left, Right, Up, Down
- Touches "Pages vers le haut/bas": Prior, Next
- Touches libellés comme sur le clavier: End, Home, Insert, Print, Tab
- Touches "Suppr", "Fin", "Inser": Delete, End, Insert
- Touches "Esc" ou "Echap", "Entrée": Escape, Return
- Touches de verrouillage des majuscules, du clavier numérique et du défilement: Caps_Lock, Num_Lock, Scroll_Lock
- Touches "Alt", "Ctrl" et "Shift": Alt_L, Control_L, Shift_L
L'utilisateur a pressé une touche normale:
- le nom de l'évènement a le même nom que le nom de la touche: a, 1, +, ...
- Barre "Espace", caractère "<": space, less
L'utilisateur a pressé une combinaison de touches:
- "Alt/Shift/Ctrl + autre touche": Alt-, Shift-, Ctrl-
Remarque:
- Tous les évènements de plus de 2 caractères sont à mettre entre <...>
- Tous les évènements sont ensuite à mettre entre '...'
## Exemples:
def toucheevent(evt): ...
w.bind('x', touche) ## on lie l'appuie du caractère "x" avec la fonction toucheevent
w.bind('<Key>', toucheevent)
w.bind('<Left>' toucheevent)
w.bind('<Alt-Up>', toucheevent)
- 94 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tkinter > Evènements > Evènements Souris
Quels sont les noms des évènements associés à la souris ?
Auteurs : Guigui_ , airod ,
L'utilisateur a pressé un bouton: Button-1, Button-2, Button-3
L'utilisateur a déplacé la souris en maintenant un bouton: B1-Motion, B2-Motion, B3-Motion
L'utilisateur a double-cliqué sur un bouton: Double-Button-1, Double-Button-2, Double-Button-3
L'utilisateur a relâché un bouton: ButtonRelease-1, ButtonRelease-2, ButtonRelease-3
L'utilisateur a utilisé la roulette de la souris: MouseWheel L'utilisateur a déplacé la souris et elle est entrée dans un
widget: Enter
L'utilisateur a déplacé la souris et elle est sorite d'un widget: Leave
Remarque:
- Tous les évènements sont à mettre entre '<...>'
## Exemples:
def sourisevent(evt):
print dir(evt)
w.bind('<Button-1>',
sourisevent) ## on lie l'appuie du Bouton gauche de la souris avec la fonction sourisevent
w.bind('<ButtonRelease-2>',
sourisevent) ## on lie le relachement du Bouton du milieu de la souris avec la fonction sourisevent
w.bind('<Double-Button-3>', sourisevent) ## on lie le double-
clic du Bouton droit de la souris avec la fonction sourisevent
Comment utiliser l'évènement de la roulette de la souris (MouseWheel) ?

Auteurs : airod ,
L'évènement généré par l'utilisation de la roulette de la souris aura un attribut delta dont le signe permet de savoir
dans quel sens la roulette a été déplacée.
root = Tk.Tk()
def ScrollEvent(event): print event.delta
root.bind('<MouseWheel>', ScrollEvent)
root.mainloop()
- 95 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tkinter > Divers
Pourquoi j'obtiens le message AttributeError: 'NoneType' object has no attribute ... ?
Auteurs : Guigui_ ,
Ce message est souvent obtenu lorsque vous positionnez votre widget en même temps que vous le créez. Les fonctions
pack(), grid(...) ou place(...) ont None comme valeur de retour. Ainsi en manipulant en même temps la construction et
l'affichage du widget vous récupérer la valeur None au lieu de l'identifiant du widget.
Pensez toujours écrire ces actions en 2 lignes
>>> import Tkinter as Tk

>>> root = Tk()
>>> variable = Tk.Entry(root).pack()
>>> print variable.get()
AttributeError: 'NoneType' object has no attribute 'get'
>>> import Tkinter as Tk

>>> root = Tk()
>>> variable = Tk.Entry(root)
>>> variable.pack()
>>> print variable.get()
''
Pourquoi j'obtiens le message RuntimeError: Too early to create image ?

Auteurs : Guigui_ ,
Comme pour la plupart des toolkit graphique, il est nécessaire en général avant de pouvoir créer des objets Tkinter
de créer une instance Tk en premier lieu. Ce message d'erreur apparaît classiquement lorsque vous créez un objet
PhotoImage alors qu'aucune instance Tk n'existe.
Python 3.1b1 (r31b1:72424, May 7 2009, 15:38:57) [MSC v.1500 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> import tkinter
>>> img = tkinter.PhotoImage()
img = tkinter.PhotoImage()
File "C:\Python31\lib\tkinter\__init__.py", line 3269, in __init__
Image.__init__(self, 'photo', name, cnf, master, **kw)
File "C:\Python31\lib\tkinter\__init__.py", line 3210, in __init__
raise RuntimeError('Too early to create image')
RuntimeError: Too early to create image
>>> root = tkinter.Tk()
>>> img = tkinter.PhotoImage()
>>>
- 96 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tix
- 97 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tix > Widget
Comment manipuler les sous-widgets d'un widget Tix ?
Auteurs : Guigui_ ,
Les objets Tix sont souvent composés de différents objets Tkinter. Pour manipuler un objet Tix, il existe parfois des
méthodes spécifiques à cet objet ou bien vous pouvez accéder directement aux objets qui le composent. Pour cela, il
vous d'utiliser le dictionnaire w.subwidget_list qui regroupe tous les sous-objets (de premier niveau) de l'objet w. Pour
avoir cette liste, il vous suffit d'exécuter l'instruction print w.subwidget_list.keys().
- 98 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tix > Tix.Combobox
Comment créer un Combobox ?
Auteurs : Guigui_ ,
Tkinter ne propose pas le widget Combobox. On peut donc utiliser la bibliothèque Tix (qui est à priori installée avec
Python) ou Pmw pour récupérer ce widget. Le Combobox se compose d'un widget Entry et d'un widget Menu qui
contient les éléments sélectionnables. Les paramètres importants sont:
• editable: indique si la valeur du champ Entry est visible ou non

• dropdown: indique si le menu se présente sous forme d'une Listbox ou d'un bouton qui permet d'afficher cette
Listbox
• variable: variable référençant la valeur sélectionnée dans la Listbox.
• command: fonction appelée lorsqu'une valeur est sélectionnée dans la Listbox
Si vous voulez avoir une Combobox dont on puisse uniquement sélectionnée une valeur dans une liste, il faut modifier
la propriété de l'état de l'Entry à readonly
import Tix
def Affiche(evt):
print varcombo.get() ## On affiche a l'ecran la valeur selectionnee
root = Tix.Tk()
varcombo = Tix.StringVar()
combo = Tix.ComboBox(root, editable=1, dropdown=1, variable=varcombo, command = Affiche)
combo.entry.config(state='readonly') ## met la zone de texte en lecture seule
combo.insert(0, 'NT')
combo.insert(1, 'Linux')
combo.pack()
root.mainloop()
Comment vider la liste de choix d'un ComboBox ?

Auteurs : Guigui_ ,
Pour vider la liste de choix d'un ComboBox, il vous faut tout d'abord accéder à l'objet listbox du ComboBox. Cet objet est
lui-même un sous-objet de l'objet slistbox de la classe Tix.ScrolledListBox. Ainsi grâce au dictionnaire c.subwidget_list,
vous pouvez tout d'abord accéder à l'objet slistbox puis avec le dictionnaire c.subwidget_list['slistbox'].subwidget_list
à l'objet listbox. Il vous suffit ensuite d'appliquer la méthode usuelle sur un objet de type ListBox pour vider celui-
ci. Ainsi, l'instruction c.subwidget_list['slistbox'].subwidget_list['listbox'].delete(0, Tk.END) permet de vider la liste de
choix du ComboBox c
import Tix
root = Tix.Tk()
combo = Tix.ComboBox(root)
combo.insert(0,'elem1')
combo.pack()
def clear():
combo.subwidget_list['slistbox'].subwidget_list['listbox'].delete(0, Tk.END)
btn = Tix.Button(root, text='vider la liste', command=clear)
- 99 -
FAQ Python
btn.pack()
root.mainloop()
lien : Comment supprimer un élément dans une Listbox ?
- 100 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tix > Tix.Notebook
Comment changer la page visualisée à l'écran d'un Notebook ?
Auteurs : Guigui_ ,
Pour cela, il suffit d'utiliser la méthode notebook.raise_page(pagename) où pagename représente le nom d'une des page
créé dans le notebook
import Tix
def changepage2(): nb.raise_page("page2")

def changepage1(): nb.raise_page("page1")
root = Tix.Tk()
nb = Tix.NoteBook(root)
nb.add("page1", label="page1")
nb.add("page2", label="page2")
p1 = nb.subwidget_list["page1"]
p2 = nb.subwidget_list["page2"]
b1 = Tk.Button(p1, text='Passe a la page 2', command=changepage2)
b2 = Tk.Button(p2, text='Passe a la page 1', command=changepage1)
nb.pack()
b1.pack()
b2.pack()
root.mainloop()
- 101 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tix > Tix.Meter
Comment créer un Meter ?
Auteurs : Guigui_ ,
Le widget Meter proposé par la bibliothèque Tix permet de créer un widget appelé plus communément progressbar. Son
utilisation est très simple. Son attribut value doit être compris entre 0 (barre vide) et 1 (barre pleine). Avec la méthode
meter.config(value = newvalue), vous pouvez changer cette valeur. Ne pas oublier de forcer un raffraîchissement d'écran
(meter.update()) si on veut que l'affichage à l'écran prenne immédiatement la modification en cours.
import Tix
root = Tix.Tk()
meter = Tix.Meter(root, value=0.)
meter.pack()
def go():
meter.config(value=float(i)/10000)
meter.update()
btn = Tix.Button(root, text = 'Go', command = go)

btn.pack()
root.mainloop()
- 102 -
FAQ Python
Sommaire > GUI > Tkinter / Tix / Pmw > Tix > Tix.Balloon
Comment afficher une infobulle quand on passe au dessus d'un widget ?
Auteurs : Guigui_ ,
bal = Tix.Balloon() ## Création d'un Balloon

bal.bind_widget(w, msg=strmsg) ## On associe l'object bal au widget w avec le message strmsg
- 103 -
FAQ Python
Sommaire > GUI > wxPython

Où télécharger wxPython ?
Auteurs : Guigui_ ,
Vous trouverez tous les liens pour télécharger wxPython sur la page http://wxpython.org/download.php. Vous
pourrez récupérer les sources ou les binaires précompilés pour un bon nombre de distributions (Windows, Linux, Mac).
Vous pourrez également télécharger les démos et exemples (environ 200), ressources indispensables pour apprendre
efficacement à développer avec wxPython
Où trouver de l'aide pour wxPython ?

Auteurs : Guigui_ ,
Les ressources en français sur wxPython sont relativement peu abondantes. En revanche vous pourrez facilement en
récupérer en anglais. Voici les ressources principales qui vous seront utiles pour apprendre wxPython:
Tutoriels
•
Programmer des interfaces graphiques avec le framework open source wxPython
•
wxDocs
•
wxPyDocs
Livres
•
wxPython in Action
Comment changer l'icône d'une fenêtre ?

Auteurs : Guigui_ ,
Pour changer l'icône d'une fenêtre, vous devez tout d'abord créer un objet de type wx.Icon. Pour cela, il vous faut
appeler la fonction wx.Icon(name, type) où name correspond au nom de l'icône à charger et type le type de l'image.
Les types permis sont wx.BITMAP_TYPE_ICO, wx.BITMAP_TYPE_ICO_RESOURCE, wx.BITMAP_TYPE_GIF,
wx.BITMAP_TYPE_XBM, wx.BITMAP_TYPE_XPM.
Vous assignez ensuite l'icône à la fenêtre en appliquant la méthode MaFrame.SetIcon(MonIcone) où MonIcone est l'objet
wx.Icon précédemment créé.
import wx
app = wx.PySimpleApp()
frameicon = wx.Icon("./appicon.ico", wx.BITMAP_TYPE_ICO)
frame = wx.Frame(None, -1)
frame.SetIcon(frameicon)
frame.Show()
- 104 -
FAQ Python
app.MainLoop()
Comment utiliser un TextCtrl en tant que zone de saisie de mot de passe ?

Auteurs : Guigui_ ,
Il vous suffit lorsque vous créer le wx.TextCtrl de définir le paramètre style = wx.TE_PASSWORD.
import wx
frame = wx.Frame(None, -1)

panel = wx.Panel(frame, -1)
tc = wx.TextCtrl(panel, -1, style = wx.TE_PASSWORD, pos = (0,0))
btn = wx.Button(panel, -1, "Get", pos = (0, 30))
def GetPassword(event): print tc.GetValue()
btn.Bind(wx.EVT_BUTTON, GetPassword)
frame.Show()
app.MainLoop()
Comment changer le curseur d'une fenêtre ?

Auteurs : Guigui_ ,
Pour changer le curseur d'une fenêtre, il vous suffira de plus lui appliquer la méthode SetCursor avec comme paramètre
le nouveau curseur. wxPython possède ses propres curseurs. Vous pouvez tout d'abord récupérer les curseurs de
wxPython en invoquant la fonction wx.StockCursor(id) où id correspondra à la constante définissant un curseur de
wxPython.
Si votre curseur se trouve sous la forme d'un fichier, il vous suffit alors d'appeler le constructeur de la classe wx.Cursor
avec le nom du fichier ainsi que son type qui doit être d'un type reconnu.
Sous Windows, ce peut être wx.BITMAP_TYPE_CUR (fichier curseur .cur ou .ani),
wx.BITMAP_TYPE_CUR_RESOURCE, i (fichier icône .ico) Dans l'exemple suivant, il vous faudra au préalable créer
un fichier arrowblue.cur et un wait.ani (curseur animé)
import wx
CURSOR_ANIWAIT = wx.Cursor("wait.ani", wx.BITMAP_TYPE_CUR)

CURSOR_ARROWBLUE = wx.Cursor("arrowblue.cur", wx.BITMAP_TYPE_CUR)
CURSOR_ARROW = wx.StockCursor(wx.CURSOR_ARROW)
CURSOR_HAND = wx.StockCursor(wx.CURSOR_HAND)
frm = wx.Frame(None)
lb = wx.ListBox(frm, -1, pos = (200, 200), choices = ["WaitAni", "ArrowBlue", "Arrow", "Hand"],
style = wx.LB_SINGLE)
def ChangeCursor(event):
if event.GetString() == "WaitAni": frm.SetCursor(CURSOR_ANIWAIT)
elif event.GetString() == "ArrowBlue": frm.SetCursor(CURSOR_ARROWBLUE)
elif event.GetString() == "Arrow": frm.SetCursor(CURSOR_ARROW)
elif event.GetString() == "Hand": frm.SetCursor(CURSOR_HAND)
- 105 -
FAQ Python
lb.Bind(wx.EVT_LISTBOX, ChangeCursor)
frm.Show(True)
app.MainLoop()
Comment changer la fonte d'un widget ?

Auteurs : Guigui_ ,
Pour modifier la fonte des widgets (lorsque celle-ci est modifiable), on utilise en général la fonction disponible
SetFont(font) de la classe wx.Window (tous les objets visibles à l'écran héritant de cette classe) où font représente un
objet de type wx.Font.
Un objet de type wx.Font se construit facilement en fournissant au constructeur les paramètres suivants:
pointSize: entier donnant taille de la fonte en points
family à choisir parmi wx.FONTFAMILY_DEFAULT, wx.FONTFAMILY_DECORATIVE,
wx.FONTFAMILY_ROMAN, wx.FONTFAMILY_SCRIPT, wx.FONTFAMILY_SWISS,
wx.FONTFAMILY_MODERN et wx.FONTFAMILY_TELETYPE
style à choisir parmi wx.FONTSTYLE_NORMAL, wx.FONTSTYLE_SLANT et wx.FONTSTYLE_ITALIC
weight à choisir parmi wx.FONTWEIGHT_NORMAL, wx.FONTWEIGHT_LIGHT et wx.FONTWEIGHT_BOLD
underline: Booléen indiquant si la fonte contient un soulignement
face: string indiquant la police ("Arial" par exemple)
encoding: encodage de la fonte.
import wx
frm = wx.Frame(None, -1)
lbl1 = wx.StaticText(frm, -1, "test de fonte", pos = (50, 30))

myfont1 = wx.Font(11, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_ITALIC, wx.FONTWEIGHT_BOLD, False, "Arial")
myfont2 = wx.Font(8, wx.FONTFAMILY_ROMAN, wx.FONTSTYLE_SLANT,
wx.FONTWEIGHT_LIGHT, True, "Kristen ITC")
myfont3 = wx.Font(20, wx.FONTFAMILY_DECORATIVE, wx.FONTSTYLE_NORMAL,
wx.FONTWEIGHT_NORMAL, False, "Verdana")
lbl1.SetFont(myfont1)
frm.Show(True)
app.MainLoop()
- 106 -
FAQ Python
Sommaire > GUI > pyGTK

Où trouver de l'aide pour PyGTK ?
Auteurs : Guigui_ ,
Les ressources en français sur PyGTK sont relativement peu abondantes. Vous avez cependant à votre disposition un
tutoriel et sa traduction qui vous apportetons énormément d'informations.
•
Tutoriel PyGTK 2.0 (traduction)
•
PyGTK Tutorial 2.0
Forum
• Forum PyGTK
Comment forcer le raffraîchissement d'une application ?

Auteurs : Guigui_ ,
Lorsque vous appelez une fonction qui prend énormément de temps et qui se passe dans le thread principal, il arrive
que l'application se fige. Néanmoins, vous pouvez forcer le raffraîchissement de l'application en rajoutant à des endroits
stratégiques l'instruction gtk.main_iteration().
# -*- coding: cp1252 -*-

import pygtk
pygtk.require('2.0')
import gtk, gobject
class TestUpdate:
def affiche(self, widget, data=None):
self.lbl.set_text(str(i))
## Raffraîchissement de la fenêtre pour voir l'apparition de tous les nombres
gtk.main_iteration()
def __init__(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_resizable(True)
self.window.set_title("Test Raffraîchissement")
self.window.set_border_width(0)
vbox = gtk.VBox(False, 5)
vbox.set_border_width(10)
self.window.add(vbox)
vbox.show()
align = gtk.Alignment(0.5, 0.5, 0, 0)

vbox.pack_start(align, False, False, 5)
align.show()
self.lbl = label = gtk.Label('')

align.add(self.lbl)
self.lbl.show()
button = gtk.Button("Affiche")
button.connect("clicked", self.affiche)
vbox.pack_start(button, False, False, 0)
- 107 -
FAQ Python
button.set_flags(gtk.CAN_DEFAULT)
button.grab_default ()
button.show()
self.window.show()
def main():
gtk.main()
return 0
if __name__ == "__main__":
TestUpdate()
main()
- 108 -
FAQ Python
Sommaire > Optimisation

Comment accélérer du code Python par une compilation en C ?
Auteurs : Guigui_ ,
La bibliothèque Psyco permet une compilation dynamique en C de vos programmes sans modification de vos sources.
Il suffira d'ajouter les lignes suivantes au début de chacun de vos fichiers sources:
try: import psyco; psyco.full()

except: pass
Il peut cependant y avoir des interférences avec des modules de déboggage (le profiler par exemple)
Comment mesurer le temps d'exécution d'une portion de code ?

Auteurs : Guigui_ ,
Pour mesurer le temps d'exécution d'une portion de code, il suffit simplement d'utiliser la fonction time.clock() qui
renvoie le temps CPU en secondes. La différence entre 2 de ces différents temps donnera le temps d'éxécution de la
portion de code encadrée.
import time
l = range(100000)
tps1 = time.clock()
random.shuffle(l)
l.sort()
tps2 = time.clock()
print(tps2 - tps1)
Si vous n'avez pas besoin d'une précision très importante, l'usage de time.clock suffira amplement. Sinon optez pour
le module timeit.
Ce module propose principalement la création d'un objet timeit.Timer([stmt='pass'[, setup='pass'[, timer=<timer
function>]]]) où stmt est la portion de code sous forme d'une chaîne de caractères qui va être évaluée, setup représente
(toujours sous forme d'une chaîne de caractères), les conditions d'initialisation. Ces 2 paramètres peuvent également
être des objets qui sont appelable sans arguments.
Cet objet possède 2 méthodes Timer.timeit([number=1000000]) et Timer.repeat([repeat=3[, number=1000000]]).
La première fonction retourne le temps total des instructions exécutées number fois.
La deuxième reproduit l'expérience de la première repeat fois. Le temps à considérer sera alors le minimum des temps
obtenus
import timeit
import random
test1 = timeit.Timer("random.shuffle(l);l.sort()", "import random;l = range(100000)")

print(test1.timeit(10))
print(test1.repeat(5, 10))
Il faut bien faire attention à la validation des données en sachant que la condition setup n'est exécutée qu'une seule fois
au tout début. C'est pourquoi il peut être aussi bien de travailler directement sur l'appel d'une fonction qui initialisera
elle-même les paramètres à chaque exécution. Dans ce cas-là, le paramètre setup contient simplement l'importation de
la fonction étudiée.
- 109 -
FAQ Python
Autrement, il suffit de prendre comme paramètre stmt directement la fonction étudiée sous forme d'objet.
def sort():
l = range(100000)
random.shuffle(l)
l.sort()
test2 = timeit.Timer("sort()", "from __main__ import sort")

test3 = timeit.Timer(sort)
lien : Python Library Reference: timeit # Measure execution time of small code snippets
- 110 -
FAQ Python
Sommaire > Déploiement

Comment déployer ses applications ?
Auteurs : Guigui_ ,
Une question qui revient relativement souvent surtout sous Windows est "Comment déployer mon application sur
un autre ordinateur". Si celui-ci possède Python, il vous suffira donc simplement de transmettre les sources (.py)
ou les sources pré-compilées (.pyc ou .pyo) tout en n'oubliant pas d'installer les bibliothèques requises pour le bon
fonctionnement de l'application. Vous pouvez dans ce cas utiliser le module disutils ( Distributing Python Modules
) spécialisé dans le déploiement.
Vous pouvez aussi passer par des logiciels spécialisés pour l'installation d'application (par exemple InnoSetup sous
Windows).
Vous pouvez encore développer vous-même un bout de code en Python pour installer tout le nécessaire (python, modules,
autres fichiers) pour le bon fonctionnement de votre application, ce qui se réalise très facilement.
Si l'ordinateur ne possède pas Python et que vous ne voulez ou ne pouvez pas l'installer, vous aurez une autre possibilté
en passant par une distribution grâce à des modules comme py2exe (Windows), cx_Freeze (Windows et Linux) ou encore
PyInstaller (Windows et Linux). Ces modules vont vous permettre de transformer vos applications en programmes
standalone qui vous éviteront ainsi d'installer Python. Cette distribution sera en général accompagnée d'une dll
contenant le moteur python ainsi que de fichiers compressés contenant toutes les sources pré-compilées des bibliothèques
ou modules que vous avez utilisé ainsi que les dlls nécessaires.
Vous pourrez trouver les liens de ces modules sur la page Outils Python
- 111 -
FAQ Python
Sommaire > Déploiement > Py2exe

Qu'est-ce que Py2exe ?
Auteurs : Guigui_ ,
La bibliothèque py2exe permet de générer sous Windows des éxécutables à partir d'un source Python. En plus, il y aura
au minimum une dll Python et un zip contenant les modules compilés que vous devrez fournir avec votre programme.
Il vous permettra également de créer toute une distribution où vous pourrez empaqueter tous les fichiers nécessaires
pour que votre programme fonctionne correctement
Comment créer un fichier .exe à partir du fichier .py ?

Auteurs : Guigui_ ,
Pour créer un fichier .exe à partir d'un fichier .py, il suffit d'écrire un petit setup.py que l'on appelera ensuite avec
l'argument py2exe
exemple: Voici un code en mode console minimaliste
testpy2exe.py
raw_input("test minimal de py2exe")
Dans le fichier setup.py, il faudra toujours faire les 2 importations et appeler la fonction setup avec des arguments qui
varieront en fonction du programme à "compiler". Dans notre cas, nous avons un unique fichier .py exécuté en mode
console. Si notre fichier a une interface graphique (développé sous Tkinter, wxPython, ...), il faudra remplacer le terme
console par windows
setup.py
from distutils.core import setup
import py2exe
setup(console=["testpy2exe.py"])
Il suffit ensuite d'exécuter, dans une fenêtre DOS (et non une console Python), la commande suivante qui crééra une
distribution.
c:/python25/python.exe setup.py py2exe
2 répertoires sont créés: dist et build - ce dernier ne sert que lors de la construction de la distribution et peut donc
être effacé
Dans le répertoire dist, vous récupérerez les fichiers:
fichiers générés remarque

w9xpopen.exe nécessaire pour une exécution sous win 9x
unicodedata.pyd
python25.dll moteur Python
MSVCR71.dll
library.zip ce zip contient les modules compilés
bz2.pyd
test2pyexe.exe exécutable de l'application
unicodedata.pyd
- 112 -
FAQ Python
Tous ces fichiers ne sont pas forcément utiles. Cela dépendra du contenu de votre fichier .py
Dans notre cas, seuls Python25.dll, library.zip et test2pyexe.exe nous sont utiles.
Si vous utilisez d'autres bibliothèques, visitez le lien suivant si vous rencontrez des difficultés: http://
starship.python.net/crew/theller/moin.cgi/Py2Exe
Comment masquer la fenêtre DOS si on a créé une application graphique ?

Auteurs : Guigui_ ,
Si vous utilisez une application graphique (développée par exemple avec Tkinter, wxPython, ...), vous n'aurez donc
sûrement pas besoin de visualiser que ce soit sur la fenêtre DOS qui s'ouvre d'habitude automatiquement lors de
l'exécution d'un fichier .py. Il vous suffit alors d'utiliser l'option windows à la place de l'option console dans le fichier
setup.py de compilation.
Voici un exemple sur une application Tkinter.
test.py
import sys
root = Tk.Tk()
btn = Tk.Button(root, text = 'Quitter', command = sys.exit)
btn.pack()
root.mainloop()
setup.py
import py2exe
setup(windows=["test.py"])
Comment intégrer le fichier library.zip dans l'exécutable ?

Auteurs : Guigui_ ,
Pour intégrer le fichier library.zip directement dans l'exécutable, il suffit de rajouter dans le setup l'option zipfile = None
testpy2exe.py
raw_input("test minimal de py2exe")
setup.py
import py2exe
setup(
zipfile = None,
- 113 -
FAQ Python
setup.py
console=["testpy2exe.py"])
Comment déployer une application Tix avec Py2exe ?

Auteurs : Guigui_ ,
Pour le déploiement d'applications contenant certains modules (notamment les modules externes), il est parfois
nécessaire d'ajouter manuellement les fichiers nécessaires au bon fonctionnement de la bilbiothèque en question. C'est
le cas pour Tix où il est nécessaire d'inclure le répertoire <Path Python>/tcl/Tix8.4 ainsi que la dll tix84.dll du répertoire
<Path Python>/Dlls.
Voici un exemple minimaliste d'un programme Python utlisant Tix
test.py
import Tix
root = Tix.Tk()
root.mainloop()
Dans le fichier setup.py, on liste l'ensemble des fichiers requis pour le bon fonctionnement de Tix que l'on insère dans
le setup de py2exe par le paramètre data_files contenant une liste de tuples (répertoire de destination relatif au répertoire
d'exécution du programme, liste des fichiers à copier dans ce répertoire). Attention, c'est exemple a été testé avec Python
2.5.2, Py2exe 0.6.8 et Tix 8.4.0. Si vous utilisez d'autres versions, il sera peut-être nécessaire de faire des ajustements
dans les fichiers à insérer.
setup.py
import sys
import os
import glob
import os.path

import py2exe
def listdirectory(path):
return filter(os.path.isfile, glob.glob(path + os.sep + '*'))
data_files=[
('Dlls', glob.glob(sys.prefix+'/DLLs/tix84.dll')),
('tcl/tix8.4', listdirectory(sys.prefix+'/tcl/tix8.4')),
('tcl/tix8.4/bitmaps', listdirectory(sys.prefix+'/tcl/tix8.4/bitmaps')),
('tcl/tix8.4/pref', listdirectory(sys.prefix+'/tcl/tix8.4/pref')),
]
setup(
script_args = ['py2exe'],
data_files = data_files,
- 114 -
FAQ Python
setup.py
windows = ['test.py'])
Comment déployer une application Pmw avec Py2exe ?

Auteurs : Guigui_ ,
Le déploiement d'une application dépendante de Pmw nécessite une intervention du programmeur. Dans le répertoire
d'installation de Pmw, il existe cependant un fichier bundlepmw.py qui va nous faciliter cette tâche. L'exécution de ce
fichier permet de concaténer l'ensemble des fichiers de Pmw dans un unique fichier Pmw.py. Il vous faudra aussi rajouter
les 2 fichier PmwColor.py et PmwBlt.py
Voici un exemple minimaliste d'une application Pmw:
test.py
import Pmw
root = Pmw.initialise()
root.mainloop()
Dans le fichier setup.py, nous allons tout d'abord modifier le fichier bundlepmw.py qui importe le module regsub qui
n'existe plus à partir de la version 2.5 de Python (donc si vous travaillez avec une version plus ancienne, vous n'avez
pas à faire cette manipulation).
Ensuite, nous exécutons ce fichier qui créera un fichier Pmw.py contenant tous les fichiers internes à Pmw. Nous copions
enfin les fichiers PmwBlt.py et PmwColor.py.
Attention, c'est exemple a été testé avec Python 2.5.2, Py2exe 0.6.8 et Pmw 1.3.2. Si vous utilisez d'autres versions, il
sera peut-être nécessaire de faire des ajustements dans les fichiers à insérer.
Le fichier setup correspondant:
setup.py
import py2exe
import os
import sys
import subprocess
import shutil
## si le fichier bundlepmw.py contient l'importation regsub (qui n'existe plus depuis la version 2.5 de Python)
## Vous pouvez sinon le faire à la main en remplaçant "regsub" par "re" et "gsub" par "sub"
fp = open(sys.prefix + os.sep + "Lib/site-packages/Pmw/Pmw_1_3/bin/bundlepmw.py")
a = fp.read().replace("regsub", "re").replace("gsub", "sub")
fp.close()
ft = open(sys.prefix + os.sep + "Lib/site-packages/Pmw/Pmw_1_3/bin/bundlepmw.py", "w")
ft.write(a)
ft.close()
## Création du fichier Pmw.py dans le répertoire courant

subprocess.call([sys.executable, sys.prefix +
os.sep + "Lib/site-packages/Pmw/Pmw_1_3/bin/bundlepmw.py",
sys.prefix + os.sep + "Lib/site-packages/Pmw/Pmw_1_3/lib"])
## On copie les 2 fichiers PmwBlt.py et PmwColor.py dans le répertoire courant
shutil.copyfile(sys.prefix + os.sep + "Lib/site-packages/Pmw/Pmw_1_3/lib/PmwBlt.py", "PmwBlt.py")
shutil.copyfile(sys.prefix +
os.sep + "Lib/site-packages/Pmw/Pmw_1_3/lib/PmwColor.py", "PmwColor.py")
setup(windows = ['test.py'])
- 115 -
FAQ Python
Sommaire > Autres bibliothèques
- 116 -
FAQ Python
Sommaire > Autres bibliothèques > Pil - Python Image Library

Qu'est-ce que Pil ?
Auteurs : Guigui_ ,
La bibliothèque Pil (Python Imaging Library) ajoute des possibilités de manipulation d'images de tout format avec la
présence de quelques fonctions de traitement d'images
Où trouver de l'aide pour Pil ?

Auteurs : Guigui_ ,
Vous pouvez consulter la documentation officielle de Pil qui est relativement complète (version html et pdf en anglais
d'un tutoriel avec présentation et exemples de la majorité des fonctions)
Comment récupérer dans une liste les valeurs des pixels d'une image ?
Auteurs : Guigui_ ,
La fonction Image.open(path) permet d'ouvrir une image de tout format (compatible avec la bibliothèque Pil)
la fonction im.getdata() retourne un objet-séquence contenant les valeurs des pixels de l'image. Cependant il n'est lisible
que par Pil. La fonction list permet ensuite de récupérer cette séquence sous un format lisible par l'utilisateur. On
récupère alors une liste de tuples à 3 compoantes si l'image est couleur, une liste simple sinon.
import Image
im = Image.open("Python.jpg")
data = list(im.getdata())
Comment créer une image à partir d'une liste de valeurs de pixels ?

Auteurs : Guigui_ ,
la fonction Image.New(mode, size) permet de créer une nouvelle image où mode ("L" ou "RGB") définit si l'image sera
couleur ou en niveau de gris et size est un tuple (NbColonnes, NbLignes).
la fonction im.putdata(data) remplit l'image avec la séquence de valeurs data
## Récupération des valeurs de l'image

import Image
im = Image.open("Python.jpg")
data = list(im.getdata())
## Reconstruction de l'image
imNew=Image.new(im.mode ,im.size)
imNew.putdata(data)
Comment décomposer une image couleur en ses 3 composantes RGB ?

Auteurs : Guigui_ ,
La fonction im.split() renvoit une séquence des 3 composantes RGB de l'image
- 117 -
FAQ Python
import Image
img = Image.open("Python.jpg") ## Ouverture de l'image Python.jpg
r,g,b = img.split() ## Récupération des différentes composantes de l'image
r.save('r.jpg') ## Sauvegarde des différents images composantes
g.save('g.jpg')
b.save('b.jpg')
Comment recomposer une image couleur à partir de ses 3 composantes RGB ?

Auteurs : Guigui_ ,
La fonction Image.merge(mode, bands) crée une image à partir des images bands selon le mode mode
import Image
img = Image.open("Python.jpg") ## Ouverture de l'image Python.jpg
comp = img.split() ## Décomposition de l'image
imgnew = Image.merge('RGB',comp) ## Recomposition de l'image
imgnew.save("PythonNew.jpg") ## Sauvegarde de l'image décomposée puis recomposée
Pourquoi j'obtiens l'erreur "AttributeError: class Image has no attribute ..." ?

Auteurs : Guigui_ ,
La bibliothèque Pil fournit plusieurs modules dont le module standart qui se nomme Image. Classiquement, on l'importe
par la commande Import Image. On accède ensuite aux fonctions de ce module par la forme Image.UneFonction. Il
arrive parfois que survienne alors l'erreur AttributeError: class Image has no attribute .... La cause peut être multiple:
• Tout d'abord, vous avez un de votre propre module qui se nomme également Image. Ainsi, au lieu d'importer le
module de Pil, vous importez finalement votre propre module qui ne contient pas les fonctions du module Image
de Pil.
• D'autres bibliothèques que vous utilisez peuvent également contenir un module Image. Si vous les importez de
la manière from ... import *, il se peut donc que vous importiez un module Image qui écrasera celui du module
Pil (ou inversement, en fonction de la position des imports). C'est une des raisons qui font qu'il est déconseillé
d'utilisez ce schéma pour l'importation.
Par exemple, le module Tkinter contient un module Image et de ce fait l'instruction from Tkinter import *
écrasera le module Image de Pil que vous auriez pu importer auparavant. C'est pour cela qu'il est préférable
pour Tkinter d'importer de la manière import Tkinter as Tk.
lien : Comment importer des modules/fonctions/fichiers ?
- 118 -
FAQ Python
Sommaire > Autres bibliothèques > Matplotlib

Qu'est-ce que Matplotlib ?
Auteurs : Guigui_ ,
La bibliothèque Matplotlib est une bibliothèque de tracés de graphe 2D. Elle permet de tracer des courbes de fonctions,
des histogrammes, des diagrammes en bâton, des diagrammes circulaires, ...
Où trouver de l'aide pour Matplotlib ?

Auteurs : Guigui_ ,
Vous trouverez directement sur le site de Matplotlib un guide d'utilisation (version pdf en anglais) et tout un panel
d'exemples présentant les possibilités de cette bibliothèque.
Comment sélectionner la bibliothèque de calculs (numpy/numarray/Numeric) utilisée par Matplotlib ?

Auteurs : Guigui_ ,
Editez le fichier matplotlibrc se trouvant dans le répertoire (Python Directory)\Lib\site-packages\matplotlib\mpl-data\.
Recherchez le champ numerix et sélectionnez la bibliothèque souhaitée. Il est toutefois conseillé d'utiliser dorénavant
la bibliothèque numpy
exemple:
numerix : numpy # numpy, Numeric or numarray
- 119 -

FAQPython

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

FAQPython

Uploaded by

Copyright:

Available Formats

FAQ Python

Date de publication : 24/05/2005

Dernière mise à jour : 23/05/2009

Guigui_ - oiffrig - Miksimus - naxelas -

1. Introduction (5) .......................................................................................................................................................................... 5

13.3. pyGTK (2) .................................................................................................................................................................. 107

Sommaire > Introduction

Où trouver de l'aide pour Python ?

Quelle implémentation de Python choisir ?

• CPython, codée en C, la plus utilisée et appelée plus simplement Python

Quel éditeur utiliser ?

A quelle version de Python se rapporte cette FAQ ?

Sommaire > IDLE

lien : Comment configurer IDLE en mode Editeur ou Shell au démarrage ?

Comment configurer IDLE en mode Editeur ou Shell au démarrage ?

Pourquoi j'obtiens le message d'erreur IndentationError:

>>> nb = input("Choisissez un nombre :")

File "<pyshell#18>", line 3

Sommaire > Généralités

lien : Comment ne pas afficher la fenêtre DOS à l'exécution du programme ?

Comment obtenir des informations utiles sur l'utilisation d'un objet/module/fonction ?

## code pour obtenir des informations sur le module math:

## code pour obtenir des informations sur la fonction math.cos:

>>> import platform

Pour connaître la plateforme sur lequel tourne Python:

>>> import sys

Pour connaître la version de Python:

>>> import sys

Comment procéder à une installation silencieuse de Python sous windows ?

et q est un paramètre qui peut prendre les valeurs suivantes:

• qn: Pas d'interface

On peut également rajouter un paramètre TARGETDIR si on veut changer le répertoire de destination

msiexec /i python<version>.msi TARGETDIR=d:\Python24

msiexec /i python-2.4.2.msi ALLUSERS=1 /qr

Comment importer des modules/fonctions/fichiers ?

Quid des importations circulaires ?

Comment importer un module qui n'est pas dans le répertoire courant ?

lien : Comment importer des modules/fonctions/fichiers ?

Comment déclarer une variable à partir d'une chaine de caractères ?

>>> class maclasse:

>>> setattr(a, 'variable2', (5,6))

>>> exec("def plus(x,y): print x+y")

Comment empêcher les messages d'avertissement lors de l'utilisation de caractères non-ASCII ?

# -*- coding: iso8859-1 -*-

Pour plus de détails: http://www.python.org/peps/pep-0263.html

Comment quitter son application ?

Comment récupérer les paramètres passés à un programme ?

Comment lancer un programme externe ?

lien : Python Library Reference: File Object Creation

Comment n'instancier qu'une seule fois un programme ?

from asyncore import dispatcher

class Server( dispatcher ):

Sommaire > Mode console

Comment empêcher la fermeture de la fenêtre DOS à l'exécution d'un programme ?

raw_input("Appuyer sur une touche pour quitter le programme")

Comment effacer le contenu de la console Dos/Shell ?

Comment afficher un texte sans aller à la ligne

Sommaire > Type de données

Sommaire > Type de données > Les nombres

>>> int('AA', 16) ## Conversion de AA de la base 16 à la base 10

Comment convertir un nombre entier dans une autre base ?

Comment convertir un nombre entier en binaire ?

Un petit test pour vérifier le gain en temps

>>> 15.9132169033 , 12.7892307542

# -- coding: iso8859-1 --

# -- coding: cp1252 --

def str(self): return '('+str(self.x)+','+str(self.y)+')' ## retourne la réprésentation du vecteur sous fo