Python Pardon vs Permission et Duck Typing

En Python, j'entends souvent dire qu'il est préférable de "demander pardon" (capture d'exception) au lieu de "demander l'autorisation" (vérification de type / condition). En ce qui concerne l'application de la frappe de canard en Python, est-ce que c'est

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

mieux ou pire que

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

en termes de performances, de lisibilité, de "pythonique" ou de tout autre facteur important?

Cela dépend vraiment de la fréquence à laquelle l’exception sera levée.

Les deux approches sont, à mon avis, également valables, du moins en termes de lisibilité et de pythonie. Mais si 90% de vos objets ne possèdent pas l'attribut, barvous remarquerez une différence de performance nette entre les deux approches:

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

Mais si 90% de vos objets n'ont l'attribut, les tables ont été transformées:

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

Du point de vue de la performance, vous devez donc choisir l’approche la mieux adaptée à votre situation.

En fin de compte, une utilisation stratégique du timeitmodule peut être la meilleure chose que vous puissiez faire en Pythonic.

En python, vous obtenez souvent de meilleures performances lorsque vous faites les choses à la manière de Python. Avec d'autres langages, l'utilisation d'exceptions pour le contrôle de flux est généralement considérée comme une idée terrible car les exceptions imposent généralement une surcharge extraordinaire. Mais comme cette technique est explicitement approuvée en Python, l'interpréteur est optimisé pour ce type de code.

Comme pour toutes les questions relatives aux performances, la seule façon d’en être certain est de profiler votre code. Écrivez les deux versions et voyez laquelle est la plus rapide. Selon mon expérience, la "méthode Python" est généralement la méthode la plus rapide.

Je pense que la performance est une préoccupation secondaire. Si cela se produit, un profileur vous aidera à vous concentrer sur les véritables goulots d'étranglement, ce qui peut être ou ne pas être la façon dont vous traitez les éventuels arguments illégaux.

La lisibilité et la simplicité, par contre, sont toujours une préoccupation majeure. Il n'y a pas de règles strictes ici, utilisez simplement votre jugement.

C'est un problème universel, mais les conventions spécifiques à l'environnement ou à la langue sont pertinentes. Par exemple, en Python, il est généralement préférable d’utiliser simplement l’attribut attendu et de laisser un éventuel AttributeError atteindre l’appelant.

Pour ce qui est de l' exactitude , je pense que la gestion des exceptions est la voie à suivre (j'utilise parfois l'approche hasattr () moi-même, cependant). Le problème fondamental de hasattr () est qu’il transforme les violations de contrats de code en échecs silencieux (c’est un gros problème en JavaScript, qui ne jette pas sur des propriétés non existantes).