Soutenez-nous

FAQ pythonConsultez toutes les FAQ

Nombre d'auteurs : 11, nombre de questions : 188, dernière mise à jour : 23 mai 2009  Ajouter une question

 

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.


SommaireGénéralités (13)
précédent sommaire suivant
 

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.

Mis à jour le 18 janvier 2007 Guigui_

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

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.

Code python :



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
## 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) 
help(math.cos) ## ou help("math.cos") 
math.cos.__doc__

Mis à jour le 2 décembre 2006 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:

Code python :



1
2
3
4
5
6
7
>>> 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:

Code python :



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

Code python :



1
2
3
4
5
6
7
8
9
10
>>> 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']

Mis à jour le 22 octobre 2007 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:

Code :



msiexec /i python<version>.msi /q
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)
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

Code :



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

Code :



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

Mis à jour le 15 décembre 2005 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:

Code python :



1
2
3
4
import MonModule  
import MonModule as MonAlias  
from MonModule import *  
from MonModule import MonObjet1 as MonAlias1, MonObjet2 as MonAlias2
Code python :



1
2
3
4
5
6
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.

Code python :



1
2
3
4
5
f=open('test.txt', 'w')  ## la fonction open est celle des objets prédéfinies de 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

Mis à jour le 28 juin 2005 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.

Mis à jour le 11 avril 2007 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.

Code python :



1
2
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 *.

Mis à jour le 21 février 2007 Guigui_

What's New in Python: 4 PEP 328: Absolute and Relative Imports
Comment importer des modules/fonctions/fichiers ?

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()

Code python :



1
2
3
>>> 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__

Code python :



1
2
3
4
5
6
>>> 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

Code python :



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

Code python :



1
2
3
4
5
6
>>> 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

Code python :



1
2
3
>>> exec("def plus(x,y): print x+y") 
>>> plus(3,5) 
8

Mis à jour le 3 août 2005 Guigui_

Quand vous lancez votre script Python, si celui-ci contient des caractères non-ASCII, vous pouvez avoir le message d'avertissement suivant:

Code :



1
2
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:

Code python :



# -*- coding: iso8859-1 -*-
Pour plus de détails: http://www.python.org/peps/pep-0263.html

Mis à jour le 11 septembre 2005 naxelas

Code python :



1
2
import sys 
sys.exit()

Mis à jour le 10 avril 2006 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é.

Mis à jour le 10 avril 2006 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.
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.

Code python :



1
2
3
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.

Code python :



1
2
3
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.

Code python :



1
2
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.

Code python :



1
2
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.

Mis à jour le 24 janvier 2007 Guigui_

Python Library Reference: File Object Creation
Python Library Reference: Process Management
Python Library Reference: Subprocess management

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.

Code python :



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/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'

Mis à jour le 7 mars 2007 jean-jacques varvenne

Proposer une nouvelle question/réponse à la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2014 Developpez Developpez LLC. Tous 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'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
 
 
 
Partenaires

PlanetHoster
Ikoula