Como usar o subprocesso Python com tubos?

Python é a linguagem de alto nível mais comum perfeita para iniciantes. É útil para aprendizado de máquina, desenvolvimento da web e outras funcionalidades. É uma das linguagens de programação mais diretas e acessíveis para ajudar os programadores a escrever código claro, preciso e simples. Ele fornece muitas funções internas, métodos fáceis de entender e vários subprocessos que permitem ao usuário executar os comandos Linux, C, C ++ ou Java diretamente do Python. Este artigo discutirá o uso de subprocessos em Python e explicará como esses subprocessos podem ser combinados com tubos. Então, vamos começar.

A documentação oficial do Python fornece uma explicação detalhada do subprocesso em Python e como usar o subprocesso Python com tubos, e é benéfico para fins de entendimento e desenvolvimento. No entanto, a documentação completa pode ser um pouco impressionante para iniciantes. Além disso, a sintaxe pode variar de uma versão para outra versão do Python, que pode confundir os iniciantes.

Por isso, temos uma solução para você e aqui explicamos o processo passo a passo de usar o subprocesso Python com tubos. Vamos explicar o processo com a ajuda de exemplos, então vamos mais para ver os exemplos, mas, primeiro, vamos ver o que é um cano para um subprocesso no Python. O tubo em Python é usado para enviar ou receber dados de um programa que está sendo executado como subprocesso no Python. Para fazer isso, podemos usar uma combinação de cano que está basicamente criando o tubo, um garfo é usado para criar o subprocesso no programa, dup2 é usado para forçar o subprocesso a usar o tubo como um canal de entrada e saída padrão e, por fim,, exec é usado para executar ou executar o novo programa. Além disso, Popen e Pclose são usados ​​para abrir ou fechar o programa, respectivamente.

O benefício de usar Popen e Pclose é que ele sugere uma interface simples e fácil de usar. No entanto, não fornece muita flexibilidade porque usa diretamente funções de baixo nível. Vamos ver os exemplos abaixo.

Exemplo 1:

O primeiro exemplo explicará como codificar o comando que contém um tubo e um redirecionamento. Vamos ver o exemplo:

ZCAT F1.dat.gz f2.dat.gz | Pigz> Out.gz

Aqui está o código Python que explica como implementar o comando UNIX com subprocesso em Python.

P1 = subprocesso.Popen (["Zcat", "F1.dat.gz "," f2.dat.gz "],
stdout = subprocesso.CANO)
fout = aberto ('Out.gz ',' wb ')
P2 = subprocesso.Run (['Pigz'], stdin = P1.stdout, stdout = fout) um

Observe que o método Popen () é usado com o primeiro subprocesso, enquanto o método run () é usado com a segunda chamada que codifica os redirecionamentos. O erro subsequente será causado se o método run () for usado com o próprio tubo.

Exemplo 2:

Este exemplo explicará como um programa Python pergunta o nome de um usuário. Então eco é com uma mensagem de saudação e pede repetidamente os nomes até que o usuário entre na saída.'Quando o usuário entra' saída 'na resposta de perguntar o nome, a condição se a condição atendeu aos critérios e execução do programa para. Veja o código fornecido abaixo.

Importar sistemas
print ("Qual é o seu nome?")
Para nome em Iter (SYS.stdin.Leia a linha, "):
nome = nome [:-1]
se nome == "saída":
quebrar
print ("Bem, como você está 0?".formato (nome))
print ("\ n qual é o seu nome?")

Aqui está a saída repetida do código acima que apenas para quando o usuário insere a palavra 'saída.'

Exemplo 3:

Este exemplo é um pouco complicado, mas fácil de entender e usar. Ele explicará como controlar a entrada e a saída de um programa usando Pipe e Subprocess in Python. Vamos ver o código primeiro.

Subprocess de importação
Importar sistemas
Proc = subprocesso.Popen (["Python", "Callmyname.py "])
enquanto proc.ReturnCode não é nenhum:
Proc.enquete()
Proc = subprocesso.Popen (["Python", "Callmyname.py "],
stdin = subprocesso.Tubo, stdout = subprocesso.CANO)
Proc.stdin.Escreva ("Alex \ n")
Proc.stdin.Escreva ("Jhon \ n")
Proc.stdin.fechar()
enquanto proc.ReturnCode não é nenhum:
Proc.enquete()
print ("Estou de volta do programa infantil isto: \ n 0".formato (Proc.stdout.ler()))

O subprocesso.Popen () leva dois argumentos nomeados, um é stdin e o segundo é stdout. Ambos os argumentos são opcionais. Esses argumentos são usados ​​para definir o tubo, que o processo infantil usa como seu stdin e stdout. O subprocesso.O tubo é passado como uma constante para que qualquer um dos subprocessos.Popen () ou subprocesso.Pipe o usuário especifica que eles desejam o resultante. Um processo infantil chamado callmyname.PY é criado no programa. Dois nomes são passados ​​para o callmyname.PY antes de enviar o sinal EOF para a entrada da criança. O processo mãe aguarda o processo infantil para terminar antes de ler a saída produzida pelo processo infantil. A seguir, é apresentada a saída do código acima do rumo.

Como você pode ver, é simples usar o Pipe com o subprocesso em Python. Se você seguir os exemplos fornecidos acima, poderá aprender facilmente o uso do tubo com subprocessos em Python.

Conclusão:

Este artigo é sobre como usar o subprocesso Python com Pipe. Primeiro, introduzimos brevemente o que um tubo é para um subprocesso em Python e depois fornecemos alguns exemplos para explicar como usar o tubo com um subprocesso no Python.