Come uccidere un ciclo while con una sequenza di tasti?

Sto leggendo dati seriali e scrivendo su un file csv usando un ciclo while. Voglio che l'utente sia in grado di terminare il ciclo while una volta che sente di aver raccolto dati sufficienti.

while True:
    #do a bunch of serial stuff

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

Ho fatto qualcosa di simile usando opencv, ma non sembra funzionare in questa applicazione (e comunque non voglio importare opencv solo per questa funzione) ...

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

Così. Come posso lasciare che l'utente esca dal giro?

Inoltre, non voglio usare l'interruzione della tastiera, perché lo script deve continuare a essere eseguito dopo che il ciclo while è terminato.

Il modo più semplice è interromperlo semplicemente con il solito Ctrl-C(SIGINT).

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

Dal momento che le Ctrl-Ccause vengono KeyboardInterruptsollevate, basta prenderlo fuori dal ciclo e ignorarlo.

Esiste una soluzione che non richiede moduli fuori standard ed è trasportabile al 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()

il codice seguente funziona per me. Richiede openCV (import cv2).

Il codice è composto da un ciclo infinito che è alla continua ricerca di un tasto premuto. In questo caso, premendo il tasto 'q', il programma termina. È possibile premere altri tasti (in questo esempio "b" o "k") per eseguire diverse azioni come modificare il valore di una variabile o eseguire una funzione.

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

Per Python 3.7, ho copiato e modificato la bellissima risposta di user297171 in modo che funzioni in tutti gli scenari in Python 3.7 che ho testato.

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

Vedi ganci per tastiera; questo è più generalizzato, se desideri interazioni da tastiera specifiche e non solo usando KeyboardInterrupt.

Inoltre, in generale (a seconda dell'utilizzo) penso che avere l'opzione Ctrl-C ancora disponibile per terminare lo script abbia senso.

Vedi anche la domanda precedente: Rileva in Python quali tasti vengono premuti

C'è sempre sys.exit().

La libreria di sistema nella libreria principale di Python ha una funzione di uscita che è molto utile durante la prototipazione. Il codice sarebbe sulla falsariga di:

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

Ho modificato la risposta di rayzinnz per terminare lo script con una chiave specifica, in questo caso la chiave di uscita

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

Seguendo questo thread nella tana del coniglio, sono arrivato a questo, funziona su Win10 e Ubuntu 20.04. Volevo qualcosa di più che uccidere lo script e utilizzare chiavi specifiche, e doveva funzionare sia su MS che su 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()

Può essere utile installare pynput con - 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 

Questa è la soluzione che ho trovato con i thread e le librerie standard Il

ciclo continua finché non viene premuto un tasto
Restituisce il tasto premuto come una singola stringa di caratteri

Funziona in Python 2.7 e 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('  :( ')

per entrare usa 'ENTER'