如何抛出和捕获多个异常？Python 异常组介绍

# 在异常组中包含异常组，并使用异常 BaseException
BaseExceptionGroup(
	'异常组 BaseExceptionGroup',
	[BaseExceptionGroup('包含在异常组中的异常组', [BaseException()])]
)


# 在异常组 ExceptionGroup 中使用异常 BaseException
ExceptionGroup(
	'异常组 ExceptionGroup',
	# ERROR 不能包含 BaseException
	[Exception(), BaseException()]
)

# SystemExit 直接继承自 BaseException
err = BaseExceptionGroup('异常组 BaseExceptionGroup', (SystemExit(),))
print(type(err))


# NameError 直接继承自 Exception
err = BaseExceptionGroup('异常组 ExceptionGroup', (NameError(),))
print(type(err))

# 抛出包含异常 ValueError 和 NameError 的异常组
raise ExceptionGroup('糟糕，又错了', (ValueError(), NameError()))

# 将 Python 异常组作为一个整体进行捕获
try:
	raise ExceptionGroup('毫无意义', (IOError(),))
except BaseExceptionGroup as err:
	print(f'捕获的异常类型为：{type(err)}')

try:
	raise BaseExceptionGroup('捕获', [NameError(), ValueError(), BaseException()])
except* (NameError, ValueError) as err:
	# 转换的异常组的类型为 ExceptionGroup
	print(f'异常类型为：{type(err)}，{err.message} {err.exceptions}')
except* BaseException:
	# 转换的异常组的类型为 BaseExceptionGroup
	import sys
	# 通过 exception 函数获取转换的异常组
	err = sys.exception()
	print(f'异常类型为：{type(err)}，{err.message} {err.exceptions}')

try:
	raise BaseExceptionGroup('匹配多个异常', [Exception(), Exception(), IOError(), IOError(), FileNotFoundError()])
except* IOError as err:
	# 匹配 IOError，FileNotFoundError
	print(err.exceptions)
except* Exception as err:
	# 只能匹配到 Exception
	print(err.exceptions)

try:
	# 异常 NameError，OSError 会被重新抛出
	try:
		raise BaseExceptionGroup(
			'重新抛出', (
				NameError(), ValueError(),
				BaseExceptionGroup('嵌套的异常', [OSError(), ValueError()])
			))
	except* ValueError:
		# 两个 ValueError 都会被捕获
		pass
except BaseExceptionGroup as err:
	# 异常组包含了 NameError 和嵌套的 OSError
	print(f'被重新抛出的异常：{type(err)} {err.exceptions}')

try:
	raise BaseExceptionGroup('异常组', [
		ExceptionGroup('子异常组', [ValueError(), NameError()])
	])
# ERROR 不能匹配 ExceptionGroup
except* ExceptionGroup:
	pass

# ERROR 无法混合使用 except* 和 except
try:
	raise ExceptionGroup('混合使用', [SystemExit()])
except* SystemExit:
	pass
except:
	pass

def jump():
	try:
		raise BaseExceptionGroup('跳转', [NameError()])
	except* NameError:
		# ERROR 不能使用跳转语句
		return


jump()

# 捕获普通的异常
try:
	raise NameError()
except* NameError as err:
	# NameError 被转换为异常组
	print(f'{type(err)} 消息：“{err.message}”，异常：{err.exceptions}')

try:
	# 由于所包含的异常均继承自 Exception，因此会得到一个 ExceptionGroup 对象
	raise BaseExceptionGroup(
		'这仅仅是一个测试！',
		[NameError(), ValueError()]
	)
except ExceptionGroup as err:
	# 显示异常组的相关内容
	print(f'来自异常组的信息：{err.message}')
	print(f'异常组中的异常：{err.exceptions}')

err = ExceptionGroup('获取异常', (
	NameError(), ValueError(),
	BaseExceptionGroup('子异常组', [OSError(), NameError()])
))


# 返回 None
print(err.subgroup(AttributeError))
# 获取异常组中的 NameError 和 ValueError
group = err.subgroup((NameError, ValueError))
print(f'{group.message} {group.exceptions}')


# 判断异常是否符合条件的函数 get_error
def get_error(err):
	return type(err) in (NameError, ValueError)


# 通过函数获取异常组中的 NameError 和 ValueError，以及剩余异常
m, r = err.split(get_error)
print(f'{m.message} {m.exceptions} {r.message} {r.exceptions}')

err = ExceptionGroup('异常组', [NameError()])
new_err = err.derive([ValueError()])


# 显示原有异常组和新异常组
print(f'{err.message} {err.exceptions}')
print(f'{new_err.message} {new_err.exceptions}')