Python documentation<\/a>.<\/p>\n <\/p>\n
5. Last but not least, you should remember about testing and debugging your code. Use such debugging techniques as print<\/i> debugging; if possible \u2013 ask someone to read your code and help you to find bugs in it or to improve it; try to isolate the fragment of code that is problematic and susceptible to errors: test your functions<\/b> by applying predictable argument values, and try to handle<\/b> the situations when someone enters wrong values; comment out<\/b> the parts of the code that obscure the issue. Finally, take breaks and come back to your code after some time with a fresh pair of eyes.<\/p>\n<\/div>\n
<\/p>\n
6. You cannot add more than one anonymous (unnamed) except branch after the named ones.<\/p>\n
:\r\n# The code that always runs smoothly.\r\n:\r\ntry:\r\n :\r\n # Risky code.\r\n :\r\nexcept Except_1:\r\n # Crisis management takes place here.\r\n except Except_2:\r\n # We save the world here.\r\nexcept:\r\n # All other issues fall here.\r\n:\r\n# Back to normal.\r\n:<\/pre>\n <\/p>\n
7. All the predefined Python exceptions form a hierarchy, i.e. some of them are more general (the one named BaseException<\/code> is the most general one) while others are more or less concrete (e.g. IndexError<\/code> is more concrete than LookupError<\/code>).<\/p>\nYou should avoid placing more general exceptions before more specific ones inside the same except branche sequence. For example, you can do this:<\/p>\n
try:\r\n # Risky code.\r\nexcept IndexError:\r\n # Taking care of mistreated lists\r\nexcept LookupError:\r\n # Dealing with other erroneous lookups<\/pre>\nbut don’t do that (unless you’re absolutely sure that you want some part of your code to be useless)<\/p>\n
try:\r\n # Risky code.\r\nexcept LookupError:\r\n # Dealing with erroneous lookups\r\nexcept IndexError:\r\n # You'll never get here<\/pre>\nRemember:<\/p>\n
\n- \n
\n- the order of the branches matters!<\/li>\n
- don’t put more general exceptions before more concrete ones;<\/li>\n
- this will make the latter one unreachable and useless;<\/li>\n
- moreover, it will make your code messy and inconsistent;<\/li>\n
- Python won’t generate any error messages regarding this issue.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
Good:<\/p>\n
try:\r\n y = 1 \/ 0\r\nexcept ZeroDivisionError:\r\n print(\"Zero Division!\")\r\nexcept ArithmeticError:\r\n print(\"Arithmetic problem!\")\r\n\r\nprint(\"THE END.\")\r\n<\/pre>\nWrong:<\/p>\n
try:\r\n y = 1 \/ 0\r\nexcept ArithmeticError:\r\n print(\"Arithmetic problem!\")\r\nexcept ZeroDivisionError:\r\n print(\"Zero Division!\")\r\n\r\nprint(\"THE END.\")<\/pre>\n <\/p>\n
Example of bad use.<\/p>\n
try: \r\n raise Exception \r\nexcept BaseException: \r\n print(\"a\") \r\nexcept Exception: \r\n print(\"b\") \r\nexcept: \r\n print(\"c\") \r\n\r\n<\/pre>\na<\/code><\/p>\n <\/p>\n
8. The Python statement raise ExceptionName<\/code> can raise an exception on demand. The same statement, but lacking ExceptionName<\/code>, can be used inside the try<\/code> branch only, and raises the same exception which is currently being handled.<\/p>\nThe instruction enables you to:<\/p>\n
\n- \n
\n- simulate raising actual exceptions (e.g., to test your handling strategy)<\/li>\n
- partially handle an exception and make another part of the code responsible for completing the handling (separation of concerns).<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
def bad_fun(n):\r\n raise ZeroDivisionError\r\n\r\ntry:\r\n bad_fun(0)\r\nexcept ArithmeticError:\r\n print(\"What happened? An error?\")\r\n\r\nprint(\"THE END.\")<\/pre>\nWhat happened? An error?<\/code>
\nTHE END.<\/code><\/p>\nThe raise instruction may also be utilized in the following way (note the absence of the exception’s name):<\/p>\n
raise<\/pre>\nThere is one serious restriction: this kind of raise instruction may be used inside the except branch only; using it in any other context causes an error.<\/p>\n
The instruction will immediately re-raise the same exception as currently handled.<\/p>\n
def bad_fun(n):\r\n try:\r\n return n \/ 0\r\n except:\r\n print(\"I did it again!\")\r\n raise\r\n\r\ntry:\r\n bad_fun(0)\r\nexcept ArithmeticError:\r\n print(\"I see!\")\r\n\r\nprint(\"THE END.\")<\/pre>\nI did it again!<\/code>
\nI see!<\/code>
\nTHE END.<\/code><\/p>\n <\/p>\n
Without rise<\/code>:<\/p>\ndef bad_fun(n):\r\n try:\r\n return n \/ 0\r\n except:\r\n print(\"I did it again!\")\r\n \r\ntry:\r\n bad_fun(0)\r\nexcept ArithmeticError:\r\n print(\"I see!\")\r\n\r\nprint(\"THE END.\")\r\n<\/pre>\nI did it again!<\/code>
\nTHE END.<\/code><\/p>\n <\/p>\n
9. The Python statement assert expression<\/code><\/p>\n\n- \n
\n- evaluates the expression;<\/li>\n
- if the expression evaluates to True, or a non-zero numerical value, or a non-empty string, or any other value different than None, it won’t do anything else;<\/li>\n
- otherwise, it automatically and immediately raises an exception named
AssertionError<\/code> (in this case, we say that the assertion has failed)<\/li>\n<\/ul>\n<\/li>\n<\/ul>\nimport math\r\n\r\nx = float(input(\"Enter a number: \"))\r\nassert x >= 0.0\r\n\r\nx = math.sqrt(x)\r\n\r\nprint(x)<\/pre>\nEnter a number: 2<\/code>
\n1.4142135623730951<\/code><\/p>\nEnter a number: -1<\/code>
\nTraceback (most recent call last):<\/code>
\nFile \"main.py\", line 4, in <module><\/code>
\nassert x >= 0.0<\/code>
\nAssertionError<\/code><\/p>\n <\/p>\n
10. The else:<\/code> branch of the try<\/code> statement is executed when there has been no exception during the execution of the try:<\/code> block.<\/p>\ndef reciprocal(n):\r\n try:\r\n n = 1 \/ n\r\n except ZeroDivisionError:\r\n print(\"Division failed\")\r\n return None\r\n else:\r\n print(\"Everything went fine\")\r\n return n\r\n\r\nprint(reciprocal(2))\r\nprint(reciprocal(0))<\/pre>\nEverything went fine<\/code>
\n0.5<\/code>
\nDivision failed<\/code>
\nNone<\/code><\/p>\n <\/p>\n
11. The finally:<\/code> branch of the try<\/code> statement is always<\/b> executed.<\/p>\ndef reciprocal(n):\r\n try:\r\n n = 1 \/ n\r\n except ZeroDivisionError:\r\n print(\"Division failed\")\r\n n = None\r\n else:\r\n print(\"Everything went fine\")\r\n finally:\r\n print(\"It's time to say goodbye\")\r\n return n\r\n\r\nprint(reciprocal(2))\r\nprint(reciprocal(0))<\/pre>\nEverything went fine<\/code>
\nIt's time to say goodbye<\/code>
\n0.5<\/code>
\nDivision failed<\/code>
\nIt's time to say goodbye<\/code>
\nNone<\/code><\/p>\n <\/p>\n
12. The syntax except Exception_Name<\/i> as an exception_object<\/i>:<\/code> lets you intercept an object carrying information about a pending exception.<\/p>\ntry:\r\n i = int(\"Hello!\")\r\nexcept Exception as e:\r\n print(e)\r\n print(e.__str__())\r\n<\/pre>\ninvalid literal for int() with base 10: 'Hello!'<\/code>
\ninvalid literal for int() with base 10: 'Hello!'<\/code><\/p>\n <\/p>\n
13. A\u00a0property named args<\/code> it’s a tuple designed to gather all arguments passed to the class constructor<\/strong>. It is empty if the construct has been invoked without any arguments, or contains just one element when the constructor gets one argument (we don’t count the self<\/code> argument here), and so on.<\/p>\ndef print_args(args):\r\n lng = len(args)\r\n if lng == 0:\r\n print(\"\")\r\n elif lng == 1:\r\n print(args[0])\r\n else:\r\n print(str(args))\r\n\r\ntry:\r\n raise Exception\r\nexcept Exception as e:\r\n print(e, e.__str__(), sep=' : ' ,end=' \\n ')\r\n print_args(e.args)\r\n\r\ntry:\r\n raise Exception(\"my exception\")\r\nexcept Exception as e:\r\n print(e, e.__str__(), sep=' : ', end=' \\n ')\r\n print_args(e.args)\r\n\r\ntry:\r\n raise Exception(\"my\", \"exception\")\r\nexcept Exception as e:\r\n print(e, e.__str__(), sep=' : ', end=' \\n ')\r\n print_args(e.args)\r\n<\/pre>\n:<\/code><\/p>\nmy exception : my exception<\/code>
\nmy exception<\/code><\/p>\n('my', 'exception') : ('my', 'exception')<\/code>
\n('my', 'exception')<\/code><\/p>\n <\/p>\n
14. The exception classes can be extended to enrich them with new capabilities, or to adopt their traits to newly defined exceptions.<\/p>\n
class MyZeroDivisionError(ZeroDivisionError):\t\r\n pass\r\n\r\ndef do_the_division(mine):\r\n if mine:\r\n raise MyZeroDivisionError(\"some worse news\")\r\n else:\t\t\r\n raise ZeroDivisionError(\"some bad news\")\r\n\r\nfor mode in [False, True]:\r\n try:\r\n do_the_division(mode)\r\n except ZeroDivisionError:\r\n print('Division by zero')\r\n\r\nfor mode in [False, True]:\r\n try:\r\n do_the_division(mode)\r\n except MyZeroDivisionError:\r\n print('My division by zero')\r\n except ZeroDivisionError:\r\n print('Original division by zero')<\/pre>\nDivision by zero<\/code>
\nDivision by zero<\/code>
\nOriginal division by zero<\/code>
\nMy division by zero<\/code><\/p>\n <\/p>\n
Another example:<\/p>\n
class PizzaError(Exception):\r\n def __init__(self, pizza, message):\r\n Exception.__init__(self, message)\r\n self.pizza = pizza\r\n\r\nclass TooMuchCheeseError(PizzaError):\r\n def __init__(self, pizza, cheese, message):\r\n PizzaError.__init__(self, pizza, message)\r\n self.cheese = cheese\r\n\r\ndef make_pizza(pizza, cheese):\r\n if pizza not in ['margherita', 'capricciosa', 'calzone']:\r\n raise PizzaError(pizza, \"no such pizza on the menu\")\r\n if cheese > 100:\r\n raise TooMuchCheeseError(pizza, cheese, \"too much cheese\")\r\n print(\"Pizza ready!\")\r\n\r\nfor (pz, ch) in [('calzone', 0), ('margherita', 110), ('mafia', 20)]:\r\n try:\r\n make_pizza(pz, ch)\r\n except TooMuchCheeseError as tmce:\r\n print(tmce, ':', tmce.cheese)\r\n except PizzaError as pe:\r\n print(pe, ':', pe.pizza)<\/pre>\nPizza ready!<\/code>
\ntoo much cheese : 110<\/code>
\nno such pizza on the menu : mafia<\/code><\/p>\n <\/p>\n
Example.<\/p>\n
try:\r\n assert __name__ == \"__main__\"\r\nexcept:\r\n print(\"fail\", end=' ')\r\nelse:\r\n print(\"success\", end=' ')\r\nfinally:\r\n print(\"done\")\r\n\r\n<\/pre>\nThe code outputs: success done<\/code>.<\/p>\n <\/p>\n
<\/p>\n
\n
Built-in exceptions<\/strong><\/h1>\n<\/div>\nBaseException<\/code><\/strong><\/p>\nLocation: BaseException<\/code><\/p>\nThe most general (abstract) of all Python exceptions – all other exceptions are included in this one; It can be said that the following two except branches are equivalent: except<\/code>: and except BaseException<\/code>:.<\/p>\n <\/p>\n
\n
ArithmeticError<\/code><\/strong><\/p>\nLocation: BaseException \u2190 Exception \u2190 ArithmeticError<\/code><\/p>\nAn abstract exception including all exceptions caused by arithmetic operations like zero division or an argument’s invalid domain.<\/p>\n
<\/p>\n
AssertionError<\/code><\/strong><\/p>\nLocation: BaseException \u2190 Exception \u2190 AssertionError<\/code><\/p>\nDescription: a concrete exception raised by the assert<\/code> instruction when its argument evaluates to False<\/code>, None<\/code>, 0<\/code>, or an empty string<\/p>\nfrom math import tan, radians\r\nangle = int(input('Enter integral angle in degrees: '))\r\n\r\n# We must be sure that angle != 90 + k * 180\r\nassert angle % 180 != 90\r\nprint(tan(radians(angle)))<\/pre>\n<\/div>\n <\/p>\n
LookupError<\/code><\/strong><\/p>\nLocation: BaseException \u2190 Exception \u2190 LookupError<\/code><\/p>\nAn abstract exception including all exceptions caused by errors resulting from invalid references to different collections (lists, dictionaries, tuples, etc.)<\/p>\n
<\/p>\n
IndexError<\/code><\/strong><\/p>\nLocation: BaseException \u2190 Exception \u2190 LookupError \u2190 IndexError<\/code><\/p>\nA concrete exception raised when you try to access a non-existent sequence’s element (e.g., a list’s element)<\/p>\n
# The code shows an extravagant way\r\n# of leaving the loop.\r\n\r\nthe_list = [1, 2, 3, 4, 5]\r\nix = 0\r\ndo_it = True\r\n\r\nwhile do_it:\r\n try:\r\n print(the_list[ix])\r\n ix += 1\r\n except IndexError:\r\n do_it = False\r\n\r\nprint('Done')<\/pre>\n <\/p>\n
KeyError<\/code><\/strong><\/p>\nLocation: BaseException \u2190 Exception \u2190 LookupError \u2190 KeyError<\/code><\/p>\nA concrete exception raised when you try to access a collection’s non-existent element (e.g., a dictionary’s element)<\/p>\n
# How to abuse the dictionary\r\n# and how to deal with it?\r\n\r\ndictionary = { 'a': 'b', 'b': 'c', 'c': 'd' }\r\nch = 'a'\r\n\r\ntry:\r\n while True:\r\n ch = dictionary[ch]\r\n print(ch)\r\nexcept KeyError:\r\n print('No such key:', ch)<\/pre>\n <\/p>\n
KeyboardInterrupt<\/code><\/strong><\/p>\nLocation: BaseException \u2190 KeyboardInterrupt<\/code><\/p>\nA concrete exception raised when the user uses a keyboard shortcut designed to terminate a program’s execution (Ctrl-C<\/code> in most OSs); if handling this exception doesn’t lead to program termination, the program continues its execution.<\/p>\nNote: this exception is not derived from the Exception class. Run the program in IDLE.<\/p>\n
# This code cannot be terminated\r\n# by pressing Ctrl-C.\r\n\r\nfrom time import sleep\r\nseconds = 0\r\n\r\nwhile True:\r\n try:\r\n print(seconds)\r\n seconds += 1\r\n sleep(1)\r\n except KeyboardInterrupt:\r\n print(\"Don't do that!\")<\/pre>\n <\/p>\n
MemoryError<\/code><\/strong><\/p>\nLocation: BaseException \u2190 Exception \u2190 MemoryError<\/code><\/p>\nA concrete exception raised when an operation cannot be completed due to a lack of free memory.<\/p>\n
# This code causes the MemoryError exception.\r\n# Warning: executing this code may affect your OS.\r\n# Don't run it in production environments!\r\n\r\nstring = 'x'\r\ntry:\r\n while True:\r\n string = string + string\r\n print(len(string))\r\nexcept MemoryError:\r\n print('This is not funny!')<\/pre>\n <\/p>\n
OverflowError<\/code><\/strong><\/p>\nLocation: BaseException \u2190 Exception \u2190 ArithmeticError \u2190 OverflowError<\/code><\/p>\n
![\"\"](\"http:\/\/miro.borodziuk.eu\/wp-content\/uploads\/Exceptions1.jpg\")
<\/p>\n