Hey there! Let's tackle your questions step by step—first figuring out why your pynput infinite loop isn't working, then covering GUI integration, and finally how to package everything into an EXE.

There are a few common culprits for this issue:

• Blocking Listener vs. Custom Loop Conflicts
  Pynput's listeners are inherently blocking. If you try to run a while True loop alongside listener.join(), the listener's blocking call will freeze your custom loop before it ever runs. Conversely, if you start a loop without properly managing the listener's lifecycle, the listener might shut down unexpectedly.

• Unhandled Exceptions
  Even a tiny uncaught error in your key/mouse event handlers can crash the entire loop silently. For example, trying to access key.char on a special key (like Shift) without handling AttributeError will terminate the listener.

• System Permission Restrictions
  Modern OSes restrict input monitoring for security. On Windows, you might need admin rights; on macOS, you have to enable "Input Monitoring" for your script/EXE in System Settings > Privacy & Security; on Linux, you may need to install additional dependencies (like python3-xlib).

• Incorrect Listener Setup
  Using a with Listener(...) as listener: block and then writing your loop outside it will cause the listener to shut down as soon as the with block exits, making your loop useless.

Fixes to Try: #

1. Leverage the Listener's Built-in Blocking Behavior
   If your only goal is to keep the listener running indefinitely, just use listener.join()—it's designed to block the main thread until the listener stops. For background tasks alongside the listener, use threads:

   from pynput import keyboard
   import threading
   import time
   
   def on_press(key):
       try:
           print(f"Pressed: {key.char}")
       except AttributeError:
           print(f"Special key pressed: {key}")
   
   def background_task():
       while True:
           print("Running background task...")
           time.sleep(5)
   
   # Start background task in a daemon thread
   threading.Thread(target=background_task, daemon=True).start()
   
   # Start listener and block main thread
   with keyboard.Listener(on_press=on_press) as listener:
       listener.join()
   

2. Add Robust Exception Handling
   Wrap your event handler logic in try-except blocks to prevent crashes:

   def on_press(key):
       try:
           # Your logic here
           pass
       except Exception as e:
           print(f"Error in handler: {e}")
           # Return True to keep the listener running
           return True
   

3. Verify System Permissions

   • Windows: Run your script/EXE as Administrator.
   • macOS: Enable Input Monitoring for your Python interpreter or packaged EXE.
   • Linux: Install python3-xlib via your package manager.

GUI frameworks (like Tkinter, PyQt) run their own blocking main loops, so you need to run the pynput listener in a separate thread to avoid freezing the UI. Here's a quick Tkinter example (since it's built into Python):

import tkinter as tk
from pynput import keyboard
import threading

class PynputGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("Pynput + Tkinter Demo")
        
        # UI Elements
        self.log_box = tk.Text(root, width=60, height=15)
        self.log_box.pack(pady=10)
        
        self.stop_btn = tk.Button(root, text="Stop", command=self.cleanup)
        self.stop_btn.pack(pady=5)
        
        # Start pynput listener in a daemon thread
        self.listener = keyboard.Listener(on_press=self.log_key)
        self.listener_thread = threading.Thread(target=self.listener.start)
        self.listener_thread.daemon = True
        self.listener_thread.start()

    def log_key(self, key):
        try:
            log_msg = f"Pressed: {key.char}\n"
        except AttributeError:
            log_msg = f"Pressed Special Key: {key}\n"
        # Update UI safely using Tkinter's after() method (avoids thread conflicts)
        self.root.after(0, self.update_log, log_msg)

    def update_log(self, msg):
        self.log_box.insert(tk.END, msg)
        self.log_box.see(tk.END)

    def cleanup(self):
        self.listener.stop()
        self.root.destroy()

if __name__ == "__main__":
    root = tk.Tk()
    app = PynputGUI(root)
    root.mainloop()

Key Note: Never modify GUI elements directly from a non-GUI thread—use your framework's thread-safe method (like Tkinter's after() or PyQt's QMetaObject.invokeMethod()).

PyInstaller is the most reliable tool for this job. Here's how to use it:

1. Install PyInstaller

   pip install pyinstaller
   

2. Basic Packaging Command
   For a GUI script (no console window):

   pyinstaller --onefile --windowed your_script.py
   

   For a console script (keep the terminal window open):

   pyinstaller --onefile your_script.py
   

   • --onefile: Packages everything into a single EXE file.
   • --windowed: Hides the console (only for GUI apps).

3. Fix Common Packaging Issues

   • Missing Pynput Dependencies: PyInstaller sometimes misses pynput's platform-specific modules. Add them manually with --hidden-import:

     # Windows
     pyinstaller --onefile --windowed --hidden-import=pynput.keyboard._win32 --hidden-import=pynput.mouse._win32 your_script.py
     # macOS
     pyinstaller --onefile --windowed --hidden-import=pynput.keyboard._osx --hidden-import=pynput.mouse._osx your_script.py
     # Linux
     pyinstaller --onefile --hidden-import=pynput.keyboard._x11 --hidden-import=pynput.mouse._x11 your_script.py
     

   • Antivirus False Positives: Input monitoring tools often trigger antivirus alerts. Add your EXE to your antivirus whitelist, or sign it with a code signing certificate (paid) to reduce false flags.
   • Admin Rights: For Windows, you can add a manifest file to force the EXE to request admin rights, or tell users to run it as Administrator.

内容的提问来源于stack exchange，提问作者무공해