Perdão em Python vs. Permissão e Digitação de Pato

Em Python, ouço muitas vezes que é melhor "pedir perdão" (captura de exceção) em vez de "pedir permissão" (verificação de tipo / condição). No que diz respeito à imposição de digitação de pato em Python, isso é

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

melhor ou pior que

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

em termos de desempenho, legibilidade, "pitônico" ou algum outro fator importante?

Realmente depende de quantas vezes você acha que a exceção será lançada.

Ambas as abordagens são, na minha opinião, igualmente válidas, pelo menos em termos de legibilidade e pitonismo. Mas se 90% dos seus objetos não tiverem o atributo, barvocê notará uma diferença de desempenho distinta entre as duas abordagens:

>>> 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

Mas se 90% dos seus objetos não têm o atributo, as mesas foram viradas:

>>> 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

Portanto, do ponto de vista do desempenho, você precisa escolher a abordagem que melhor funciona para suas circunstâncias.

No final, algum uso estratégico do timeitmódulo pode ser a coisa mais pitônica que você pode fazer.

Em python, você geralmente obtém melhor desempenho fazendo as coisas da maneira Python. Em outros idiomas, o uso de exceções para controle de fluxo é geralmente considerado uma péssima idéia, porque as exceções normalmente impõem uma sobrecarga extraordinária. Mas, como essa técnica é explicitamente recomendada em Python, o intérprete é otimizado para esse tipo de código.

Como em todas as questões de desempenho, a única maneira de ter certeza é criar um perfil do seu código. Escreva as duas versões e veja qual delas roda mais rápido. Embora, na minha experiência, o "caminho Python" seja tipicamente o caminho mais rápido.

Sinto-me que o desempenho é uma preocupação secundária. Se surgir, um criador de perfil ajudará você a se concentrar nos gargalos reais, que podem ou não ser como você trata possíveis argumentos ilegais.

Legibilidade e simplicidade, por outro lado, são sempre uma preocupação primordial. Não há regras rígidas aqui, apenas use seu julgamento.

Essa é uma questão universal, mas as convenções específicas ao ambiente ou ao idioma são relevantes. Por exemplo, no Python, geralmente é bom simplesmente usar o atributo que você espera e permitir que um possível AttributeError alcance o chamador.

Em termos de correção , acho que o tratamento de exceções é o caminho a seguir (às vezes uso a abordagem hasattr ()). O problema básico de confiar em hasattr () é que ele transforma violações de contratos de código em falhas silenciosas (esse é um grande problema no JavaScript, que não gera propriedades não existentes).