Skambinkite išorine komanda pythone

Kaip galiu skambinti išorine komanda (tarsi aš įvedžiau ją Unix apvalkalu arba „Windows“ komandinėje eilutėje) iš „Python“ scenarijaus?

4003
18 сент. „FreshWoWer “ nustatytas 18 sep . 2008-09-18 04:35 '08 at 4:35 2008-09-18 04:35
@ 56 atsakymai
  • 1
  • 2

Pažvelkite į standartinės bibliotekos subproceso modulį :

 import subprocess subprocess.run(["ls", "-l"]) 

Subproceso pranašumas, palyginti su sistema, yra tai, kad jis yra lankstesnis (galite gauti stdout, stderr, „real“ statuso kodą, geresnį klaidų apdorojimą ir tt).

Oficiali dokumentacija rekomenduoja antrinio proceso modulį vietoj alternatyviosios sistemos ():

Subproceso modulis suteikia galingesnius įrankius naujų procesų neršimui ir jų rezultatams gauti; naudojant šį modulį, geriau naudoti šią funkciją [ os.system() ].

Skyriuje „ Senų funkcijų pakeitimas subproceso moduliusubprocesų dokumentuose gali būti keletas naudingų receptų.

3839
18 сент. David Cournapeau atsakymas, pateiktas rugsėjo 18 d 2008-09-18 04:39 '08 at 4:39 2008-09-18 04:39

Čia trumpai aprašoma, kaip skambinti išorinėms programoms ir kiekvieno iš jų privalumai ir trūkumai:

  • os.system("some_command with args") perduoda komandą ir argumentus jūsų sistemos apvalkalui. Tai gera, nes tokiu būdu galite vienu metu paleisti kelias komandas ir konfigūruoti kanalus bei I / O peradresavimą. Pavyzdžiui:

     os.system("some_command < input_file | another_command > output_file") 

    Tačiau, nors tai patogu, turite rankiniu būdu valdyti gaubto simbolių, pvz., Tarpų ir kt. Kita vertus, ji taip pat leidžia jums paleisti komandas, kurios yra tik korpuso komandos, o ne iš tikrųjų išorinės programos. Žr. Dokumentaciją .

  • stream = os.popen("some_command with args") atliks tą patį, kaip os.system , išskyrus tai, kad jis suteikia jums failą panašų objektą, kurį galite naudoti norėdami pasiekti standartinį I / O procesą. Yra dar trys popen parinktys, kurios šiek tiek skirtingai valdo „i / o“. Jei viską perduosite kaip eilutę, jūsų komanda perduodama korpusui; jei juos perduosite į sąrašą, jums nereikės nerimauti vengiant nieko. Žr. Dokumentaciją .

  • Klasės „ Popen modulio Popen . Tai turėtų pakeisti os.popen , tačiau turi trūkumų, nes tai yra šiek tiek sudėtingesnė dėl to, kad jis yra toks išsamus. Pvz., Galėtumėte pasakyti:

     print subprocess.Popen("echo Hello World", shell=True, stdout=subprocess.PIPE).stdout.read() 

    vietoj:

     print os.popen("echo Hello World").read() 

    bet malonu turėti visas galimybes vienoje klasėje vietoj 4 skirtingų popen funkcijų. Žr. Dokumentaciją .

  • call funkcija iš subprocess modulio. Tai iš esmės yra tas pats, kas Popen klasė, ir priima visus tuos pačius argumentus, tačiau tik laukia, kol komanda bus baigta ir gausite grąžinimo kodą. Pavyzdžiui:

     return_code = subprocess.call("echo Hello World", shell=True) 

    Žr. Dokumentaciją .

  • Jei naudojate Python 3.5 ar naujesnę subprocess.run galite naudoti naują subprocess.run funkciją, kuri yra labai panaši į aukščiau pateiktą, bet dar lankstesnė ir grąžina CompletedProcess objektą, kai komanda užbaigia vykdymą.

  • „O“ modulyje taip pat yra visos „C“ programoje esančios šakės / exec / spawn funkcijos, tačiau nerekomenduoju jų naudoti tiesiogiai.

subprocess modulis turbūt turėtų būti naudojamas.

border=0

Galiausiai, nepamirškite, kad už visus metodus, kuriuose perduodate galutinę komandą, kurią lukštas atliks kaip eilutę, jūs esate atsakingas už jo ištrynimą. Esama rimtų saugumo pasekmių, jei jokia perduodamos eilutės dalis negali būti visiškai patikima. Pavyzdžiui, jei vartotojas įveda bet kurią / bet kurią eilutės dalį. Jei nesate tikri, naudokite šiuos metodus tik su konstantomis. Jei norite nurodyti pasekmes, apsvarstykite šį kodą:

 print subprocess.Popen("echo %s " % user_input, stdout=PIPE).stdout.read() 

ir įsivaizduokite, kad vartotojas įeina į „mano mama nepatiko man rm -rf /“.

2641
18 сент. Atsakymą pateikė Eli Courtwright 18 sep . 2008-09-18 16:11 '08 at 4:11 pm 2008-09-18 16:11

Aš paprastai naudoju:

 import subprocess p = subprocess.Popen('ls', shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) for line in p.stdout.readlines(): print line, retval = p.wait() 

Galite atlikti tai, ko norite, naudodami stdout duomenis vamzdyje. Tiesą sakant, galite paprasčiausiai praleisti šiuos parametrus ( stdout= ir stderr= ), ir jis veiks kaip os.system() .

290
18 сент. Atsakymą pateikia „ EmmEff 18“ sep . 2008-09-18 21:20 '08 at 9:20 pm 2008-09-18 21:20

Kai kurie patarimai, kaip nutraukti vaiko procesą nuo skambinančiojo (vaiko proceso vykdymas fone).

Tarkime, kad norite paleisti ilgą užduotį iš CGI scenarijaus, ty vaiko procesas turi gyventi ilgiau nei CGI scenarijaus vykdymo procesas.

Klasikinis pavyzdys iš subprocesų modulio dokumentų:

 import subprocess import sys # some code here pid = subprocess.Popen([sys.executable, "longtask.py"]) # call subprocess # some more code here 

Idėja čia yra ta, kad nenorite laukti „skambučių“ subproceso tol, kol bus baigtas longtask.py. Tačiau neaišku, kas atsitinka po pavyzdžio „eilutė„ dar vienas kodas “.

Mano tikslinė platforma buvo nemokama, tačiau plėtra buvo Windows sistemoje, todėl pirmą kartą susidūriau su Windows problema.

>

Sprendimas yra perduoti DETACHED_PROCESS proceso kūrimo vėliavą pagrindinei CreateProcess funkcijai laimėjimo API. Jei įdiegėte pywin32, galite importuoti vėliavą iš „win32process“ modulio, kitaip jūs turite jį apibrėžti:

 DETACHED_PROCESS = 0x00000008 pid = subprocess.Popen([sys.executable, "longtask.py"], creationflags=DETACHED_PROCESS).pid 

/ * UPD 2015.10.27 @eryksun toliau pateiktose pastabose pažymi, kad semantiškai teisinga vėliava yra: CREATE_NEW_CONSOLE (0x00000010) * /

Freebsd sistemoje iškyla dar viena problema: kai baigiamas pirminis procesas, jis taip pat nutraukia vaiko procesus. Ir tai ne tai, ko norite CGI scenarijuje. Kai kurie eksperimentai parodė, kad problema, atrodo, dalijasi sys.stdout. Darbo sprendimas buvo toks:

 pid = subprocess.Popen([sys.executable, "longtask.py"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE) 

Aš neperžiūrėjau kodo kitose platformose ir nežinau, kodėl elgiamasi freebsd. Jei kas nors žino, pasidalinkite savo idėjomis. „Google“, kai „Python“ veikia foniniai procesai, vis dar nedega.

182
12 февр. atsakymas suteiktas naujienas 12 vasaris 2010-02-12 13:15 '10, 13:15, 2010-02-12 13:15

Norėčiau naudoti subproceso modulį vietoj os.system, nes jis jums neleidžiamas, todėl yra daug saugesnis: http://docs.python.org/library/subprocess.html

 subprocess.call(['ping', 'localhost']) 
113
18 сент. atsakymas, kurį pateikė sirwart 18 sep . 2008-09-18 04:42 '08, 4:42 2008-09-18 04:42
 import os cmd = 'ls -al' os.system(cmd) 

Jei norite grąžinti komandos rezultatus, galite naudoti os.popen . Tačiau tai buvo nuvertinta nuo 2.6 versijos naudai subproceso moduliui, kurį kiti atsakymai buvo gerai apsvarstyti.

110
18 сент. Alexandra Franks atsakymas rugsėjo 18 d 2008-09-18 04:37 '08 2008-09-18 04:37 04:37
 import os os.system("your command") 

Atminkite, kad tai pavojinga, nes komanda nėra išvalyta. Aš palieku tai jums google, kad gautumėte atitinkamus dokumentus apie modulius "os" ir "sys". Yra daugybė funkcijų (exec * ir neršia *), kurios tai padarys.

97
18 сент. Atsakymą pateikia nimish 18 sep . 2008-09-18 04:37 '08 2008-09-18 04:37 04:37

Yra daug skirtingų bibliotekų, leidžiančių skambinti išorinėms komandoms naudojant „Python“. Kiekvienai bibliotekai pateikiau aprašą ir parodiau išorinio komandos skambinimo pavyzdį. Pavyzdžiui, naudoju ls -l (visų failų sąrašas). Jei norite sužinoti daugiau apie bet kurią iš išvardytų bibliotekų ir susieti kiekvienos iš jų dokumentus.

Šaltiniai:

Tai visos bibliotekos:

Tikiuosi, kad tai padės jums nuspręsti, kurią biblioteką naudoti :)

subprocesas

Subprocesas leidžia jums skambinti išorinėms komandoms ir prijungti jas prie įvesties / išvesties / klaidų kanalų (stdin, stdout ir stderr). Subprocesas yra numatytasis pasirinkimas komandoms, tačiau kartais kiti moduliai yra geresni.

 subprocess.run(["ls", "-l"]) # Run command subprocess.run(["ls", "-l"], stdout=subprocess.PIPE) # This will run the command and return any output subprocess.run(shlex.split("ls -l")) # You can also use the shlex library to split the command 

OS

„os“ yra naudojama „nuo operacinės sistemos priklausomai funkcijai“. Jis taip pat gali būti naudojamas išorinėms komandoms naudoti, naudojant os.system ir os.popen (Pastaba: taip pat yra .prop). „os“ visada vykdys korpusą ir yra paprasta alternatyva žmonėms, kuriems jų nereikia, arba nežino, kaip naudoti subprocess.run .

 os.system("ls -l") # run command os.popen("ls -l").read() # This will run the command and return any output 

sh

sh yra subproceso sąsaja, kuri leidžia jums skambinti programomis taip, lyg jos būtų funkcijos. Tai naudinga, jei norite paleisti komandą kelis kartus.

 sh.ls("-l") # Run command normally ls_cmd = sh.Command("ls") # Save command as a variable ls_cmd() # Run command as if it were a function 

Švinas

„Plumbum“ yra „scenarijų tipo“ Python programų biblioteka. Galite skambinti programoms, pvz., Funkcijoms, pvz. Plumbum yra naudinga, jei norite paleisti vamzdyną be įvynioklio.

 ls_cmd = plumbum.local("ls -l") # get command ls_cmd() # run command 

žvilgsnis

„pexpect“ leidžia jums sukurti vaikų programas, valdyti jas ir rasti modelius jūsų leidinyje. Tai geriausias „Unix“ komandų ne-tty subprocesas.

 pexpect.run("ls -l") # Run command as normal child = pexpect.spawn('scp foo user@example.com:.') # Spawns child application child.expect('Password:') # When this is the output child.sendline('mypassword') 

audinys

audinys yra Python 2.5 ir 2.7 biblioteka. Tai leidžia jums vykdyti vietines ir nuotolines apvalkalo komandas. Audinys yra paprasta alternatyva paleisti komandas saugiame korpuse (SSH)

 fabric.operations.local('ls -l') # Run command as normal fabric.operations.local('ls -l', capture = True) # Run command and receive output 

pasiuntinys

pasiuntinys vadinamas „subprocesu žmonėms“. Jis naudojamas kaip patogus dangtelis aplink subprocess modulį.

 r = envoy.run("ls -l") # Run command r.std_out # get output 

Komandos

commands yra „ os.popen apvyniojimo funkcijų, tačiau ji buvo pašalinta iš „Python 3“, nes subprocess yra geriausia alternatyva.

Redagavimas buvo pagrįstas JF Sebastiano komentarais.

61
29 окт. Atsakymas Tom Fuller 29 spalis 2016-10-29 17:02 '16 at 17:02 2016-10-29 17:02

Aš visada naudoju fabric tokiems dalykams kaip:

 from fabric.operations import local result = local('ls', capture=True) print "Content:/n%s" % (result, ) 

Tačiau tai atrodo kaip gera priemonė: „ sh („Python“ subproceso sąsaja) .

Žr. Pavyzdį:

 from sh import vgdisplay print vgdisplay() print vgdisplay('-v') print vgdisplay(v=True) 
59
13 марта '12 в 3:12 2012-03-13 03:12 Atsakymą pateikė Jorge E. Cardona kovo 13 d. 12:12 2012-03-13 03:12

Taip pat patikrinkite „Python“ biblioteką „pexpect“.

Tai leidžia interaktyviai valdyti išorines programas / komandas, net ssh, ftp, telnet ir kt. Galite tiesiog įrašyti kažką panašaus:

 child = pexpect.spawn('ftp 192.168.0.24') child.expect('(?i)name .*: ') child.sendline('anonymous') child.expect('(?i)password') 
58
07 окт. atsakymas duotas athanassis 07 spalis. 2010-10-07 10:09 '10, 10:09, 2010-10-07 10:09

Jei reikia išvesties iš komandos, kurią skambinate, galite naudoti subprocess.check_output (Python 2. 7+).

 >>> subprocess.check_output(["ls", "-l", "/dev/null"]) 'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n' 

Taip pat atkreipkite dėmesį į korpuso parinktį.

Jei korpusas yra True , nurodyta komanda bus vykdoma per apvalkalą. Tai gali būti naudinga, jei naudojate „Python“ pirmiausia pažangiausiems valdymo srautams, kuriuos ji siūlo daugumai sistemos korpusų, ir vis tiek norite turėti patogią prieigą prie kitų apvalkalo funkcijų, pvz. plėtinys ~ naudotojų katalogui. Tačiau atkreipkite dėmesį, kad pats „Python“ siūlo daugelio „shell“ funkcijų įgyvendinimą (ypač „ glob , „ fnmatch , „ os.walk() , os.path.expandvars() , os.path.expanduser() ir „ shutil .

52
28 апр. „ Facundo Casco“ atsakymą pateikė balandžio 28 d 2011-04-28 23:29 '11, 11:29 PM 2011-04-28 23:29

Su standartine biblioteka

Modulio subproceso naudojimas (Python 3):

 import subprocess subprocess.run(['ls', '-l']) 

Tai yra rekomenduojamas standartinis metodas. Tačiau sudėtingesnės užduotys (vamzdžiai, išėjimai, įvestis ir kt.) Gali būti varginantys kurti ir rašyti.

Pastaba: Jei vis dar naudojate „Python 2“, subprocess.call veikia taip pat.

„ProTip“: „ shlex.split“ gali padėti jums išanalizuoti komandą, skirtą run , call ir kitoms subprocess funkcijoms, jei nenorite (ar negalite) pateikti juos sąrašuose:

 import shlex import subprocess subprocess.run(shlex.split('ls -l')) 

Su išorinėmis priklausomybėmis

Jei neprieštaraujate išorinėms priklausomybėms, naudokite plumbum :

 from plumbum.cmd import ifconfig print(ifconfig['wlan0']()) 

Tai geriausias subprocess apvalkalas. Tai yra kompleksinė platforma, ty ji veikia tiek su „Windows“, tiek su „Unix“ sistemomis. Įdiekite „ pip install plumbum .

Kita populiari biblioteka yra:

 from sh import ifconfig print(ifconfig('wlan0')) 

Nepaisant to, „ sh atsisakė palaikyti „Windows“, todėl jis nėra toks nuostabus kaip anksčiau. Įdiekite „ pip install sh .

48
11 апр. Atsakymą pateikė Honza Javorek balandžio 11 d 2013-04-11 20:17 '13, 08:17 pm 2013-04-11 20:17

Štai kaip aš paleisiu savo komandas. Šiame kode yra viskas, ko jums reikia.

 from subprocess import Popen, PIPE cmd = "ls -l ~/" p = Popen(cmd , shell=True, stdout=PIPE, stderr=PIPE) out, err = p.communicate() print "Return code: ", p.returncode print out.rstrip(), err.rstrip() 
44
28 окт. Atsakymą pateikė Usmanas Khanas spalio 28 d. 2012-10-28 08:14 '12 8:14 am 2012-10-28 08:14

Atnaujinti:

subprocess.run yra rekomenduojamas požiūris iš „Python 3.5“ , jei jūsų kodui nereikia išlaikyti suderinamumo su ankstesnėmis „Python“ versijomis. Jis yra nuoseklesnis ir siūlo panašų paprastumą naudoti kaip pasiuntinį. (Dujotiekis nėra toks paprastas, bet šį klausimą žiūrėkite kaip .)

Štai keletas dokumentų pavyzdžių.

Paleiskite procesą:

 >>> subprocess.run(["ls", "-l"]) # doesn't capture output CompletedProcess(args=['ls', '-l'], returncode=0) 

Pakelti nepavyko paleisti:

 >>> subprocess.run("exit 1", shell=True, check=True) Traceback (most recent call last): ... subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1 

Fotografavimo išėjimas:

 >>> subprocess.run(["ls", "-l", "/dev/null"], stdout=subprocess.PIPE) CompletedProcess(args=['ls', '-l', '/dev/null'], returncode=0, stdout=b'crw-rw-rw- 1 root root 1, 3 Jan 23 16:23 /dev/null\n') 

Originalus atsakymas:

Aš rekomenduoju bandyti pasiuntinį . Tai subproceso apvalkalas, kuris savo ruožtu bando pakeisti senesnius modulius ir funkcijas. Žiniasklaida yra žmonių procesas.

„Readme“ pavyzdys:

 >>> r = envoy.run('git config', data='data to pipe in', timeout=2) >>> r.status_code 129 >>> r.std_out 'usage: git config [options]' >>> r.std_err '' 

Atsparumas vamzdžiui:

 >>> r = envoy.run('uptime | pbcopy') >>> r.command 'pbcopy' >>> r.status_code 0 >>> r.history [<Response 'uptime'>] 
41
15 нояб. Atsakymą pateikė Joe lapkričio 15 d. 2012-11-15 20:13 '12 20:13 2012-11-15 20:13

Be išvesties:

 import os os.system("your command here") 

Išleidus rezultatą:

 import commands commands.getoutput("your command here") or commands.getstatusoutput("your command here") 
33
18 апр. Atsakymas, kurį pateikė Zuckonit balandžio 18 d 2013-04-18 04:09 '13, 4:09, 2013-04-18 04:09

https://docs.python.org/2/library/subprocess.html

... arba labai paprasta komanda:

 import os os.system('cat testfile') 
27
18 сент. Ben Hoffstein atsakymas rugsėjo 18 d 2008-09-18 04:43 '08 at 4:43 2008-09-18 04:43

os.system Gerai, bet atrodo datuota. Jis taip pat nėra labai saugus. Išbandykite subprocess . subprocess tiesiogiai neskambina sh ir yra saugesnis už os.system .

Čia rasite daugiau informacijos.

26
18 сент. Atsakymą pateikė Martin W 18 sep. 2008-09-18 04:53 '08 at 4:53 2008-09-18 04:53

Taip pat yra vandentiekis

 >>> from plumbum import local >>> ls = local["ls"] >>> ls LocalCommand(<LocalPath /bin/ls>) >>> ls() u'build.py\ndist\ndocs\nLICENSE\nplumbum\nREADME.rst\nsetup.py\ntests\ntodo.txt\n' >>> notepad = local["c:\\windows\\notepad.exe"] >>> notepad() # Notepad window pops up u'' # Notepad window is closed by user, command returns 
26
10 окт. atsakymas duotas stuckintheshuck 10 oct. 2014-10-10 20:41 '14 at 20:41 2014-10-10 20:41

Skambinkite išorine komanda pythone

Paprastas, naudokite subprocess.run , kuris grąžina CompletedProcess :

 >>> import subprocess >>> completed_process = subprocess.run('python --version') Python 3.6.1 :: Anaconda 4.4.0 (64-bit) >>> completed_process CompletedProcess(args='python --version', returncode=0) 

Kodėl

Kaip ir Python 3.5, dokumentuose rekomenduojama atlikti subprocess.run :

Rekomenduojamas būdas skambinti subprocesams yra paleisti () funkciją visais naudojimo atvejais, kuriuos jis gali apdoroti. Išsamesniam naudojimui Popen sąsaja gali būti naudojama tiesiogiai.

Čia pateikiamas paprasčiausio galimo naudojimo pavyzdys - ir jis taip pat klausia:

 >>> import subprocess >>> completed_process = subprocess.run('python --version') Python 3.6.1 :: Anaconda 4.4.0 (64-bit) >>> completed_process CompletedProcess(args='python --version', returncode=0) 

run laukia, kol komanda bus baigta, ir tada grąžina „ CompletedProcess objektą. Vietoj to jis gali pakelti „ TimeoutExpired (jei suteikiate jam argumentą timeout= ) arba CalledProcessError (jei jis nepavyksta ir check=True ).

Kaip jau galite padaryti, iš aukščiau pateikto pavyzdžio, stdout ir stderr yra neįvykdyti savo stdout ir stderr.

Galime patikrinti grąžintą objektą ir pamatyti nurodytą komandą bei grąžinimo kodą:

 >>> completed_process.args 'python --version' >>> completed_process.returncode 0 

Išvesties surinkimas

Jei norite užfiksuoti išvestį, galite perduoti subprocess.PIPE į tinkamą stderr arba stdout :

 >>> cp = subprocess.run('python --version', stderr=subprocess.PIPE, stdout=subprocess.PIPE) >>> cp.stderr b'Python 3.6.1 :: Anaconda 4.4.0 (64-bit)\r\n' >>> cp.stdout b'' 

(Manau, kad įdomu ir šiek tiek prieštaringa, kad versijos informacija patenka į stderr, o ne stdout.)

Pateikti komandų sąrašą

Galite lengvai persijungti iš rankinio komandų eilutės (pvz., Klausimo) pateikimo į programiškai sukurtą eilutę. Neprogramuokite eilutės programiškai. Tai yra galimas saugumo klausimas. Geriau manyti, kad nepasitikite įvesties duomenimis.

 >>> import textwrap >>> args = ['python', textwrap.__file__] >>> cp = subprocess.run(args, stdout=subprocess.PIPE) >>> cp.stdout b'Hello there.\r\n This is indented.\r\n' 

Atkreipkite dėmesį, kad pozicijos turi būti perduodamos tik args .

Visas parašas

Čia yra faktinis parašas šaltinyje ir kaip parodyta help(run) :

 def run(*popenargs, input=None, timeout=None, check=False, **kwargs): 

popenargs ir kwargs priskiriami Popen konstruktoriui. input gali būti baitų eilutė (arba Unicode, jei nurodote kodavimą arba universal_newlines=True ), kuri bus perduota stdin subprocesui.

Dokumentai aprašo timeout= ir check=True geriau nei galėčiau:

„Timeout“ argumentas perduodamas „Popen.communicate“ (). Pasibaigus terminui, vaiko procesas bus nužudytas ir laukiamas. Išimtis „TimeoutExpired“ bus iškelta po to, kai bus nutrauktas vaiko procesas.

Jei patikrinimas yra teisingas ir procesas baigiasi nuliniu išėjimo kodu, skambutis bus iškviestas. Šios išimties atributai apima argumentus, išėjimo kodą ir stdout ir stderr, jei jie yra užfiksuoti.

ir šis check=True pavyzdys check=True geresnis už tą, kurį galėčiau galvoti:

 >>> subprocess.run("exit 1", shell=True, check=True) Traceback (most recent call last): ... subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1 

Išplėstas parašas

Čia yra dokumentuose nurodytas išplėstinis parašas:

 subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, shell=False, cwd=None, timeout=None, check=False, encoding=None, errors=None) 

Atkreipkite dėmesį, kad tai reiškia, kad tik argumentų sąrašas turi būti perduotas poziciškai. Taigi, perduokite likusius argumentus kaip argumentus raktiniam žodžiui.

Popenas

Vietoj „ Popen ? Man būtų sunku rasti precedentą, pagrįstą tik argumentais. Vis dėlto Popen naudojant „ Popen galėsite pasiekti savo metodus, įskaitant poll , „send_signal“, „endate“ ir „wait“.

Čia parašas Popen , nurodytas šaltinyje . Manau, kad tai yra tiksliausias informacijos kapsuliavimas (priešingai nei „ help(Popen) ):

 def __init__(self, args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=_PLATFORM_DEFAULT_CLOSE_FDS, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0, restore_signals=True, start_new_session=False, pass_fds=(), *, encoding=None, errors=None): 

Tačiau Popen dokumentacija yra informatyvesnė:

 subprocess.Popen(args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=True, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0, restore_signals=True, start_new_session=False, pass_fds=(), *, encoding=None, errors=None) 

Pradėkite vaiko programą naujame procese. POSIX sistemoje klasė naudoja os.execvp () - panašų elgesį vykdant vaiko programą. „Windows“ klasėje naudojama „Windows CreateProcess“ () funkcija. Argumentai Popene:

Suprasdami likusius Popen dokumentus, skaitytojui bus paliktas pratimas.

24
18 окт. Atsakyti Aaron Hall 18 spalis. 2017-10-18 19:37 '17, 7:37 pm 2017-10-18 19:37

Naudoti:

 import os cmd = 'ls -al' os.system(cmd) 

os - šis modulis suteikia nešiojamą būdą naudoti operacinės sistemos funkcijas.

Для более os функций здесь является документация.

23
ответ дан Priyankara 29 июня '15 в 14:34 2015-06-29 14:34