Python ignora l'eccezione e torna a dove ero

Question

So usare il codice seguente per ignorare una certa eccezione, ma come lasciare che il codice torni dove ha ottenuto l'eccezione e continua a eseguire? Di 'se l'eccezione' Exception 'aumenta in do_something1, come far sì che il codice lo ignori e continui a fare do_something1 e processa do_something2? Il mio codice si limita a bloccare definitivamente dopo il passaggio del processo tranne il blocco. Si prega di avvisare, grazie.

try: 
    do_something1 
    do_something2 
    do_something3 
    do_something4 
except Exception: 
    pass 
finally: 
    clean_up 

EDIT: Grazie per la risposta. Ora so qual è il modo corretto per farlo. Ma ecco un'altra domanda, posso semplicemente ignorare un'eccezione specifica (ad esempio se conosco il numero di errore). È possibile il codice seguente?

try: 
    do_something1 
except Exception.strerror == 10001: 
    pass 

try: 
    do_something2 
except Exception.strerror == 10002: 
    pass 
finally: 
    clean_up 

do_something3 
do_something4 

Answer 1

aggiornamento

. Il modo per ignorare le eccezioni specifiche è catturare il tipo di eccezione che desideri, testarlo per vedere se vuoi ignorarlo e rilanciarlo se non lo fai.

try: 
    do_something1 
except TheExceptionTypeThatICanHandleError, e: 
    if e.strerror != 10001: 
     raise 
finally: 
    clean_up 

Si noti inoltre, che ogni try dichiarazione bisogno di un proprio finally clausola, se si desidera avere uno. Non si "attacca" alla precedente dichiarazione try. Una dichiarazione raise con nient'altro è il modo corretto per controrilanciare l'ultima eccezione. Non permettere a nessuno di dirti altrimenti.

---

Quello che vuoi sono continuazioni che Python non fornisce nativamente. Oltre a ciò, la risposta alla tua domanda dipende esattamente da ciò che vuoi fare. Se si desidera che do_something1 continui indipendentemente dalle eccezioni, quindi , lo dovrebbe rilevare le eccezioni e ignorarle.

se si desidera che lo do_something2 si verifichi a prescindere dal fatto che do_something1 completi, è necessaria una dichiarazione separata try per ognuno.

try: 
    do_something1() 
except: 
    pass 

try: 
    do_something2() 
except: 
    pass 

ecc Se è possibile fornire un esempio più dettagliato di che cosa è che si vuole fare, allora c'è una buona probabilità che io o qualcuno più intelligente di me può o si o (più probabilmente) parlare aiutare te ne esci e proponi un'alternativa più ragionevole.

Answer 2

Non esiste un modo diretto per il codice di tornare all'interno del blocco try-except. Se, tuttavia, stai cercando di eseguire queste diverse azioni indipendenti e continua ad eseguirle quando uno fallisce (senza copiare/incollare il try/except block), dovrai scrivere qualcosa come:

actions = (
    do_something1, do_something2, #... 
    ) 
for action in actions: 
    try: 
     action() 
    except Exception, error: 
     pass 

Answer 3

Questo è praticamente il punto di eccezione.

Se la prima istruzione ha generato un'eccezione, il sistema si trova in uno stato indeterminato e si deve considerare la seguente dichiarazione come non sicura da eseguire.

Se si conoscono le affermazioni che potrebbero non riuscire e come potrebbero non riuscire, è possibile utilizzare la gestione delle eccezioni per risolvere in modo specifico i problemi che potrebbero verificarsi con un particolare blocco di istruzioni prima di passare alla sezione successiva.

Quindi, l'unica vera risposta è quella di gestire le eccezioni in giro ogni set di istruzioni che si desidera trattare come atomica

Answer 4

eccezioni sono di solito generati quando un compito l'esecuzione non può essere completata in un modo previsto dal codice a causa per alcuni motivi. Solitamente viene sollevato come eccezioni. Le eccezioni dovrebbero essere gestite e non ignorate. L'idea di eccezione è che il programma non può continuare nel normale flusso di esecuzione senza risultati anormali.

Cosa succede se si scrive un codice per aprire un file e leggerlo? Cosa succede se questo file non esiste?

È molto meglio aumentare l'eccezione. Non puoi leggere un file dove non esiste nessuno. Quello che puoi fare è gestire l'eccezione, far sapere all'utente che nessun file di questo tipo esiste. Quale vantaggio si otterrebbe per continuare a leggere il file quando non è possibile aprire un file.

In realtà le risposte di cui sopra fornite da Aaron funzionano sul principio di gestire le eccezioni.

Answer 5

si potrebbe avere tutti i do_something in un elenco e iterare attraverso di loro in questo modo, quindi non è così verboso. È possibile utilizzare le funzioni lambda al posto se avete bisogno di argomenti per le funzioni di lavoro

work = [lambda: dosomething1(args), dosomething2, lambda: dosomething3(*kw, **kwargs)] 

for each in work: 
    try: 
     each() 
    except: 
     pass 

cleanup() 

Answer 6

ho postato questo recente come una risposta a un'altra domanda. Qui si ha una funzione che restituisce una funzione che ignora ("trap") le eccezioni specificate quando si chiama qualsiasi funzione. Quindi invochi indirettamente la funzione desiderata attraverso la "trappola".

def maketrap(*exceptions): 
    def trap(func, *args, **kwargs): 
     try: 
      return func(*args, **kwargs) 
     except exceptions: 
      return None 
    return trap 

# create a trap that ignores all exceptions 
trapall = maketrap(Exception) 

# create a trap that ignores two exceptions 
trapkeyattrerr = maketrap(KeyError, AttributeError) 

# Now call some functions, ignoring specific exceptions 
trapall(dosomething1, arg1, arg2) 
trapkeyattrerr(dosomething2, arg1, arg2, arg3) 

In generale io sono con chi dice che ignorare le eccezioni è una cattiva idea, ma se lo si fa, si dovrebbe essere il più specifici possibile su quali eccezioni pensate che il vostro codice può tollerare.