Hvordan bruke Python -underprosess med rør?

Python er det vanligste språket på høyt nivå perfekt for nybegynnere. Det er nyttig for maskinlæring, nettutvikling og andre funksjoner. Det er et av de mest enkle og tilgjengelige programmeringsspråkene for å hjelpe programmerere med å skrive klare, presise og enkle koder. Det gir mange innebygde funksjoner, lettfattelige metoder og flere underprosesser som lar brukeren utføre Linux, C, C ++ eller Java-kommandoer direkte fra Python. Denne artikkelen vil diskutere bruken av underprosesser i Python og forklare hvordan disse underprosessene kan kombineres med rør. Så la oss starte.

Den offisielle Python -dokumentasjonen gir en detaljert forklaring av underprosessen i Python og hvordan du bruker Python -underprosessen med rør, og det er gunstig for forståelse og utviklingsformål. Imidlertid kan den komplette dokumentasjonen være litt overveldende for nybegynnere. Dessuten kan syntaksen variere fra en versjon til en annen versjon av Python, som kan forvirre nybegynnere.

Derfor har vi en løsning for deg, og her forklarer vi trinn-for-trinn-prosessen med å bruke Python-underprosessen med rør. Vi vil forklare prosessen ved hjelp av eksempler, så la oss gå videre for å se eksemplene, men for det første, la oss se hva et rør er for en underprosess i Python. Røret i Python brukes til å sende eller motta data fra et program som kjører som en underprosess i Python. For å gjøre dette, kan vi bruke en kombinasjon av rør som i utgangspunktet skaper røret, en gaffel brukes til å lage underprosessen i programmet, dup2 brukes til å tvinge underprosessen til å bruke røret som en standardinngangs- og utgangskanal, og til slutt, Exec brukes til å utføre eller kjøre det nye programmet. Dessuten brukes popen og pClose til å åpne eller lukke programmet henholdsvis.

Fordelen med å bruke Popen og PClose er at det antyder et enkelt og brukervennlig grensesnitt. Imidlertid gir det ikke mye fleksibilitet fordi den direkte bruker funksjoner på lavt nivå. La oss se eksemplene nedenfor.

Eksempel 1:

Det første eksemplet vil forklare hvordan du koder for kommandoen som inneholder et rør og en omdirigering. La oss se eksemplet:

ZCAT F1.Dat.GZ F2.Dat.gz | Pigz> ut.gz

Her er Python -koden som forklarer hvordan du implementerer UNIX -kommandoen med underprosess i Python.

P1 = underprosess.Popen (["ZCAT", "F1.Dat.GZ "," F2.Dat.gz "],
stdout = underprosess.RØR)
fout = åpen ('ut.GZ ',' WB ')
P2 = underprosess.løp (['Pigz'], stdin = P1.stdout, stdout = fout) a

Merk at Popen () -metoden brukes med den første underprosessen, mens RUN () -metoden brukes med den andre samtalen som koder for omdirigeringene. Den påfølgende feilen vil være forårsaket hvis RUN () -metoden brukes med selve røret.

Eksempel 2:

Dette eksemplet vil forklare hvordan et Python -program spør en brukers navn. Så ekko er det med en hilsenmelding og ber gjentatte ganger om navnene til brukeren går inn i avkjørselen.'Når brukeren kommer inn i "exit" i svaret med å spørre navnet, stopper IF -tilstanden de gitte kriteriene og utførelsen av programmet. Se koden gitt nedenfor.

Importer Sys
trykk ("Hva heter du?")
For navn i Iter (SYS.stdin.Readline, "):
Navn = navn [:-1]
Hvis navn == "Avslutt":
gå i stykker
trykk ("Vel, hvordan har du det 0?"".Format (navn))
trykk ("\ n Hva heter du?")

Her er den gjentatte utdata fra ovennevnte kode som bare stopper når brukeren legger inn ordet 'Avslutt.'

Eksempel 3:

Dette eksemplet er litt komplisert, men lett å forstå og bruke. Det vil forklare hvordan du kan kontrollere inngangen og utgangen til et program ved hjelp av rør og underprosess i Python. La oss se koden først.

Importer underprosess
Importer Sys
proc = underprosess.Popen (["Python", "Callmyname.py "])
Mens Proc.returkode er ingen:
Proc.avstemming()
proc = underprosess.Popen (["Python", "Callmyname.py "],
stdin = underprosess.Rør, stdout = underprosess.RØR)
Proc.stdin.Skriv ("Alex \ n")
Proc.stdin.Skriv ("Jhon \ n")
Proc.stdin.Lukk()
Mens Proc.returkode er ingen:
Proc.avstemming()
trykte ("Jeg er tilbake fra barneprogrammet dette: \ n 0".Format (Proc.stdout.lese()))

Underprosessen.Popen () tar to navngitte argumenter, den ene er stdin og den andre er stdout. Begge disse argumentene er valgfrie. Disse argumentene brukes til å stille røret, som barnetprosessen bruker som sin stdin og stdout. Underprosessen.Røret føres som en konstant slik at en av underprosessene.Popen () eller underprosess.Rør brukeren spesifiserer at de vil ha det resulterende. En barneprosess som heter Callmyname.PY er opprettet i programmet. To navn sendes til callmyname.py før du sender EOF -signalet til inngangen til barnet. Morprosessen venter på at barneprosessen skal avsluttes før den leser utdataene som produseres av barneprosessen. Følgende er utgangen fra den ovennevnte koden.

Som du kan se, er det enkelt å bruke rør med underprosessen i Python. Hvis du følger eksemplene gitt ovenfor, kan du enkelt lære bruken av rør med underprosesser i Python.

Konklusjon:

Denne artikkelen handler om hvordan du bruker Python -underprosessen med rør. For det første introduserte vi kort hva et rør er for en underprosess i Python, og deretter ga vi noen eksempler for å forklare hvordan du bruker røret med en underprosess i Python.