Exemples de Python Subprocess.Popen
Le module subprocess de Python est l'un des modules utiles qui est utilisé pour exécuter différentes commandes shell, processus et exécuter un autre script ou des fichiers exécutables à l'aide du script Python. Il peut également être utilisé pour rediriger les données d'un processus à un autre et gérer les erreurs générées par les processus enfants. Le module subprocess contient de nombreuses classes utilisées à diverses fins. La classe « subprocess.Popen » est l'une des classes de ce module utilisée pour interagir avec les processus externes et effectuer différents types de tâches parmi les processus. Plusieurs utilisations de la classe « subprocess.Popen » dans le script Python sont montrées dans ce tutoriel.
Table des matières :
- Exécutez une commande Linux simple
- Exécuter une commande avec des données d'entrée
- Exécuter un script Python
- Gérer l'erreur de sous-processus
- Retournez le code de Subprocess.Popen
- Rediriger la sortie du sous-processus vers un fichier
- Multiprocessing en utilisant Subprocess.Popen
- Gérer les flux d'entrée et de sortie
- Contrôler le délai et la temporisation
- Lire une entrée en streaming
Exécuter une commande Linux simple
La commande "date" est utilisée pour afficher la date et l'heure système actuelles. Créez un fichier Python avec le script suivant qui crée un sous-processus exécutant la commande "date" et imprime la sortie de cette commande :
#Import the module
import subprocess
#Define a command for the subprocess and
#open process by using Popen() function
output = subprocess.Popen(["date"], stdout=subprocess.PIPE)
#Retrieve the output and error by communicating with the process
stdout, stderr = output.communicate()
#Print the output
print(stdout.decode())Sortie :
La sortie suivante apparaît après l'exécution du script précédent :
Aller en haut
Exécuter une commande avec des données d'entrée
La commande « wc » avec l'option « -c » est utilisée pour compter le nombre total de caractères de la valeur de chaîne fournie avec cette commande. Créez un fichier Python avec le script suivant qui crée un sous-processus avec la fonction Popen() pour exécuter la commande « wc -c ». La valeur de chaîne est prise depuis le terminal après l'exécution du script et le nombre total de caractères de la chaîne d'entrée est imprimé dans la sortie.
#Import the module
import subprocess
#Define a command for the subprocess and
#Open process by using Popen() function
output = subprocess.Popen(["wc", "-c"], stdout=subprocess.PIPE)
#Retrieve the output and error by communicating with the process
stdout, stderr = output.communicate()
#Print the output
print(stdout.decode())Sortie :
La sortie suivante apparaît pour la valeur d'entrée « Exemples de sous-processus Python » :
Aller en haut
Exécuter un script Python
Créez un fichier Python nommé "sum.py" avec le script suivant qui calcule la somme de deux nombres et ces nombres sont fournis en tant qu'arguments de la ligne de commande :
sum.py
#Import necessary module
import sys
#Count total arguments
n = len(sys.argv)
#Add the first two argument values
sum = int(sys.argv[1]) + int(sys.argv[2])
#Print the addition result
print("The sum of " + sys.argv[1] + " and " + sys.argv[2] + " is", sum)
Create a Python file with the following script that will run a Python file named sum.py with two arguments by creating a subprocess.
#Import the module
import subprocess
#Run python script in the subprocess and
#open the process by using Popen() function
output = subprocess.Popen(["python3", "sum.py", "25", "55"], stdout=subprocess.PIPE)#Retrieve the output and error by communicating with the process
stdout, stderr = output.communicate()
#Print the output
print(stdout.decode())Sortie :
La sortie suivante apparaît après l'exécution du script précédent :
Aller en haut
`
Gérer l'erreur de sous-processus
Créez un fichier Python avec le script suivant qui gère les erreurs du sous-processus en utilisant le bloc "try-except". Une commande est prise de l'utilisateur et elle est exécutée par le sous-processus. Le message d'erreur est affiché si une commande invalide est fournie par l'utilisateur.
#Import the modules
import subprocess
import sys
#Take command from the user
command = input("Enter a valid command: ")
try:
#Open process by using Popen() function
output = subprocess.Popen([command], stdout=subprocess.PIPE)
#Retrieve the output and error by communicating with the process
stdout, stderr = output.communicate()
#Print the output
print (stdout.decode())
except:
print ("Error:", sys.exc_info())Sortie :
La sortie suivante apparaît si la commande « pwd » est considérée comme une entrée valide :
La sortie suivante apparaît si la commande « usr » est considérée comme une entrée valide :
Aller en haut
Retourner le code de Subprocess.Popen
Créez un fichier Python avec le script suivant qui exécute une commande "ls" via le sous-processus pour obtenir la liste de tous les fichiers Python à partir de l'emplacement actuel. Le script attend la fin du sous-processus et imprime le code de retour.
#Import the modules
import subprocess
import sys
#Set the command
command = ['ls', '-l', '*.py']
try:
#Open process by using Popen() function
output = subprocess.Popen(command, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, text=True)
#Wait to complete the process
retCode = output.wait()
#Print the return code
print("Return Code:", retCode)
except:
#Print error message for the wrong
print ("Error:", sys.exc_info())Sortie :
Une sortie similaire apparaît après l'exécution du script précédent :
Aller en haut
Rediriger la sortie du sous-processus vers un fichier
Créez un fichier Python avec le script suivant qui écrit la sortie du sous-processus dans un fichier texte. La commande exécutée par le sous-processus est prise de l'utilisateur.
#Import module
import subprocess
#Define the filename
filename = "outfile.txt"
#Take a ping command
cmd = input("Enter a ping command: ")
#Split the taken input based on the space
args = cmd.split()
#Write the command output in the file
with open(filename, 'w') as outdata:
process = subprocess.Popen(args,stdout=outdata)
#Wait for completing the process
return_code = process.wait()Sortie :
Selon la sortie suivante, la commande « ping -c 3 www.google.com » est prise de l'utilisateur et la commande « cat » est utilisée pour afficher le contenu du fichier qui est écrit par le sous-processus :
Aller en haut
Multiprocessing avec Subprocess.Popen
Créez un fichier Python avec le script suivant où l'utilisation de la multiprogrammation est montrée en utilisant le sous-processus. Ici, une fonction nommée display_msg() est appelée plusieurs fois en utilisant la multiprogrammation.
#Import necessary modules
import multiprocessing
import subprocess
#Define the function that will be called by multiprocessing
def display_msg(n):
#Define the command with the format() function
cmd = "echo 'Python Programming'".format(n)
#Open process by using Popen() function
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
#Retrieve the output and error by communicating with the process
stdout, error = process.communicate()
#Print the output
print (stdout.decode())
#Call the function 5 times by creating the multiprocessing.Pool
with multiprocessing.Pool(multiprocessing.cpu_count()) as mp:
#Map the function
mp.map(display_msg, range(1, 5))Sortie :
La sortie suivante apparaît après l'exécution du script précédent :
Aller en haut
Gérer les Flux d'Entrée et de Sortie
Créez un fichier texte nommé "test.txt" avec le contenu suivant avant de créer le script Python de cet exemple.
test.txt
PERL
python
bash
php
Créez un fichier Python avec le script suivant qui utilise un sous-processus pour lire le contenu du fichier « test.txt » et un autre sous-processus pour rechercher un mot particulier dans ce fichier texte. Ici, le mot « python » est recherché dans le fichier « test.txt » qui contient ce mot.
#Import modules
import subprocess
#Define a process for the input stream
in_process = subprocess.Popen(["cat", "test.txt"], stdout=subprocess.PIPE, text=Tru>#Define a process for the output stream
out_process = subprocess.Popen(
["grep", "python"], stdin=in_process.stdout,
stdout=subprocess.PIPE, text=True)
#Store the output of the input and output processes
output, _ = out_process.communicate()
#Print the output
print ("Output:", output)Sortie :
La sortie suivante apparaît après l'exécution du script :
Aller en haut
Contrôlez le sous-processus à l'aide d'un minuteur
Créez un fichier Python avec le script suivant qui utilise un minuterie pour exécuter une commande à l'aide d'un sous-processus. Ici, le bloc "try-except" est utilisé pour démarrer le chronomètre et le bloc "finally" est utilisé pour annuler le chronomètre.
#Import the subprocess module
import subprocess
#Import the Timer module
from threading import Timer
#Define the command
cmd = ['ping', 'www.example.com']
#Open the process
p = subprocess.Popen(
cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
#Define the timer
timer = Timer(2, lambda process: process.kill(), [p])
try:
#Start the timer
timer.start()
#Read output
stdout, _ = p.communicate()
#Print output
print (stdout.decode())
except:
#Print error message for the wrong
print ("Error:", sys.exc_info())
finally:
#Stop the timer
timer.cancel()Sortie :
La sortie suivante apparaît après l'exécution du script :
Aller en haut
Lisez l'entrée en streaming
Créez un fichier Python qui lit le contenu de la sortie du sous-processus à l'aide d'une boucle « while » et stocke le contenu dans une variable. Le contenu de cette variable est imprimé plus tard. Ici, la commande « curl » est utilisée dans le sous-processus pour l'URL www.google.com.
#Import module
import subprocess
#Define command
cmd = ["curl", "www.example.com"]
p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, text=True>
#Initialize the output variable
output = ""
while True:
#Read the process output line by line
ln = p.stdout.readline()
#Terminate from the loop when the subprocess finishes
if not ln:
break
output = output + ln
#Print the line
print (output)
#Get the return code after finishing the process
return_code = p.wait()
#Print the return code
print ("Return code: ", return_code)Sortie :
La dernière partie des trois sorties est montrée dans l'image suivante. Le code de retour après avoir terminé le sous-processus est 0 :
Aller en haut
Conclusion
Différentes utilisations de la fonction Python subprocess.Popen() sont montrées dans ce tutoriel à l'aide de plusieurs scripts Python qui aideront les utilisateurs de Python à connaître les utilisations de base de cette fonction.