Perché questo script python viene eseguito in background consumando il 100% di CPU?

Voglio eseguire un semplice script Python in background che legge il testo dagli Appunti e lo stampa. Ecco il mio codice

#!/usr/bin/env python

import Tkinter

last_clipboard = ""

def get_clipboard():
  global last_clipboard
  root = Tkinter.Tk()
  root.withdraw() # Hide the main window (optional)
  text_in_clipboard = root.clipboard_get()
  if text_in_clipboard != last_clipboard:
    last_clipboard = text_in_clipboard
    print last_clipboard


while True:
  get_clipboard()

Funziona come previsto ma consuma troppa CPU (100% CPU).

Come posso farlo funzionare correttamente senza consumare così tanto?

Hai dimenticato il time.sleep()nel tuo whileloop, secondo questa risposta su SO dormire per 0,2 secondi è un buon compromesso tra frequenza di polling e carico della CPU:

import time

while True:
  get_clipboard()
  time.sleep(0.2) # sleep for 0.2 seconds

Controllare gli appunti ogni 0,2 secondi sembra abbastanza spesso abbastanza spesso; se vuoi meno carico della CPU puoi persino aumentare questo valore: pochi utenti cambiano il contenuto degli appunti da un secondo all'altro.

Si noti che in generale il polling in un ciclo spesso non è considerato un buon design. Un approccio migliore sarebbe quello di agire in caso di modifica del contenuto degli appunti, un esempio per GTK può essere trovato in questa risposta SO .

Ulteriori letture

• articolo di linuxconfig.org su Python While Loops
• cyberciti.biz articolo su time.sleep()
• articolo di blog su Come far aspettare Python discutendo di modi diversi, alcuni dei quali sono molto più elaborati e flessibili rispetto allo staticotime.sleep()

Finalmente riesco a farlo funzionare senza loop. Questo è il codice:

Ho dovuto installare alcuni moduli: sudo apt install python3-gi python3-gi-cairo gir1.2-gtk-3.0

#!/usr/bin/env python3
import gi, sys
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, Gdk

last_clipboard = ""

def callBack(*args):
  global last_clipboard
  new_clipboard = clip.wait_for_text()
  if new_clipboard != last_clipboard:
    last_clipboard = new_clipboard
    print("new Clipboard")
    print(new_clipboard)

clip = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
clip.connect('owner-change',callBack)
Gtk.main()

sentiti libero di scegliere la soluzione adatta a te.

Stai eseguendo la cosa in un while True:ciclo! Ciò significa che la CPU esegue costantemente il loop. Basta aggiungere una piccola pausa lì e dovresti vedere precipitare l'utilizzo della CPU:

#!/usr/bin/env python

import Tkinter
import time

last_clipboard = ""

def get_clipboard():
  global last_clipboard
  root = Tkinter.Tk()
  root.withdraw() # Hide the main window (optional)
  text_in_clipboard = root.clipboard_get()
  if text_in_clipboard != last_clipboard:
    last_clipboard = text_in_clipboard
    print last_clipboard

while True:
  get_clipboard()
  time.sleep(1)

Sono stato incuriosito da questo progetto, quindi ho scritto uno script bash per quelli più a suo agio in quell'ambiente:

#!/bin/bash

xclip -o -sel clip > /tmp/LastClip

while true ; do 

    xclip -o -sel clip > /tmp/NewClip
    diff -q /tmp/LastClip /tmp/NewClip > /tmp/DiffClip
    if [[ -s /tmp/DiffClip ]] ; then
        cat /tmp/NewClip    # For testing dump to screen instead of printing
        cp -a /tmp/NewClip /tmp/LastClip
    fi
    sleep 1.0

done

Richiede il xclippacchetto di Xorg :

sudo apt install xclip

Sta scaricando il contenuto degli appunti sullo schermo usando il catcomando. Se si desidera la copia cartacea invece sostituirla catcon lpe specificare il nome della stampante, l'orientamento e possibilmente l'opzione "adatta alla pagina".

Vedrai un po 'di ritardo sullo schermo perché scelgo sleep 1.0quale sarebbe invisibile con una stampante e ancora più veloce di quanto le persone possano evidenziare il testo e usare Ctrl+ C.

Se copi negli Appunti lo stesso identico testo evidenziato, ciò non determina alcuna differenza. Una lettera in più o in meno attiverà una risposta.