Comment écrire un script d'inspection Python

Méthode 1, utilisez la méthode système du module os

os.system (cmd), la valeur de retour est le code d'état renvoyé après l'exécution de la commande shell,
int type, #🎜 🎜#0--Indique que la commande shell a été exécutée avec succès,
256--Indique que le shell n'a pas été trouvé,
Cette méthode convient aux scénarios où la commande shell n'a pas besoin pour sortir du contenu.

Méthode 2. Utilisez os.popen()

Cette méthode renvoie le résultat de l'exécution de la commande shell sous la forme d'un fichier ,

Vous pouvez utiliser la méthode read() ou readlines() lorsque vous avez besoin d'obtenir du contenu, par exemple :

#🎜🎜 #Méthode 3. Utilisez le module de commandes Il existe trois méthodes à utiliser

(1) commands.getstatusoutput(cmd), qui renvoie le résultat de sortie et code d'état sous la forme d'une chaîne, c'est-à-dire (statut, sortie).

(2) commands.getoutput(cmd), renvoie le résultat de sortie de cmd.

(3) commands.getstatus(file), renvoie la chaîne de résultat de l'exécution du fichier ls -l et appelle getoutput Cette méthode n'est pas recommandée

.

Méthode 4, module de sous-processus

permet la création de nombreux sous-processus Lors de la création, vous pouvez spécifier le sous-processus. -processus et l'entrée des pipelines de sous-processus, de sortie et de sortie d'erreur Après l'exécution, les résultats de sortie et l'état d'exécution peuvent être obtenus.

(1) subprocess.run() : Une nouvelle fonction dans python3.5, exécute la commande spécifiée, attend que la commande soit exécutée et renvoie une instance de la classe CompletedProcess contenant le résultat de l'exécution .

(2) subprocess.call() : Exécute la commande spécifiée et renvoie l'état d'exécution de la commande La fonction est similaire à os.system (cmd).

(3) subprocess.check_call() : Une nouvelle fonction dans python2.5, exécute la commande spécifiée et renvoie un code d'état si l'exécution réussit, sinon une exception est levée.

Description : subprocess.run(args, *, stdin=Aucun, input=Aucun, stdout=Aucun, stderr=Aucun, shell=False, timeout=Aucun, check=False, universal_newlines=False)

Subprocess.call(args, *, stdin=Aucun, stdout=Aucun, stderr=Aucun, shell=False, timeout=Aucun)

subprocess.check_call(args, *, stdin=Aucun, stdout=Aucun, stderr=Aucun, shell=False, timeout=Aucun)

　 args : Indique les instructions du shell si les instructions du shell sont données sous forme de chaîne, telles que "ls. - l "Vous devez définir shell = True. Sinon, les variables shell sont exprimées par défaut sous forme de tableau, telles que "ls", "-l".

Lorsque vous utilisez des instructions shell plus complexes, vous pouvez d'abord utiliser la méthode shlex.split() du module shlex pour aider à formater la commande, puis la transmettre à la méthode run() ou Popen.

Ci-joint le code source du module de sous-processus dans python2.7 pour la compréhension (source de la méthode d'affichage pycharm code, ctrl+clic gauche).

# Stubs for subprocess

# Based on http://docs.python.org/2/library/subprocess.html and Python 3 stub

from typing import Sequence, Any, Mapping, Callable, Tuple, IO, Union, Optional, List, Text

_FILE = Union[None, int, IO[Any]]
_TXT = Union[bytes, Text]
_CMD = Union[_TXT, Sequence[_TXT]]
_ENV = Union[Mapping[bytes, _TXT], Mapping[Text, _TXT]]

# Same args as Popen.__init__
def call(args: _CMD,
         bufsize: int = ...,
         executable: _TXT = ...,
         stdin: _FILE = ...,
         stdout: _FILE = ...,
         stderr: _FILE = ...,
         preexec_fn: Callable[[], Any] = ...,
         close_fds: bool = ...,
         shell: bool = ...,
         cwd: _TXT = ...,
         env: _ENV = ...,
         universal_newlines: bool = ...,
         startupinfo: Any = ...,
         creationflags: int = ...) -> int: ...

def check_call(args: _CMD,
               bufsize: int = ...,
               executable: _TXT = ...,
               stdin: _FILE = ...,
               stdout: _FILE = ...,
               stderr: _FILE = ...,
               preexec_fn: Callable[[], Any] = ...,
               close_fds: bool = ...,
               shell: bool = ...,
               cwd: _TXT = ...,
               env: _ENV = ...,
               universal_newlines: bool = ...,
               startupinfo: Any = ...,
               creationflags: int = ...) -> int: ...

# Same args as Popen.__init__ except for stdout
def check_output(args: _CMD,
                 bufsize: int = ...,
                 executable: _TXT = ...,
                 stdin: _FILE = ...,
                 stderr: _FILE = ...,
                 preexec_fn: Callable[[], Any] = ...,
                 close_fds: bool = ...,
                 shell: bool = ...,
                 cwd: _TXT = ...,
                 env: _ENV = ...,
                 universal_newlines: bool = ...,
                 startupinfo: Any = ...,
                 creationflags: int = ...) -> bytes: ...

PIPE = ...  # type: int
STDOUT = ...  # type: int

class CalledProcessError(Exception):
    returncode = 0
    # morally: _CMD
    cmd = ...  # type: Any
    # morally: Optional[bytes]
    output = ...  # type: Any

    def __init__(self,
                 returncode: int,
                 cmd: _CMD,
                 output: Optional[bytes] = ...) -> None: ...

class Popen:
    stdin = ...  # type: Optional[IO[Any]]
    stdout = ...  # type: Optional[IO[Any]]
    stderr = ...  # type: Optional[IO[Any]]
    pid = 0
    returncode = 0

    def __init__(self,
                 args: _CMD,
                 bufsize: int = ...,
                 executable: Optional[_TXT] = ...,
                 stdin: Optional[_FILE] = ...,
                 stdout: Optional[_FILE] = ...,
                 stderr: Optional[_FILE] = ...,
                 preexec_fn: Optional[Callable[[], Any]] = ...,
                 close_fds: bool = ...,
                 shell: bool = ...,
                 cwd: Optional[_TXT] = ...,
                 env: Optional[_ENV] = ...,
                 universal_newlines: bool = ...,
                 startupinfo: Optional[Any] = ...,
                 creationflags: int = ...) -> None: ...

    def poll(self) -> int: ...
    def wait(self) -> int: ...
    # morally: -> Tuple[Optional[bytes], Optional[bytes]]
    def communicate(self, input: Optional[_TXT] = ...) -> Tuple[Any, Any]: ...
    def send_signal(self, signal: int) -> None: ...
    def terminate(self) -> None: ...
    def kill(self) -> None: ...
    def __enter__(self) -> 'Popen': ...
    def __exit__(self, type, value, traceback) -> bool: ...

# Windows-only: STARTUPINFO etc.

STD_INPUT_HANDLE = ...  # type: Any
STD_OUTPUT_HANDLE = ...  # type: Any
STD_ERROR_HANDLE = ...  # type: Any
SW_HIDE = ...  # type: Any
STARTF_USESTDHANDLES = ...  # type: Any
STARTF_USESHOWWINDOW = ...  # type: Any
CREATE_NEW_CONSOLE = ...  # type: Any
CREATE_NEW_PROCESS_GROUP = ...  # type: Any

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!