...     open('database.sqlite') 
... except IOError: 
...     raise RuntimeError from None 
... Traceback (most recent call last):   File "", line 4, in  RuntimeError  
>>> try:
...     open('database.sqlite') 
... except IOError:
...     raise RuntimeError from None 
...Traceback (most recent call last):File "", line 4, in RuntimeError 


 
 8.6. User-defined Exceptions  
 
 8.6. 用户自定义异常
 
Programs may name their own exceptions by creating a new exception class (see Classes for more about Python classes).  Exceptions should typically be derived from the "Exception" class, either directly or indirectly. 
 
程序可以通过创建新的异常类来命名它们自己的异常（有关Python 类的更多信息，请参阅 类）。异常通常应该直接或间接地从 "Exception" 类派生。

 
Exception classes can be defined which do anything any other class can do, but are usually kept simple, often only offering a number of attributes that allow information about the error to be extracted by handlers for the exception.  When creating a module that can raise several distinct errors, a common practice is to create a base class for exceptions defined by that module, and subclass that to create specific exception classes for different error conditions: 
 
可以定义异常类，它可以执行任何其他类可以执行的任何操作，但通常保持简单，通常只提供许多属性，这些属性允许处理程序为异常提取有关错误的信息。在创建可能引发多个不同错误的模块时，通常的做法是为该模块定义的异常创建基类，并为不同错误条件创建特定异常类的子类:

 
   class Error(Exception): 
       """Base class for exceptions in this module.""" 
       pass 
 
   class InputError(Error): 
       """Exception raised for errors in the input. 
 
       Attributes: 
           expression -- input expression in which the error occurred 
           message -- explanation of the error 
       """ 
 
       def __init__(self, expression, message): 
           self.expression = expression 
           self.message = message 
 
   class TransitionError(Error): 
       """Raised when an operation attempts a state transition that's not 
       allowed. 
 
       Attributes: 
           previous -- state at beginning of transition 
           next -- attempted new state 
           message -- explanation of why the specific transition is not allowed 
       """ 
 
       def __init__(self, previous, next, message): 
           self.previous = previous 
           self.next = next 
           self.message = message 
 
Most exceptions are defined with names that end in "Error", similar to the naming of the standard exceptions. 
 
大多数异常都定义为名称以“Error”结尾，类似于标准异常的命名。

 
Many standard modules define their own exceptions to report errors that may occur in functions they define.  More information on classes is presented in chapter Classes. 
 
许多标准模块定义了它们自己的异常，以报告它们定义的函数中可能出现的错误。有关类的更多信息，请参见类 类。

 


 
 8.7. Defining Clean-up Actions  
 
 8.7. 定义清理操作
 
The "try" statement has another optional clause which is intended to define clean-up actions that must be executed under all circumstances. For example: 
 
"try" 语句有另一个可选子句，用于定义必须在所有情况下执行的清理操作。例如:

 
   >>> try: 
   ...     raise KeyboardInterrupt 
   ... finally: 
   ...     print('Goodbye, world!') 
   ... 
   Goodbye, world! 
   Traceback (most recent call last): 
     File "", line 2, in  
   KeyboardInterrupt 
 
If a "finally" clause is present, the "finally" clause will execute as the last task before the "try" statement completes. The "finally" clause runs whether or not the "try" statement produces an exception. The following points discuss more complex cases when an exception occurs: 
 
If a "finally" clause is present, the "finally" clause will execute asthe last task before the "try" statement completes. The "finally"clause runs whether or not the "try" statement produces an exception.The following points discuss more complex cases when an exceptionoccurs:

 
• If an exception occurs during execution of the "try" clause, the   exception may be handled by an "except" clause. If the exception is   not handled by an "except" clause, the exception is re-raised after   the "finally" clause has been executed. 
 
• If an exception occurs during execution of the "try" clause, theexception may be handled by an "except" clause. If the exception isnot handled by an "except" clause, the exception is re-raised afterthe "finally" clause has been executed.

 
• An exception could occur during execution of an "except" or "else"   clause. Again, the exception is re-raised after the "finally" clause   has been executed. 
 
• An exception could occur during execution of an "except" or "else"clause. Again, the exception is re-raised after the "finally" clausehas been executed.

 
• If the "try" statement reaches a "break", "continue" or "return"   statement, the "finally" clause will execute just prior to the   "break", "continue" or "return" statement's execution. 
 
• If the "try" statement reaches a "break", "continue" or "return"statement, the "finally" clause will execute just prior to the"break", "continue" or "return" statement's execution.

 
• If a "finally" clause includes a "return" statement, the "finally"   clause's "return" statement will execute before, and instead of, the   "return" statement in a "try" clause. 
 
• If a "finally" clause includes a "return" statement, the "finally"clause's "return" statement will execute before, and instead of, the"return" statement in a "try" clause.

 
For example: 
 
For example:

 
   >>> def bool_return(): 
   ...     try: 
   ...         return True 
   ...     finally: 
   ...         return False 
   ... 
   >>> bool_return() 
   False 
 
A more complicated example: 
 

   >>> def divide(x, y): 
   ...     try: 
   ...         result = x / y 
   ...     except ZeroDivisionError: 
   ...         print("division by zero!") 
   ...     else: 
   ...         print("result is", result) 
   ...     finally: 
   ...         print("executing finally clause") 
   ... 
   >>> divide(2, 1) 
   result is 2.0 
   executing finally clause 
   >>> divide(2, 0) 
   division by zero! 
   executing finally clause 
   >>> divide("2", "1") 
   executing finally clause 
   Traceback (most recent call last): 
     File "", line 1, in  
     File "", line 3, in divide 
   TypeError: unsupported operand type(s) for /: 'str' and 'str' 
 

8.8. Predefined Clean-up Actions

8.8. 预定义的清理操作

   for line in open("myfile.txt"): 
       print(line, end="") 
 

   with open("myfile.txt") as f: 
       for line in f: 
           print(line, end="")