The standard approach is to use the select module.

However, this doesn't work on Windows. For that, you can use the msvcrt module's keyboard polling.

Often, this is done with multiple threads -- one per device being "watched" plus the background processes that might need to be interrupted by the device.

You can use method #3 of https://stackoverflow.com/a/57644349/9997212:

Method #3: Using the function on_press_key:

import keyboard

keyboard.on_press_key("p", lambda _: print("You pressed p"))

It needs a callback function. I used _ because the keyboard function returns the keyboard event to that function.

Once executed, it will run the function when the key is pressed. You can stop all hooks by running this line:

keyboard.unhook_all()

This will allow your program to be event-oriented and will not block your main thread.

To listen to all keys instead of a specific one, use keyboard.hook. It works the same way:

import keyboard

keyboard.hook(lambda event: print(f'You pressed {event.name}'))

The key is to set up a global variable as a boolean. The hook works as an interrumption, therefore, everytime that it is triggered, you activate as True the boolean. After the check that you need you turn it back to False. Something like this:

import keyboard

try: #the try, finally is used to activate and relase the hooks to the keyboard
        
        def handle_key(event):
            global KeyPressed #the almighty global variable that monitors whether the keyboard was pressed or not.
            
            KeyPressed = True
            # print("KeyPressed is now:", event.name) #in case you want to know what did you pressed.
            return 
        
        global KeyPressed #the almighty global variable that monitors whether the keyboard was pressed or not.
        
        KeyPressed = False #initialize as False, no key was touched

        keyboard.hook(lambda event: handle_key(event) ) #this activates the detection of pressed keys. Must end with "keyboard.unhook_all()"

        if not KeyPressed: #means you have not pressed a key
            do_something()
                
        else: #Then a key was pressed
            KeyPressed = False #reset the pressed state to False
                    
        sleep(PAUSE) #wait the specified pause
finally:
        keyboard.unhook_all() #this resets the "keyboard.hook(lambda event: handle_key(event) )" so that no more keys are registered

Your question is a little bit ambiguous (as noted by @TankorSmash). But here goes...

from multiprocessing import Process, Pipe

def f(c2):
    count = 1
    while not c2.poll():
        print('hit ENTER to stop ({})'.format(count))
        count += 1

c1, c2 = Pipe()
p = Process(target=f, args=(c2,)) 
p.start()
raw_input()
c1.send(None)
p.join()

My answer still uses while, but it doesn't block the running code. Does this work for you?

Python has a keyboard module with many features. Install it, perhaps with this command:

pip3 install keyboard

Then use it in code like:

import keyboard  # using module keyboard
while True:  # making a loop
    try:  # used try so that if user pressed other than the given key error will not be shown
        if keyboard.is_pressed('q'):  # if key 'q' is pressed 
            print('You Pressed A Key!')
            break  # finishing the loop
    except:
        break  # if user pressed a key other than the given key the loop will break

# make a function that will be called when a key is pressed
def on_key_press(event):
    # check if the pressed key is the 'Up' arrow key
    if event.keysym == 'Up':
        # do whatever needs to be done when that key is pressed
        print("Hurray, up!")

# create an instance of Tk, which is the main window of the application in tkinter
root = tk.Tk()

# bind the key press event to the 'on_key_press' function for the main window
root.bind("<KeyPress>", on_key_press)

# to enter the main loop and keep the window open, waiting for events
root.mainloop()