在 Windows 机器上，我尝试从 Python 调用外部可执行文件并收集其输出以进行进一步处理.因为在调用可执行文件之前必须设置一个本地路径变量，所以我创建了一个批处理脚本，
On a Windows machine, I'm trying to call an external executable from Python and gather its outputs for further processing. Because a local path variable has to be set before calling the executable, I created a batch script that
*.bat 文件如下所示:
The *.bat file looks like this:
@echo off
call set_path.bat
@echo on
executable.exe %*
Python 代码如下:
And the Python code like this:
print("before call");
result = subprocess.check_output([batfile, parameters], stderr=subprocess.STDOUT, shell=True);
print("after call");
print("------- ------- ------- printing result ------- ------- ------- ");
print(result);
print("------- ------- ------- /printing result ------- ------- ------- ");
现在，从技术上讲，这是可行的.使用预期的参数调用可执行文件，运行，完成并产生结果.我知道这一点，因为它们在运行 Python 脚本的控制台中被嘲弄地显示.
Now, technically, this works. The executable is called with the intended parameters, runs, finishes and produces results. I know this, because they are mockingly displayed in the very console in which the Python script is running.
但是，结果字符串只包含批处理脚本返回的内容，而不是可执行文件的输出:
However, the result string only contains what the batch script returns, not the executables outputs:
通话前
喂?是的，这是executable.exe
hello? yes, this is executable.exe
通话后
------- ------- -------- 打印结果 ------- ------- -------
------- ------- ------- printing result ------- ------- -------
C:UsersmeDocumentspythonscriptexecuteexecutable.exe "para1|para2|para3"
C:UsersmeDocumentspythonscriptexecuteexecutable.exe "para1|para2|para3"
------- ------- -------/打印结果 ------- ------- -------
------- ------- ------- /printing result ------- ------- -------
subprocess.check_output 命令本身以某种方式将预期的输出打印到控制台，它返回的内容仅包含@echo 再次打开后批处理文件的输出.
The subprocess.check_output command itself somehow prints the intended output to the console, what it returns only contains the batch file's outputs after @echo is on again.
如何访问可执行文件的输出并将其保存为字符串以便进一步工作?
或者我是否必须以某种方式修改批处理文件以捕获并打印输出，以便它最终会出现在 check_output 的结果中?如果是这样，我该怎么做?
Or do I have to somehow modify the batch file to catch and print the output, so that it will end upt in check_output's results? If so, how could I go about doing that?
如果程序直接写入控制台(例如通过打开 CONOUT$ 设备)而不是进程标准句柄，则唯一的选择是直接读取控制台屏幕缓冲区.为了使这更简单，从一个新的空屏幕缓冲区开始.通过以下函数创建、调整大小、初始化和激活新的屏幕缓冲区:
If a program writes directly to the console (e.g. by opening the CONOUT$ device) instead of to the process standard handles, the only option is to read the console screen buffer directly. To make this simpler, start with a new, empty screen buffer. Create, size, initialize, and activate a new screen buffer via the following functions:
CreateConsoleScreenBufferGetConsoleScreenBufferInfoEx(最低支持客户端:Windows远景)SetConsoleScreenBufferInfoEx(最低支持客户端:Windows远景)SetConsoleWindowInfoFillConsoleOutputCharacterSetConsoleActiveScreenBuffer确保请求 GENERIC_READ |GENERIC_WRITE 在调用 CreateConsoleScreenBuffer 时访问.稍后您需要读取权限才能读取屏幕内容.
Make sure to request GENERIC_READ | GENERIC_WRITE access when calling CreateConsoleScreenBuffer. You'll need read access later in order to read the contents of the screen.
专门针对 Python，使用 ctypes 在 Windows 控制台 API 中调用函数.此外，如果您通过 msvcrt.open_osfhandle 使用 C 文件描述符包装句柄，则可以将其作为 stdout 或 stderr 参数传递subprocess.Popen.
Specifically for Python, use ctypes to call functions in the Windows console API. Also, if you wrap the handle with a C file descriptor via msvcrt.open_osfhandle, then you can pass it as the stdout or stderr argument of subprocess.Popen.
屏幕缓冲区的文件描述符或句柄不能直接通过read、ReadFile甚至ReadConsole读取.如果您有文件描述符，请通过 msvcrt.get_osfhandle 获取底层句柄.给定屏幕缓冲区句柄，调用 ReadConsoleOutputCharacter 来读取从屏幕上.下面示例代码中的 read_screen 函数演示了从屏幕缓冲区开始到光标位置的读取.
The file descriptor or handle for the screen buffer can't be read directly via read, ReadFile, or even ReadConsole. If you have a file descriptor, get the underlying handle via msvcrt.get_osfhandle. Given a screen buffer handle, call ReadConsoleOutputCharacter to read from the screen. The read_screen function in the sample code below demonstrates reading from the beginning of the screen buffer up to the cursor position.
需要将进程附加到控制台才能使用控制台 API.为此，我包含了一个简单的 allocate_console 上下文管理器来临时打开一个控制台.这在通常不附加到控制台的 GUI 应用程序中很有用.
A process needs to be attached to a console in order to use the console API. To that end, I've included a simple allocate_console context manager to temporarily open a console. This is useful in a GUI application, which normally isn't attached to a console.
以下示例在 Windows 7 和 10、Python 2.7 和 3.5 中进行了测试.
The following example was tested in Windows 7 and 10, in Python 2.7 and 3.5.
import os
import contextlib
import msvcrt
import ctypes
from ctypes import wintypes
kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
GENERIC_READ = 0x80000000
GENERIC_WRITE = 0x40000000
FILE_SHARE_READ = 1
FILE_SHARE_WRITE = 2
CONSOLE_TEXTMODE_BUFFER = 1
INVALID_HANDLE_VALUE = wintypes.HANDLE(-1).value
STD_OUTPUT_HANDLE = wintypes.DWORD(-11)
STD_ERROR_HANDLE = wintypes.DWORD(-12)
def _check_zero(result, func, args):
if not result:
raise ctypes.WinError(ctypes.get_last_error())
return args
def _check_invalid(result, func, args):
if result == INVALID_HANDLE_VALUE:
raise ctypes.WinError(ctypes.get_last_error())
return args
if not hasattr(wintypes, 'LPDWORD'): # Python 2
wintypes.LPDWORD = ctypes.POINTER(wintypes.DWORD)
wintypes.PSMALL_RECT = ctypes.POINTER(wintypes.SMALL_RECT)
class COORD(ctypes.Structure):
_fields_ = (('X', wintypes.SHORT),
('Y', wintypes.SHORT))
class CONSOLE_SCREEN_BUFFER_INFOEX(ctypes.Structure):
_fields_ = (('cbSize', wintypes.ULONG),
('dwSize', COORD),
('dwCursorPosition', COORD),
('wAttributes', wintypes.WORD),
('srWindow', wintypes.SMALL_RECT),
('dwMaximumWindowSize', COORD),
('wPopupAttributes', wintypes.WORD),
('bFullscreenSupported', wintypes.BOOL),
('ColorTable', wintypes.DWORD * 16))
def __init__(self, *args, **kwds):
super(CONSOLE_SCREEN_BUFFER_INFOEX, self).__init__(
*args, **kwds)
self.cbSize = ctypes.sizeof(self)
PCONSOLE_SCREEN_BUFFER_INFOEX = ctypes.POINTER(
CONSOLE_SCREEN_BUFFER_INFOEX)
LPSECURITY_ATTRIBUTES = wintypes.LPVOID
kernel32.GetStdHandle.errcheck = _check_invalid
kernel32.GetStdHandle.restype = wintypes.HANDLE
kernel32.GetStdHandle.argtypes = (
wintypes.DWORD,) # _In_ nStdHandle
kernel32.CreateConsoleScreenBuffer.errcheck = _check_invalid
kernel32.CreateConsoleScreenBuffer.restype = wintypes.HANDLE
kernel32.CreateConsoleScreenBuffer.argtypes = (
wintypes.DWORD, # _In_ dwDesiredAccess
wintypes.DWORD, # _In_ dwShareMode
LPSECURITY_ATTRIBUTES, # _In_opt_ lpSecurityAttributes
wintypes.DWORD, # _In_ dwFlags
wintypes.LPVOID) # _Reserved_ lpScreenBufferData
kernel32.GetConsoleScreenBufferInfoEx.errcheck = _check_zero
kernel32.GetConsoleScreenBufferInfoEx.argtypes = (
wintypes.HANDLE, # _In_ hConsoleOutput
PCONSOLE_SCREEN_BUFFER_INFOEX) # _Out_ lpConsoleScreenBufferInfo
kernel32.SetConsoleScreenBufferInfoEx.errcheck = _check_zero
kernel32.SetConsoleScreenBufferInfoEx.argtypes = (
wintypes.HANDLE, # _In_ hConsoleOutput
PCONSOLE_SCREEN_BUFFER_INFOEX) # _In_ lpConsoleScreenBufferInfo
kernel32.SetConsoleWindowInfo.errcheck = _check_zero
kernel32.SetConsoleWindowInfo.argtypes = (
wintypes.HANDLE, # _In_ hConsoleOutput
wintypes.BOOL, # _In_ bAbsolute
wintypes.PSMALL_RECT) # _In_ lpConsoleWindow
kernel32.FillConsoleOutputCharacterW.errcheck = _check_zero
kernel32.FillConsoleOutputCharacterW.argtypes = (
wintypes.HANDLE, # _In_ hConsoleOutput
wintypes.WCHAR, # _In_ cCharacter
wintypes.DWORD, # _In_ nLength
COORD, # _In_ dwWriteCoord
wintypes.LPDWORD) # _Out_ lpNumberOfCharsWritten
kernel32.ReadConsoleOutputCharacterW.errcheck = _check_zero
kernel32.ReadConsoleOutputCharacterW.argtypes = (
wintypes.HANDLE, # _In_ hConsoleOutput
wintypes.LPWSTR, # _Out_ lpCharacter
wintypes.DWORD, # _In_ nLength
COORD, # _In_ dwReadCoord
wintypes.LPDWORD) # _Out_ lpNumberOfCharsRead
@contextlib.contextmanager
def allocate_console():
allocated = kernel32.AllocConsole()
try:
yield allocated
finally:
if allocated:
kernel32.FreeConsole()
@contextlib.contextmanager
def console_screen(ncols=None, nrows=None):
info = CONSOLE_SCREEN_BUFFER_INFOEX()
new_info = CONSOLE_SCREEN_BUFFER_INFOEX()
nwritten = (wintypes.DWORD * 1)()
hStdOut = kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
kernel32.GetConsoleScreenBufferInfoEx(
hStdOut, ctypes.byref(info))
if ncols is None:
ncols = info.dwSize.X
if nrows is None:
nrows = info.dwSize.Y
elif nrows > 9999:
raise ValueError('nrows must be 9999 or less')
fd_screen = None
hScreen = kernel32.CreateConsoleScreenBuffer(
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
None, CONSOLE_TEXTMODE_BUFFER, None)
try:
fd_screen = msvcrt.open_osfhandle(
hScreen, os.O_RDWR | os.O_BINARY)
kernel32.GetConsoleScreenBufferInfoEx(
hScreen, ctypes.byref(new_info))
new_info.dwSize = COORD(ncols, nrows)
new_info.srWindow = wintypes.SMALL_RECT(
Left=0, Top=0, Right=(ncols - 1),
Bottom=(info.srWindow.Bottom - info.srWindow.Top))
kernel32.SetConsoleScreenBufferInfoEx(
hScreen, ctypes.byref(new_info))
kernel32.SetConsoleWindowInfo(hScreen, True,
ctypes.byref(new_info.srWindow))
kernel32.FillConsoleOutputCharacterW(
hScreen, u' ', ncols * nrows, COORD(0,0), nwritten)
kernel32.SetConsoleActiveScreenBuffer(hScreen)
try:
yield fd_screen
finally:
kernel32.SetConsoleScreenBufferInfoEx(
hStdOut, ctypes.byref(info))
kernel32.SetConsoleWindowInfo(hStdOut, True,
ctypes.byref(info.srWindow))
kernel32.SetConsoleActiveScreenBuffer(hStdOut)
finally:
if fd_screen is not None:
os.close(fd_screen)
else:
kernel32.CloseHandle(hScreen)
def read_screen(fd):
hScreen = msvcrt.get_osfhandle(fd)
csbi = CONSOLE_SCREEN_BUFFER_INFOEX()
kernel32.GetConsoleScreenBufferInfoEx(
hScreen, ctypes.byref(csbi))
ncols = csbi.dwSize.X
pos = csbi.dwCursorPosition
length = ncols * pos.Y + pos.X + 1
buf = (ctypes.c_wchar * length)()
n = (wintypes.DWORD * 1)()
kernel32.ReadConsoleOutputCharacterW(
hScreen, buf, length, COORD(0,0), n)
lines = [buf[i:i+ncols].rstrip(u' ')
for i in range(0, n[0], ncols)]
return u'
'.join(lines)
if __name__ == '__main__':
import io
import textwrap
import subprocess
text = textwrap.dedent('''
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do
eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut
enim ad minim veniam, quis nostrud exercitation ullamco laboris
nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor
in reprehenderit in voluptate velit esse cillum dolore eu
fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
proident, sunt in culpa qui officia deserunt mollit anim id est
laborum.''')
cmd = ("python -c ""
"print('piped output');"
"conout = open(r'CONOUT$', 'w');"
"conout.write('''%s''')"" % text)
with allocate_console() as allocated:
with console_screen(nrows=1000) as fd_conout:
stdout = subprocess.check_output(cmd).decode()
conout = read_screen(fd_conout)
with io.open('result.txt', 'w', encoding='utf-8') as f:
f.write(u'stdout:
' + stdout)
f.write(u'
conout:
' + conout)
stdout:
piped output
conout:
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do
eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut
enim ad minim veniam, quis nostrud exercitation ullamco laboris
nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor
in reprehenderit in voluptate velit esse cillum dolore eu
fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
proident, sunt in culpa qui officia deserunt mollit anim id est
laborum.
这篇关于通过 subprocess.check_output 调用的可执行文件在控制台上打印，但不返回结果的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持跟版网！