如何用按键杀死while循环？

我正在读取串行数据，并使用while循环写入csv文件。我希望用户一旦感到自己已经收集了足够的数据，便能够杀死while循环。

while True:
    #do a bunch of serial stuff

    #if the user presses the 'esc' or 'return' key:
        break

我已经使用opencv完成了这样的事情，但是它似乎在此应用程序中不起作用（而且我真的不希望为此功能导入opencv）...

        # Listen for ESC or ENTER key
        c = cv.WaitKey(7) % 0x100
        if c == 27 or c == 10:
            break

所以。如何让用户摆脱困境？

另外，我也不想使用键盘中断，因为该脚本需要在while循环终止后继续运行。

最简单的方法是仅使用通常的Ctrl-C（SIGINT）中断它。

try:
    while True:
        do_something()
except KeyboardInterrupt:
    pass

由于Ctrl-C会引发原因KeyboardInterrupt，因此只需将其捕获到循环之外并忽略它即可。

有一种解决方案，不需要非标准模块，并且100％可运输

import thread

def input_thread(a_list):
    raw_input()
    a_list.append(True)

def do_stuff():
    a_list = []
    thread.start_new_thread(input_thread, (a_list,))
    while not a_list:
        stuff()

以下代码对我有用。它需要openCV（导入cv2）。

该代码由一个无限循环组成，该循环不断寻找按下的键。在这种情况下，当按下“ q”键时，程序结束。可以按下其他键（在此示例中为“ b”或“ k”）以执行不同的动作，例如更改变量值或执行功能。

import cv2

while True:
    k = cv2.waitKey(1) & 0xFF
    # press 'q' to exit
    if k == ord('q'):
        break
    elif k == ord('b'):
        # change a variable / do something ...
    elif k == ord('k'):
        # change a variable / do something ...

对于Python 3.7，我复制并更改了user297171的非常好的答案，因此它在我测试的Python 3.7中的所有情况下均适用。

import threading as th

keep_going = True
def key_capture_thread():
    global keep_going
    input()
    keep_going = False

def do_stuff():
    th.Thread(target=key_capture_thread, args=(), name='key_capture_thread', daemon=True).start()
    while keep_going:
        print('still going...')

do_stuff()

pyHook可能会有所帮助。http://sourceforge.net/apps/mediawiki/pyhook/index.php?title=PyHook_Tutorial#tocpyHook%5FTutorial4

请参阅键盘挂钩；如果您想进行特定的键盘交互，而不仅仅是使用KeyboardInterrupt，则可以更通用。

另外，一般来说（取决于您的使用），我认为仍然可以使用Ctrl-C选项杀死脚本。

另请参阅上一个问题：在python中检测按下了哪些键

总有sys.exit()。

Python核心库中的系统库具有退出功能，在进行原型制作时非常方便。该代码将遵循以下原则：

import sys

while True:
    selection = raw_input("U: Create User\nQ: Quit")
    if selection is "Q" or selection is "q":
        print("Quitting")
        sys.exit()
    if selection is "U" or selection is "u":
        print("User")
        #do_something()

我修改了rayzinnz的答案，以特定的键结束脚本，在本例中为转义键

import threading as th
import time
import keyboard

keep_going = True
def key_capture_thread():
    global keep_going
    a = keyboard.read_key()
    if a== "esc":
        keep_going = False


def do_stuff():
    th.Thread(target=key_capture_thread, args=(), name='key_capture_thread', daemon=True).start()
    i=0
    while keep_going:
        print('still going...')
        time.sleep(1)
        i=i+1
        print (i)
    print ("Schleife beendet")


do_stuff()

从沿兔子洞的这个线程开始，我来到这里，可以在Win10和Ubuntu 20.04上运行。我不仅要杀死脚本并使用特定的密钥，而且还必须在MS和Linux上都能工作。

import _thread
import time
import sys
import os

class _Getch:
    """Gets a single character from standard input.  Does not echo to the screen."""
    def __init__(self):
        try:
            self.impl = _GetchWindows()
        except ImportError:
            self.impl = _GetchUnix()

    def __call__(self): return self.impl()

class _GetchUnix:
    def __init__(self):
        import tty, sys

    def __call__(self):
        import sys, tty, termios
        fd = sys.stdin.fileno()
        old_settings = termios.tcgetattr(fd)
        try:
            tty.setraw(sys.stdin.fileno())
            ch = sys.stdin.read(1)
        finally:
            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
        return ch

class _GetchWindows:
    def __init__(self):
        import msvcrt

    def __call__(self):
        import msvcrt
        msvcrt_char = msvcrt.getch()
        return msvcrt_char.decode("utf-8")

def input_thread(key_press_list):
    char = 'x'
    while char != 'q': #dont keep doing this after trying to quit, or 'stty sane' wont work
        time.sleep(0.05)
        getch = _Getch()
        char = getch.impl()
        pprint("getch: "+ str(char))
        key_press_list.append(char)

def quitScript():
    pprint("QUITTING...")
    time.sleep(0.2) #wait for the thread to die
    os.system('stty sane')
    sys.exit()

def pprint(string_to_print): #terminal is in raw mode so we need to append \r\n
    print(string_to_print, end="\r\n")

def main():
    key_press_list = []
    _thread.start_new_thread(input_thread, (key_press_list,))
    while True:
        #do your things here
        pprint("tick")
        time.sleep(0.5)

        if key_press_list == ['q']:
            key_press_list.clear()
            quitScript()

        elif key_press_list == ['j']:
            key_press_list.clear()
            pprint("knock knock..")

        elif key_press_list:
            key_press_list.clear()

main()

这可能对安装pynput很有帮助-pip install pynput

from pynput.keyboard import Key, Listener
def on_release(key):
    if key == Key.esc:
        # Stop listener
        return False

# Collect events until released
while True:
    with Listener(
            on_release=on_release) as listener:
        listener.join()
    break 

这是我在线程和标准库中找到的解决方案，

循环一直进行到按下一个键为止，
返回按下的键为单个字符串，

在Python 2.7和3中都有效

import thread
import sys

def getch():
    import termios
    import sys, tty
    def _getch():
        fd = sys.stdin.fileno()
        old_settings = termios.tcgetattr(fd)
        try:
            tty.setraw(fd)
            ch = sys.stdin.read(1)
        finally:
            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
        return ch
    return _getch()

def input_thread(char):
    char.append(getch())

def do_stuff():
    char = []
    thread.start_new_thread(input_thread, (char,))
    i = 0
    while not char :
        i += 1

    print "i = " + str(i) + " char : " + str(char[0])

do_stuff()

import keyboard

while True:
    print('please say yes')
    if keyboard.is_pressed('y'):
         break
print('i got u :) ')
print('i was trying to write you are a idiot ')
print('  :( ')

输入使用'ENTER'