编辑：

Question

除了脚本自己的控制台（什么都不做）我想打开两个控制台并在不同的控制台中打印变量con1和con2，我怎样才能实现此

con1 = 'This is Console1'
con2 = 'This is Console2'

我不知道如何实现这一点并花了几个小时尝试使用subprocess之类的模块，但没有运气。顺便说一句，我在窗户上。

编辑：

threading模块会完成这项工作吗？还是需要multiprocessing？

例如：

enter image description here

Answer 1

如果您不想reconsider your problem and use a GUI @Kevin's answer，那么您可以使用subprocess模块同时启动两个新控制台并在打开的窗口中显示两个给定的字符串：

#!/usr/bin/env python3
import sys
import time
from subprocess import Popen, PIPE, CREATE_NEW_CONSOLE

messages = 'This is Console1', 'This is Console2'

# open new consoles
processes = [Popen([sys.executable, "-c", """import sys
for line in sys.stdin: # poor man's `cat`
    sys.stdout.write(line)
    sys.stdout.flush()
"""],
    stdin=PIPE, bufsize=1, universal_newlines=True,
    # assume the parent script is started from a console itself e.g.,
    # this code is _not_ run as a *.pyw file
    creationflags=CREATE_NEW_CONSOLE)
             for _ in range(len(messages))]

# display messages
for proc, msg in zip(processes, messages):
    proc.stdin.write(msg + "\n")
    proc.stdin.flush()

time.sleep(10) # keep the windows open for a while

# close windows
for proc in processes:
    proc.communicate("bye\n")

这是一个不依赖CREATE_NEW_CONSOLE的简化版本：

#!/usr/bin/env python
"""Show messages in two new console windows simultaneously."""
import sys
import platform
from subprocess import Popen

messages = 'This is Console1', 'This is Console2'

# define a command that starts new terminal
if platform.system() == "Windows":
    new_window_command = "cmd.exe /c start".split()
else:  #XXX this can be made more portable
    new_window_command = "x-terminal-emulator -e".split()

# open new consoles, display messages
echo = [sys.executable, "-c",
        "import sys; print(sys.argv[1]); input('Press Enter..')"]
processes = [Popen(new_window_command + echo + [msg])  for msg in messages]

# wait for the windows to be closed
for proc in processes:
    proc.wait()

Answer 2

你可以使用两个Tkinter Text小部件来获得之类的两个控制台。

from Tkinter import *
import threading

class FakeConsole(Frame):
    def __init__(self, root, *args, **kargs):
        Frame.__init__(self, root, *args, **kargs)

        #white text on black background,
        #for extra versimilitude
        self.text = Text(self, bg="black", fg="white")
        self.text.pack()

        #list of things not yet printed
        self.printQueue = []

        #one thread will be adding to the print queue, 
        #and another will be iterating through it.
        #better make sure one doesn't interfere with the other.
        self.printQueueLock = threading.Lock()

        self.after(5, self.on_idle)

    #check for new messages every five milliseconds
    def on_idle(self):
        with self.printQueueLock:
            for msg in self.printQueue:
                self.text.insert(END, msg)            
                self.text.see(END)
            self.printQueue = []
        self.after(5, self.on_idle)

    #print msg to the console
    def show(self, msg, sep="\n"):
        with self.printQueueLock:
            self.printQueue.append(str(msg) + sep)

#warning! Calling this more than once per program is a bad idea.
#Tkinter throws a fit when two roots each have a mainloop in different threads.
def makeConsoles(amount):
    root = Tk()
    consoles = [FakeConsole(root) for n in range(amount)]
    for c in consoles:
        c.pack()
    threading.Thread(target=root.mainloop).start()
    return consoles

a,b = makeConsoles(2)

a.show("This is Console 1")
b.show("This is Console 2")

a.show("I've got a lovely bunch of cocounts")
a.show("Here they are standing in a row")

b.show("Lorem ipsum dolor sit amet")
b.show("consectetur adipisicing elit")

结果：

enter image description here

Answer 3

我不知道它是否适合您，但您可以使用Windows start命令打开两个Python解释器：

from subprocess import Popen
p1 = Popen('start c:\python27\python.exe', shell=True)
p2 = Popen('start c:\python27\python.exe', shell=True)

当然有问题，现在Python以交互模式运行，这不是您想要的（您也可以将文件作为参数传递，并且该文件将被执行）。

在Linux上我会尝试创建命名管道，将文件名传递给python.exe并将python命令写入该文件。 '也许'它会起作用;）

但我不知道如何在Windows上创建命名管道。 Windows API ...（填写自己）。

Answer 4

如果您在 Windows 上，您可以使用 win32console 模块为您的线程或子进程输出打开第二个控制台。如果您使用的是 Windows，这是最简单、最简单的方法。

这是一个示例代码：

<?xml version="1.0" encoding="UTF-8"?>
<root>
    <WC>
        <workCenter>WC1</workCenter>>
        <alerts>alerts:true</alerts>
        <dashboard>dashboard:true</dashboard>
         <incident>incident:true</incident>
    </WC>
    <WC>
       <workCenter>WC2</workCenter>>
        <alerts>alerts:true</alerts>
        <dashboard>dashboard:true</dashboard>
         <incident>incident:false</incident>
    </WC>
    <WC>
    
     <workCenter>WC3</workCenter>>
     <alerts>alerts:false</alerts>
    <dashboard>dashboard:false</dashboard>
     <incident>incident:false</incident>
      
    </WC>
    <WC>
    
     <workCenter>WC4</workCenter>>
     <alerts>alerts:false</alerts>
    <dashboard>dashboard:false</dashboard>
     <incident>incident:false</incident>
      
    </WC>
</root>

您也可以使用线程来做到这一点。如果您想要队列功能，则必须使用 queue module，因为线程模块没有队列

这是win32console module documentation

Answer 5

pymux

pymux接近您想要的：https://github.com/jonathanslenders/pymux

不幸的是，它主要是tmux的CLI工具替代品，并且没有像样的编程API。

但是，如果您对此很认真的话，最好对其进行破解以公开该API。

Answer 6

我使用了jfs的回复。这是我对jfs响应的修饰/盗窃。这是专为在Win10上运行而设计的，还可以处理Unicode：

# https://stackoverflow.com/questions/19479504/how-can-i-open-two-consoles-from-a-single-script
import sys, time, os, locale
from subprocess import Popen, PIPE, CREATE_NEW_CONSOLE

class console(Popen)  :
    NumConsoles = 0
    def __init__(self, color=None, title=None):
        console.NumConsoles += 1

        cmd = "import sys, os, locale"
        cmd += "\nos.system(\'color " + color + "\')" if color is not None else ""
        title = title if title is not None else "console #" + str(console.NumConsoles)
        cmd += "\nos.system(\"title " + title + "\")"
        # poor man's `cat`
        cmd += """
print(sys.stdout.encoding, locale.getpreferredencoding() )
endcoding = locale.getpreferredencoding()
for line in sys.stdin:
    sys.stdout.buffer.write(line.encode(endcoding))
    sys.stdout.flush()
"""

        cmd = sys.executable, "-c", cmd
        # print(cmd, end="", flush=True)
        super().__init__(cmd, stdin=PIPE, bufsize=1, universal_newlines=True, creationflags=CREATE_NEW_CONSOLE, encoding='utf-8')


    def write(self, msg):
        self.stdin.write(msg + "\n" )

if __name__ == "__main__":
    myConsole = console(color="c0", title="test error console")
    myConsole.write("Thank you jfs. Cool explanation")
    NoTitle= console()
    NoTitle.write("default color and title! This answer uses Windows 10")
    NoTitle.write(u"♥♥♥♥♥♥♥♥")
    NoTitle.write("♥")
    time.sleep(5)
    myConsole.terminate()
    NoTitle.write("some more text. Run this at the python console.")
    time.sleep(4)
    NoTitle.terminate()
    time.sleep(5)

Answer 7

你知道screen / tmux吗？

tmuxp怎么样？例如，您可以尝试在拆分窗格中运行cat并使用“sendkeys”发送输出（但是挖掘文档，可能有更简单的方法来实现此目的）。

作为副作用，这可以在文本控制台或GUI中使用。

如何从单个脚本中打开两个控制台

编辑：

7 个答案: