Programmation des processus
en Python
Pierre Prades
Exécuter une commande système depuis
Python
• Pour exécuter une commande système depuis python on doit utiliser le
module os
• La fonction system()
• Elle prend en paramètre une commande à exécuter, affiche le résultat de la commande
et renvoie son code de retour
• Elle s’exécute dans un environnement particulier externe à python
• Exemple :
import os
retour = [Link]("dir") # Commande Windows
print ("Code d'erreur: {0:d}".format(retour))
retour = [Link]("ls") # Commande Linux
print ("Code d'erreur: {0:d}".format(retour))
La fonction popen
• Fonction [Link]()
• Comme system elle prend une commande en paramètre
• Toutefois, au lieu de renvoyer le code de retour de la commande, elle renvoie un objet,
appelé pipe qui permet de lire le retour de la commande.
import os
cmd = [Link]('dir')
affichage = [Link]()
lines=[Link]()
for line in lines:
print(line)
Passage d'informations aux programmes
• Un programme ne s’exécute pas dans un univers fermé, on doit pouvoir
l’utiliser dans différents contextes, avec différentes options. Il serait
impensable d'avoir une version différente de chaque programme pour
chaque contexte avec lequel un programme peut être utilisé. Il doit
donc être possible de spécifier au démarrage du programme un contexte
dans lequel ce programme sera exécuté. Il nous faut donc un
mécanisme pour transmettre des informations au programme. La
transmission d’informations au démarrage d'un programme peut se
faire de trois façons différentes :
• sur la ligne de commandes
• par variable d’environnement
• par un fichier d'initialisation (par exemple un .ini)
Les arguments de la ligne de commande
• Le passage d’informations sur la ligne de commandes est la méthode la plus connue
: les "arguments" à fournir au programme, à la fonction main sont placés après le
nom du programme lors de son invocation, typiquement comme ceci :
nom_programme options parametres.
• Une ligne de commandes transmise à la coquille (le shell) est décomposée en
différents éléments (nom du programme, paramètres, symboles de redirection des
entrées ou des sorties, tubes).
• Lors de l’appel d’un programme, le préambule ajouté automatiquement par le
compilateur analyse la ligne de commandes et stocke les arguments dans une zone
accessible sur la pile par le programme. Les adresses de ces arguments sont stockées
dans un tableau transmis au programme. Le nombre d’arguments est aussi
communiqué au programme. En python ils sont stockés dans la liste [Link]
Exemple:
• Voici un petit programme qui se contente d'afficher la valeur des
arguments passés au programme:
#! /usr/bin/python3
import sys
for i in range(0, len([Link])):
print("L'argument en position %d est %s" % (i, [Link]
v[i]))
Les variables d’environnement
• La seconde méthode pour communiquer avec un processus consiste à stocker, dans
une variable d’environnement, différentes informations qui peuvent être très variées
: répertoire, nom de fichier, mode d’ouverture de fichier, adresse d’une donnée, etc.
• La commande env affiche l'état des variables d'environnement. L'utilisation des
variables d'environnement ne devrait être utilisée que pour des valeurs durables. Par
exemple, la variable d'environnement PATH est utilisée pour stocker tous les
dossiers contenant des logiciels à exécuter sans avoir besoin du chemin d'accès
complet. Une valeur passée par argument ne survit que pour la durée du
programme alors qu'une variable d'environnement survit pour l'ensemble des
programme déclenchés dans cet environnement.
• Sous Linux, pour ajouter une variable d'environnement, on utilise la commande
export. Une variable d'environnement a pour effet d'être visible pour tous les
programmes s'exécutant dans cet environnement. Il faut donc les utiliser pour des
valeurs qui doivent survivre suite à l'exécution d'un programme, ce qui n'est pas le
cas pour les arguments de programme.
Les variables d’environnement
• Une variable d’environnement doit être exportée pour être disponible aux
programmes appelés par le shell. Généralement on utilise un fichier /etc/profile
ou /etc/environnement ou encore le fichier caché .bash_profile dans le répertoire
de l’utilisateur. Les variables d’environnement sont stockées sous forme d’une
chaîne de caractères terminée par un zéro contenant la variable et sa valeur associée,
séparées par le caractère =.
• Sous DOS/Windows, la commande set permet de créer ou de détruire une variable
d’environnement et celles-ci sont définies dans la fenêtre « Variables
d’environnement » accessible via les propriétés du poste de travail (onglet avancé,
bouton variables d’environnement). Elles sont très souvent directement insérées
dans ces fichiers par les logiciels d’installation des applications.
• Lors de la création d’un processus, le système transmet à celui-ci une copie de la
zone d’environnement. Une version de la fonction de création de processus (exece,
execve, execle) permet de passer de nouvelles variables d'environnement.
Exemple:
• Voici comment dans un programme Python, on peut aller chercher les
variables d'environnement :
#! /usr/bin/python3
import os
environ = [Link]
for variable, valeur in [Link]():
print (variable + "=" + valeur)
Exercice
• Modifier le programme des fichiers pour passer le chemin en paramètre
d’exécution du programme, si aucun chemin n’est spécifié on listera le
répertoire courant.
• Créer un programme qui récupère la variable d’environnement « path »
et qui liste les programmes contenus dans les répertoires de « path ».
Principes généraux de la programmation des
processus sous Linux
• Les processus d’un système peuvent s’exécuter concurremment (en « même temps »), et
doivent pouvoir être créés et détruits dynamiquement. Par conséquent, le SE doit fournir
un mécanisme de création et de destruction de processus.
• Un processus peut créer plusieurs nouveaux processus, via des appels système de création de
processus durant le cours de son exécution. Le processus créateur est le processus parent, le
processus créé est le processus fils. Le fils peut, à son tour, créer des processus, donnant lieu
à un arbre de processus.
• En général, un processus nécessitera certaines ressources (mémoire, fichiers, périphériques)
pour s’exécuter. Ces ressources peuvent être obtenues du parent.
• Quand un processus crée un nouveau processus fils, 2 possibilités existent en ce qui
concerne le parent :
• le parent continue à tourner concurremment avec son ou ses enfants ;
• le parent reste bloqué jusqu’à ce que tous ses enfants aient terminé leur exécution.
• Lorsqu'on crée un processus il devient une copie intégrale du parent. Toutefois, il est
possible de lui demander d'exécuter un autre programme immédiatement après.
Création d'un processus fils
• Le système de processus n'autorise que trois types d'opérations sur les
processus :
• La fonction [Link] qui crée un processus et nous permet de passer une
commande.
• La duplication d'un processus existant par la fonction [Link]; (c'est vrai pour
tous les processus)
• Le remplacement d'un programme dans un processus en cours par la fonction
[Link].
Création d'un processus fils
• Fonction system
• C'est une façon simple de créer un processus à l'intérieur d'un programme.
Toutefois, elle ne permet pas au programme appelant de continuer à s'exécuter.
Il attendra la fin du programme appelé par system.
• Fonction fork
• L’appel système fork crée un nouveau processus fils. Le processus fils a un
nouveau PID (identificateur de processus) et il devient une copie du père.
• La fonction fork retourne le PID du processus créé au père. Pour le fils, elle
retourne 0. Ceci permet de déterminer si on est dans le fils ou dans le père.
Après la création du nouveau processus chacun des processus a son propre fil
d'exécution mais dans le même programme, ce sont simplement des processus
différents exécutant le même programme.
Exemple utilisant le fork :
#! /usr/bin/python3
# -*- coding: utf-8 -*-
import sys
import os
pid = [Link]()
if pid == 0:
print ("Nous sommes dans le fils avec le pid: " + str([Link]()))
[Link](0)
elif pid > 0:
print ("Nous sommes dans le père avec le pid: " + str([Link]()) + ". Le pid de fiston est: " + str(pid))
[Link]()
else:
print("Erreur de création de processus", file=[Link])
Cet exemple illustre également bien que chaque
processus possède sa propre copie des variables :
#! /usr/bin/python3
# -*- coding: utf-8 -*-
import os
import sys
import time
valeur = 0
pid = [Link]()
if pid == 0:
for i in range(0, 10):
[Link](4)
valeur = valeur + 1
print ("Valeur affichée par le fils: %d." % (valeur))
[Link](0)
elif pid > 0:
for i in range(0, 10):
[Link](2)
valeur = valeur + 1
print ("Valeur affichée par le père: %d." % (valeur))
[Link]()
else:
print("Erreur de création de processus.", file=[Link])
Synchronisation des processus
• Lorsqu'un processus fils a été créé, le processus père a deux possibilités :
• Il peut attendre la fin du processus fils (exécution de processus synchrone) et en évaluer ensuite
la valeur de retour.
• Il peut poursuivre sans attendre la fin du processus fils (exécution de processus asynchrone) et
continuer.
• L’exécution synchrone et l’exécution asynchrone des processus père et fils ne
présentent qu’une seule différence : l’exécution de processus synchrone utilise la
fonction wait lorsqu’on veut que le père attende l’enfant.
• La commande wait permet la synchronisation ultérieure d’un processus père et d’un
processus fils. L’appel wait permet en plus d’attendre la fin d’un processus et de
traiter le statut de ce processus terminé.
• L’appel exit(code_de_sortie) et l’instruction return code_de_sortie mettent fin à un
processus. La valeur du paramètre code_de_sortie parvient jusqu’au wait du parent;
c’est la valeur de retour. L’appel de exit ferme automatiquement tous les fichiers
ouverts, envoie des signaux à tous les processus fils, libère la mémoire allouée, etc.
Et sous windows?
• Malheureusement on ne peut pas faire de fork sous windows.
• Cependant on peut utiliser la classe Process du module multiprocessing. Exemple:
from multiprocessing import Process
import os
def info(titre):
print(titre)
print('nom de module:', __name__)
print('process parent:', [Link]())
print('id du process:', [Link]())
def f(name):
info('fonction f')
print('Salut', name)
if __name__ == '__main__':
info('Processus principal')
print('\n\n-----------Processus fils-----------')
p = Process(target=f, args=('papa',))
[Link]()
[Link]()
Explications
• p est l’objet qui stocke notre process
• [Link]() lance le processus fils
• [Link]() force le parent à attendre la fin du fils avant de continuer son
exécution.
• Autres fonctions:
• p.is_alive() retourne True si le processus roule sinon False
• [Link]() termine le processus.
• close() ferme l'objet Process, libérant toutes les ressources qui lui sont associées
• Notez que les méthodes start(), join(), is_alive(), terminate() et exitcode ne
devraient être appelées que par le processus ayant créé l'objet process.
La classe Queue
• On peut utiliser une Queue pour communiquer avec le process principal:
from multiprocessing import Process, Queue
import time
def f(q):
[Link]([42, None, 'hello'])
[Link](5)
[Link]([43, 'test'])
if __name__ == '__main__':
q = Queue()
p = Process(target=f, args=(q,))
[Link]()
print([Link]()) # affiche "[42, None, 'hello']"
[Link]()
print([Link]()) # affiche "[43, 'test’]" après 5s.
Exercices
• Écrivez un court programme Python qui lit deux prénoms en argument. Le
programme doit créer un processus fils et affiche dans le parent le premier
des deux prénoms, et dans le fils, le second prénom. Protégez votre
programme contre un nombre incorrect d’arguments. Ajoutez un join.
• Écrivez un programme qui crée un processus, et qui, dans le fils, utilise la
fonction popen pour lancer la commande dir sur votre répertoire personnel.
Pour le répertoire personnel, utilisez la variable d’environnement appropriée.
Le père ne fait rien sauf attendre que le fils termine.
• Écrivez un programme qui se contente de démarrer le programme [Link].
Ensuite, il attend le programme pour 5 secondes. Si le programme n'est pas
terminé, il doit alors le terminer.