Python “异常处理机制” ——Python面试100道实战题目练习，巩固知识、检查技术、成功就业

第一章：选择题

题1：在Python中，用于捕获异常的关键字是： A. catch B. try C. except D. finally

题2：下列哪个语句可以单独使用来捕获所有类型的异常？ A. except Exception as e B. except C. except BaseException as e D. except Error as e

题3：当使用try…except语句时，如果希望在捕获异常后执行一些清理工作，无论是否发生异常都会执行，应该使用哪个关键字？ A. finally B. else C. elif D. cleanup

题4：以下哪个选项不能作为try…except语句中except后面跟的异常类型？ A. ValueError B. ZeroDivisionError C. SyntaxError D. TypeError

题5：在Python中，可以使用raise关键字来： A. 捕获异常 B. 触发一个异常 C. 忽略异常 D. 停止程序运行

题6：下列关于try…except…else结构的说法，哪一个是正确的？ A. else块在try块执行成功且没有异常发生时执行 B. else块在except块执行后总是执行 C. else块用于捕获特定的异常 D. else块可以单独使用，不需要try和except

题7：当你想要捕获多个特定的异常类型时，应该怎么做？ A. 使用多个except语句 B. 使用逗号分隔异常类型在单个except语句中 C. 使用or关键字连接异常类型 D. 使用and关键字连接异常类型

题8：下列哪个函数或方法可以用来获取当前异常的详细信息？ A. sys.exc_info() B. traceback.format_exc() C. str(exception) D. 以上都可以

题9：在Python中，自定义异常类应该继承自哪个基类？ A. BaseException B. Exception C. Error D. RuntimeError

题10：当在try块中发生异常且没有被任何except块捕获时，程序将： A. 正常运行 B. 终止并显示错误信息 C. 跳转到else块 D. 跳转到finally块

题11：在Python中，try…except语句块中，else部分和finally部分的执行顺序是： A. else先执行，然后finally执行（如果try成功） B. finally先执行，然后else执行（如果try成功） C. else和finally总是同时执行 D. else只在try成功时执行，finally总是执行

题12：以下哪个异常是在尝试除以零时引发的？ A. ZeroDivisionError B. ValueError C. TypeError D. ArithmeticError

题13：当你想要捕获一个异常并重新引发它时，应该怎么做？ A. 使用raise关键字再次引发 B. 使用except关键字再次捕获 C. 无需做任何操作，异常会自动重新引发 D. 使用pass语句忽略异常

题14：在Python中，try…except…finally结构中，finally块的主要目的是什么？ A. 捕获异常 B. 执行清理代码，如关闭文件或释放资源 C. 忽略异常 D. 替代else块的功能

题15：下列哪个函数或方法可以用来获取当前异常对象的类型？ A. sys.exc_info()[0] B. traceback.format_exc() C. str(exception) D. exception.type

题16：在自定义异常类时，如果你想在引发异常时显示自定义的错误信息，你应该怎么做？ A. 在异常类的构造函数中定义__str__方法 B. 在异常类的构造函数中定义__repr__方法 C. 在引发异常时使用str(message) D. 在try块中捕获异常后打印错误信息

题17：当你在try块中引发了一个异常，但没有对应的except块来处理它，将会发生什么？ A. 程序将正常继续执行 B. 程序将终止，并显示一个错误跟踪 C. 异常将被自动忽略 D. finally块将捕获并处理该异常

题18：下列哪个语句可以用来捕获所有类型的异常，并且还能获取异常对象？ A. except Exception as e B. except BaseException as e C. except as e D. except:, e = sys.exc_info()[1]

题19：在Python中，try…except…else…finally结构中的else和finally块是否都可以省略？ A. 是的，它们都可以省略 B. 不，else块可以省略，但finally块不能 C. 不，finally块可以省略，但else块不能 D. 它们都不能省略，必须同时使用

题20：下列哪个表达式可以正确地表示一个自定义异常类？ A. class MyError(Exception): pass B. class MyError: pass C. def MyError(Exception): pass D. MyError = Exception

题21：在Python中，with语句通常用于什么目的？ A. 捕获异常 B. 管理资源，如文件或网络连接 C. 定义上下文管理器 D. 替代try…finally结构

题22：下列哪个表达式可以正确地打开一个文件并立即使用with语句关闭它？ A. with open(‘file.txt’, ‘r’): f = open(‘file.txt’, ‘r’) B. with open(‘file.txt’, ‘r’) as f: pass C. f = open(‘file.txt’, ‘r’); with f: pass D. with f = open(‘file.txt’, ‘r’): pass

题23：当你使用with语句时，如果上下文管理器没有实现__enter__或__exit__方法，将会发生什么？ A. 程序将正常继续执行 B. 程序将抛出AttributeError C. with语句将不起作用 D. 程序将抛出TypeError

题24：在Python中，contextlib.contextmanager装饰器的主要作用是什么？ A. 将一个生成器函数转换为上下文管理器 B. 捕获并处理异常 C. 管理线程或进程上下文 D. 提供额外的装饰功能，如日志记录

题25：下列哪个语句可以用来检查一个对象是否支持上下文管理协议（即是否具有__enter__和__exit__方法）？ A. hasattr(obj, ‘enter’) and hasattr(obj, ‘exit’) B. isinstance(obj, ContextManager) C. obj.context_manager D. obj.is_context_manager()

题26：在使用with语句时，__enter__方法返回的对象通常用于什么？ A. 作为上下文管理器的标识符 B. 在with块外部访问文件或资源 C. 在with块内部使用资源或文件对象 D. 控制异常的传播

题27：下列哪个表达式可以正确地使用contextlib.suppress来抑制特定的异常？ A. with suppress(Exception): … B. with suppress(ValueError, ZeroDivisionError): … C. suppress(Exception): … D. try: … except suppress(Exception): …

题28：当你在with语句的__exit__方法中返回True时，意味着什么？ A. 异常已被处理，不需要进一步传播 B. 上下文管理器已成功完成其任务 C. with块中的代码引发了异常 D. with块中的代码没有引发异常

题29：在Python中，try…except…finally和with语句在资源管理方面的主要区别是什么？ A. try…except…finally更灵活，可以处理更复杂的资源释放逻辑 B. with语句更简洁，自动处理资源的获取和释放 C. try…except…finally可以捕获更多的异常类型 D. with语句只能用于文件操作

题30：下列哪个表达式展示了如何使用contextlib.closing来自动关闭一个对象（如文件对象）？ A. with closing(open(‘file.txt’, ‘r’)) as f: … B. closing(open(‘file.txt’, ‘r’)): … C. with f = closing(open(‘file.txt’, ‘r’)): … D. try: f = open(‘file.txt’, ‘r’); finally: closing(f)

题31：在Python中，super()函数的主要用途是什么？ A. 调用父类的构造函数 B. 调用当前类的构造函数 C. 调用父类的方法，但仅限于__init__ D. 调用父类的方法，包括但不限于__init__

题32：下列哪个表达式正确地使用了super()来调用父类的__init__方法？ A. super().init() B. super(ClassName, self).init() C. ClassName.init(self) D. self.init()

题33：在多重继承的情况下，super()函数如何确保每个父类的方法只被调用一次？ A. 通过维护一个内部调用栈 B. 通过检查类名和方法名 C. 通过递归调用父类的方法 D. 通过在类中定义一个特殊的属性

题34：下列哪个方法可以用来在子类中重写父类的方法？ A. override B. redefine C. 使用与父类相同的方法名 D. super_method

题35：在Python中，__mro__属性代表什么？ A. 类的成员列表 B. 方法的解析顺序 C. 类的继承树 D. 类的属性字典

题36：下列哪个表达式可以用来检查一个类是否是另一个类的子类？ A. issubclass(ClassA, ClassB) B. isinstance(obj, ClassA) C. ClassA in ClassB.subclasses() D. ClassA.bases

题37：在使用super()时，如果当前类没有直接父类，将会发生什么？ A. 抛出AttributeError B. 抛出TypeError C. super()将返回None D. super()将调用object类的相应方法（如果存在）

题38：下列哪个表达式展示了如何在多重继承中正确地使用super()来调用所有父类的方法？ A. 在每个子类的__init__方法中调用super().init() B. 手动调用每个父类的__init__方法 C. 使用__init__方法的一个变体名来避免冲突 D. 在子类的构造函数外部调用super()

题39：在Python中，metaclass的主要作用是什么？ A. 定义类的行为 B. 定义对象的行为 C. 管理类的内存分配 D. 提供额外的装饰功能，如日志记录

题40：下列哪个表达式可以用来创建一个使用自定义元类的类？ A. class MyClass(metaclass=MyMetaClass): … B. MyClass = MyMetaClass(MyClass) C. MyClass = type(‘MyClass’, (MyMetaClass,), {}) D. class MyClass(MyMetaClass.new()): …

第二章：判断题

题目1： 在Python中，异常处理是通过try和except关键字来实现的。

题目2： 如果一个函数在执行过程中抛出了一个异常，而这个异常没有被捕获，那么程序会立即终止。

题目3： 使用try…except语句时，只能捕获一个特定的异常类型。

题目4： else子句在try…except语句中是必需的，用于指定当没有异常发生时执行的代码。

题目5： finally子句在try…except语句中是可选的，它包含的代码无论是否发生异常都会执行。

题目6： 在Python中，可以使用raise关键字来手动抛出一个异常。

题目7： 捕获异常时，可以使用as关键字来给异常对象命名。

题目8： 所有的异常类型都是Exception类的子类。

题目9： 在Python中，异常对象一旦被捕获，就不能再次被抛出。

题目10： try…except…else…finally结构中，else子句和finally子句不能同时存在。

题目11： 在Python中，自定义异常类必须继承自BaseException类。

题目12： 使用try…except语句捕获异常时，如果except块中没有处理完异常，则异常会继续向上传播。

题目13： 在Python中，可以使用sys.exc_info()函数来获取当前异常的信息。

题目14： try…except语句只能捕获在try块中直接引发的异常。

题目15： 在Python中，异常处理机制仅适用于运行时错误，不适用于语法错误。

题目16： 捕获异常后，可以使用traceback模块来打印异常的堆栈跟踪。

题目17： 在Python中，可以使用with语句来自动管理资源，如文件操作，它会在代码块执行完毕后自动关闭文件，无论是否发生异常。

题目18： 在try…except语句中，可以使用多个except块来捕获不同类型的异常。

题目19： 在Python中，如果一个函数内部抛出了一个异常，但该异常在函数外部没有被捕获，那么整个程序会崩溃。

题目20： 在Python中，异常对象一旦创建，其属性就不能被修改。

题目21： 在Python中，可以使用else子句在try…except语句中指定当没有异常发生时执行的代码，但else子句是必需的。

题目22： try…except语句中的except块可以没有异常类型，这样它会捕获所有类型的异常。

题目23： 在Python中，自定义异常类时，必须重写__init__方法。

题目24： try…finally语句中的finally块总是会执行，即使try块中包含了return语句。

题目25： 在Python中，可以使用try…except…else…finally结构来同时处理异常、执行无异常时的代码以及确保某些代码无论如何都会执行。

题目26： 异常传播的过程中，如果某个异常被捕获并处理，那么它就不会继续向上传播。

题目27： 在Python中，try块和except块可以嵌套使用。

题目28： try…except语句只能捕获由Python解释器抛出的异常，不能捕获由用户自定义函数抛出的异常。

题目29： 在Python中，异常处理机制可以提高代码的健壮性和可读性。

题目30： 捕获异常后，可以使用raise语句重新抛出当前捕获的异常，但必须使用相同的异常类型和异常对象。

题目31： 在Python中，异常对象一旦创建，其类型就不能改变。

题目32： try…except语句可以捕获由第三方库函数抛出的异常。

题目33： 在Python中，自定义异常类时，继承自Exception类是最常见的做法。

题目34： try…finally语句中的finally块可以包含return语句，这将覆盖try块中的return语句。

题目35： 在Python中，可以使用raise语句在else子句中抛出异常。

题目36： 异常传播的过程中，如果某个异常被捕获并处理，那么它的堆栈跟踪信息会被清除。

题目37： 在Python中，try块中的代码可以包含多个语句，但通常建议只包含一个可能引发异常的语句，以提高代码的可读性。

题目38： try…except语句中的except块可以捕获多个异常类型，只需将它们作为元组列出。

题目39： 在Python中，异常处理机制只能用于捕获和处理运行时异常，不能用于处理编译时异常。

题目40： 捕获异常后，可以使用sys.exc_clear()函数来清除当前异常的状态。

第三章：填空题

题目1： 在Python中，异常处理机制主要通过使用 __________ 和 __________ 关键字来实现。

题目2： 当你想要捕获所有可能发生的异常时，可以使用 __________ 作为异常类型。

题目3： 你可以使用 __________ 语句来捕获特定类型的异常，并且可以根据需要添加多个这样的语句来处理不同类型的异常。

题目4： 当异常被捕获后，并且相应的处理代码块执行完毕后，程序将继续执行 __________ 的代码。

题目5： 可以通过 __________ 函数获取异常的详细信息。

题目6： 使用 __________ 语句可以捕获并忽略特定的异常，而不执行任何处理代码。

题目7： 如果想要在执行完异常处理代码后，再次引发当前捕获的异常，可以使用 __________ 语句。

题目8： Python中，使用 __________ 语句可以引发一个异常。

题目9： 你可以使用 __________ 语句来为自定义异常类命名。

题目10： 当在捕获异常的过程中，引发了另一个异常，这种情况称为 __________。

题目11： 在Python中，try…except语句之后，可以有一个可选的__________子句，用于指定当没有异常发生时执行的代码。

题目12： 当异常发生时，Python会搜索与该异常类型相匹配的__________块来处理它。

题目13： 如果在try块中引发了异常，但没有找到匹配的except块，那么该异常会__________传播到上层调用者。

题目14： 在try…except…finally结构中，无论是否发生异常，__________块中的代码都会执行。

题目15： 在Python中，可以使用__________函数来检查当前线程是否有未处理的异常。

第四章：实战题

题目1：处理文件读取异常

编写一个Python程序，该程序尝试从一个名为example.txt的文件中读取内容，并将其打印到控制台。如果文件不存在或读取过程中发生其他I/O错误，请捕获这些异常并打印一条友好的错误消息。

题目2：处理除零异常

编写一个Python程序，该程序要求用户输入两个数字，并计算它们的除法结果。如果用户在输入过程中输入了非数字字符，或者在除法运算中除以零，请捕获这些异常并打印一条友好的错误消息。

题目3：处理网络请求异常

编写一个Python程序，该程序使用requests库向一个指定的URL发送GET请求，并打印响应内容。如果请求过程中发生网络错误（如连接超时、DNS解析失败等），请捕获这些异常并打印一条友好的错误消息。

题目4：处理JSON解析异常

编写一个Python程序，该程序尝试从一个字符串中解析JSON数据。如果字符串不是有效的JSON格式，或者解析过程中发生其他错误，请捕获这些异常并打印一条友好的错误消息。

题目5：处理数据库连接异常

编写一个Python程序，该程序使用sqlite3库尝试连接到一个SQLite数据库文件，并在数据库中创建一个新表。如果连接数据库失败（如文件不存在且无法创建，或者权限不足），请捕获这些异常并打印一条友好的错误消息。

答案

选择题

题1： 答案：B

• 解析：在Python中，try关键字用于开始一个异常处理块，而except用于捕获异常，finally用于执行清理工作，catch不是Python中的关键字。

题2： 答案：C

• 解析：BaseException是所有异常的基类，包括Exception和SystemExit等。except BaseException as e可以捕获所有类型的异常。except单独使用是不合法的，Exception会捕获除了系统退出等以外的所有标准异常，但不包括如SystemExit等由BaseException直接派生的异常。Error不是Python中的标准异常基类。

题3： 答案：A

• 解析：finally块用于执行清理代码，无论是否发生异常，finally块中的代码都会被执行。

题4： 答案：C

• 解析：SyntaxError是在代码解析阶段发生的错误，不是运行时异常，因此不能通过try…except捕获。

题5： 答案：B

• 解析：raise关键字用于触发一个异常，可以显式地抛出一个错误。

题6： 答案：A

• 解析：在try…except…else结构中，else块仅在try块成功执行且没有异常发生时执行。

题7： 答案：B

• 解析：可以通过在单个except语句中使用逗号分隔多个异常类型来捕获多个特定的异常。

题8： 答案：D

• 解析：sys.exc_info()返回一个包含当前异常信息的元组；traceback.format_exc()返回格式化后的异常字符串；str(exception)可以将异常对象转换为字符串表示。这三者都可以用来获取异常的详细信息。

题9： 答案：B

• 解析：自定义异常类应该继承自Exception类或其子类。

题10： 答案：B

• 解析：如果try块中发生异常且没有被任何except块捕获，程序将终止并显示错误信息。finally块中的代码仍然会被执行，但它不捕获异常。

题11： 答案：D

• 解析：在try…except…else…finally结构中，如果try块成功执行没有异常发生，else块将执行；无论是否发生异常，finally块都会执行，但finally总是在else（如果有的话）之后执行。

题12： 答案：A

• 解析：当尝试除以零时，Python会引发ZeroDivisionError异常。

题13： 答案：A

• 解析：如果你想要捕获一个异常并重新引发它（可能是为了记录日志或进行某些处理后再引发），你可以使用raise关键字再次引发它。

题14： 答案：B

• 解析：finally块的主要目的是执行清理代码，如关闭文件、释放资源等，无论是否发生异常，finally块中的代码都会被执行。

题15： 答案：A

• 解析：sys.exc_info()[0]返回当前异常对象的类型。traceback.format_exc()返回格式化后的异常字符串，str(exception)将异常对象转换为字符串表示，而exception.type不是Python中的标准属性。

题16： 答案：A

• 解析：在自定义异常类中，如果你想在引发异常时显示自定义的错误信息，你应该在异常类的构造函数中定义__str__方法（或__repr__方法，但__str__更常用于显示错误信息）。

题17： 答案：B

• 解析：如果try块中引发了一个异常，但没有对应的except块来处理它，程序将终止，并显示一个错误跟踪（包括堆栈跟踪和异常信息）。

题18： 答案：B

• 解析：BaseException是所有异常的基类，包括Exception和SystemExit等。except BaseException as e可以捕获所有类型的异常，并且还能获取异常对象e。except as e是不合法的语法，except:, e = sys.exc_info()[1]虽然可以获取异常对象，但不是标准的异常捕获方式。

题19： 答案：A

• 解析：在Python中，try…except…else…finally结构中的else和finally块都是可选的，它们都可以省略。只使用try和except块也是合法的。

题20： 答案：A

• 解析：自定义异常类应该继承自Exception类或其子类。正确的表示方式是class MyError(Exception): pass。

题21： 答案：B

• 解析：with语句在Python中通常用于管理资源，如文件或网络连接，确保这些资源在使用后能够被正确关闭或释放。

题22： 答案：B

• 解析：with open(‘file.txt’, ‘r’) as f: pass是正确使用with语句打开并立即关闭文件的表达式。as f将open函数返回的文件对象赋值给变量f，而with语句确保文件在使用后会被关闭。

题23： 答案：D

• 解析：如果上下文管理器没有实现__enter__或__exit__方法，with语句将抛出TypeError异常，因为它期望上下文管理器是一个具有这些方法的对象。

题24： 答案：A

• 解析：contextlib.contextmanager装饰器的主要作用是将一个生成器函数转换为上下文管理器，允许它使用with语句。

题25： 答案：A

• 解析：要检查一个对象是否支持上下文管理协议，可以使用hasattr函数来检查对象是否具有__enter__和__exit__方法。

题26： 答案：C

• 解析：在使用with语句时，__enter__方法返回的对象通常用于在with块内部使用资源或文件对象。这个返回值被赋值给as子句中的变量。

题27： 答案：B

• 解析：contextlib.suppress用于抑制特定的异常，可以传入一个或多个异常类型。正确的使用方式是with suppress(ValueError, ZeroDivisionError): …。

题28： 答案：A

• 解析：当with语句的__exit__方法返回True时，意味着异常已被处理，不需要进一步传播。如果返回False或没有返回值（默认为None），则异常会被正常传播。

题29： 答案：B

• 解析：try…except…finally和with语句在资源管理方面的主要区别是with语句更简洁，它自动处理资源的获取和释放，而try…except…finally则需要手动编写资源获取和释放的代码。

题30： 答案：A

• 解析：contextlib.closing用于自动关闭一个对象（如文件对象），正确的使用方式是with closing(open(‘file.txt’, ‘r’)) as f: …。这确保了文件在使用后会被正确关闭。

题31： 答案：D

• 解析：super()函数在Python中用于调用父类的方法，包括但不限于__init__。它允许子类调用父类中定义的方法，而无需直接引用父类名。

题32： 答案：A

• 解析：在Python 3中，super()函数可以不带参数调用，它会隐式地传递当前类和实例（self）给super()，从而正确地调用父类的__init__方法。因此，super().init()是正确的调用方式。

题33： 答案：A

• 解析：在多重继承的情况下，super()函数通过维护一个内部调用栈来确保每个父类的方法只被调用一次。这个调用栈跟踪了已经访问过的类和方法，从而避免了重复调用。

题34： 答案：C

• 解析：在子类中重写父类的方法是通过使用与父类相同的方法名来实现的。当子类定义了与父类同名的方法时，子类的方法将覆盖父类的方法。

题35： 答案：B

• 解析：在Python中，__mro__属性代表方法的解析顺序（Method Resolution Order）。它是一个元组，包含了类及其父类（包括间接父类）的线性化顺序，用于确定在继承中如何解析方法调用。

题36： 答案：A

• 解析：issubclass(ClassA, ClassB)函数用于检查ClassA是否是ClassB的子类。如果ClassA是ClassB的子类（或相同的类），则返回True；否则返回False。

题37： 答案：D

• 解析：在使用super()时，如果当前类没有直接父类（即它是object类的直接子类或本身就是object类），super()将调用object类的相应方法（如果存在）。如果没有相应的方法，则调用将失败，但通常不会抛出异常，而是返回None或执行其他默认行为。然而，在严格意义上，这里的描述更接近于super()将尝试调用object类的方法，因此选择D作为最接近正确答案的选项。

题38： 答案：A

• 解析：在多重继承中，为了确保所有父类的方法都被正确调用，应该在每个子类的__init__方法中调用super().init()。这样做可以确保按照方法的解析顺序（MRO）依次调用每个父类的__init__方法。

题39： 答案：A

• 解析：在Python中，metaclass是一个用于定义类的行为的特殊类。它允许你控制类的创建过程，包括设置类的属性、方法以及继承关系等。通过定义自定义元类，你可以为类添加额外的功能或行为。

题40： 答案：A

• 解析：在Python中，要创建一个使用自定义元类的类，可以在类定义时使用metaclass关键字参数。例如，class MyClass(metaclass=MyMetaClass): …将创建一个使用MyMetaClass作为元类的MyClass类。这是创建自定义元类实例的最常见和推荐的方法。选项B和C虽然也可以创建类实例，但它们不是使用自定义元类创建类的标准方法。选项D中的语法是错误的。

判断题

题目1： 正确

• 解析：在Python中，使用try块来包裹可能引发异常的代码，使用except块来捕获和处理这些异常。

题目2： 错误

• 解析：如果一个函数在执行过程中抛出了一个异常，而这个异常没有被捕获（即没有相应的try…except语句来处理），那么异常会传播到调用该函数的地方。如果最终都没有被捕获，程序会打印一个错误消息并终止，但这一过程被称为“异常传播”，而不是立即终止程序运行的所有部分。

题目3： 错误

• 解析：try…except语句可以捕获多个异常类型，通过在except后面列出多个异常类型（用逗号分隔），或者使用单个except语句并指定Exception基类来捕获所有异常。

题目4： 错误

• 解析：else子句在try…except语句中是可选的，它用于指定当没有异常发生时执行的代码。不是每个try…except结构都必须有else子句。

题目5： 正确

• 解析：finally子句是可选的，但它非常有用，因为它包含的代码无论是否发生异常都会执行。常用于清理资源，如关闭文件或释放锁。

题目6： 正确

• 解析：raise关键字用于显式地抛出一个异常，可以是预定义的异常类型，也可以是自定义的异常类型。

题目7： 正确

• 解析：在except语句中，可以使用as关键字给捕获的异常对象命名，这允许在except块中访问异常对象的属性和方法。

题目8： 正确

• 解析：在Python的异常层次结构中，几乎所有的异常类型（除了内置的SystemExit、KeyboardInterrupt等）都是Exception类的子类。

题目9： 错误

• 解析：捕获异常后，可以在except块中处理它，然后使用raise语句再次抛出（可能是重新抛出当前捕获的异常，也可能是抛出另一个新的异常）。

题目10： 错误

• 解析：在Python的try…except…else…finally结构中，else子句和finally子句可以同时存在。else子句在没有异常发生时执行，而finally子句无论是否发生异常都会执行。

题目11： 错误

• 解析：在Python中，自定义异常类应该继承自Exception类（或Exception的子类），而不是BaseException类。BaseException是所有异常的基类，包括系统退出和键盘中断等不应该被普通try…except语句捕获的异常。

题目12： 正确

• 解析：如果在except块中没有处理完异常（即没有在except块中使用return、break、continue等语句跳出当前异常处理流程），则异常会继续向上传播，直到找到能够处理它的except块，或者程序终止。

题目13： 正确

• 解析：sys.exc_info()函数返回一个包含当前异常信息的三元组（type, value, traceback），其中type是异常类型，value是异常对象，traceback是异常的堆栈跟踪信息。

题目14： 错误

• 解析：try…except语句不仅可以捕获在try块中直接引发的异常，还可以捕获在try块中调用的函数或方法内部引发的异常，只要这些异常传播到try块外部并被相应的except块捕获。

题目15： 正确

• 解析：Python的异常处理机制主要用于捕获和处理运行时错误，如除零错误、文件不存在错误等。对于语法错误，Python解释器在代码执行之前就会检测并报告，因此无法通过try…except语句来捕获和处理。

题目16： 正确

• 解析：traceback模块提供了打印和处理异常的堆栈跟踪信息的功能。在捕获异常后，可以使用traceback模块的相关函数来打印异常的详细堆栈跟踪信息。

题目17： 正确

• 解析：with语句用于自动管理资源，如文件操作、线程锁等。它会在代码块执行完毕后自动调用资源的清理方法（通常是资源的__exit__方法），无论是否发生异常。这使得资源管理更加简洁和安全。

题目18： 正确

• 解析：在try…except语句中，可以使用多个except块来捕获不同类型的异常。每个except块指定一个异常类型（或异常类型的元组），并包含处理该类型异常的代码。当异常发生时，Python会依次检查每个except块，直到找到能够处理该异常的块。

题目19： 错误

• 解析：如果一个函数内部抛出了一个异常，但该异常在函数外部没有被捕获，那么异常会传播到调用该函数的地方。如果最终都没有被捕获，程序会打印一个错误消息并终止当前线程的执行（对于多线程程序），但不会导致整个程序崩溃（除非是在主线程中抛出了未捕获的异常）。

题目20： 错误

• 解析：在Python中，异常对象一旦创建，其某些属性（如异常消息和堆栈跟踪）可能是不可变的，但其他属性（如自定义异常类的实例属性）是可以被修改的。不过，通常不建议修改异常对象的属性，因为这可能会导致异常处理逻辑变得复杂和难以维护。

题目21： 错误

• 解析：在try…except语句中，else子句是可选的，用于指定当没有异常发生时执行的代码。它不是必需的。

题目22： 正确（但需注意最佳实践）

• 解析：try…except语句中的except块可以省略异常类型，从而捕获所有类型的异常。然而，这种做法通常不推荐，因为它会隐藏潜在的错误，使得调试变得更加困难。更好的做法是捕获具体的异常类型，或者至少捕获Exception类及其子类。

题目23： 错误

• 解析：在Python中，自定义异常类时，并不一定要重写__init__方法。如果只需要默认的初始化行为，可以省略重写。当然，如果需要自定义初始化逻辑（如添加额外的属性），则需要重写__init__方法。

题目24： 正确

• 解析：在try…finally语句中，finally块总是会执行，无论try块中是否发生了异常，以及是否包含了return、break或continue语句。这使得finally块非常适合用于清理资源，如关闭文件或释放锁。

题目25： 正确

• 解析：try…except…else…finally结构是Python中异常处理的一种完整形式，它允许同时处理异常、执行无异常时的代码以及确保某些代码无论如何都会执行。

题目26： 正确

• 解析：异常传播的过程中，如果某个异常被捕获并处理（即在except块中执行了相应的代码），那么它就不会继续向上传播到调用栈的更高层次。

题目27： 正确

• 解析：在Python中，try块和except块可以嵌套使用，这允许在更细粒度的层次上捕获和处理异常。

题目28： 错误

• 解析：try…except语句不仅可以捕获由Python解释器抛出的异常，还可以捕获由用户自定义函数抛出的异常。只要这些异常是通过raise语句抛出的，并且它们的类型与except块中指定的类型相匹配（或省略类型以捕获所有异常）。

题目29： 正确

• 解析：异常处理机制是编程中的一种重要工具，它允许程序员在代码中处理潜在的错误情况，从而提高代码的健壮性和可读性。通过捕获和处理异常，可以避免程序因未处理的错误而崩溃，并提供有用的错误消息来帮助调试。

题目30： 错误

• 解析：捕获异常后，可以使用raise语句重新抛出当前捕获的异常。但是，并不必须使用相同的异常类型和异常对象。可以使用raise语句重新抛出捕获的异常（不带任何参数），这将保留原始异常的类型和对象。另外，也可以抛出一个新的异常对象（可能是相同类型的另一个实例，或者是完全不同类型的异常）。

题目31： 正确

• 解析：在Python中，异常对象一旦创建，其类型（即异常类）是固定的，不能改变。异常对象的其他属性（如消息字符串、堆栈跟踪等）可能可以修改，但类型本身是不可变的。

题目32： 正确

• 解析：try…except语句可以捕获由任何Python代码抛出的异常，包括第三方库函数。只要这些异常是通过raise语句抛出的，并且它们的类型与except块中指定的类型相匹配（或省略类型以捕获所有异常）。

题目33： 正确

• 解析：在Python中，自定义异常类时，继承自Exception类是最常见的做法。Exception是所有标准异常的基类（除了SystemExit、KeyboardInterrupt和GeneratorExit），因此自定义异常类通常应该继承自它或它的子类。

题目34： 正确

• 解析：在try…finally语句中，finally块可以包含return语句。如果finally块中的return语句被执行，它将覆盖try块中的任何return语句（以及else子句中的return语句，如果有的话）。这是因为finally块总是会在try块或else子句之后执行，无论是否发生了异常。

题目35： 正确

• 解析：在Python中，else子句是try…except语句的可选部分，用于指定当没有异常发生时执行的代码。虽然else子句通常用于执行正常流程的代码，但也可以使用raise语句在其中抛出异常。

题目36： 错误

• 解析：异常传播的过程中，如果某个异常被捕获并处理（即在except块中执行了相应的代码），那么它的堆栈跟踪信息不会被清除。相反，异常对象及其堆栈跟踪信息仍然可以被访问（例如，通过sys.exc_info()函数）。只是异常本身不再继续向上传播。

题目37： 正确（但需注意实践中的灵活性）

• 解析：虽然try块中的代码可以包含多个语句，但为了提高代码的可读性和可维护性，通常建议将可能引发异常的语句单独放在try块中。这样做可以更容易地确定哪些语句可能引发异常，并相应地处理它们。然而，在实践中，有时需要将多个相关语句放在try块中以捕获和处理它们可能引发的共同异常。

题目38： 正确

• 解析：在try…except语句中，except块可以捕获多个异常类型。为此，可以将这些异常类型作为元组列出在except关键字之后。当异常发生时，Python会检查这个元组中的每个异常类型，直到找到能够匹配当前异常的类型。

题目39： 正确（但需注意术语的准确性）

• 解析：在Python中，异常处理机制主要用于捕获和处理运行时异常（即在程序执行过程中发生的异常）。然而，需要注意的是，Python没有传统意义上的“编译时异常”。Python代码是在解释器运行时动态地解释和执行的，因此所谓的“编译时异常”通常指的是在代码解析阶段由解释器报告的语法错误或静态分析错误。这些错误不是通过异常处理机制来捕获和处理的，而是由解释器直接报告给用户的。

题目40： 正确

• 解析：在Python中，sys.exc_clear()函数用于清除当前线程中记录的异常状态（即清除由最近一次未处理的异常设置的sys.exc_info()返回的值）。这通常用于在异常被处理后清理异常状态，以避免对后续代码产生不必要的干扰。然而，需要注意的是，在大多数情况下，不需要手动调用sys.exc_clear()来清除异常状态，因为异常处理机制会在处理完异常后自动清除它。但在某些情况下（例如，在异常处理代码中需要再次引发相同的异常时），可能需要手动调用该函数来确保异常状态被正确清除。

填空题

题1： 在Python中，异常处理机制主要通过使用 try 和 except 关键字来实现。

• 解析：try 块包含可能引发异常的代码，而 except 块则包含处理这些异常的代码。

题2： 当你想要捕获所有可能发生的异常时，可以使用 Exception 作为异常类型。

• 解析：Exception 是所有内建异常类的基类，捕获它可以处理几乎所有异常。

题3： 你可以使用 except 语句来捕获特定类型的异常，并且可以根据需要添加多个这样的语句来处理不同类型的异常。

• 解析：通过指定不同的异常类型，可以在不同的 except 块中处理不同类型的异常。

题4： 当异常被捕获后，并且相应的处理代码块执行完毕后，程序将继续执行 try 块之后的代码。

• 解析：异常处理完毕后，程序控制流会回到 try 块之后的代码继续执行。

题5： 可以通过 str() 函数获取异常的详细信息。

• 解析：str() 函数可以将异常对象转换为字符串，显示异常的描述信息。

题6： 使用 pass 语句可以捕获并忽略特定的异常，而不执行任何处理代码。

• 解析：pass 是一个空操作语句，当用它来作为 except 块的内容时，相当于捕获异常但不做任何处理。

题7： 如果想要在执行完异常处理代码后，再次引发当前捕获的异常，可以使用 raise 语句。

• 解析：使用 raise 语句可以在异常处理之后重新引发当前捕获的异常。

题8： Python中，使用 raise 语句可以引发一个异常。

• 解析：raise 语句可以用来引发一个指定的异常，可以附带异常对象和描述信息。

题9： 你可以使用 class 语句来为自定义异常类命名。

• 解析：通过定义一个继承自 Exception 的类，可以创建自定义的异常类。

题10： 当在捕获异常的过程中，引发了另一个异常，这种情况称为 异常链（Exception Chaining）。

• 解析：在捕获异常的处理代码中再次引发另一个异常时，Python会保留原始异常的上下文信息，这被称为异常链。

题11： 在Python中，try…except语句之后，可以有一个可选的else子句，用于指定当没有异常发生时执行的代码。

• 解析：else子句是try…except语句的可选部分，当没有异常被捕获时，else子句中的代码会被执行。

题12： 当异常发生时，Python会搜索与该异常类型相匹配的except块来处理它。

• 解析：Python会按照try…except语句中except块的顺序，查找与异常类型相匹配的except块来处理异常。

题13： 如果在try块中引发了异常，但没有找到匹配的except块，那么该异常会向上层调用者传播。

• 解析：如果异常没有在当前的try…except语句中被捕获，它会继续传播到调用该代码的函数或方法中，直到找到匹配的except块或程序终止。

题14： 在try…except…finally结构中，无论是否发生异常，finally块中的代码都会执行。

• 解析：finally块用于执行清理代码，如关闭文件、释放资源等，无论是否发生异常，finally块中的代码都会执行。

题15： 在Python中，可以使用sys.exc_info()函数来检查当前线程是否有未处理的异常。

• 解析：sys.exc_info()函数返回一个包含当前异常信息的三元组（异常类型、异常对象、堆栈跟踪信息），如果没有未处理的异常，则返回(None, None, None)。

实战题

题目1答案：

# 导入os模块，用于检查文件是否存在  
import os  
  
# 定义文件路径  
file_path = 'example.txt'  
  
# 检查文件是否存在  
if not os.path.exists(file_path):  
    # 如果文件不存在，打印错误消息  
    print(f"Error: The file '{file_path}' does not exist.")  
else:  
    try:  
        # 尝试打开并读取文件内容  
        with open(file_path, 'r') as file:  
            content = file.read()  
            # 打印文件内容  
            print(content)  
    except FileNotFoundError:  
        # 捕获文件未找到异常（虽然前面已经检查过，但这里为了演示异常处理机制）  
        print(f"Error: The file '{file_path}' was not found.")  
    except IOError:  
        # 捕获其他I/O错误  
        print(f"Error: An I/O error occurred while reading the file '{file_path}'.")  
  
# 假设example.txt文件存在且内容为"Hello, World!"，则运行结果为：  
# Hello, World!  
# 如果文件不存在，则运行结果为：  
# Error: The file 'example.txt' does not exist.

• 导入os模块用于检查文件是否存在。
• 定义文件路径file_path。
• 使用os.path.exists()函数检查文件是否存在，如果不存在则直接打印错误消息。
• 如果文件存在，则使用try…except语句块尝试读取文件内容。
• with open(file_path, ‘r’) as file:语句使用上下文管理器打开文件，确保文件在操作完成后自动关闭。
• 读取文件内容并打印。
• 捕获FileNotFoundError异常（虽然前面已经检查过文件存在性，但这里为了演示异常处理机制）。
• 捕获IOError异常以处理其他可能的I/O错误。

题目2答案

# 提示用户输入两个数字  
num1 = input("Enter the first number: ")  
num2 = input("Enter the second number: ")  
  
try:  
    # 将用户输入转换为浮点数  
    num1 = float(num1)  
    num2 = float(num2)  
    # 计算除法结果  
    result = num1 / num2  
    # 打印结果  
    print(f"The result of the division is: {result}")  
except ValueError:  
    # 捕获值错误异常（用户输入非数字字符）  
    print("Error: Please enter valid numbers.")  
except ZeroDivisionError:  
    # 捕获除零异常  
    print("Error: Division by zero is not allowed.")  
  
# 假设用户输入为：  
# Enter the first number: 10  
# Enter the second number: 0  
# 则运行结果为：  
# Error: Division by zero is not allowed.  
# 如果用户输入为：  
# Enter the first number: abc  
# Enter the second number: 5  
# 则运行结果为：  
# Error: Please enter valid numbers.

• 提示用户输入两个数字，并将输入存储在num1和num2变量中。
• 使用try…except语句块尝试将用户输入转换为浮点数。
• 如果转换成功，则计算除法结果并打印。
• 捕获ValueError异常以处理用户输入非数字字符的情况。
• 捕获ZeroDivisionError异常以处理除以零的情况。
• 根据不同的异常类型打印相应的错误消息。

题目3答案

# 导入requests库  
import requests  
  
# 定义要请求的URL  
url = 'http://example.com'  
  
try:  
    # 发送GET请求，设置超时时间为5秒  
    response = requests.get(url, timeout=5)  
    # 检查响应状态码是否为200（OK）  
    if response.status_code == 200:  
        # 打印响应内容  
        print(response.text)  
    else:  
        # 如果状态码不是200，打印错误信息  
        print(f"Error: Received status code {response.status_code} from the server.")  
except requests.exceptions.RequestException as e:  
    # 捕获requests库抛出的所有异常类型  
    print(f"Error: {e}")  
  
# 假设请求成功且响应内容为"Hello, World!"，则运行结果为：  
# Hello, World!  
# 如果URL不可达或请求超时，则运行结果为类似：  
# Error: HTTPConnectionPool(host='example.com', port=80): Max retries exceeded with url: / (Caused by ConnectTimeoutError(<urllib3.connection.HTTPConnection object at 0x...>, 'Connection to example.com timed out. (connect timeout=5)'))

• 导入requests库。
• 定义要请求的URL。
• 使用try…except语句块发送GET请求，并设置超时时间为5秒。
• 检查响应状态码是否为200（OK），如果是则打印响应内容。
• 如果状态码不是200，打印错误信息。
• 捕获requests.exceptions.RequestException异常，该异常是requests库抛出的所有异常类型的基类，用于处理网络错误等异常情况。

题目4答案：

# 导入json库  
import json  
  
# 定义要解析的JSON字符串（这里故意使用一个无效的JSON格式作为示例）  
json_str = '{"name": "Alice", "age": 30, "city": "Wonderland", "extra_comma": }'  
  
try:  
    # 尝试解析JSON字符串  
    data = json.loads(json_str)  
    # 打印解析后的数据  
    print(data)  
except json.JSONDecodeError as e:  
    # 捕获JSON解析异常  
    print(f"Error: {e}")  
  
# 假设json_str是一个有效的JSON字符串，则运行结果为解析后的字典对象。  
# 由于这里的json_str是无效的，所以运行结果为：  
# Error: Expecting property name enclosed in double quotes: line 1 column 42 (char 41)

• 导入json库。
• 定义一个要解析的JSON字符串，这里故意使用一个无效的JSON格式作为示例。
• 使用try…except语句块尝试解析JSON字符串。
• 如果解析成功，打印解析后的数据。
• 捕获json.JSONDecodeError异常，该异常是json库在解析无效JSON格式时抛出的异常。
• 打印异常信息，包括错误位置和描述。

题目5答案

import sqlite3  
  
# 定义数据库文件路径  
db_path = 'example.db'  
  
try:  
    # 尝试连接到SQLite数据库  
    conn = sqlite3.connect(db_path)  
    cursor = conn.cursor()  
      
    # 创建新表  
    create_table_sql = '''  
    CREATE TABLE IF NOT EXISTS users (  
        id INTEGER PRIMARY KEY AUTOINCREMENT,  
        name TEXT NOT NULL,  
        age INTEGER NOT NULL  
    )  
    '''  
    cursor.execute(create_table_sql)  
      
    # 提交事务  
    conn.commit()  
      
    # 打印成功消息  
    print("Table created successfully.")  
      
except sqlite3.Error as e:  
    # 捕获SQLite数据库相关的异常  
    print(f"Error: {e}")  
      
finally:  
    # 确保连接被关闭  
    if conn:  
        conn.close()  
  
# 假设数据库文件不存在且程序有权限创建它，则运行结果为：  
# Table created successfully.  
# 如果数据库文件无法被创建或连接（如权限不足），则运行结果为类似：  
# Error: unable to open database file

• 导入sqlite3库。
• 定义数据库文件路径db_path。
• 使用try…except…finally语句块尝试连接到SQLite数据库。
• 在try块中，创建数据库连接对象conn和游标对象cursor。
• 使用SQL语句创建新表，如果表已存在则不执行创建操作（CREATE TABLE IF NOT EXISTS）。
• 提交事务以保存更改。
• 捕获sqlite3.Error异常，该异常是sqlite3库抛出的所有数据库相关异常的基类。
• 在finally块中，确保数据库连接被关闭，无论是否发生异常。