การรันคำสั่งเชลล์และการดักจับเอาต์พุต

ฉันต้องการเขียนฟังก์ชั่นที่จะรันคำสั่งเชลล์และส่งคืนเอาต์พุตเป็นสตริงไม่ว่าจะเป็นข้อผิดพลาดหรือข้อความแจ้งความสำเร็จ ฉันแค่อยากได้ผลลัพธ์แบบเดียวกับที่ฉันได้รับจากบรรทัดคำสั่ง

อะไรคือตัวอย่างโค้ดที่จะทำสิ่งนั้น?

ตัวอย่างเช่น:

def run_command(cmd):
    # ??????

print run_command('mysqladmin create test -uroot -pmysqladmin12')
# Should output something like:
# mysqladmin: CREATE DATABASE failed; error: 'Can't create database 'test'; database exists'

คำตอบสำหรับคำถามนี้ขึ้นอยู่กับเวอร์ชันของ Python ที่คุณใช้ วิธีที่ง่ายที่สุดคือการใช้subprocess.check_outputฟังก์ชั่น:

>>> subprocess.check_output(['ls', '-l'])
b'total 0\n-rw-r--r--  1 memyself  staff  0 Mar 14 11:04 files\n'

check_outputรันโปรแกรมเดียวที่รับอาร์กิวเมนต์เป็นอินพุตเท่านั้น ¹stdoutก็จะส่งกลับผลตรงตามที่พิมพ์ไป หากคุณต้องการเขียนอินพุตให้stdinข้ามไปข้างหน้าrunหรือPopenส่วนต่างๆ หากคุณต้องการรันคำสั่งเชลล์ที่ซับซ้อนดูบันทึกย่อshell=Trueที่ท้ายคำตอบนี้

check_outputฟังก์ชั่นนี้ใช้งานได้กับ Python เกือบทุกรุ่นที่ยังใช้งานอยู่ (2.7+) ²แต่สำหรับเวอร์ชั่นล่าสุดมันไม่ได้เป็นแนวทางที่แนะนำอีกต่อไป

Python เวอร์ชันใหม่ (3.5 หรือสูงกว่า): run

หากคุณกำลังใช้งูหลาม 3.5หรือสูงกว่าและไม่จำเป็นต้องทำงานร่วมกันหลังที่ใหม่runฟังก์ชั่นขอแนะนำ มันให้ API ระดับสูงทั่วไปมากสำหรับsubprocessโมดูล ในการดักจับเอาต์พุตของโปรแกรมให้ส่งsubprocess.PIPEค่าสถานะไปยังstdoutอาร์กิวเมนต์คีย์เวิร์ด จากนั้นเข้าถึงstdoutแอตทริบิวต์ของCompletedProcessวัตถุที่ส่งคืน:

>>> import subprocess
>>> result = subprocess.run(['ls', '-l'], stdout=subprocess.PIPE)
>>> result.stdout
b'total 0\n-rw-r--r--  1 memyself  staff  0 Mar 14 11:04 files\n'

ค่าส่งคืนเป็นbytesวัตถุดังนั้นหากคุณต้องการสตริงที่เหมาะสมคุณจะต้องใช้decodeมัน สมมติว่ากระบวนการที่เรียกคืนสตริงที่เข้ารหัส UTF-8:

>>> result.stdout.decode('utf-8')
'total 0\n-rw-r--r--  1 memyself  staff  0 Mar 14 11:04 files\n'

ทั้งหมดนี้สามารถบีบอัดให้เป็นหนึ่งซับ:

>>> subprocess.run(['ls', '-l'], stdout=subprocess.PIPE).stdout.decode('utf-8')
'total 0\n-rw-r--r--  1 memyself  staff  0 Mar 14 11:04 files\n'

หากคุณต้องการส่งผ่านข้อมูลไปยังกระบวนการstdinให้ส่งbytesวัตถุไปยังinputอาร์กิวเมนต์คำหลัก:

>>> cmd = ['awk', 'length($0) > 5']
>>> input = 'foo\nfoofoo\n'.encode('utf-8')
>>> result = subprocess.run(cmd, stdout=subprocess.PIPE, input=input)
>>> result.stdout.decode('utf-8')
'foofoo\n'

คุณสามารถดักจับข้อผิดพลาดโดยผ่านstderr=subprocess.PIPE(capture to result.stderr) หรือstderr=subprocess.STDOUT(capture ไปยังresult.stdoutพร้อมกับเอาต์พุตปกติ) เมื่อความปลอดภัยไม่ได้เป็นกังวลคุณยังสามารถเรียกใช้คำสั่งเชลล์ที่ซับซ้อนมากขึ้นโดยส่งผ่านshell=Trueตามที่อธิบายไว้ในหมายเหตุด้านล่าง

สิ่งนี้เพิ่มความซับซ้อนเพียงเล็กน้อยเมื่อเทียบกับวิธีการทำสิ่งเก่า แต่ฉันคิดว่ามันคุ้มค่ากับการจ่ายเงิน: ตอนนี้คุณสามารถทำอะไรก็ได้ที่คุณต้องทำกับrunฟังก์ชั่นเพียงอย่างเดียว

Python เวอร์ชันเก่ากว่า (2.7-3.4): check_output

หากคุณใช้ Python เวอร์ชั่นเก่ากว่าหรือต้องการความเข้ากันได้แบบย้อนหลังคุณอาจใช้check_outputฟังก์ชั่นตามที่อธิบายไว้ข้างต้นโดยย่อ สามารถใช้งานได้ตั้งแต่ Python 2.7

subprocess.check_output(*popenargs, **kwargs)  

มันจะใช้เวลาขัดแย้งกันเป็นPopen(ดูด้านล่าง) และส่งกลับสตริงที่มีผลลัพธ์ของโปรแกรม จุดเริ่มต้นของคำตอบนี้มีตัวอย่างการใช้ที่ละเอียดยิ่งขึ้น ใน Python 3.5 และสูงกว่าcheck_outputเทียบเท่ากับการดำเนินการrunกับcheck=Trueและstdout=PIPEและส่งคืนเฉพาะแอstdoutททริบิวต์

คุณสามารถส่งผ่านstderr=subprocess.STDOUTเพื่อให้มั่นใจว่าข้อความผิดพลาดที่จะถูกรวมในการส่งออกกลับ - แต่ในบางรุ่นของงูใหญ่ผ่านstderr=subprocess.PIPEไปcheck_outputอาจทำให้เกิดการติดตาย เมื่อความปลอดภัยไม่ได้เป็นกังวลคุณยังสามารถเรียกใช้คำสั่งเชลล์ที่ซับซ้อนมากขึ้นโดยส่งผ่านshell=Trueตามที่อธิบายไว้ในหมายเหตุด้านล่าง

หากคุณต้องการไพพ์จากstderrหรือส่งผ่านอินพุตไปยังกระบวนการcheck_outputจะไม่ขึ้นอยู่กับภารกิจ ดูPopenตัวอย่างด้านล่างในกรณีนั้น

แอปพลิเคชั่นที่ซับซ้อน & Python เวอร์ชั่นดั้งเดิม (2.6 และต่ำกว่า): Popen

หากคุณต้องการความเข้ากันได้อย่างลึกล้ำหรือหากคุณต้องการฟังก์ชั่นที่ซับซ้อนมากกว่าที่check_outputมีให้คุณจะต้องทำงานกับPopenวัตถุโดยตรงซึ่งจะห่อหุ้ม API ระดับต่ำสำหรับกระบวนการย่อย

คอนPopenสตรัคยอมรับทั้งคำสั่งเดียวโดยไม่มีข้อโต้แย้งหรือรายการที่มีคำสั่งเป็นรายการแรกตามด้วยจำนวนอาร์กิวเมนต์ใด ๆ แต่ละรายการเป็นรายการแยกต่างหากในรายการ shlex.splitสามารถช่วยวิเคราะห์สตริงในรายการที่จัดรูปแบบอย่างเหมาะสม Popenออบเจ็กต์ยังยอมรับโฮสต์ของอาร์กิวเมนต์ที่แตกต่างกันสำหรับการจัดการกระบวนการ IO และการกำหนดค่าระดับต่ำ

ในการส่งอินพุตและเอาต์พุตจับภาพcommunicateเป็นวิธีที่ต้องการเกือบทุกครั้ง ในขณะที่:

output = subprocess.Popen(["mycmd", "myarg"], 
                          stdout=subprocess.PIPE).communicate()[0]

หรือ

>>> import subprocess
>>> p = subprocess.Popen(['ls', '-a'], stdout=subprocess.PIPE, 
...                                    stderr=subprocess.PIPE)
>>> out, err = p.communicate()
>>> print out
.
..
foo

ถ้าคุณตั้งค่าstdin=PIPE, communicateนอกจากนี้ยังช่วยให้คุณสามารถส่งผ่านข้อมูลในการประมวลผลผ่านstdin:

>>> cmd = ['awk', 'length($0) > 5']
>>> p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
...                           stderr=subprocess.PIPE,
...                           stdin=subprocess.PIPE)
>>> out, err = p.communicate('foo\nfoofoo\n')
>>> print out
foofoo

หมายเหตุคำตอบแอรอนฮอลล์ซึ่งแสดงให้เห็นว่าในบางระบบคุณอาจจำเป็นต้องชุดstdout, stderrและstdinทุกคนที่จะPIPE(หรือDEVNULL) ที่จะได้รับcommunicateในการทำงานที่ทุกคน

ในบางกรณีที่หายากคุณอาจต้องใช้การจับภาพเอาต์พุตแบบเรียลไทม์ที่ซับซ้อน คำตอบของVartecแนะนำวิธีไปข้างหน้า แต่วิธีการอื่นนอกจากcommunicateมีแนวโน้มที่จะหยุดชะงักหากไม่ได้ใช้อย่างระมัดระวัง

shell=Trueเช่นเดียวกับทุกฟังก์ชั่นดังกล่าวข้างต้นเมื่อการรักษาความปลอดภัยไม่กังวลคุณสามารถเรียกใช้คำสั่งเชลล์ที่ซับซ้อนมากขึ้นโดยผ่าน

หมายเหตุ

1. การรันคำสั่งเชลล์: shell=Trueอาร์กิวเมนต์

โดยปกติแต่ละการเรียกไปrun, check_outputหรือPopenคอนสตรัรันโปรแกรมเดียว นั่นหมายความว่าไม่มีท่อทุบตีสไตล์แฟนซี หากคุณต้องการรันคำสั่งเชลล์ที่ซับซ้อนคุณสามารถส่งผ่านshell=Trueซึ่งทั้งสามฟังก์ชั่นสนับสนุน

แต่การทำเช่นนั้นทำให้เกิดความกังวลด้านความปลอดภัย หากคุณกำลังทำอะไรมากกว่าสคริปต์ไฟคุณอาจจะดีกว่าที่จะเรียกแต่ละกระบวนการแยกจากกันและส่งผ่านเอาต์พุตจากแต่ละวิธีเป็นอินพุตไปยังถัดไป

run(cmd, [stdout=etc...], input=other_output)

หรือ

Popen(cmd, [stdout=etc...]).communicate(other_output)

สิ่งล่อใจที่จะเชื่อมต่อท่อโดยตรงนั้นแข็งแกร่ง ต่อต้านมัน มิฉะนั้นคุณอาจจะเห็นการติดตายหรือมีการทำสิ่ง hacky เช่นนี้

2. ข้อควรพิจารณาของ Unicode

check_outputส่งคืนสตริงใน Python 2 แต่เป็นbytesวัตถุใน Python 3 มันควรใช้เวลาสักครู่เพื่อเรียนรู้เกี่ยวกับยูนิโค้ดถ้าคุณยังไม่ได้ทำ

วิธีนี้ง่ายกว่า แต่ใช้ได้กับ Unix (รวมถึง Cygwin) และ Python2.7 เท่านั้น

import commands
print commands.getstatusoutput('wc -l file')

ส่งคืน tuple ด้วย (return_value, เอาต์พุต)

สำหรับวิธีแก้ปัญหาที่ใช้งานได้ทั้ง Python2 และ Python3 ให้ใช้subprocessโมดูลแทน:

from subprocess import Popen, PIPE
output = Popen(["date"],stdout=PIPE)
response = output.communicate()
print response

อะไรแบบนั้น:

def runProcess(exe):    
    p = subprocess.Popen(exe, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    while(True):
        # returns None while subprocess is running
        retcode = p.poll() 
        line = p.stdout.readline()
        yield line
        if retcode is not None:
            break

โปรดทราบว่าฉันกำลังเปลี่ยนเส้นทาง stderr ไปยัง stdout อาจไม่ตรงกับที่คุณต้องการ แต่ฉันต้องการข้อความแสดงข้อผิดพลาดด้วย

ฟังก์ชั่นนี้ให้ผลทีละบรรทัดตามปกติ (โดยปกติคุณจะต้องรอให้กระบวนการย่อยเสร็จสิ้นเพื่อให้ได้ผลลัพธ์ทั้งหมด)

สำหรับกรณีของคุณการใช้จะเป็น:

for line in runProcess('mysqladmin create test -uroot -pmysqladmin12'.split()):
    print line,

คำตอบของ Vartecไม่ได้อ่านทุกบรรทัดดังนั้นฉันจึงสร้างเวอร์ชันที่ทำขึ้น:

def run_command(command):
    p = subprocess.Popen(command,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.STDOUT)
    return iter(p.stdout.readline, b'')

การใช้งานเหมือนกับคำตอบที่ยอมรับ:

command = 'mysqladmin create test -uroot -pmysqladmin12'.split()
for line in run_command(command):
    print(line)

นี้เป็นเรื่องยุ่งยากแต่ง่ายสุดวิธีการแก้ปัญหาที่ทำงานในหลาย ๆ สถานการณ์:

import os
os.system('sample_cmd > tmp')
print open('tmp', 'r').read()

ไฟล์ชั่วคราว (นี่คือ tmp) สร้างขึ้นด้วยเอาต์พุตของคำสั่งและคุณสามารถอ่านจากเอาต์พุตที่คุณต้องการ

หมายเหตุเพิ่มเติมจากความคิดเห็น: คุณสามารถลบไฟล์ tmp ในกรณีของงานครั้งเดียว หากคุณจำเป็นต้องทำหลาย ๆ ครั้งไม่จำเป็นต้องลบ tmp

os.remove('tmp')

ฉันมีปัญหาเดียวกัน แต่หาวิธีง่ายๆในการทำสิ่งนี้:

import subprocess
output = subprocess.getoutput("ls -l")
print(output)

หวังว่าจะช่วยออก

หมายเหตุ: วิธีนี้เป็น Python3 เฉพาะเนื่องจากsubprocess.getoutput()ไม่สามารถใช้งานได้ใน Python2

คุณสามารถใช้คำสั่งต่อไปนี้เพื่อเรียกใช้คำสั่งเชลล์ใด ๆ ฉันใช้มันกับอูบุนตูแล้ว

import os
os.popen('your command here').read()

หมายเหตุ:สิ่งนี้เลิกใช้แล้วตั้งแต่ python 2.6 subprocess.Popenตอนนี้คุณต้องใช้ ด้านล่างเป็นตัวอย่าง

import subprocess

p = subprocess.Popen("Your command", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()[0]
print p.split("\n")

การสะสมไมล์ของคุณอาจแตกต่างกันฉันพยายามหมุน @ senderle ในโซลูชันของ Vartec ใน Windows บน Python 2.6.5 แต่ฉันพบข้อผิดพลาดและไม่มีวิธีแก้ไขปัญหาอื่น ๆ ข้อผิดพลาดของฉันคือ: WindowsError: [Error 6] The handle is invalid.

ฉันพบว่าฉันต้องกำหนด PIPE ให้กับหมายเลขอ้างอิงทุกตัวเพื่อให้ได้ผลลัพธ์ที่ฉันต้องการ - รายการต่อไปนี้ใช้ได้สำหรับฉัน

import subprocess

def run_command(cmd):
    """given shell command, returns communication tuple of stdout and stderr"""
    return subprocess.Popen(cmd, 
                            stdout=subprocess.PIPE, 
                            stderr=subprocess.PIPE, 
                            stdin=subprocess.PIPE).communicate()

และเรียกสิ่งนี้ ( [0]รับส่วนแรกของ tuple stdout):

run_command('tracert 11.1.0.1')[0]

หลังจากเรียนรู้เพิ่มเติมฉันเชื่อว่าฉันต้องการข้อโต้แย้งไปป์เหล่านี้เพราะฉันทำงานกับระบบที่กำหนดเองที่ใช้มือจับที่แตกต่างกันดังนั้นฉันจึงต้องควบคุม std ทั้งหมดโดยตรง

หากต้องการหยุดป๊อปอัปคอนโซล (กับ Windows) ให้ทำดังนี้

def run_command(cmd):
    """given shell command, returns communication tuple of stdout and stderr"""
    # instantiate a startupinfo obj:
    startupinfo = subprocess.STARTUPINFO()
    # set the use show window flag, might make conditional on being in Windows:
    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
    # pass as the startupinfo keyword argument:
    return subprocess.Popen(cmd,
                            stdout=subprocess.PIPE, 
                            stderr=subprocess.PIPE, 
                            stdin=subprocess.PIPE, 
                            startupinfo=startupinfo).communicate()

run_command('tracert 11.1.0.1')

ฉันมีปัญหาที่แตกต่างเล็กน้อยของปัญหาเดียวกันกับข้อกำหนดต่อไปนี้:

1. จับภาพและส่งคืนข้อความ STDOUT ตามที่สะสมในบัฟเฟอร์ STDOUT (เช่นในเรียลไทม์)
   • @vartec แก้ไข Pythonically นี้ด้วยการใช้เครื่องกำเนิดไฟฟ้าและ
     คำหลัก'ผลผลิต' ด้านบน
2. พิมพ์บรรทัด STDOUT ทั้งหมด ( แม้ว่ากระบวนการจะออกก่อนที่บัฟเฟอร์ STDOUT จะสามารถอ่านได้อย่างเต็มที่ )
3. อย่าเสีย CPU รอบการสำรวจกระบวนการที่ความถี่สูง
4. ตรวจสอบรหัสส่งคืนของกระบวนการย่อย
5. พิมพ์ STDERR (แยกจาก STDOUT) หากเราได้รับรหัสส่งคืนข้อผิดพลาดที่ไม่เป็นศูนย์

ฉันได้รวมและปรับคำตอบก่อนหน้านี้เพื่อให้ได้สิ่งต่อไปนี้:

import subprocess
from time import sleep

def run_command(command):
    p = subprocess.Popen(command,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE,
                         shell=True)
    # Read stdout from subprocess until the buffer is empty !
    for line in iter(p.stdout.readline, b''):
        if line: # Don't print blank lines
            yield line
    # This ensures the process has completed, AND sets the 'returncode' attr
    while p.poll() is None:                                                                                                                                        
        sleep(.1) #Don't waste CPU-cycles
    # Empty STDERR buffer
    err = p.stderr.read()
    if p.returncode != 0:
       # The run_command() function is responsible for logging STDERR 
       print("Error: " + str(err))

รหัสนี้จะถูกดำเนินการเช่นเดียวกับคำตอบก่อนหน้า:

for line in run_command(cmd):
    print(line)

การแยกคำสั่งเริ่มต้นสำหรับผู้ที่subprocessอาจยุ่งยากและยุ่งยาก

ใช้shlex.split()เพื่อช่วยตัวเองออก

คำสั่งตัวอย่าง

git log -n 5 --since "5 years ago" --until "2 year ago"

รหัส

from subprocess import check_output
from shlex import split

res = check_output(split('git log -n 5 --since "5 years ago" --until "2 year ago"'))
print(res)
>>> b'commit 7696ab087a163e084d6870bb4e5e4d4198bdc61a\nAuthor: Artur Barseghyan...'

ไม่มีshlex.split()รหัสจะมีลักษณะดังนี้

res = check_output([
    'git', 
    'log', 
    '-n', 
    '5', 
    '--since', 
    '5 years ago', 
    '--until', 
    '2 year ago'
])
print(res)
>>> b'commit 7696ab087a163e084d6870bb4e5e4d4198bdc61a\nAuthor: Artur Barseghyan...'

หากคุณจำเป็นต้องเรียกใช้คำสั่ง shell ในหลาย ๆ ไฟล์นี่เป็นเคล็ดลับสำหรับฉัน

import os
import subprocess

# Define a function for running commands and capturing stdout line by line
# (Modified from Vartec's solution because it wasn't printing all lines)
def runProcess(exe):    
    p = subprocess.Popen(exe, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    return iter(p.stdout.readline, b'')

# Get all filenames in working directory
for filename in os.listdir('./'):
    # This command will be run on each file
    cmd = 'nm ' + filename

    # Run the command and capture the output line by line.
    for line in runProcess(cmd.split()):
        # Eliminate leading and trailing whitespace
        line.strip()
        # Split the output 
        output = line.split()

        # Filter the output and print relevant lines
        if len(output) > 2:
            if ((output[2] == 'set_program_name')):
                print filename
                print line

แก้ไข: เพิ่งเห็นวิธีแก้ปัญหาของ Max Persson พร้อมคำแนะนำของ JF Sebastian ไปข้างหน้าและรวมที่

ตามที่ @senderle หากคุณใช้ python3.6 เช่นฉัน:

def sh(cmd, input=""):
    rst = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, input=input.encode("utf-8"))
    assert rst.returncode == 0, rst.stderr.decode("utf-8")
    return rst.stdout.decode("utf-8")

sh("ls -a")

จะทำหน้าที่เหมือนกับที่คุณเรียกใช้คำสั่งใน bash

หากคุณใช้subprocessโมดูลหลามคุณจะสามารถจัดการกับ STDOUT, STDERR และส่งคืนรหัสคำสั่งแยกจากกัน คุณสามารถดูตัวอย่างสำหรับการใช้งานคำสั่งที่สมบูรณ์ แน่นอนคุณสามารถขยายด้วยtry..exceptถ้าคุณต้องการ

ฟังก์ชั่นด้านล่างส่งคืน STDOUT, STDERR และโค้ดส่งคืนเพื่อให้คุณสามารถจัดการได้ในสคริปต์อื่น

import subprocess

def command_caller(command=None)
    sp = subprocess.Popen(command, stderr=subprocess.PIPE, stdout=subprocess.PIPE, shell=False)
    out, err = sp.communicate()
    if sp.returncode:
        print(
            "Return code: %(ret_code)s Error message: %(err_msg)s"
            % {"ret_code": sp.returncode, "err_msg": err}
            )
    return sp.returncode, out, err

เช่นดำเนินการ ('ls -ahl') สร้างผลตอบแทนที่เป็นไปได้สามถึงสี่และแพลตฟอร์มระบบปฏิบัติการ:

1. ไม่มีเอาต์พุต แต่รันสำเร็จ
2. บรรทัดที่ว่างเปล่าเอาท์พุททำงานได้สำเร็จ
3. การเรียกใช้ล้มเหลว
4. ส่งออกบางสิ่งบางอย่างทำงานได้สำเร็จ

ฟังก์ชั่นด้านล่าง

def execute(cmd, output=True, DEBUG_MODE=False):
"""Executes a bash command.
(cmd, output=True)
output: whether print shell output to screen, only affects screen display, does not affect returned values
return: ...regardless of output=True/False...
        returns shell output as a list with each elment is a line of string (whitespace stripped both sides) from output
        could be 
        [], ie, len()=0 --> no output;    
        [''] --> output empty line;     
        None --> error occured, see below

        if error ocurs, returns None (ie, is None), print out the error message to screen
"""
if not DEBUG_MODE:
    print "Command: " + cmd

    # https://stackoverflow.com/a/40139101/2292993
    def _execute_cmd(cmd):
        if os.name == 'nt' or platform.system() == 'Windows':
            # set stdin, out, err all to PIPE to get results (other than None) after run the Popen() instance
            p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
        else:
            # Use bash; the default is sh
            p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, executable="/bin/bash")

        # the Popen() instance starts running once instantiated (??)
        # additionally, communicate(), or poll() and wait process to terminate
        # communicate() accepts optional input as stdin to the pipe (requires setting stdin=subprocess.PIPE above), return out, err as tuple
        # if communicate(), the results are buffered in memory

        # Read stdout from subprocess until the buffer is empty !
        # if error occurs, the stdout is '', which means the below loop is essentially skipped
        # A prefix of 'b' or 'B' is ignored in Python 2; 
        # it indicates that the literal should become a bytes literal in Python 3 
        # (e.g. when code is automatically converted with 2to3).
        # return iter(p.stdout.readline, b'')
        for line in iter(p.stdout.readline, b''):
            # # Windows has \r\n, Unix has \n, Old mac has \r
            # if line not in ['','\n','\r','\r\n']: # Don't print blank lines
                yield line
        while p.poll() is None:                                                                                                                                        
            sleep(.1) #Don't waste CPU-cycles
        # Empty STDERR buffer
        err = p.stderr.read()
        if p.returncode != 0:
            # responsible for logging STDERR 
            print("Error: " + str(err))
            yield None

    out = []
    for line in _execute_cmd(cmd):
        # error did not occur earlier
        if line is not None:
            # trailing comma to avoid a newline (by print itself) being printed
            if output: print line,
            out.append(line.strip())
        else:
            # error occured earlier
            out = None
    return out
else:
    print "Simulation! The command is " + cmd
    print ""

เอาต์พุตสามารถเปลี่ยนเส้นทางไปยังไฟล์ข้อความแล้วอ่านกลับ

import subprocess
import os
import tempfile

def execute_to_file(command):
    """
    This function execute the command
    and pass its output to a tempfile then read it back
    It is usefull for process that deploy child process
    """
    temp_file = tempfile.NamedTemporaryFile(delete=False)
    temp_file.close()
    path = temp_file.name
    command = command + " > " + path
    proc = subprocess.run(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
    if proc.stderr:
        # if command failed return
        os.unlink(path)
        return
    with open(path, 'r') as f:
        data = f.read()
    os.unlink(path)
    return data

if __name__ == "__main__":
    path = "Somepath"
    command = 'ecls.exe /files ' + path
    print(execute(command))

เพิ่งเขียนสคริปต์ทุบตีขนาดเล็กเพื่อทำสิ่งนี้โดยใช้ curl

https://gist.github.com/harish2704/bfb8abece94893c53ce344548ead8ba5

#!/usr/bin/env bash

# Usage: gdrive_dl.sh <url>

urlBase='https://drive.google.com'
fCookie=tmpcookies

curl="curl -L -b $fCookie -c $fCookie"
confirm(){
    $curl "$1" | grep jfk-button-action | sed -e 's/.*jfk-button-action" href="\(\S*\)".*/\1/' -e 's/\&amp;/\&/g'
}

$curl -O -J "${urlBase}$(confirm $1)"