Question

Possible Duplicate:
Python FAQ: “How fast are exceptions?”

I remember reading that Python implements a “Better to seek forgiveness than to ask permission” philosophy with regards to exceptions. According to the author, this meant Python code should use a lot of try – except clauses, rather than trying to determine ahead of time if you were about to do something that would cause an exception.

I just wrote some try – except clauses on my web app in which an exception will be raised most of the time the code is run. So, in this case, raising and catching an exception will be the norm. Is this bad from an efficiency point of view? I also remember someone telling me that catching a raised exception has a large performance overhead.

Is it unnecessarily inefficient to use try – except clauses in which you expect an exception to be raised and caught almost all of the time?

Here’s the code — its using the Django ORM to check for objects that associate users with various third party social providers.

try:
    fb_social_auth = UserSocialAuth.objects.get(user=self, provider='facebook')
    user_dict['facebook_id'] = fb_social_auth.uid
except ObjectDoesNotExist:
    user_dict['facebook_id'] = None

try:
    fs_social_auth = UserSocialAuth.objects.get(user=self, provider='foursquare')
    user_dict['foursquare_id'] = fs_social_auth.uid
except ObjectDoesNotExist:
    user_dict['foursquare_id'] = None

try:
    tw_social_auth = UserSocialAuth.objects.get(user=self, provider='twitter')
    user_dict['twitter_id'] = tw_social_auth.uid
except ObjectDoesNotExist:
    user_dict['twitter_id'] = None

The first one will rarely take the exception, since right now we are enforcing “Sign In With Facebook” as the primary method for new users to join the site. But, Twitter and Foursquare are optional, in case they want to import friends or followers, and I expect most people will not.

I’m open to better ways to code this logic.

Answer 1

Whenever you code there is a balancing of concerns: performance, readability, correctness, extendability, maintainability, etc.
Unfortunately, it is often not possible to improve code in each of these directions at the same time. What is fast may not be as readable for instance.

One of the reasons why try..except is encouraged in Python is because you often can not anticipate all the ways your code may be used, so rather than checking if a specific condition exists, it is more general to just catch any of a certain class of error that might arise. Thus try..except may make your code more reusable.

However, it is also true that try..except is slow if the except clause is often being reached.

Is there a way to code that block so that an exception is not being raised and use try..except to catch the less frequent condition?

Or if not, for the sake of efficiency, you may choose not to use try..except. There are few hard and fast rules in programming. You have to choose your way based on your balance of concerns.