python - كتابة - ملخص لغة بايثون




استدعاء أمر خارجي في بايثون (20)

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

بسيطة ، استخدم 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)

لماذا ا؟

اعتبارًا من Python 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 (إذا قمت TimeoutExpired timeout= argument) أو CalledProcessError (إذا فشلت وتمرير check=True ).

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

يمكننا فحص الكائن المرتجع ورؤية الأمر الذي تم إعطاؤه ورمز العودة:

>>> 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 فقط الموقف.

التوقيع الكامل

إليك التوقيع الفعلي في المصدر وكما هو موضح في help(run) :

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

يتم إعطاء popenargs و kwargs Popen . يمكن أن يكون input عبارة عن سلسلة من وحدات البايت (أو unicode ، في حالة تحديد الترميز أو universal_newlines=True ) التي سيتم توجيهها إلى stprocess stdin.

تصف الوثائق timeout= check=True أفضل من استطيع:

يتم تمرير الوسيطة timeout إلى Popen.communicate (). إذا انتهت المهلة ، سيتم قتل عملية الطفل وانتظر. سيتم re-raised الاستثناء TimeoutExpired بعد إنهاء عملية تابعة.

إذا كان التحقق صحيحًا ، وتخرج العملية باستخدام رمز إنهاء غير صفري ، فسيتم رفع استثناء CalledProcessError. تحتفظ سمات هذا الاستثناء بالوسائط وشفرة الإنهاء و stdout و 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)

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

Popen

عند استخدام Popen بدلا من ذلك؟ أجد صعوبة في إيجاد حالة استخدام استنادًا إلى الحجج وحدها. ومع ذلك ، يمنحك الاستخدام المباشر لـ Popen إمكانية الوصول إلى أساليبه ، بما في ذلك poll ، و "send_signal" ، و "الإنهاء" ، و "الانتظار".

إليك توقيع Popen كما هو 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 هي وثائق 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 ، تستخدم الفئة os.execvp () - سلوكًا شبيهًا لتنفيذ البرنامج الفرعي. في Windows ، يستخدم الفئة الدالة Windows CreateProcess (). الحجج ل Popen هي على النحو التالي.

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

كيف يمكنني الاتصال بأمر خارجي (كما لو كنت اكتبه في shell Unix أو موجه أوامر Windows) من خلال نص برمجي Python؟


تحديث:

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

إليك بعض الأمثلة من المستندات .

قم بتشغيل عملية:

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

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

أوصي المحاولة https://github.com/kennethreitz/envoy . وهو عبارة عن غلاف للمعالجة الثانوية ، والذي يهدف بدوره إلى استبدال الوحدات والوظائف القديمة. المبعوث هو عملية فرعية للبشر.

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

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

أستخدم دائمًا 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)

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

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


إذا كنت بحاجة إلى الإخراج من الأمر الذي تتصل به ، فيمكنك استخدام 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'

لاحظ أيضًا معلمة shell .

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


استعمال:

import os

cmd = 'ls -al'

os.system(cmd)

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

لمزيد من وظائف os ، here الوثائق.


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

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

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

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

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

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

المثال الكلاسيكي من مستندات وحدة المعالجة الفرعية هو:

import subprocess
import sys

# some code here

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

# some more code here

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

كان النظام الأساسي المستهدف هو freebsd ، ولكن كان التطوير على النوافذ ، لذلك واجهت المشكلة على النوافذ أولاً.

على النوافذ (win xp) ، لن تنتهي العملية الأصل حتى تنتهي longtask.py من عملها. ليس ما تريد في السيناريو CGI. المشكلة ليست خاصة بيثون ، في مجتمع PHP المشاكل هي نفسها.

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

DETACHED_PROCESS = 0x00000008

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

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

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

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

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


فيما يلي ملخص لطرق استدعاء البرامج الخارجية ومزايا وعيوب كل منها:

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

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

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

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

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

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

    بدلا من:

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

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

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

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

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

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

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

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

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

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

وتخيل أن المستخدم يدخل "ماما لم تحبني && rm -rf /".


هذه هي الطريقة التي أدير بها الأوامر. يحتوي هذا الرمز على كل ما تحتاج إليه كثيرًا

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

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

مصادر:

هذه كلها مكتبات:

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

فرعي أو جانبي

Subprocess يسمح لك باستدعاء الأوامر الخارجية وتوصيلها إلى أنابيب الإدخال / الإخراج / الخطأ (stdin و stdout و 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 في "وظيفة تعتمد على نظام التشغيل". ويمكن أيضا أن تستخدم لاستدعاء الأوامر الخارجية مع os.system و os.popen (ملاحظة: هناك أيضا subprocess.popen). سيعمل نظام التشغيل دائمًا مع shell وهو بديل بسيط للأشخاص الذين لا يحتاجون إلى ذلك ، أو لا يعرفون كيفية استخدام subprocess.run .

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

ش

sh هي واجهة معالجة فرعية تسمح لك باستدعاء البرامج كما لو كانت دالات. هذا مفيد إذا كنت تريد تشغيل أمر عدة مرات.

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 هي مكتبة لبرامج Python "مثل البرامج النصية". يمكنك استدعاء برامج مثل وظائف كما هو الحال في sh . Plumbum مفيد إذا كنت ترغب في تشغيل خط أنابيب دون قذيفة.

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

pexpect

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

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

قماش

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

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

مبعوث

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

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

الأوامر

تحتوي commands على وظائف المجمع لـ os.popen ، ولكنها تمت إزالتها من Python 3 نظرًا لأن os.popen هي بديل أفضل.

اعتمد التعديل على تعليق JF Sebastian.


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

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

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

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


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


هناك اختلاف آخر هنا لم يرد ذكره من قبل.

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

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

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

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

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


يمكنك استخدام Popen ، ومن ثم يمكنك التحقق من حالة الإجراء:

from subprocess import Popen

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

تحقق من subprocess.Popen .


أنا أميل إلى استخدام فرعي أو جانبي مع 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)

ضمن Linux ، في حالة رغبتك في استدعاء أمر خارجي سيتم تنفيذه بشكل مستقل (سيبقى قيد التشغيل بعد إنهاء البرنامج النصي python) ، يمكنك استخدام قائمة انتظار بسيطة كمخزن مؤقت للمهام أو الأمر at

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

#!/usr/bin/python
import os
netid= "nova net-list | awk '/ External / { print $2 }'"
temp=os.popen(netid).read()  /* here temp also contains new line (\n) */
networkId=temp.rstrip()
print(networkId)

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

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

    ts -S <number-of-slots>

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


قابس خزي ، كتبت مكتبة لهذا: P https://github.com/houqp/shell.py

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

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

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

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





external