Argomento dei contenuti:
- Esegui un semplice comando Linux
- Esegui un comando con dati di input
- Esegui uno script Python
- Gestire l'errore del sottoprocesso
- Restituisce il codice di Subprocess.Popen
- Reindirizzare l'output del sottoprocesso su file
- Multiprocessing utilizzando Subprocess.Popen
- Gestire il flusso di input e output S
- Controlla il timeout e il ritardo
- Leggere un input in streaming
Esegui un semplice comando Linux
Il comando 'date' viene utilizzato per visualizzare la data e l'ora correnti del sistema. Crea un file Python con il seguente script che crea un sottoprocesso che esegue il comando 'date' e stampa l'output di questo comando:
#Importa il moduloimportare sottoprocesso
#Definire un comando per il sottoprocesso e
#apri il processo utilizzando la funzione Popen()
produzione = sottoprocesso . Popen ( [ 'data' ] , stdout = sottoprocesso . TUBO )
#Recupera l'output e l'errore comunicando con il processo
stdout , stderr = produzione. comunicare ( )
#Stampa l'output
stampa ( stdout. decodificare ( ) )
Produzione:
Dopo l'esecuzione dello script precedente viene visualizzato il seguente output:
Esegui un comando con dati di input
Il comando 'wc' con l'opzione '-c' viene utilizzato per contare il numero totale di caratteri del valore stringa fornito con questo comando. Crea un file Python con il seguente script che crea un sottoprocesso con la funzione Popen() per eseguire i comandi “wc –c”. Il valore della stringa viene preso dal terminale dopo aver eseguito lo script e i caratteri totali della stringa di input vengono stampati nell'output.
#Importa il moduloimportare sottoprocesso
#Definire un comando per il sottoprocesso e
#Apri il processo utilizzando la funzione Popen()
produzione = sottoprocesso . Popen ( [ 'wc' , '-C' ] , stdout = sottoprocesso . TUBO )
#Recupera l'output e l'errore comunicando con il processo
stdout , stderr = produzione. comunicare ( )
#Stampa l'output
stampa ( stdout. decodificare ( ) )
Produzione:
Viene visualizzato il seguente output per il valore di input 'Esempi di sottoprocesso Python':
Esegui uno script Python
Crea un file Python denominato 'sum.py' con il seguente script che calcola la somma di due numeri e questi numeri vengono forniti come argomenti della riga di comando:
somma.py
#Importa il modulo necessarioimportare sistema
#Conta gli argomenti totali
N = soltanto ( sistema . argv )
#Aggiungi i primi due valori degli argomenti
somma = int ( sistema . argv [ 1 ] ) + int ( sistema . argv [ 2 ] )
#Stampa il risultato dell'addizione
stampa ( 'La somma di ' + sistema . argv [ 1 ] + ' E ' + sistema . argv [ 2 ] + ' È' , somma )
Crea un pitone file con il seguente script che eseguirà un Python file di nome somma . pi con due argomenti creando a sottoprocesso .
#Importa il modulo
importare sottoprocesso
#Esegui lo script Python nel sottoprocesso e
#apri il processo utilizzando la funzione Popen()
produzione = sottoprocesso . Popen ( [ 'python3' , 'sum.py' , '25' , '55' ] , stdout = sottoprocesso . TUBO ) #Recupera l'output e l'errore comunicando con il processo
stdout , stderr = produzione. comunicare ( )
#Stampa l'output
stampa ( stdout. decodificare ( ) )
Produzione:
Dopo l'esecuzione dello script precedente viene visualizzato il seguente output:
`
Gestire l'errore del sottoprocesso
Crea un file Python con il seguente script che gestisce gli errori del sottoprocesso utilizzando il blocco 'try-Exception'. Un comando viene preso dall'utente e viene eseguito dal sottoprocesso. Il messaggio di errore viene visualizzato se l'utente riceve un comando non valido.
#Importa i moduliimportare sottoprocesso
importare sistema
#Prendi il comando dall'utente
comando = ingresso ( 'Inserisci un comando valido: ' )
Tentativo :
#Apri il processo utilizzando la funzione Popen()
produzione = sottoprocesso . Popen ( [ comando ] , stdout = sottoprocesso . TUBO )
#Recupera l'output e l'errore comunicando con il processo
stdout , stderr = produzione. comunicare ( )
#Stampa l'output
stampa ( stdout. decodificare ( ) )
tranne :
stampa ( 'Errore:' , sistema . exc_info ( ) )
Produzione:
Se viene preso come input il comando 'pwd' che è un comando valido, viene visualizzato il seguente output:
Se viene preso come input il comando 'usr' viene visualizzato il seguente output che è un comando valido:
Restituisce il codice di Subprocess.Popen
Crea un file Python con il seguente script che esegue un comando 'ls' attraverso il sottoprocesso per ottenere l'elenco di tutti i file Python dalla posizione corrente. Lo script attende di completare il sottoprocesso e stampa il codice di ritorno.
#Importa i moduliimportare sottoprocesso
importare sistema
#Imposta il comando
comando = [ 'l' , '-l' , '*.py' ]
Tentativo :
#Apri il processo utilizzando la funzione Popen()
produzione = sottoprocesso . Popen ( comando , stdout = sottoprocesso . TUBO ,
stderr = sottoprocesso . TUBO , testo = VERO )
#Attendere per completare il processo
retCode = produzione. Aspettare ( )
#Stampa il codice di reso
stampa ( 'Codice di reso:' , retCode )
tranne :
#Stampa il messaggio di errore per l'errore
stampa ( 'Errore:' , sistema . exc_info ( ) )
Produzione:
Un output simile appare dopo l'esecuzione dello script precedente:
Reindirizzare l'output del sottoprocesso su file
Crea un file Python con il seguente script che scrive l'output del sottoprocesso in un file di testo. Il comando eseguito dal sottoprocesso viene preso dall'utente.
#Modulo di importazioneimportare sottoprocesso
#Definire il nome del file
nome del file = 'fileout.txt'
#Prendi un comando ping
cmq = ingresso ( 'Inserisci un comando ping: ' )
#Dividi l'input preso in base allo spazio
arg = cmq . diviso ( )
#Scrivi l'output del comando nel file
con aprire ( nome del file , 'In' ) COME dati obsoleti:
processi = sottoprocesso . Popen ( arg , stdout = dati obsoleti )
#Attendere il completamento del processo
codice_ritorno = processi. Aspettare ( )
Produzione:
Secondo il seguente output, il comando 'ping -c 3 www.google.com Il comando ' viene preso dall'utente e il comando 'cat' viene utilizzato per visualizzare il contenuto del file scritto dal sottoprocesso:
Multiprocessing utilizzando Subprocess.Popen
Crea un file Python con il seguente script in cui viene mostrato l'uso del multiprocessing utilizzando subprocess. Qui, una funzione denominata display_msg() viene chiamata più volte utilizzando il multiprocessing.
#Importa i moduli necessariimportare multielaborazione
importare sottoprocesso
#Definisce la funzione che verrà chiamata dal multiprocessing
def display_msg ( N ) :
#Definisci il comando con la funzione format()
cmq = 'echo 'Programmazione Python'' . formato ( N )
#Apri il processo utilizzando la funzione Popen()
processi = sottoprocesso . Popen ( cmq , conchiglia = VERO , stdout = sottoprocesso . TUBO )
#Recupera l'output e l'errore comunicando con il processo
stdout , errore = processi. comunicare ( )
#Stampa l'output
stampa ( stdout. decodificare ( ) )
#Chiama la funzione 5 volte creando il multiprocessing.Pool
con multielaborazione. Piscina ( multielaborazione. conteggio_cpu ( ) ) COME mp:
#Mappatura della funzione
mp. carta geografica ( display_msg , allineare ( 1 , 5 ) )
Produzione:
Dopo l'esecuzione dello script precedente viene visualizzato il seguente output:
Gestire i flussi di input e output
Crea un file di testo denominato 'test.txt' con il seguente contenuto prima di creare lo script Python di questo esempio.
prova.txt
PERL
pitone
bash
php
Crea un file Python con il seguente script che utilizza un sottoprocesso per leggere il contenuto del file 'test.txt' e un altro sottoprocesso per cercare una parola particolare in quel file di testo. Qui, la parola 'python' viene cercata nel 'file test.txt' che contiene questa parola.
#Importa moduliimportare sottoprocesso
#Definire un processo per il flusso di input
in corso = sottoprocesso . Popen ( [ 'gatto' , 'prova.txt' ] , stdout = sottoprocesso . TUBO , testo = Vero > #Definire un processo per il flusso di output
out_process = sottoprocesso . Popen (
[ 'presa' , 'pitone' ] , stdin = in corso. stdout ,
stdout = sottoprocesso . TUBO , testo = VERO )
#Memorizza l'output dei processi di input e output
produzione , _ = out_process. comunicare ( )
#Stampa l'output
stampa ( 'Produzione:' , produzione )
Produzione:
Dopo l'esecuzione dello script viene visualizzato il seguente output:
Controllare il sottoprocesso utilizzando un timer
Crea un file Python con il seguente script che utilizza un timer per eseguire un comando utilizzando un sottoprocesso. Qui, il blocco “try-eccetto” viene utilizzato per avviare il timer e il blocco “finalmente” viene utilizzato per annullare il timer.
#Importa il modulo del sottoprocessoimportare sottoprocesso
#Importa il modulo Timer
da filettatura importare Timer
#Definire il comando
cmq = [ 'ping' , 'www.example.com' ]
#Apri il processo
P = sottoprocesso . Popen (
cmq , stdout = sottoprocesso . TUBO , stderr = sottoprocesso . TUBO )
#Definire il timer
Timer = Timer ( 2 , lambda processo: processo. uccisione ( ) , [ P ] )
Tentativo :
#Avvia il timer
Timer. inizio ( )
#Leggi l'output
stdout , _ = P. comunicare ( )
#Uscita di stampa
stampa ( stdout. decodificare ( ) )
tranne :
#Stampa il messaggio di errore per l'errore
stampa ( 'Errore:' , sistema . exc_info ( ) )
Finalmente :
#Ferma il timer
Timer. Annulla ( )
Produzione:
Dopo l'esecuzione dello script viene visualizzato il seguente output:
Leggi l'input di streaming
Crea un file Python che legge il contenuto dell'output del sottoprocesso utilizzando un ciclo 'mentre' e memorizza il contenuto in una variabile. Il contenuto di questa variabile viene stampato successivamente. Qui, il comando 'curl' viene utilizzato nel sottoprocesso per il file www.google.com URL.
#Modulo di importazioneimportare sottoprocesso
#Definisci comando
cmq = [ 'arricciare' , 'www.example.com' ]
P = sottoprocesso . Popen ( cmq , stdout = sottoprocesso . TUBO ,
stderr = sottoprocesso . TUBO , testo = VERO >
#Inizializza la variabile di output
produzione = ''
Mentre VERO :
#Leggi l'output del processo riga per riga
ln = P. stdout . linea di lettura ( )
#Termina il ciclo al termine del sottoprocesso
Se non ln:
rottura
produzione = uscita + ln
#Stampa la riga
stampa ( produzione )
#Ottieni il codice di ritorno dopo aver terminato il processo
codice_ritorno = P. Aspettare ( )
#Stampa il codice di reso
stampa ( 'Codice di ritorno: ' , codice_ritorno )
Produzione:
L'ultima parte dei tre output è mostrata nell'immagine seguente. Il codice di ritorno dopo aver completato il sottoprocesso è 0:
Conclusione
Diversi usi del sottoprocesso Python.Popen() sono mostrati in questo tutorial utilizzando più script Python che aiuteranno gli utenti Python a conoscere gli usi di base di questa funzione.