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.

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 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__

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

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

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

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

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.

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

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

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

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é.

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.

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.

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.

#!/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'