Quante volte abbiamo utilizziamo la combo Ctrl-C per terminare i programmi lanciati dalla console di Linux? Innumerevoli: sono due tasti comodi da premere!
Sono i due tasti preposti a segnalare, solitamente alla console, la volontà di interrompere l’esecuzione di un programma.
Quante volte programmando si vorrebbe interrompere l’elaborazione del programma in qualsiasi punto della sua esecuzione in modo controllato? Con il termine controllato intendo che il programmatore ha provveduto a scrivere una routine apposita da invocare quando si vuole finire l’esecuzione del programma anzitempo.
Utilizzando Python, verifichiamo come si comporta l’interprete nei confronti dell’evento Ctrl-C. Apriamo una console e lanciamo l’interprete Python (dovreste ottenere una schermata di questo tipo):

$ python
Python 2.5.2 (r252:60911, Apr 21 2008, 11:12:42)
[GCC 4.2.3 (Ubuntu 4.2.3-2ubuntu7)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

Premendo Ctrl-C l’interprete risponde in questo modo

>>>
KeyboardInterrupt
>>>

Quindi alla pressione dei 2 tasti l’interprete risponde segnalando una KeyboardInterrupt. Vediamo adesso allora come catturare questa segnalazione, scrivendo un semplice programmino che stampi a video l’ora corrente e che l’aggiorni ogni secondo.

#!/usr/bin/env python
from time import localtime, sleep, strftime
# ciclo infinito
while 1:
    print strftime('%H:%M:%S', localtime())
    sleep(1.0)

e lo salviamo nel file pytime, ricordandoci di aggiungere al file il permesso di esecuzione chmod +x pytime, in modo da lanciarlo digitando semplicemente ./pytime e naturalmente per uscire premiamo Ctrl-C

$ ./pytime
00:33:27
00:33:28
00:33:29
00:33:30
Traceback (most recent call last):
  File "./pytime", line 6, in <module>
    sleep(1.0)
KeyboardInterrupt
$

Analizziamo un attimo il codice: è presente un unico ciclo while destinato da essere eseguito all’infinito al cui intero ci sono le istruzioni stampa ora e attendi 1 secondo. Questo programma ha ben poca intenzione di terminare in modo autonomo. Lo stampato dell’esecuzione sottolinea come la pressione dei 2 tasti abbia sollevato una KeyboardInterrupt. Sfruttiamo questa “interruzione” per terminare in modo corretto il programma.

Nel prossimo programma dovremmo indicare all’interprete Python di intercettare la pressione dei 2 tast e di eseguire l’uscita dal programma.

#!/usr/bin/env python
import sys
from time import localtime, sleep, strftime
def exit():
    """uscita dal programma"""
    sys.exit(1)
if __name__ == "__main__":
    signal(signal.SIGINT, exit)
    # ciclo infinito
    while 1:
        print strftime('%H:%M:%S', localtime())
        sleep(1.0)

Questo codice è abbastanza semplice, ma evidenza come sia possibile effettuare l’intercettazione della pressione dei 2 tasti. In particolare dobbiamo indicare all’interprete di intercettare il segnale desiderato tramite la funzione signal.
In questo caso intercettiamo il segnale SIGINT, quello relativo ai tasti Ctrl-C.
La funzione signal “lega” l’esecuzione di una funzione all’intercettazione di un dato segnale, nel nostro caso alla pressione di Ctrl-C l’interprete prevvederà ad eseguire la routine exit.
Tutto qua! Semplice, no?