Redémarrer le script en Python

Pour redémarrer un script Python, déterminez si vous avez besoin d’un nouveau processus d’interpréteur ou simplement de répéter le travail de votre programme. os.execv() remplace le processus actuel, subprocess.call() lance un processus enfant et attend qu’il se termine, tandis qu’une boucle permet de relancer la logique de votre application sans redémarrer Python.

Méthode 1 : remplacer le processus actuel avec os.execv()

Utilisez os.execv() lorsque l’interpréteur actuel doit être remplacé par une nouvelle exécution du même script. Indiquez l’interpréteur actif comme exécutable et transmettez-lui la liste des arguments du script :

os.execv(sys.executable, [sys.executable, *sys.argv])

Importez os et sys, puis appelez cette expression lorsque la condition de redémarrage est remplie. sys.argv contient le chemin du script et les arguments qui lui ont été fournis ; le nouvel interpréteur les reçoit donc à nouveau. Si execv() réussit, le code Python précédent ne reprend pas son exécution : le système d’exploitation lance le programme de remplacement dans le même emplacement de processus. Videz les tampons de sortie dont vous souhaitez conserver le contenu avant de remplacer le processus. Cette opération dépend de la plateforme et l’exemple n’est pas présenté comme ayant été exécuté.

Méthode 2 : lancer un nouveau processus avec subprocess.call()

Utilisez subprocess.call() lorsqu’un interpréteur distinct doit exécuter le script tandis que le processus actuel reste son parent. L’appel est subprocess.call([sys.executable, *sys.argv]) ; importez d’abord subprocess et sys. La fonction attend la fin du processus enfant, puis renvoie son code de sortie au parent. Le parent ne se termine pas automatiquement : si vous voulez qu’il s’arrête, faites un retour ou quittez la branche de redémarrage après l’appel. L’enfant peut hériter de la même logique de redémarrage ; veillez donc à ce que sa condition finisse par permettre à l’exécution de se terminer. Ce comportement de lancement de processus n’est pas présenté ici avec une sortie issue d’une exécution.

Méthode 3 : répéter la logique du programme avec une boucle

Si seule l’activité de l’application doit être relancée, placez-la dans une fonction et appelez celle-ci depuis une boucle contrôlée. L’interpréteur reste ainsi le même et vous évitez de créer une chaîne de processus enfants. L’exemple utilise une séquence fixe de choix pour montrer deux exécutions suivies d’une sortie normale ; remplacez cette séquence par votre saisie ou par la condition propre à votre application.

Exécutez cet exemple :

def run_task(number):
    print(f"Run {number}")

for number, action in enumerate(("restart", "restart", "exit"), start=1):
    if action == "exit":
        print("Done")
        break
    run_task(number)

Run 1
Run 2
Done

Dans un véritable programme en ligne de commande, lisez une action à chaque passage dans la boucle et appelez run_task() uniquement lorsque l’utilisateur demande de recommencer. Prévoyez une condition de sortie claire. Répéter une fonction ne réinitialise ni les variables globales du module, ni les ressources ouvertes, ni l’état de l’interpréteur ; fermez ou réinitialisez tout ce que l’exécution suivante ne doit pas réutiliser.

Choisir la bonne méthode de redémarrage

Utilisez os.execv() pour remplacer le processus d’un script ponctuel, subprocess.call() lorsque le processus parent doit attendre une exécution distincte, et une boucle pour répéter certaines tâches de l’application. Ces approches ont des cycles de vie différents : après le remplacement, aucune ancienne trame Python ne peut reprendre ; lors de l’exécution d’un enfant, le parent reste actif pendant l’attente ; une boucle conserve l’état de l’interpréteur actuel. Pour un service web, utilisez le gestionnaire de processus ou les mécanismes de déploiement au lieu de redémarrer un worker depuis un gestionnaire de requêtes ; un redémarrage pendant une requête peut interrompre les utilisateurs et faire perdre l’état en mémoire.

Foire aux questions

Quelle méthode choisir ?

Choisissez une boucle pour répéter des actions de l’application, os.execv() pour remplacer le processus actuel, ou subprocess.call() lorsqu’un processus parent doit attendre une nouvelle exécution de l’interpréteur.

Un script peut-il redémarrer automatiquement ?

Oui. Une condition, comme un changement de configuration, peut déclencher le redémarrage sans demander confirmation à l’utilisateur. Veillez à ce que cette condition puisse devenir fausse ou qu’un autre mécanisme mette fin au cycle de redémarrage.

Le redémarrage a-t-il un effet sur les performances ?

Le démarrage d’un interpréteur a un coût, et des redémarrages fréquents peuvent répéter le travail d’initialisation. Une boucle évite ce démarrage de processus, mais conserve l’état de l’interpréteur actuel, qui peut nécessiter un nettoyage explicite.

Puis-je modifier les arguments lors du redémarrage ?

Oui. Construisez une nouvelle liste d’arguments pour os.execv() ou subprocess.call() au lieu de réutiliser sys.argv sans la modifier. Placez l’exécutable de l’interpréteur en premier, puis le chemin du script avant ses arguments propres à l’application.

Une application web doit-elle redémarrer son script à la suite d’une requête ?

En général, non. Le redémarrage d’un worker pendant une requête peut interrompre le service et supprimer l’état en mémoire. Utilisez le mécanisme de redémarrage et de déploiement prévu par le serveur ou le gestionnaire de processus.