Are nested try except blocks in Python a good programming practice

Question

I m writing my own container  which needs to give access to a dictionary inside by attribute calls  The typical use of the container would be like this  dict container   DictContainer   dict container  foo     bar     print dict container foo  I know that it might be stupid to write something like this  but that s the functionality I need to provide  I was thinking about implementing this in a following way  def   getattribute   self  item       try          return object   getattribute   item      except AttributeError          try              return self dict item          except KeyError              print  quot The object doesn t have such attribute quot   I m not sure whether nested try except blocks are a good practice  so another way would be to use hasattr   and has key    def   getattribute   self  item           if hasattr self  item               return object   getattribute   item          else              if self dict has key item                   return self dict item              else                  raise AttributeError  quot some customised error quot    Or to use one of them and one try catch block like this  def   getattribute   self  item       if hasattr self  item           return object   getattribute   item      else          try              return self dict item          except KeyError              raise AttributeError  quot some customised error quot    Which option is most Pythonic and elegant

User · Answer

In my opinion  this would be the most Pythonic way to handle it  although and because it makes your question moot  Note that this defines   getattr     instead of   getattribute       because doing so means it only has to deal with the  quot special quot  attributes being kept in the internal dictionary  def   getattr   self  name        quot  quot  quot Only called when an attribute lookup in the usual places has failed quot  quot  quot      try          return self my dict name      except KeyError          raise AttributeError  quot some customized error message quot

User · Answer

In Python it is easier to ask for forgiveness than permission  Don t sweat the nested exception handling   Besides  has  almost always uses exceptions under the cover anyway

User · Answer

While in Java it s indeed a bad practice to use exceptions for flow control  mainly because exceptions force the JVM to gather resources  more here    in Python you have two important principles  duck typing and EAFP  This basically means that you are encouraged to try using an object the way you think it would work  and handle when things are not like that  In summary  the only problem would be your code getting too much indented  If you feel like it  try to simplify some of the nestings  like lqc suggested in the suggested answer above

User · Answer

A good and simple example for nested try except could be the following  import numpy as np  def divide x  y       try          out   x y     except          try              out   np inf   x   abs x          except              out   np nan     finally          return out   Now try various combinations and you will get the correct result  divide 15  3    5 0  divide 15  0    inf  divide -15  0    -inf  divide 0  0    nan    Of course  we have NumPy  so we don t need to create this function

User · Answer

try       if it gone wrong then it will go to except except      try           if it also go wrong then it will go to except     except          try               if it also go wrong then  it will go to except         except               print  write what is your need    code for above content  def        try          A   5         raise SyntaxError     except          try             A   5            raise SyntaxError        except             try                 A   5                raise SyntaxError            except                 print  None      finally        return A

User · Answer

I don t think it s a matter of being Pythonic or elegant  It s a matter of preventing exceptions as much as you can  Exceptions are meant to handle errors that might occur in code or events you have no control over  In this case  you have full control when checking if an item is an attribute or in a dictionary  so avoid nested exceptions and stick with your second attempt

User · Answer

If try-except-finally is nested inside a finally block  the result from  quot child quot  finally is preserved  I have not found an official explanation yet  but the following code snippet shows this behavior in Python 3 6  def f2        try          a   4         raise SyntaxError     except SyntaxError as se          print  log SE           raise se from None     finally          try              raise ValueError         except ValueError as ve              a   5             print  log VE               raise ve from None         finally              return 6         return a  In  1   f2   log SE log VE Out 2   6

User · Answer

I like to avoid raising a new exception while handling an old one   It makes the error messages confusing to read  For example  in my code  I originally wrote try      return tuple   getitem   self  i  key  except IndexError      raise KeyError key   And I got this message   gt  gt  gt  During handling of above exception  another exception occurred   I wanted this  try      return tuple   getitem   self  i  key  except IndexError      pass raise KeyError key   It doesn t affect how exceptions are handled   In either block of code  a KeyError would have been caught   This is merely an issue of getting style points

User · Answer

For your specific example  you don t actually need to nest them   If the expression in the try block succeeds  the function will return  so any code after the whole try except block will only be run if the first attempt fails   So you can just do   def   getattribute   self  item       try          return object   getattribute   item      except AttributeError          pass       execution only reaches here when try block raised AttributeError     try          return self dict item      except KeyError          print  The object doesn t have such attribute    Nesting them isn t bad  but I feel like leaving it flat makes the structure more clear  you re sequentially trying a series of things and returning the first one that works   Incidentally  you might want to think about whether you really want to use   getattribute   instead of   getattr   here   Using   getattr   will simplify things because you ll know that the normal attribute lookup process has already failed

User · Answer

According to the documentation  it is better to handle multiple exceptions through tuples or like this  import sys  try      f   open  myfile txt       s   f readline       i   int s strip    except IOError as e      print  quot I O error  0     1  quot  format e errno  e strerror  except ValueError      print  quot Could not convert data to an integer  quot  except      print  quot Unexpected error   quot   sys exc info   0      raise

User · Answer

Your first example is perfectly fine  Even the official Python documentation recommends this style known as EAFP  Personally  I prefer to avoid nesting when it s not necessary  def   getattribute   self  item       try          return object   getattribute   item      except AttributeError          pass    Fallback to dict     try          return self dict item      except KeyError          raise AttributeError  quot The object doesn t have such attribute quot   from None  PS  has key   has been deprecated for a long time in Python 2  Use item in self dict instead

User · Answer

Just be careful - in this case the first finally is touched  but skipped too  def a z       try          100 z     except ZeroDivisionError          try              print  x           finally              return 42     finally          return 1   In  1   a 0  x Out 1   1

[python] Are nested try/except blocks in Python a good programming practice?

Examples related to python