استدعاء الأوامر الخارجية في بايثون

StackOverflow https://stackoverflow.com/questions/89228

سؤال

كيف يمكنني استدعاء الأوامر الخارجية (كما لو كنت كتبته في غلاف Unix أو Windows موجه الأوامر) من داخل Python السيناريو ؟

هل كانت مفيدة؟

المحلول

نظرة على subprocess وحدة في المكتبة القياسية:

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

ميزة subprocess مقابل نظام هو أكثر مرونة (يمكنك الحصول على المعياري ، stderr, "الحقيقي" قانون الأحوال أفضل معالجة الأخطاء ، الخ...).

على الوثائق الرسمية توصي subprocess وحدة على بديل نظام التشغيل.نظام():

على subprocess وتوفر وحدة أقوى مرافق التفريخ عمليات جديدة واسترجاع نتائجها ؛ باستخدام هذه الوحدة هي الأفضل استخدام هذه الوظيفة [os.system()].

إن "استبدال القديمة الوظائف مع subprocess وحدة"في قسم subprocess الوثائق قد يكون لها بعض وصفات مفيدة.

الإصدارات القديمة من بيثون استخدام المكالمات:

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

نصائح أخرى

هنا ملخص طرق الاتصال الخارجي البرامج و مزايا و عيوب كل منها:

  1. os.system("some_command with args") يمر الأمر والحجج إلى النظام الخاص بك قذيفة.هذا هو لطيف لأنه في الواقع يمكنك تشغيل أوامر متعددة في آن واحد في هذه الطريقة وانشاء أنابيب الإدخال/الإخراج إعادة التوجيه.على سبيل المثال: 

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

    ومع ذلك ، في حين أن هذا هو مريحة ، يجب عليك يدويا التعامل مع الهروب من قذيفة الشخصيات مثل المسافات.... الخمن ناحية أخرى ، وهذا أيضا يتيح لك تشغيل الأوامر التي هي ببساطة الأوامر قذيفة ولا فعلا برامج خارجية.انظر الوثائق.

  2. stream = os.popen("some_command with args") وسوف نفعل نفس الشيء os.system إلا أنه يعطي لك ملف مثل الكائنات التي يمكنك استخدامها للوصول إلى مستوى الإدخال/الإخراج لهذه العملية.هناك 3 أنواع أخرى من popen أن كل معالجة i/o بشكل مختلف قليلا.إذا كنت تمر كل شيء كسلسلة ، ثم أمر يتم تمريرها إلى شل ؛ إذا كنت تمر لهم قائمة بعد ذلك كنت لا داعي للقلق حول الهروب من أي شيء.انظر الوثائق.

  3. على Popen فئة من subprocess وحدة نمطية.هذا هو المقصود كبديل os.popen ولكن الجانب السلبي من يجري قليلا أكثر تعقيدا بحكم كوني شامل.على سبيل المثال, كنت أقول:

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

    بدلا من: 

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

    ولكن من الجميل أن يكون لديك كل الخيارات هناك في واحد موحد الصف بدلا من 4 مختلفة popen وظائف.انظر الوثائق.

  4. على call وظيفة من subprocess وحدة نمطية.هذا هو أساسا مجرد مثل Popen فئة ويأخذ كل نفس الحجج ، لكنه ببساطة ينتظر حتى اكتمال الأمر و يعطيك رمز الإرجاع.على سبيل المثال:

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

    انظر الوثائق.

  5. إذا كنت على الثعبان 3.5 أو في وقت لاحق, يمكنك استخدام جديدة subprocess.run وظيفة وهو كثير مثل ما ورد أعلاه ولكن حتى أكثر مرونة و ترجع CompletedProcess الكائن عند انتهاء تنفيذ الأوامر.

  6. نظام التشغيل وحدة لديها أيضا كل من شوكة/exec/تفرخ الوظائف التي سيكون لديك في برنامج C, ولكن أنا لا أنصح باستخدام لهم مباشرة.

على subprocess وحدة ربما ينبغي أن يكون ما كنت تستخدم.

أخيرا يرجى أن يكون على علم أن جميع طرق حيث يمكنك تمرير النهائي الأوامر ليتم تنفيذها من قبل قذيفة كسلسلة و أنت مسؤول عن مفر من ذلك. هناك آثار أمنية خطيرة إذا كان أي جزء من السلسلة التي تمر لا يمكن أن يكون موثوق به ثقة كاملة.على سبيل المثال إذا كان المستخدم هو إدخال بعض/أي جزء من السلسلة.إذا كنت غير متأكد, فقط استخدام هذه الأساليب مع الثوابت.تعطيك تلميحا من آثار النظر في هذا الكود:

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

و تخيل أن المستخدم يدخل شيئا "أمي لم تحبني && rm-rf /" الذي يمكن أن يمحو الملفات بأكمله.

أنا عادة استخدام:

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()

أنت حر في أن تفعل ما تريد مع stdout البيانات في الأنابيب.في الواقع, يمكنك ببساطة حذف هذه المعلمات (stdout= و stderr=) وانها سوف تتصرف مثل os.system().

بعض التلميحات على فصل عملية طفل من استدعاء واحد (بدءا من عملية طفل في الخلفية).

افترض أنك تريد أن تبدأ مهمة طويلة من CGI-script, هذا هو عملية طفل أن يعيش أطول من CGI-script تنفيذ العملية.

والمثال الكلاسيكي من subprocess وحدة المستندات هي:

import subprocess
import sys

# some code here

pid = subprocess.Popen([sys.executable, "longtask.py"]) # call subprocess

# some more code here

الفكرة هنا هو أن كنت لا تريد الانتظار في خط الاتصال subprocess' حتى longtask.py انتهى....ولكن ليس من الواضح ما الذي سيحدث بعد الخط 'المزيد من هنا كود' من المثال.

هدفي منصة فري ، ولكن التنمية على النوافذ حتى أنا واجهت هذه المشكلة على ويندوز الأولى.

على ويندوز (win xp) الوالد العملية لن تنتهي حتى longtask.py قد انتهت من عملها.ليس ما تريد في CGI-script.المشكلة ليست محددة Python, PHP المجتمع المشاكل هي نفسها.

الحل هو تمرير DETACHED_PROCESS عملية إنشاء العلم الأساسية الدالة CreateProcess في win API.إذا كنت يحدث أن يكون مثبتا pywin32 يمكنك استيراد العلم من win32process الوحدة, وإلا يجب أن تحدد بنفسك:

DETACHED_PROCESS = 0x00000008

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

/* محدث 2015.10.27 @eryksun في التعليق أدناه الملاحظات التي لغويا العلم الصحيح هو CREATE_NEW_CONSOLE (0x00000010) */

على فري لدينا مشكلة أخرى:عند الوالد يتم الانتهاء من عملية, ينتهي الطفل من عمليات.و هذا ليس ما تريد في CGI-script سواء.بعض التجارب أظهرت أن المشكلة تبدو في تقاسم sys.stdout.و العمل الحل هو التالي:

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

أنا لم دققت رمز على منصات أخرى و لا معرفة أسباب السلوك فري.إذا كان أي شخص يعرف, يرجى حصة أفكارك.غوغلينغ على خلفية انطلاق العمليات في بيثون لا يلقي أي ضوء حتى الآن.

أنصح باستخدام subprocess وحدة بدلا من نظام التشغيل.نظام لأنه لا شل الهروب بالنسبة لك وبالتالي أكثر أمانا: http://docs.python.org/library/subprocess.html

subprocess.call(['ping', 'localhost'])

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

إذا كنت ترغب في العودة نتائج الأمر ، يمكنك استخدام os.popen.ومع ذلك, هذا هو مستنكر منذ الإصدار 2.6 في صالح subprocess وحدة, الذي إجابات أخرى مغطاة جيدا.

import os
os.system("your command")

لاحظ أن هذا أمر خطير لأن الأمر ليس تنظيفها.أترك لك جوجل عن الوثائق ذات الصلة على نظام التشغيل " و "sys' وحدات.هناك مجموعة من المهام (exec* و تفرخ*) من شأنها أن تفعل أشياء مماثلة.

هناك الكثير من المكتبات المختلفة التي تسمح لك لاستدعاء الأوامر الخارجية مع بيثون.لكل مكتبة لقد أعطيت وصف يظهر مثال على استدعاء الأوامر الخارجية.الأمر كنت تستخدم المثال هو ls -l (قائمة بجميع الملفات).إذا كنت ترغب في معرفة المزيد عن أي من المكتبات لقد سرد ربط الوثائق لكل منهم.

المصادر:

هذه هي جميع المكتبات:

نأمل أن هذا سوف تساعدك على اتخاذ قرار بشأن أي مكتبة الاستخدام :)

subprocess

Subprocess يسمح لك استدعاء الأوامر الخارجية وربطها الإدخال/الإخراج/خطأ الأنابيب (stdin ، المعياري ، stderr).Subprocess هو الخيار الافتراضي لتشغيل الأوامر, ولكن في بعض الأحيان وحدات أخرى أفضل.

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.system و os.popen (ملاحظة:وهناك أيضا subprocess.popen).نظام التشغيل تشغيل دائما قذيفة و هو بسيط بديل للأشخاص الذين لا يحتاجون أو لا يعرفون كيفية استخدام subprocess.run.

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

sh

sh هو subprocess واجهة التي تمكنك من الاتصال البرامج كما لو كانوا وظائف.وهذا مفيد إذا كنت ترغب في تشغيل الأمر عدة مرات.

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

plumbum

plumbum هو مكتبة "النصي مثل" برامج بيثون.يمكنك الاتصال برامج مثل وظائف في sh.Plumbum مفيد إذا كنت ترغب في تشغيل خط أنابيب دون قذيفة.

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

pexpect

pexpect يتيح لك تفرخ الطفل التطبيقات السيطرة عليها و إيجاد أنماط في الإخراج.هذا هو أفضل بديل subprocess عن الأوامر التي نتوقع tty على Unix.

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')

النسيج

النسيج هو بايثون 2.5 و 2.7 المكتبة.فإنه يسمح لك لتنفيذ المحلية والبعيدة الأوامر قذيفة.النسيج هو بسيط البديلة لتشغيل الأوامر في الصدفة الآمن (SSH)

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

المبعوث

المبعوث يعرف باسم "subprocess للبشر".يتم استخدامه بمثابة الراحة التفاف حول subprocess وحدة نمطية.

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

الأوامر

commands يحتوي المجمع وظائف os.popen, ولكن تم إزالتها من بيثون 3 منذ subprocess هو أفضل بديل.

تحرير يستند إلى J. F.سيباستيان التعليق.

أنا دائما استخدام fabric هذه الأشياء مثل:

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

ولكن هذا يبدو أن يكون وسيلة جيدة: sh (الثعبان subprocess واجهة).

انظر على سبيل المثال:

from sh import vgdisplay
print vgdisplay()
print vgdisplay('-v')
print vgdisplay(v=True)

التحقق من "pexpect" بيثون المكتبة أيضا.

فإنه يسمح التفاعلية السيطرة على البرامج الخارجية/الأوامر حتى ssh, ftp, telnet, الخ.يمكنك فقط اكتب شيئا مثل:

child = pexpect.spawn('ftp 192.168.0.24')

child.expect('(?i)name .*: ')

child.sendline('anonymous')

child.expect('(?i)password')

إذا كنت في حاجة إلى الإخراج من الأمر تدعو إليه ، ثم يمكنك استخدام subprocess.check_output (بايثون 2.7+).

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

نلاحظ أيضا شل معلمة.

إذا قذيفة True, المحدد الأوامر سيتم تنفيذها من خلال قذيفة.هذا يمكن أن يكون مفيدا إذا كنت تستخدم بايثون في المقام الأول على تعزيز التحكم في التدفق ويحتوي على معظم نظام والقذائف لا تزال ترغب سهولة الوصول إلى قذيفة أخرى ميزات مثل شل أنابيب اسم الملف البدل ، متغير البيئة التوسع والتوسع ~ إلى الدليل الرئيسي للمستخدم.لاحظ أن الثعبان نفسه يوفر تطبيقات عديدة مثل شل الميزات (على وجه الخصوص ، glob, fnmatch, os.walk(), os.path.expandvars(), os.path.expanduser(), ، shutil).

مع المكتبة القياسية

على استخدام subprocess وحدة (بيثون 3):

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

فمن المستحسن طريقة قياسية.ولكن أكثر تعقيدا المهام (الأنابيب الإخراج أو الإدخال.... الخ) يمكن أن تكون شاقة لبناء والكتابة.

ملاحظة على الثعبان الإصدار:إذا كنت لا تزال تستخدم بايثون 2, subprocess.الاتصال يعمل بطريقة مماثلة.

بروتيب: shlex.تقسيم يمكن أن تساعدك على تحليل الأمر run, call, وغيرها subprocess وظائف في حال كنت لا تريد (أو لا!) تقدم لهم في شكل قوائم:

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

مع الاعتماد على الخارج

إذا كنت لا تمانع في تبعيات خارجية ، استخدام plumbum:

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

هو أفضل subprocess المجمع.هو عبر منصة ، أييعمل على كل من ويندوز يونكس مثل أنظمة.تثبيت عن طريق pip install plumbum.

آخر شعبية المكتبة sh:

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

ومع ذلك ، sh انخفض دعم Windows, حتى انها ليست رهيبة كما كانت عليه من قبل.تثبيت عن طريق pip install sh.

هذا هو كيف يمكنني تشغيل الأوامر.هذا الرمز يحتوي على كل ما تحتاجه تقريبا

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()

تحديث:

subprocess.run هو النهج الموصى به كما الثعبان 3.5 إذا التعليمات البرمجية الخاصة بك لا تحتاج إلى الحفاظ على التوافق مع في وقت سابق من إصدارات بيثون.انها أكثر اتساقا عروض مماثلة سهولة الاستخدام كما المبعوث.(الأنابيب ليست واضحة على الرغم من.انظر هذا السؤال كيف.)

وهنا بعض الأمثلة من مستندات.

تشغيل عملية:

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

زيادة على فشل تشغيل:

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

التقاط الإخراج:

>>> 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')

الجواب الأصلية:

أوصي تحاول المبعوث.هذا المجمع subprocess ، والذي بدوره يهدف إلى استبدال أقدم وحدات وظائف.مبعوث subprocess للبشر.

مثال الاستخدام من التمهيدي:

>>> 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
''

الأنابيب الأمور أيضا:

>>> r = envoy.run('uptime | pbcopy')

>>> r.command
'pbcopy'
>>> r.status_code
0

>>> r.history
[<Response 'uptime'>]

دون إخراج النتيجة:

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

مع إخراج النتيجة:

import commands
commands.getoutput("your command here")
or
commands.getstatusoutput("your command here")

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

...أو بسيط جدا الأمر:

import os
os.system('cat testfile')

هناك أيضا Plumbum

>>> 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

os.system هو موافق ، ولكن نوع من مؤرخة.كما أنها ليست آمنة جدا.بدلا من ذلك, حاول subprocess. subprocess لا يدعو sh مباشرة وبالتالي فهو أكثر أمنا من os.system.

الحصول على مزيد من المعلومات هنا.

استدعاء الأوامر الخارجية في بايثون

بسيطة الاستخدام subprocess.run, والتي ترجع 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)

لماذا ؟

كما الثعبان 3.5 الوثائق توصي subprocess.تشغيل:

النهج الموصى به إلى الاحتجاج فرعية هي استخدام الدالة run() لاستخدام كافة الحالات التي يمكن التعامل معها.لمزيد من حالات الاستخدام الأساسي Popen واجهة يمكن استخدامها مباشرة.

هنا مثال من أبسط ممكن الاستخدام و يفعل بالضبط كما طلبت:

>>> 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 ينتظر الأوامر بنجاح النهاية ، ثم ترجع CompletedProcess الكائن.أنه بدلا من ذلك قد رفع TimeoutExpired (إذا كنت تعطيه timeout= حجة) أو CalledProcessError (إذا كان فشل تمرير check=True).

كما قد نستنتج من المثال أعلاه ، المعياري و stderr على حد سواء الحصول على الأنابيب الخاصة بك المعياري و stderr بشكل افتراضي.

ونحن يمكن أن تفقد عاد موضوع رؤية الأوامر التي أعطيت و returncode:

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

التقاط الإخراج

إذا كنت ترغب في التقاط الإخراج ، يمكنك تمرير subprocess.PIPE المناسبة stderr أو 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''

(أجد أنه من المثير للاهتمام قليلا متوقع أن معلومات النسخة يحصل على وضع إلى stderr بدلا من stdout.)

تمرير قائمة الأوامر

يمكن للمرء بسهولة الانتقال من يدويا توفير سلسلة الأوامر (مثل السؤال يوحي) إلى توفير سلسلة بنيت برمجيا. لا بناء سلاسل برمجيا. هذا هو مشكلة أمنية محتملة.أنه من الأفضل أن نفترض أن كنت لا تثق الإدخال. 

>>> 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'

ملاحظة فقط args ينبغي أن تنتقل positionally.

توقيع كامل

هنا التوقيع الفعلي في المصدر كما هو مبين من قبل help(run):

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

على popenargs و kwargs تعطى Popen منشئ. input يمكن أن تكون سلسلة من البايتات (أو يونيكود ، إن تحديد ترميز أو universal_newlines=True) التي سيتم ضخها إلى subprocess ستدين.

وثائق توضح timeout= و check=True أفضل مما يمكن أن:

مهلة الحجة يتم تمريرها إلى Popen.التواصل().إذا المهلة تنتهي عملية طفل سيتم قتل وانتظر.على TimeoutExpired استثناء سيتم إعادة رفع بعد عملية طفل لديه إنهاء.

إذا كان الاختيار صحيحا ، و إنهاء العملية مع غير الصفر الخروج على القانون ، CalledProcessError استثناء سيتم رفع.الصفات التي استثناء عقد الحجج, كود الخروج ، المعياري و stderr إذا تم القبض عليهم.

و هذا مثال check=True هو أفضل من واحد أنا يمكن أن تأتي مع:

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

توسيع التوقيع

وهنا موسعة التوقيع ، على النحو الوارد في الوثائق:

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

علما أن هذا يشير إلى أن وسائط القائمة يجب أن تكون مرت positionally.حتى تمر المتبقية الحجج الكلمة الحجج.

Popen

عند استخدام Popen بدلا من ذلك ؟ أود أن النضال من أجل العثور على استخدام القضية استنادا إلى الحجج وحدها.الاستخدام المباشر من Popen بيد أن تعطيك الوصول إلى الطرق ، بما في ذلك poll, 'send_signal', 'إنهاء', 'الانتظار'.

هنا Popen التوقيع كما هو محدد في المصدر.أعتقد أن هذا هو الأكثر دقة التغليف المعلومات (بدلا من 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):

ولكن أكثر إفادة هو على Popen الوثائق:

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)

تنفيذ برنامج الطفل في عملية جديدة.على POSIX, يستخدم الفئة نظام التشغيل.execvp () مثل السلوك لتنفيذ برنامج الطفل.على ويندوز ، الطبقة يستخدم ويندوز CreateProcess() وظيفة.الحجج Popen هي على النحو التالي.

فهم الوثائق المتبقية على Popen سيتم ترك ممارسة للقارئ.

استخدام:

import os

cmd = 'ls -al'

os.system(cmd)

os - توفر هذه الوحدة المحمولة طريقة استخدام نظام التشغيل التي تعتمد على وظيفة.

أكثر os وظائف ، هنا هي الوثائق.

يمكن أن يكون هذا بسيط:

import os
cmd = "your command"
os.system(cmd)

استخدام نظام التشغيل وحدة

import os
os.system("your command")

على سبيل المثال

import os
os.system("ifconfig")

subprocess.check_call مريحة إذا كنت لا ترغب في اختبار العودة القيم.فإنه يلقي استثناء على أي خطأ.

أنا أميل إلى استخدام subprocess جنبا إلى جنب مع shlex (التعامل مع الهروب من السلاسل بين علامات الاقتباس):

>>> import subprocess, shlex
>>> command = 'ls -l "/your/path/with spaces/"'
>>> call_params = shlex.split(command)
>>> print call_params
["ls", "-l", "/your/path/with spaces/"]
>>> subprocess.call(call_params)

هناك فرق آخر هنا غير المذكورة سابقا.

subprocess.Popen ينفذ <command> كما subprocess.في حالتي, أنا بحاجة إلى تنفيذ الملف <a> الذي يحتاج إلى التواصل مع برنامج آخر <b>.

حاولت subprocess و التنفيذ الناجح.ومع ذلك <b> لا يمكن التواصل مع <a>.كل شيء طبيعي عند تشغيل كلا من المحطة.

أكثر واحد:(ملاحظة:kwrite يتصرف مختلفة من التطبيقات الأخرى.إذا كنت في محاولة أدناه مع فايرفوكس ، فإن النتائج لن تكون هي نفسها.)

إذا كنت في محاولة os.system("kwrite"), برنامج تدفق يتجمد حتى إغلاق المستخدم kwrite.للتغلب على أن حاولت بدلا من ذلك os.system(konsole -e kwrite).هذا البرنامج في الوقت استمرت في التدفق ، ولكن kwrite أصبح subprocess من وحدة التحكم.

أي شخص يدير kwrite لا يجري subprocess (أيفي "مراقب النظام" يجب أن تظهر في أقصى اليسار حافة شجرة).

os.system لا يسمح لك لتخزين النتائج ، لذلك إذا كنت ترغب في تخزين النتائج في قائمة أو شيء subprocess.call يعمل.

أنا تماما مثل shell_command لبساطته.انها بنيت على أعلى من subprocess وحدة.

هنا مثال من مستندات:

>>> from shell_command import shell_call
>>> shell_call("ls *.py")
setup.py  shell_command.py  test_shell_command.py
0
>>> shell_call("ls -l *.py")
-rw-r--r-- 1 ncoghlan ncoghlan  391 2011-12-11 12:07 setup.py
-rw-r--r-- 1 ncoghlan ncoghlan 7855 2011-12-11 16:16 shell_command.py
-rwxr-xr-x 1 ncoghlan ncoghlan 8463 2011-12-11 16:17 test_shell_command.py
0

المكونات وقح, كتبت في مكتبة هذا :P https://github.com/houqp/shell.py

انها في الأساس المجمع popen و shlex الآن.كما أنها تدعم الأنابيب الأوامر حتى تتمكن من سلسلة الأوامر أسهل في بيثون.لذلك يمكنك أن تفعل أشياء مثل:

ex('echo hello shell.py') | "awk '{print $2}'"

تحت لينكس, في حال كنت ترغب في استدعاء الأوامر الخارجية التي ستنفذ بشكل مستقل (سوف تبقى تعمل بعد بيثون السيناريو إنهاء), يمكنك استخدام بسيط الانتظار كما مهمة التخزين المؤقت أو في الأمر

على سبيل المثال مع مهمة التخزين المؤقت:

import os
os.system('ts <your-command>')

ملاحظات حول مهمة التخزين المؤقت (ts):

  1. يمكنك تعيين عدد من العمليات المتزامنة إلى تشغيل ("فتحات") مع:

    ts -S <number-of-slots>

  2. تثبيت ts لا تتطلب امتيازات المسؤول.يمكنك تحميل وتجميع من المصدر مع بسيطة make, إضافة إلى المسار والانتهاء من ذلك.

يمكنك استخدام Popen, ثم يمكنك التحقق من وضع هذا الإجراء:

from subprocess import Popen

proc = Popen(['ls', '-l'])
if proc.poll() is None:
    proc.kill()

تحقق من subprocess.Popen.

مرخصة بموجب: CC-BY-SA مع الإسناد
لا تنتمي إلى StackOverflow
scroll top