Introduction détaillée au package de sous-processus de la bibliothèque standard Python

Le contenu ici est basé sur les bases des processus Linux et les flux de texte Linux. La fonction principale du package de sous-processus est d'exécuter des commandes et des programmes externes. Par exemple, je dois utiliser wget pour télécharger un fichier. J'appelle le programme wget en Python. En ce sens, le sous-processus fonctionne de la même manière que le shell.

sous-processus et fonctions d'encapsulation couramment utilisées

Lorsque nous exécutons Python, nous créons et exécutons un processus. Comme nous l'avons introduit dans Linux Process Basics, un processus peut créer un processus enfant et laisser le processus enfant exécuter un autre programme. En Python, nous utilisons le package de sous-processus dans la bibliothèque standard pour créer un sous-processus et exécuter un programme externe (voir Bases des processus Linux pour fork et exec).

Le package de sous-processus définit plusieurs fonctions pour créer des sous-processus. Ces fonctions créent des sous-processus de différentes manières, nous pouvons donc en choisir un à utiliser en fonction de nos besoins. De plus, le sous-processus fournit également des outils pour gérer les flux et canaux standard afin d'utiliser la communication textuelle entre les processus.

Lorsque vous utilisez la fonction du package de sous-processus pour créer un processus enfant, veuillez noter :

1) Après avoir créé le processus enfant, si le processus parent est en pause et attend que le processus enfant courir.

2) Que renvoie la fonction ?

3) Lorsque le code de retour n'est pas 0, comment le processus parent le gère-t-il.

subprocess.call()

Le processus parent attend que le processus enfant se termine

Renvoyer les informations de sortie (code de retour, équivalent au code de sortie, voir les bases du processus Linux)

subprocess.check_call()

Le processus parent attend que le processus enfant se termine

Retour 0

Vérifiez les informations de sortie, si le code de retour n'est pas 0 , déclenche l'erreur subprocess.CalledProcessError, qui L'objet contient un attribut returncode, qui peut être vérifié avec try...sauf... (voir Gestion des erreurs Python).

subprocess.check_output()

Le processus parent attend la fin du processus enfant

Renvoie le résultat de sortie du processus enfant à la sortie standard

Vérifiez les informations de sortie, si si le code de retour n'est pas 0, l'erreur subprocess.CalledProcessError est générée. L'objet contient l'attribut returncode et l'attribut de sortie est le résultat de la sortie standard et peut être vérifié avec try. ...sauf....

L'utilisation de ces trois fonctions est similaire. Nous utilisons subprocess.call() pour illustrer :

import subprocess
rc = subprocess.call(["ls","-l"])

Nous changeons le nom du programme (ls ) et les paramètres (-l) sont placés dans un tableau et passés à subprocess.call()

Une chaîne entière peut être interprétée via un shell :

import subprocess
out = subprocess.call("ls -l", shell=True)
out = subprocess.call("cd ..", shell=True)

Nous avons utilisé le paramètre shell=True. Cette fois, nous utilisons une chaîne entière au lieu d'une table pour exécuter le processus enfant. Python exécutera d'abord un shell, puis utilisera ce shell pour interpréter la chaîne entière.

Certaines commandes du shell sont des commandes intégrées au shell. Ces commandes doivent être exécutées via le shell, $cd. shell=True nous permet d'exécuter de telles commandes.

Popen()

En fait, nos trois fonctions ci-dessus sont toutes des wrappers basés sur Popen(). Le but de ces encapsulations est de faciliter l’utilisation des sous-processus. Lorsque nous souhaitons être plus personnalisés selon nos besoins, nous nous tournons vers la classe Popen, qui génère des objets qui représentent des processus enfants.

Différent de l'encapsulation ci-dessus, une fois l'objet Popen créé, le programme principal n'attendra pas automatiquement la fin du sous-processus. Nous devons appeler la méthode wait() de l'objet pour que le processus parent attende (c'est-à-dire bloque le bloc) :

import subprocess
child = subprocess.Popen(["ping","-c","5","www.google.com"])
print("parent process")

Comme le montre Dans les résultats en cours d'exécution, le processus parent est dans Après avoir démarré le processus enfant, il n'attend pas que l'enfant termine, mais exécute directement l'impression.

Comparez la situation d'attente :

import subprocess
child = subprocess.Popen(["ping","-c","5","www.google.com"])
child.wait()
print("parent process")

De plus, vous pouvez également effectuer d'autres opérations sur le processus enfant dans le processus parent, comme dans notre exemple ci-dessus L'objet enfant :

child.poll()      # 检查子进程状态

child.kill()      # 终止子进程

child.send_signal()  # 向子进程发送信号

child.terminate()   # 终止子进程

Le PID du processus enfant est stocké dans child.pid

Le contrôle de flux de texte de l'enfant process

(Hérité du sous-processus enfant) L'entrée standard, la sortie standard et l'erreur standard du processus enfant peuvent également être représentées par les attributs suivants :

child.stdin

child.stdout

child.stderr

Nous pouvons modifier l'entrée standard, la sortie standard et l'erreur standard lorsque Popen() crée un processus enfant, et pouvons utiliser subprocess.PIPE pour connectez l'entrée et la sortie de plusieurs processus enfants ensemble pour former un pipeline (pipe) :

import subprocess
child1 = subprocess.Popen(["ls","-l"], stdout=subprocess.PIPE)
child2 = subprocess.Popen(["wc"], stdin=child1.stdout,stdout=subprocess.PIPE)
out = child2.communicate()
print(out)

subprocess.PIPE fournit en fait une zone tampon pour le flux de texte. La sortie standard de Child1 affiche le texte dans la zone tampon, puis la sortie standard de Child2 lit le texte à partir du PIPE. Le texte de sortie de child2 est également stocké dans PIPE jusqu'à ce que la méthode communicate() lise le texte dans PIPE à partir de PIPE.

Il convient de noter que communicate() est une méthode de l'objet Popen, qui bloque le processus parent jusqu'à ce que le processus enfant soit terminé.

Nous pouvons également utiliser la méthode communicate() pour utiliser PIPE pour saisir des données dans le processus enfant :

import subprocess
child = subprocess.Popen(["cat"], stdin=subprocess.PIPE)
child.communicate("vamei")

我们启动子进程之后，cat会等待输入，直到我们用communicate()输入"vamei"。

通过使用subprocess包，我们可以运行外部程序。这极大的拓展了Python的功能。如果你已经了解了操作系统的某些应用，你可以从Python中直接调用该应用(而不是完全依赖Python)，并将应用的结果输出给Python，并让Python继续处理。shell的功能(比如利用文本流连接各个应用)，就可以在Python中实现。

总结

subprocess.call, subprocess.check_call(), subprocess.check_output()

subprocess.Popen(), subprocess.PIPE

Popen.wait(), Popen.communicate()

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!