Python Perdono vs. Permesso e Duck Typing

In Python, ho spesso sentito che è meglio "chiedere perdono" (rilevazione delle eccezioni) invece di "chiedere l'autorizzazione" (controllo del tipo / condizione). Per quanto riguarda l'applicazione della tipizzazione anatra in Python, è questo

try:
    x = foo.bar
except AttributeError:
    pass
else:
    do(x)

meglio o peggio di

if hasattr(foo, "bar"):
    do(foo.bar)
else:
    pass

in termini di prestazioni, leggibilità, "pythonic" o qualche altro fattore importante?

Dipende davvero dalla frequenza con cui pensi che verrà generata l'eccezione.

Entrambi gli approcci sono, secondo me, ugualmente validi, almeno in termini di leggibilità e sensibilità pitonica. Ma se il 90% dei tuoi oggetti non ha l'attributo barnoterai una differenza di prestazioni distinta tra i due approcci:

>>> import timeit
>>> def askforgiveness(foo=object()):
...     try:
...         x = foo.bar
...     except AttributeError:
...         pass
... 
>>> def askpermission(foo=object()):
...     if hasattr(foo, 'bar'):
...         x = foo.bar
... 
>>> timeit.timeit('testfunc()', 'from __main__ import askforgiveness as testfunc')
2.9459929466247559
>>> timeit.timeit('testfunc()', 'from __main__ import askpermission as testfunc')
1.0396890640258789

Ma se il 90% degli oggetti non hanno l'attributo, i tavoli sono stati trasformati:

>>> class Foo(object):
...     bar = None
... 
>>> foo = Foo()
>>> timeit.timeit('testfunc(foo)', 'from __main__ import askforgiveness as testfunc, foo')
0.31336188316345215
>>> timeit.timeit('testfunc(foo)', 'from __main__ import askpermission as testfunc, foo')
0.4864199161529541

Quindi, dal punto di vista delle prestazioni, è necessario scegliere l'approccio più adatto alle proprie circostanze.

Alla fine, un uso strategico del timeitmodulo potrebbe essere la cosa più Pythonic che puoi fare.

In Python spesso ottieni prestazioni migliori facendo le cose in modo Python. Con altre lingue, l'uso delle eccezioni per il controllo del flusso è generalmente considerato un'idea terribile perché le eccezioni impongono in genere un sovraccarico straordinario. Ma poiché questa tecnica è esplicitamente approvata in Python, l'interprete è ottimizzato per questo tipo di codice.

Come per tutte le domande sulle prestazioni, l'unico modo per essere certi è creare un profilo del codice. Scrivi entrambe le versioni e vedi quale corre più veloce. Sebbene nella mia esperienza, il "modo Python" è in genere il modo più veloce.

La performance, credo, è una preoccupazione secondaria. Se si presenta, un profiler ti aiuterebbe a concentrarti sui veri colli di bottiglia, che potrebbero essere o meno il modo in cui tratti i possibili argomenti illegali.

La leggibilità e la semplicità, d'altra parte, sono sempre una delle preoccupazioni principali. Non ci sono regole rigide qui, basta usare il tuo giudizio.

Questo è un problema universale, ma le convenzioni specifiche per l'ambiente o la lingua sono rilevanti. Ad esempio, in Python di solito va bene usare semplicemente l'attributo che ci si aspetta e lasciare che un possibile AttributeError raggiunga il chiamante.

In termini di correttezza , penso che la gestione delle eccezioni sia la strada da percorrere (a volte uso l'approccio hasattr (), però). Il problema di base quando si fa affidamento su hasattr () è che trasforma le violazioni dei contratti di codice in errori silenziosi (questo è un grosso problema in JavaScript, che non genera proprietà inesistenti).