Qu'est-ce qu'un sousprocess en Python ? [5 exemples d'utilisation]
By
Daniel Diaz
Solprocessil vous permet d'interagir de manière globaleally nouveau niveau avec le système opérationnel.
Notre ordinateur fonctionne sousprocesses tout le temps. En fait, rien qu'en lisant cet article, vous exécutez beaucoup de processc'est comme un gestionnaire de réseau ou Internet browseuh çaself.
Ce qui est intéressant, c'est que toute action que nous effectuons sur notre ordinateur implique l'appel d'un sous-marin.process. Cela reste vrai même si nous écrivons un simple "Bonjour le monde" script dans python.
Le concept de la dessousprocess peut sembler obscur même si vous apprenez la programmation depuis un certain temps. Cet article examinera en profondeur le concept principal du sous-marin.process, et comment utiliser Python dessousprocess bibliothèque standard.
À la fin de ce didacticiel, vous allez:
- Comprendre le concept de sousprocess
- Avoir appris les bases du sous Pythonprocess bibliothèque
- Pratiquez vos compétences Python avec des exemples utiles
Entrons dedans
Le concept de sousprocess
En gros, un sousprocess est une ordinateur process CREated par un autre process.
On peut penser à un sousprocess comme un arbre, dans lequel chaque parent process a un enfant processil court derrière. Je sais que cela peut être assez déroutant, mais voyons cela avec un simple graphique.
Il existe plusieurs manières de visualiser le process fonctionnant sur notre ordinateur. Par exemple, sous UNIX (Linux et MAC), nous avons haut, qui est un interactif process téléspectateur.
La mode arborescence est l'outil le plus utile pour jeter un œil au sous-marin en cours d'exécutionprocesses. Nous pouvons activerate avec F5.
Si nous regardons attentivement la section commande, nous pouvons remarquer la structure du processes en cours d’exécution sur notre ordinateur.
Tout commence par / sbin / init quelle est la commande qui démarre chaque process sur notre ordinateur. À partir de là, nous pouvons voir le début d’autres processes comme xfce4-capture d'écran les nouveautés terminal xfce4 (Ce qui conduit à encore plus de sousprocess)
Jetant un œil à Windows, nous avons le mythique gestionnaire des tâches ce qui est utile pour tuer ces programmes qui plantent sur notre machine.
Nous avons désormais un concept très clair. Voyons comment nous pouvons implémenter le sousprocessc'est en Python.
Solprocessoui en Python
Un sousprocess en Python est une tâche qu'un script Python délègueates au système d'exploitation (OS).
Le sousprocess la bibliothèque nous permet d'exécuter et de gérer des sousprocesses directement depuis Python. Cela implique de travailler avec l'entrée standard stdin, sortie standard stdoutet les codes de retour.
Nous n'avons pas à l'installer avec PIP, car il fait partie de Python bibliothèque standard.
Nous pouvons donc commencer à utiliser subprocesses en python simplement en important le module.
import subprocess
# Using the module ....Remarque: Pour suivre cet article, vous devriez avoir Python 3.5 +
À vérifier la version python vous avez actuellement, exécutez simplement.
❯ python --version
Python 3.9.5 # My result
Dans le cas où la version Python que vous obtenez est 2.x, vous pouvez utiliser la commande suivante
python3 --versionPour continuer avec le sujet, l'idée principale derrière le sous-marinprocess La bibliothèque est de pouvoir interagir avec le système d'exploitation en exécutant toutes les commandes souhaitées, directement depuis l'interpréteur Python.
Cela signifie que nous pouvons faire quoiatecomme nous le souhaitons, tant que notre OS nous le permet (Et tant que vous ne supprimez pas votre système de fichiers racine 😅).
Voyons comment l'utiliser en créant un script simple qui répertorie les fichiers du répertoire courant.
Premier sousprocess application
Tout d'abord, créonsate un fichier list_dir.py. Ce sera le fichier dans lequel nous allons tester les fichiers de liste.
touch list_dir.pyMaintenant, ouvrons ce fichier et utilisons le code suivant.
import subprocess
subprocess.run('ls')Tout d'abord, nous importons le sousprocess module, puis en utilisant la fonction courir qui s'exécute, la commande que nous passons en argument.
Cette fonction a été introduite dans Python 3.5, comme un raccourci convivial vers dessousprocess.Pouvrir. Le sousprocessLa fonction .run nous permet d'exécuter une commande et d'attendre qu'elle se termine, contrairement à Popen où nous avons la possibilité d'appeler communicate later.
Parler de la sortie du code, ls est une Commande UNIX qui répertorie les fichiers du répertoire dans lequel vous vous trouvez. Par conséquent, si vous exécutez cette commande, vous obtiendrez une liste des fichiers présents dans le répertoire courant.
❯ python list_dir.py
example.py LICENSE list_dir.py README.mdRemarque: Tenez compte du fait que si vous êtes dans Windows, vous devrez utiliser différentes commandes. Par exemple, au lieu d'utiliser «Ls» vous pouvez utiliser "Dir"
Cela peut paraître trop simple et vous avez raison. Vous souhaitez adopter une approche complète de toute la puissance que la coque vous apporte. Apprenons donc à passer des arguments au shell avec subprocess.
Par exemple pour lister également les fichiers cachés (ceux qui commencent par un point), et également lister toutes les métadonnées des fichiers, nous écrivons le code suivant.
import subprocess
# subprocess.run('ls') # Simple command
subprocess.run('ls -la', shell=True)Nous exécutons cette commande sous forme de chaîne et utilisons l'argument coquille. Cela signifie que nous invoquons un shell au début de l'exécution de notre sousprocess, et l'argument de la commande est interprété directement par le shell.
Cependant, l'utilisation shell = Vrai présente de nombreux inconvénients, et les pires sont les éventuelles fuites de sécurité. Vous pouvez lire à leur sujet dans le documentation officielle.
La meilleure façon de passer des commandes à la fonction d'exécution est d'utiliser une liste où lst [0] est la commande à appeler (ls dans ce cas) et lst [n] sont les arguments de cette commande.
Si nous le faisons, notre code ressemblera à ceci.
import subprocess
# subprocess.run('ls') # Simple command
# subprocess.run('ls -la', shell=True) # Dangerous command
subprocess.run(['ls', '-la'])Si nous voulons stocker la sortie standard d'un sousprocess dans une variable, nous pouvons le faire en définissant l'argument capture_output sur true.
list_of_files = subprocess.run(['ls', '-la'], capture_output=True)
print(list_of_files.stdout)
❯ python list_dir.py
b'total 36\ndrwxr-xr-x 3 daniel daniel 4096 may 20 21:08 .\ndrwx------ 30 daniel daniel 4096 may 20 18:03 ..\n-rw-r--r-- 1 daniel daniel 55 may 20 20:18 example.py\ndrwxr-xr-x 8 daniel daniel 4096 may 20 17:31 .git\n-rw-r--r-- 1 daniel daniel 2160 may 17 22:23 .gitignore\n-rw-r--r-- 1 daniel daniel 271 may 20 19:53 internet_checker.py\n-rw-r--r-- 1 daniel daniel 1076 may 17 22:23 LICENSE\n-rw-r--r-- 1 daniel daniel 216 may 20 22:12 list_dir.py\n-rw-r--r-- 1 daniel daniel 22 may 17 22:23 README.md\n'Pour accéder à la sortie d'un process, nous utilisons l'attribut instance Stdout.
Dans ce cas, nous voulons stocker la sortie sous forme de chaîne, au lieu d'octets et nous pouvons le faire en définissant l'argument de texte sur true.
list_of_files = subprocess.run(['ls', '-la'], capture_output=True, text=True)
print(list_of_files.stdout)
❯ python list_dir.py
total 36
drwxr-xr-x 3 daniel daniel 4096 may 20 21:08 .
drwx------ 30 daniel daniel 4096 may 20 18:03 ..
-rw-r--r-- 1 daniel daniel 55 may 20 20:18 example.py
drwxr-xr-x 8 daniel daniel 4096 may 20 17:31 .git
-rw-r--r-- 1 daniel daniel 2160 may 17 22:23 .gitignore
-rw-r--r-- 1 daniel daniel 271 may 20 19:53 internet_checker.py
-rw-r--r-- 1 daniel daniel 1076 may 17 22:23 LICENSE
-rw-r--r-- 1 daniel daniel 227 may 20 22:14 list_dir.py
-rw-r--r-- 1 daniel daniel 22 may 17 22:23 README.mdParfait, maintenant que nous connaissons les bases de la dessousprocess bibliothèque, il est temps de passer à quelques exemples d'utilisation.
Exemples d'utilisation de subprocess en Python
Dans cette section, nous allons revDécouvrez quelques utilisations pratiques du subprocess bibliothèque. Vous pouvez tous les vérifier ici Github référentiel.
Vérificateur de programme
L'une des principales utilisations de cette bibliothèque est la possibilité d'effectuer des opérations simples sur le système d'exploitation.
Par exemple, un simple script qui vérifie si un programme est installé. Sous Linux, nous pouvons le faire avec le qui commander.
'''Program checker with subprocess'''
import subprocess
program = 'git'
process = subprocess. run(['which', program], capture_output=True, text=True)
if process.returncode == 0:
print(f'The program "{program}" is installed')
print(f'The location of the binary is: {process.stdout}')
else:
print(f'Sorry the {program} is not installed')
print(process.stderr)Remarque: Sous UNIX, lorsqu'une commande réussit, son code d'état est 0. Autrewise, quelque chose s'est mal passé lors de l'exécution
Puisque nous n'utilisons pas le shell = Vrai argument, nous pouvons prendre l'entrée de l'utilisateur en toute sécurité. En outre, nous pouvons vérifier si l'entrée est un programme valide avec un modèle d'expression régulière.
import subprocess
import re
programs = input('Separe the programs with a space: ').split()
secure_pattern = '[\w\d]'
for program in programs:
if not re.match(secure_pattern, program):
print("Sorry we can't check that program")
continue
process = subprocess. run(
['which', program], capture_output=True, text=True)
if process.returncode == 0:
print(f'The program "{program}" is installed')
print(f'The location of the binary is: {process.stdout}')
else:
print(f'Sorry the {program} is not installed')
print(process.stderr)
print('\n')
Dans ce cas, nous obtenons les programmes de l'utilisateur et utilisons une expression regex qui certifie que la chaîne du programme ne comprend que des lettres et des chiffres. Nous vérifions l'existence de chaque programme avec une boucle for.
Remarque : vérifiez ceci testeur de regex en ligne.
Grep simple en Python
Ton ami Tom a une liste de modèles dans un fichier texte et un autre gros fichier dans lequel il veut obtenir le nombre de correspondances pour chaque modèle. Il passerait des heures à courir le commande grep pour chaque modèle.
Fortunately, vous savez comment résoudre ce problème avec Python, et vous l'aiderez à accomplir cette tâche en quelques secondes.
import subprocess
patterns_file = 'patterns.txt'
readfile = 'romeo-full.txt'
with open(patterns_file, 'r') as f:
for pattern in f:
pattern = pattern.strip()
process = subprocess.run(
['grep', '-c', f'{pattern}', readfile], capture_output=True, text=True)
if int(process.stdout) == 0:
print(
f'The pattern "{pattern}" did not match any line of {readfile}')
continue
print(f'The pattern "{pattern}" matched {process.stdout.strip()} times')
En regardant ce fichier, nous définissons deux variables qui sont les noms de fichiers avec lesquels nous voulons travailler. Ensuite, nous ouvrons le fichier qui contient tous les modèles et iterate au dessus d'eux. Ensuite, nous appelons un sousprocess qui exécute une commande grep avec le "-C" flag (signifie count) et déterminer la sortie de la correspondance avec un conditionnel.
Si vous exécutez ce fichier (n'oubliez pas que vous pouvez télécharger les fichiers texte à partir du Github repo)
Configurer un virtualenv avec subprocess
L'une des choses les plus intéressantes que vous puissiez faire avec Python est process automatisation. Ce type de script peut vous faire gagner des heures par semaine.
Par exemple, nous allons créerate un script de configuration qui créeateun environnement virtuel pour nous et essaie de trouver un conditions.txt dans le répertoire courant pour installer toutes les dépendances.
import subprocess
from pathlib import Path
VENV_NAME = '.venv'
REQUIREMENTS = 'requirements.txt'
process1 = subprocess.run(['which', 'python3'], capture_output=True, text=True)
if process1.returncode != 0:
raise OSError('Sorry python3 is not installed')
python_bin = process1.stdout.strip()
print(f'Python found in: {python_bin}')
process2 = subprocess.run('echo "$SHELL"', shell=True, capture_output=True, text=True)
shell_bin = process2.stdout.split('/')[-1]
create_venv = subprocess.run([python_bin, '-m', 'venv', VENV_NAME], check=True)
if create_venv.returncode == 0:
print(f'Your venv {VENV_NAME} has been created')
pip_bin = f'{VENV_NAME}/bin/pip3'
if Path(REQUIREMENTS).exists():
print(f'Requirements file "{REQUIREMENTS}" found')
print('Installing requirements')
subprocess.run([pip_bin, 'install', '-r', REQUIREMENTS])
print('Process completed! Now activate your environment with "source .venv/bin/activate"')
else:
print("No requirements specified ...")Dans ce cas, nous utilisons plusieurs processes et analyser les données dont nous avons besoin dans notre script python. Nous utilisons également le cheminlib bibliothèque qui nous permet de le comprendre si le conditions.txt le fichier existe.
Si vous exécutez le fichier python, vous obtiendrez des messages utiles sur ce qui se passe avec le système d'exploitation.
❯ python setup.py
Python found in: /usr/bin/python3
Your venv .venv has been created
Requirements file "requirements.txt" found
Installing requirements
Collecting asgiref==3.3.4 .......
Process completed! Now activate your environment with "source .venv/bin/activate"Notez que nous obtenons le résultat de l'installation process car nous ne redirigeons pas la sortie standard vers une variable.
Exécuter un autre langage de programmation
Nous pouvons exécuter d'autres langages de programmation avec Python et obtenir le résultat de ces fichiers. Ceci est possible parce que le sousprocesses interagissent directement avec le système d’exploitation.
Par exemple, créonsate un programme Hello World en C++ et Java. Afin d'exécuter le fichier suivant, vous devrez installer C + + et le Java compilateurs.
bonjour le monde.cpp
#include <iostream>
int main(){
std::cout << "This is a hello world in C++" << std::endl;
return 0;
}
bonjour le monde.java
class HelloWorld{
public static void main(String args[]){
System.out.println("This is a hello world in Java");
}
}
Je sais que cela semble beaucoup de code par rapport à un simple one-liner Python, mais c'est juste à des fins de test.
Nous allons créerate un script Python qui exécute tous les fichiers C++ et Java d'un répertoire. Pour ce faire, nous voulons d'abord obtenir une liste de fichiers en fonction de l'extension du fichier, et glob nous permet de le faire facilement!
from glob import glob
# Gets files with each extension
java_files = glob('*.java')
cpp_files = glob('*.cpp')Après cela, nous pouvons commencer à utiliser subprocesses pour exécuter chaque type de fichier.
for file in cpp_files:
process = subprocess.run(f'g++ {file} -o out; ./out', shell=True, capture_output=True, text=True)
output = process.stdout.strip() + ' BTW this was runned by Python'
print(output)
for file in java_files:
without_ext = file.strip('.java')
process = subprocess.run(f'java {file}; java {without_ext}',shell=True, capture_output=True, text=True)
output = process.stdout.strip() + ' A Python subprocess runned this :)'
print(output)Une petite astuce consiste à utiliser la fonction string bande pour modifier la sortie et obtenir uniquement ce dont nous avons besoin.
Remarque: Soyez prudent d'exécuter de gros fichiers Java ou C ++ car nous chargeons leur sortie en mémoire et cela pourrait produire une fuite de mémoire.
Ouvrir des programmes externes
Nous sommes capables d'exécuter d'autres programmes simplement en appelant l'emplacement de leurs binaires via un sous-programme.process.
Essayons-le en ouvrant braver, mon web préféré browser.
import subprocess
subprocess.run('brave')Cela ouvrira abrowspar exemple, ou juste un autre onglet si vous avez déjà exécuté le browser.
Comme avec tout autre programme qui accepte les drapeaux, nous pouvons les utiliser pour produire le comportement souhaité.
import subprocess
subprocess.run(['brave', '--incognito'])
Pour résumer
Un sous-process est un ordinateur process CREated par un autre process. Nous pouvons vérifier le processes, notre ordinateur fonctionne avec des outils comme htop et le gestionnaire de tâches.
Python a sa propre bibliothèque pour travailler avec subprocesses. Actuellement, le courir la fonction nous donne une interface simple pour créerate et gérer les sousprocesspar exemple.
Nous pouvons créerate n'importe quel type d'application avec eux car nous interagissons directement avec le système d'exploitation.
finally, rappelez-vous que la meilleure façon d'apprendre est de CREate quelque chose vous souhaitez utiliser.
