检查是否在任何版本中都可以提高

Question

我正在从事一个项目，我们希望验证是否可以在必要时将参数作为异常引发。我们选择了以下内容：

def is_raisable(exception):
    funcs = (isinstance, issubclass)
    return any(f(exception, BaseException) for f in funcs)

这处理以下用例，满足我们的需求（目前）：

is_raisable(KeyError) # the exception type, which can be raised
is_raisable(KeyError("key")) # an exception instance, which can be raised

但是，对于在旧版本 (2.x) 中可以引发的旧样式类，它会失败。然后我们尝试以这种方式解决它：

IGNORED_EXCEPTIONS = [
    KeyboardInterrupt,
    MemoryError,
    StopIteration,
    SystemError,
    SystemExit,
    GeneratorExit
]
try:
    IGNORED_EXCEPTIONS.append(StopAsyncIteration)
except NameError:
    pass
IGNORED_EXCEPTIONS = tuple(IGNORED_EXCEPTIONS)

def is_raisable(exception, exceptions_to_exclude=IGNORED_EXCEPTIONS):

    funcs_to_try = (isinstance, issubclass)
    can_raise = False

    try:
        can_raise = issubclass(exception, BaseException)
    except TypeError:
        # issubclass doesn't like when the first parameter isn't a type
        pass

    if can_raise or isinstance(exception, BaseException):
        return True

    # Handle old-style classes
    try:
        raise exception
    except TypeError as e:
        # It either couldn't be raised, or was a TypeError that wasn't 
        # detected before this (impossible?)
        return exception is e or isinstance(exception, TypeError)
    except exceptions_to_exclude as e:
        # These are errors that are unlikely to be explicitly tested here,
        # and if they were we would have caught them before, so percolate up
        raise
    except:
        # Must be bare, otherwise no way to reliably catch an instance of an
        # old-style class
        return True

这通过了我们所有的测试，但它不是很漂亮，如果我们正在考虑一些我们不希望用户传递的东西，但它仍然会让人觉得很笨拙，但无论如何可能会被扔进去原因。

def test_is_raisable_exception(self):
    """Test that an exception is raisable."""

    self.assertTrue(is_raisable(Exception))

def test_is_raisable_instance(self):
    """Test that an instance of an exception is raisable."""

    self.assertTrue(is_raisable(Exception()))

def test_is_raisable_old_style_class(self):
    """Test that an old style class is raisable."""

    class A: pass

    self.assertTrue(is_raisable(A))

def test_is_raisable_old_style_class_instance(self):
    """Test that an old style class instance is raisable."""

    class A: pass

    self.assertTrue(is_raisable(A()))

def test_is_raisable_excluded_type_background(self):
    """Test that an exception we want to ignore isn't caught."""

    class BadCustomException:
        def __init__(self):
            raise KeyboardInterrupt

    self.assertRaises(KeyboardInterrupt, is_raisable, BadCustomException)

def test_is_raisable_excluded_type_we_want(self):
    """Test that an exception we normally want to ignore can be not
    ignored."""

    class BadCustomException:
        def __init__(self):
            raise KeyboardInterrupt

    self.assertTrue(is_raisable(BadCustomException, exceptions_to_exclude=()))

def test_is_raisable_not_raisable(self):
    """Test that something not raisable isn't considered rasiable."""

    self.assertFalse(is_raisable("test"))

不幸的是，我们需要继续支持 Python 2.6+（很快将只支持 Python 2.7，所以如果您有一个在 2.6 中不起作用的解决方案，那很好，但并不理想）和 Python 3.x。理想情况下，我希望在没有明确测试版本的情况下这样做，但如果没有其他方法可以做到这一点。

最后，我的问题是：

1. 有没有更简单的方法可以做到这一点并支持所有列出的版本？
2. 如果没有，是否有更好或更安全的方法来处理“特殊异常”，例如KeyboardInterrupt。
3. 作为最 Pythonic 的人，我想请求宽恕而不是许可，但考虑到我们可以获得两种类型的 TypeError（一种是因为它有效，一种是因为它没有），这也让人感觉很奇怪（但无论如何我都必须依靠它来获得 2.x 支持）。

Answer 1

你在 Python 中测试大多数东西的方式是 try 然后看看你是否得到了异常。

这适用于raise。如果某些东西不能被提升，你会得到一个TypeError；否则，您将得到您提出的（或您提出的实例）。这适用于 2.6（甚至 2.3）和 3.6。在 2.6 中作为异常的字符串将是可引发的；在 3.6 中不继承自 BaseException 的类型将不可引发；等等——你会得到所有事情的正确结果。无需检查BaseException 或以不同方式处理旧式和新式类；让raise 做它该做的事情。

当然，我们确实需要特例 TypeError，因为它会出现在错误的位置。但是由于我们不关心 pre-2.4，所以没有必要比isinstance 和issubclass 测试更复杂；除了返回 False 之外，没有任何奇怪的对象可以做任何事情。一个棘手的问题（我最初弄错了；感谢 user2357112 抓住它）是您必须先进行 isinstance 测试，因为如果对象是 TypeError 实例，issubclass 将引发 TypeError ，所以我们需要短路并返回 True 而不要尝试。

另一个问题是处理我们不想意外捕获的任何特殊异常，例如KeyboardInterrupt 和SystemError。但幸运的是，these all go back to before 2.6。 isinstance/issubclass 和 except clauses（只要你不关心捕获异常值，我们不关心）都可以使用在 3.x 中也可以使用的语法获取元组。由于要求我们为这些情况返回True，因此我们需要在尝试提高它们之前对其进行测试。但它们都是BaseException 的子类，所以我们不必担心经典类或类似的东西。

所以：

def is_raisable(ex, exceptions_to_exclude=IGNORED_EXCEPTIONS):
    try:
        if isinstance(ex, TypeError) or issubclass(ex, TypeError):
            return True
    except TypeError:
        pass
    try:
        if isinstance(ex, exceptions_to_exclude) or issubclass(ex, exceptions_to_exclude):
            return True
    except TypeError:
        pass
    try:
        raise ex
    except exceptions_to_exclude:
        raise
    except TypeError:
        return False
    except:
        return True

这并没有通过您编写的测试套件，但我认为这是因为您的某些测试不正确。我假设您希望 is_raisable 对于在当前 Python 版本中可提升的对象为真，而不是在任何支持的版本中可提升的对象 即使它们是'在当前版本中不可提升。您不希望 is_raisable('spam') 在 3.6 中返回 True 然后尝试 raise 'spam' 会失败，对吧？所以，在我脑海中浮现：

• not_raisable 测试引发了一个字符串 - 但这些在 2.6 中可以引发。
• excluded_type 测试引发了一个类，Python 2.x 可以通过实例化该类来处理该类，但这不是必需的，CPython 2.6 具有将在这种情况下触发的优化.
• old_style 测试在 3.6 中引发了新式类，它们不是 BaseException 的子类，因此它们不可引发。

如果不为 2.6、3.x 甚至 2.7 甚至可能为两个 2.x 版本的不同实现编写单独的测试，我不确定如何编写正确的测试（尽管您可能没有有没有用户，比如 Jython？）。

Answer 2

您可以引发对象，捕获异常，然后使用is 关键字检查引发的异常是对象还是对象的实例。如果引发了其他任何问题，则为TypeError，表示该对象不可引发。

此外，要处理任何可提升的对象，我们可以使用sys.exc_info。这也将捕获诸如KeyboardInterrupt 之类的异常，但如果与参数的比较不确定，我们可以重新引发它们。

import sys

def is_raisable(obj):
    try:
        raise obj
    except:
        exc_type, exc = sys.exc_info()[:2]

        if exc is obj or exc_type is obj:
            return True
        elif exc_type is TypeError:
            return False
        else:
            # We reraise exceptions such as KeyboardInterrupt that originated from outside
            raise

is_raisable(ValueError) # True
is_raisable(KeyboardInterrupt) # True
is_raisable(1) # False

Answer 3

如果您想检测旧式类和实例，只需对它们进行显式检查：

import types

if isinstance(thing, (types.ClassType, types.InstanceType)):
    ...

您可能希望将其包装在某种版本检查中，这样它就不会在 Python 3 上失败。