Wie man eine while-Schleife mit einem Tastendruck beendet?

Ich lese serielle Daten und schreibe mit einer while-Schleife in eine CSV-Datei. Ich möchte, dass der Benutzer die while-Schleife beenden kann, sobald er das Gefühl hat, genügend Daten gesammelt zu haben.

while True:
    #do a bunch of serial stuff

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

Ich habe so etwas mit opencv gemacht, aber es scheint in dieser Anwendung nicht zu funktionieren (und ich möchte opencv wirklich nicht nur für diese Funktion importieren) ...

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

Damit. Wie kann ich den Benutzer aus der Schleife ausbrechen lassen?

Außerdem möchte ich keinen Tastaturinterrupt verwenden, da das Skript nach Beendigung der while-Schleife weiter ausgeführt werden muss.

Am einfachsten ist es, es einfach mit dem üblichen Ctrl-C(SIGINT) zu unterbrechen .

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

Da die Ctrl-CUrsachen KeyboardInterruptausgelöst werden, fangen Sie es einfach außerhalb der Schleife und ignorieren Sie es.

Es gibt eine Lösung, die keine nicht standardmäßigen Module erfordert und zu 100% transportabel ist

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

Der folgende Code funktioniert für mich. Es erfordert openCV (Import cv2).

Der Code besteht aus einer Endlosschleife, die ständig nach einer gedrückten Taste sucht. In diesem Fall endet das Programm, wenn die Taste 'q' gedrückt wird. Andere Tasten können gedrückt werden (in diesem Beispiel 'b' oder 'k'), um verschiedene Aktionen auszuführen, z. B. einen Variablenwert ändern oder eine Funktion ausführen.

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

Für Python 3.7 habe ich die sehr schöne Antwort von user297171 kopiert und geändert, damit sie in allen von mir getesteten Szenarien in Python 3.7 funktioniert.

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 könnte helfen. http://sourceforge.net/apps/mediawiki/pyhook/index.php?title=PyHook_Tutorial#tocpyHook%5FTutorial4

Siehe Tastaturhaken; Dies ist allgemeiner - wenn Sie bestimmte Tastaturinteraktionen wünschen und nicht nur KeyboardInterrupt verwenden möchten.

Im Allgemeinen (abhängig von Ihrer Verwendung) halte ich es für sinnvoll, die Strg-C-Option weiterhin verfügbar zu haben, um Ihr Skript zu beenden.

Siehe auch vorherige Frage: Ermitteln Sie in Python, welche Tasten gedrückt werden

Es gibt immer sys.exit().

Die Systembibliothek in Pythons Kernbibliothek verfügt über eine Exit-Funktion, die beim Prototyping sehr praktisch ist. Der Code würde wie folgt lauten:

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

Ich habe die Antwort von rayzinnz geändert, um das Skript mit einem bestimmten Schlüssel zu beenden, in diesem Fall dem Escape-Schlüssel

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

Nachdem ich diesem Thread im Kaninchenbau gefolgt bin, bin ich zu diesem Thema gekommen, das unter Win10 und Ubuntu 20.04 funktioniert. Ich wollte mehr als nur das Skript beenden und bestimmte Schlüssel verwenden, und es musste sowohl unter MS als auch unter Linux funktionieren.

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

Dies kann hilfreich sein, um pynput mit - pip install pynput zu installieren

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 

Dies ist die Lösung, die ich mit Threads und Standardbibliotheken gefunden habe. Die

Schleife wird fortgesetzt, bis eine Taste gedrückt wird.
Gibt die als einzelne Zeichenfolge gedrückte Taste zurück.

Funktioniert in Python 2.7 und 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('  :( ')

für die Eingabe verwenden Sie 'ENTER'