Capture a interrupção do teclado em Python sem tentar, exceto

Existe alguma maneira no Python de capturar KeyboardInterrupteventos sem colocar todo o código dentro de uma instrução try- except?

Desejo sair sem deixar rastros se o usuário pressionar Ctrl+ C.

Sim, você pode instalar um manipulador de interrupção usando o sinal do módulo e esperar para sempre usando um threading . Evento :

import signal
import sys
import time
import threading

def signal_handler(signal, frame):
    print('You pressed Ctrl+C!')
    sys.exit(0)

signal.signal(signal.SIGINT, signal_handler)
print('Press Ctrl+C')
forever = threading.Event()
forever.wait()

Se tudo o que você quer é não mostrar o traceback, faça seu código assim:

## all your app logic here
def main():
   ## whatever your app does.


if __name__ == "__main__":
   try:
      main()
   except KeyboardInterrupt:
      # do nothing here
      pass

(Sim, eu sei que isso não responde diretamente à pergunta, mas não está muito claro por que a necessidade de um bloco try / except é questionável - talvez isso o torne menos incômodo para o OP)

Uma alternativa para definir seu próprio manipulador de sinal é usar um gerenciador de contexto para capturar a exceção e ignorá-la:

>>> class CleanExit(object):
...     def __enter__(self):
...             return self
...     def __exit__(self, exc_type, exc_value, exc_tb):
...             if exc_type is KeyboardInterrupt:
...                     return True
...             return exc_type is None
... 
>>> with CleanExit():
...     input()    #just to test it
... 
>>>

Isso remove o bloco try- exceptenquanto preserva alguma menção explícita do que está acontecendo.

Isso também permite que você ignore a interrupção apenas em algumas partes do seu código, sem ter que definir e redefinir novamente os manipuladores de sinal todas as vezes.

Eu sei que esta é uma pergunta antiga, mas eu vim aqui primeiro e depois descobri o atexitmódulo. Não sei sobre seu histórico de plataforma cruzada ou uma lista completa de advertências ainda, mas até agora é exatamente o que eu estava procurando ao tentar lidar com o pós- KeyboardInterruptlimpeza no Linux. Só queria apresentar outra maneira de abordar o problema.

Quero fazer uma limpeza pós-saída no contexto das operações do Fabric, portanto, encerrar tudo try/ exceptnão era uma opção para mim também. Acho que atexitpode ser um bom ajuste em tal situação, onde seu código não está no nível superior do fluxo de controle.

atexit é muito capaz e legível fora da caixa, por exemplo:

import atexit

def goodbye():
    print "You are now leaving the Python sector."

atexit.register(goodbye)

Você também pode usá-lo como um decorador (a partir de 2.6; este exemplo é dos documentos):

import atexit

@atexit.register
def goodbye():
    print "You are now leaving the Python sector."

Se você quiser torná-lo específico KeyboardInterruptapenas para , a resposta de outra pessoa a essa pergunta provavelmente é melhor.

Mas observe que o atexitmódulo tem apenas ~ 70 linhas de código e não seria difícil criar uma versão semelhante que trate as exceções de maneira diferente, por exemplo, passando as exceções como argumentos para as funções de retorno de chamada. (A limitação atexitdisso garantiria uma versão modificada: atualmente, não consigo conceber uma maneira de as funções de retorno de chamada de saída saberem sobre as exceções; o atexitmanipulador captura a exceção, chama seu (s) retorno (ões) de chamada e aumenta novamente essa exceção. Mas você poderia fazer isso de forma diferente.)

Para obter mais informações, consulte:

• Documentação oficial em atexit
• A postagem do Módulo Python da semana , uma boa introdução

Você pode evitar a impressão de um rastreamento de pilha para KeyboardInterrupt, sem try: ... except KeyboardInterrupt: pass(a solução mais óbvia e provavelmente a "melhor", mas você já a conhece e pediu outra coisa) substituindo sys.excepthook. Algo como

def custom_excepthook(type, value, traceback):
    if type is KeyboardInterrupt:
        return # do nothing
    else:
        sys.__excepthook__(type, value, traceback)

Tentei as soluções sugeridas por todos, mas tive que improvisar o código sozinho para fazê-lo funcionar. A seguir está meu código improvisado:

import signal
import sys
import time

def signal_handler(signal, frame):
    print('You pressed Ctrl+C!')
    print(signal) # Value is 2 for CTRL + C
    print(frame) # Where your execution of program is at moment - the Line Number
    sys.exit(0)

#Assign Handler Function
signal.signal(signal.SIGINT, signal_handler)

# Simple Time Loop of 5 Seconds
secondsCount = 5
print('Press Ctrl+C in next '+str(secondsCount))
timeLoopRun = True 
while timeLoopRun:  
    time.sleep(1)
    if secondsCount < 1:
        timeLoopRun = False
    print('Closing in '+ str(secondsCount)+ ' seconds')
    secondsCount = secondsCount - 1

Se alguém está em busca de uma solução rápida e mínima,

import signal

# The code which crashes program on interruption

signal.signal(signal.SIGINT, call_this_function_if_interrupted)

# The code skipped if interrupted