Unter Eingabe von sys.stdin, non-blocking

Durch drehen blockieren ausgeschaltet, können Sie nur Lesen ein Zeichen in einer Zeit. Also, es gibt keinen Weg, um readline() arbeiten in einer non-blocking-Kontext. Ich nehme an, Sie wollen einfach nur read-Taste drückt, um den Roboter zu Steuern.

Hatte ich kein Glück mit select.select() auf Linux und die Möglichkeit geschaffen, mit tweaking termios Einstellungen. So, das ist Linux-spezifisch, aber funktioniert bei mir:

old_settings=None

def init_anykey():
   global old_settings
   old_settings = termios.tcgetattr(sys.stdin)
   new_settings = termios.tcgetattr(sys.stdin)
   new_settings[3] = new_settings[3] & ~(termios.ECHO | termios.ICANON) # lflags
   new_settings[6][termios.VMIN] = 0  # cc
   new_settings[6][termios.VTIME] = 0 # cc
   termios.tcsetattr(sys.stdin, termios.TCSADRAIN, new_settings)

@atexit.register
def term_anykey():
   global old_settings
   if old_settings:
      termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old_settings)

def anykey():
   ch_set = []
   ch = os.read(sys.stdin.fileno(), 1)
   while ch != None and len(ch) > 0:
      ch_set.append( ord(ch[0]) )
      ch = os.read(sys.stdin.fileno(), 1)
   return ch_set;

init_anykey()
while True:
   key = anykey()
   if key != None:
      print key
   else:
      time.sleep(0.1)

Besser Windows oder cross-Plattform-Antwort finden Sie hier: Python-nicht blockierende Konsolen-Eingabe

Können Sie Selektoren für Griff-I/O-multiplexing:

https://docs.python.org/3/library/selectors.html

Probieren Sie es aus:

#! /usr/bin/python3

import sys
import fcntl
import os
import selectors

# set sys.stdin non-blocking
orig_fl = fcntl.fcntl(sys.stdin, fcntl.F_GETFL)
fcntl.fcntl(sys.stdin, fcntl.F_SETFL, orig_fl | os.O_NONBLOCK)

# function to be called when enter is pressed
def got_keyboard_data(stdin):
    print('Keyboard input: {}'.format(stdin.read()))

# register event
m_selector = selectors.DefaultSelector()
m_selector.register(sys.stdin, selectors.EVENT_READ, got_keyboard_data)

while True:
    sys.stdout.write('Type something and hit enter: ')
    sys.stdout.flush()
    for k, mask in m_selector.select():
        callback = k.data
        callback(k.fileobj)

Dem obigen code wird halten Sie auf der Linie

for k, mask in m_selector.select():

bis ein registriertes event Auftritt, wird die Rücksendung eines selector_key Instanz (k) und eine Maske der zu überwachenden Ereignisse.

In dem obigen Beispiel haben wir nur registriert, ein Ereignis (Enter-Taste drücken):

m_selector.register(sys.stdin, selectors.EVENT_READ, got_keyboard_data)

Den Selektor Schlüssel-Instanz ist wie folgt definiert:

abstractmethod register(fileobj, events, data=None)

Daher, die register-Methode sets-k.Daten, wie Sie unsere callback-Funktion got_keyboard_data, und nennt es, wenn die Geben Sie - Taste gedrückt wird :

    callback = k.data
    callback(k.fileobj)

Ein vollständigeres Beispiel (und hoffentlich nützlicher) wäre die multiplex stdin Daten von Benutzer ankommende verbindungen aus dem Netzwerk:

import selectors
import socket
import sys
import os
import fcntl

m_selector = selectors.DefaultSelector()

# set sys.stdin non-blocking
def set_input_nonblocking():
    orig_fl = fcntl.fcntl(sys.stdin, fcntl.F_GETFL)
    fcntl.fcntl(sys.stdin, fcntl.F_SETFL, orig_fl | os.O_NONBLOCK)

def create_socket(port, max_conn):
    server_addr = ('localhost', port)
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server.setblocking(False)
    server.bind(server_addr)
    server.listen(max_conn)
    return server

def read(conn, mask):
    global GO_ON
    client_address = conn.getpeername()
    data = conn.recv(1024)
    print('Got {} from {}'.format(data, client_address))
    if not data:
         GO_ON = False

def accept(sock, mask):
    new_conn, addr = sock.accept()
    new_conn.setblocking(False)
    print('Accepting connection from {}'.format(addr))
    m_selector.register(new_conn, selectors.EVENT_READ, read)

def quit():
    global GO_ON
    print('Exiting...')
    GO_ON = False


def from_keyboard(arg1, arg2):
    line = arg1.read()
    if line == 'quit\n':
        quit()
    else:
        print('User input: {}'.format(line))

GO_ON = True
set_input_nonblocking()

# listen to port 10000, at most 10 connections
server = create_socket(10000, 10)

m_selector.register(server, selectors.EVENT_READ, accept)
m_selector.register(sys.stdin, selectors.EVENT_READ, from_keyboard)

while GO_ON:
    sys.stdout.write('>>> ')
    sys.stdout.flush()
    for k, mask in m_selector.select():
        callback = k.data
        callback(k.fileobj, mask)


# unregister events
m_selector.unregister(sys.stdin)

# close connection
server.shutdown()
server.close()

#  close select
m_selector.close()

Können Sie testen, mit zwei Klemmen.
erste terminal:

$ python3 test.py 
>>> bla

öffnen Sie ein weiteres terminal und führen:

 $ nc localhost 10000
 hey!

zurück zu der ersten

>>> qwerqwer     

Ergebnis (gesehen auf der main terminal):

$ python3 test.py 
>>> bla
User input: bla

>>> Accepting connection from ('127.0.0.1', 39598)
>>> Got b'hey!\n' from ('127.0.0.1', 39598)
>>> qwerqwer     
User input: qwerqwer

>>> 

Verwenden einen generator, der - zum Glück sys.stdin ist bereits ein generator!

Einen generator ermöglicht Ihnen die Arbeit auf einem unendlichen Strom. Immer, wenn Sie es nennen, es gibt das nächste element. Um einen generator benötigen Sie das yield Stichwort.

for line in sys.stdin:
    print line

    if a_certain_situation_happens:
        break        

Nicht vergessen, ein break - Anweisung in die Schleife, wenn eine bestimmte, wünschte situation passiert.

Finden Sie weitere Informationen über Generatoren auf:

• http://www.dabeaz.com/generators/index.html
• http://linuxgazette.net/100/pramode.html