用于包装尝试的通用装饰器除了在 python 中？

Question

我会与很多我没有编写的深度嵌套的 json 进行交互，并且想让我的 python 脚本对无效输入更加“宽容”。我发现自己在编写涉及 try-except 块，而宁愿将可疑的函数包装起来。

我知道吞下异常是一个糟糕的策略，但我宁愿稍后打印和分析它们，而不是实际停止执行。在我的用例中，继续循环执行比获取所有键更有价值。

这是我现在正在做的事情：

try:
    item['a'] = myobject.get('key').METHOD_THAT_DOESNT_EXIST()
except:
    item['a'] = ''
try:
    item['b'] = OBJECT_THAT_DOESNT_EXIST.get('key2')
except:
    item['b'] = ''
try:
    item['c'] = func1(ARGUMENT_THAT_DOESNT_EXIST)
except:
    item['c'] = ''
...
try:
    item['z'] = FUNCTION_THAT_DOESNT_EXIST(myobject.method())
except:
    item['z'] = ''

这是我想要的，(1)：

item['a'] = f(myobject.get('key').get('subkey'))
item['b'] = f(myobject.get('key2'))
item['c'] = f(func1(myobject)
...

或（2）：

@f
def get_stuff():
   item={}
   item['a'] = myobject.get('key').get('subkey')
   item['b'] = myobject.get('key2')
   item['c'] = func1(myobject)
   ...
   return(item)

...我可以将单个数据项 (1) 或主函数 (2) 包装在某个函数中，该函数将执行停止异常转换为空字段，并打印到标准输出。前者将是一种逐项跳过 - 在该键不可用的情况下，它记录为空白并继续前进 - 后者是行跳过，如果任何字段不起作用，则整个记录是跳过。

我的理解是某种包装器应该能够解决这个问题。这是我尝试过的，带有一个包装器：

def f(func):
   def silenceit():
      try:
         func(*args,**kwargs)
      except:
         print('Error')
      return(silenceit)

这就是它不起作用的原因。调用一个不存在的函数，它不会尝试捕获它：

>>> f(meow())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'meow' is not defined

在我什至添加一个空白返回值之前，我想让它正确地尝试捕获。如果该功能有效，这将打印“错误”，对吗？

包装函数是正确的方法吗？

更新

我在下面得到了很多非常有用、有用的答案，并感谢他们——但我已经编辑了上面使用的示例来说明我试图捕获的不仅仅是嵌套的键错误，我正在寻找一个专门为...包装 try-catch 的函数。

1. 当方法不存在时。
2. 当一个对象不存在，并且正在获取对其调用的方法时。
3. 当一个不存在的对象作为函数的参数被调用时。
4. 这些东西的任意组合。
5. 奖励，当函数不存在时。

Answer 1

您可以使用 defaultdict 和 the context manager approach as outlined in Raymond Hettinger's PyCon 2013 presentation

from collections import defaultdict
from contextlib import contextmanager

@contextmanager
def ignored(*exceptions):
  try:
    yield
  except exceptions:
    pass 

item = defaultdict(str)

obj = dict()
with ignored(Exception):
  item['a'] = obj.get(2).get(3) 

print item['a']

obj[2] = dict()
obj[2][3] = 4

with ignored(Exception):
  item['a'] = obj.get(2).get(3) 

print item['a']

Answer 2

这里有很多很好的答案，但我没有看到任何可以解决您是否可以通过装饰器完成此任务的问题。

简短的回答是“不”，至少在不对代码进行结构更改的情况下不会。装饰器在功能级别上运行，而不是在单个语句上运行。因此，为了使用装饰器，您需要将每个要装饰的语句移动到自己的函数中。

但请注意，您不能只将赋值本身放在修饰函数中。您需要从修饰函数中返回 rhs 表达式（要赋值的值），然后在外面进行赋值。

根据您的示例代码，可以使用以下模式编写代码：

@return_on_failure('')
def computeA():
    item['a'] = myobject.get('key').METHOD_THAT_DOESNT_EXIST()

item["a"] = computeA()

return_on_failure 可能类似于：

def return_on_failure(value):
  def decorate(f):
    def applicator(*args, **kwargs):
      try:
         return f(*args,**kwargs)
      except:
         print('Error')
         return value

    return applicator

  return decorate

Answer 3

使用可配置的装饰器很容易实现。

def get_decorator(errors=(Exception, ), default_value=''):

    def decorator(func):

        def new_func(*args, **kwargs):
            try:
                return func(*args, **kwargs)
            except errors, e:
                print "Got error! ", repr(e)
                return default_value

        return new_func

    return decorator

f = get_decorator((KeyError, NameError), default_value='default')
a = {}

@f
def example1(a):
    return a['b']

@f
def example2(a):
    return doesnt_exist()

print example1(a)
print example2(a)

只需将错误类型传递给 get_decorator 元组，您希望将其静音并返回默认值。 输出将是

Got error!  KeyError('b',)
default
Got error!  NameError("global name 'doesnt_exist' is not defined",)
default

编辑：感谢 martineau，我将错误的默认值更改为具有基本异常的元组以防止错误。

Answer 4

这取决于您期望的例外情况。

如果你唯一的用例是get()，你可以这样做

item['b'] = myobject.get('key2', '')

对于其他情况，您的装饰器方法可能有用，但不是您使用的方式。

我会试着给你看：

def f(func):
   def silenceit(*args, **kwargs): # takes all kinds of arguments
      try:
         return func(*args, **kwargs) # returns func's result
      except Exeption, e:
         print('Error:', e)
         return e # not the best way, maybe we'd better return None
                  # or a wrapper object containing e.
  return silenceit # on the correct level

尽管如此，f(some_undefined_function()) 不起作用，因为

a) f() 在执行时尚未激活，并且

b) 使用错误。正确的方法是包装函数然后调用它：f(function_to_wrap)()。

“lambda 层”在这里会有所帮助：

wrapped_f = f(lambda: my_function())

包装一个 lambda 函数，该函数又调用一个不存在的函数。调用wrapped_f() 会导致调用包装器，该包装器调用试图调用my_function() 的lambda。如果这不存在，则 lambda 会引发一个被包装器捕获的异常。

这是因为名称 my_function 不是在定义 lambda 时执行，而是在执行时执行。然后这个执行被函数f() 保护和包装。因此异常发生在 lambda 内部，并传播到装饰器提供的包装函数，由装饰器优雅地处理。

如果您尝试将 lambda 函数替换为像这样的包装器，那么这种向 lambda 函数内部的移动是行不通的

g = lambda function: lambda *a, **k: function(*a, **k)

后跟一个

f(g(my_function))(arguments)

因为这里的名称解析是“回到表面”：my_function 无法解析，这发生在 g() 甚至 f() 被调用之前。所以它不起作用。

如果你尝试做类似的事情

g(print)(x.get('fail'))

如果你没有x，它也不能正常工作，因为g() 保护print，而不是x。

如果你想在这里保护x，你必须这样做

value = f(lambda: x.get('fail'))

因为f() 提供的包装器调用了引发异常的 lambda 函数，该异常随后被静音。

Answer 5

在您的情况下，您首先评估 meow 调用的值（不存在），然后将其包装在装饰器中。这样不行。

首先在包装之前引发异常，然后包装器错误地缩进（silenceit 不应返回自身）。您可能想要执行以下操作：

def hardfail():
  return meow() # meow doesn't exist

def f(func):
  def wrapper():
    try:
      func()
    except:
      print 'error'
  return wrapper

softfail =f(hardfail)

输出：

>>> softfail()
error

>>> hardfail()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in hardfail
NameError: global name 'meow' is not defined

无论如何，在您的情况下，我不明白您为什么不使用诸如

之类的简单方法

def get_subkey(obj, key, subkey):
  try:
    return obj.get(key).get(subkey, '')
  except AttributeError:
    return ''

在代码中：

 item['a'] = get_subkey(myobject, 'key', 'subkey')

已编辑：

如果您想要在任何深度都可以工作的东西。您可以执行以下操作：

def get_from_object(obj, *keys):
  try:
    value = obj
    for k in keys:
        value = value.get(k)
    return value
  except AttributeError:
    return ''

你会这样称呼：

>>> d = {1:{2:{3:{4:5}}}}
>>> get_from_object(d, 1, 2, 3, 4)
5
>>> get_from_object(d, 1, 2, 7)
''
>>> get_from_object(d, 1, 2, 3, 4, 5, 6, 7)
''
>>> get_from_object(d, 1, 2, 3)
{4: 5}

并使用您的代码

item['a'] = get_from_object(obj, 2, 3) 

顺便说一句，就个人而言，我也喜欢使用上下文管理器的@cravoori 解决方案。但这意味着每次都要写三行代码：

item['a'] = ''
with ignored(AttributeError):
  item['a'] = obj.get(2).get(3) 

Answer 6

扩展@iruvar 答案 - 从 Python 3.4 开始，Python 标准库中有一个现有的上下文管理器：https://docs.python.org/3/library/contextlib.html#contextlib.suppress

from contextlib import suppress

with suppress(FileNotFoundError):
    os.remove('somefile.tmp')

with suppress(FileNotFoundError):
    os.remove('someotherfile.tmp')

Answer 7

由于您要处理大量损坏的代码，在这种情况下使用eval 可能是情有可原的。

def my_eval(code):
  try:
    return eval(code)
  except:  # Can catch more specific exceptions here.
    return ''

然后包装所有可能损坏的语句：

item['a'] = my_eval("""myobject.get('key').get('subkey')""")
item['b'] = my_eval("""myobject.get('key2')""")
item['c'] = my_eval("""func1(myobject)""")

Answer 8

为什么不直接使用循环？

for dst_key, src_key in (('a', 'key'), ('b', 'key2')):
    try:
        item[dst_key] = myobject.get(src_key).get('subkey')
    except Exception:  # or KeyError?
        item[dst_key] = ''

或者如果你想写一个小助手：

def get_value(obj, key):
    try:
        return obj.get(key).get('subkey')
    except Exception:
        return ''

如果你有几个地方需要获取价值，你也可以将这两种解决方案结合起来，辅助函数会更合理。

不确定您是否真的需要装饰器来解决您的问题。

Answer 9

为同步和异步函数尝试除装饰器

注意：logger.error 可以替换为print

最新版本可以在here找到。

Answer 10

这样的事情怎么样：

def exception_handler(func):
def inner_function(*args, **kwargs):
    try:
        func(*args, **kwargs)
    except TypeError:
        print(f"{func.__name__} error")
return inner_function

然后

@exception_handler
def doSomethingExceptional():
    a=2/0

所有学分转到：https://medium.com/swlh/handling-exceptions-in-python-a-cleaner-way-using-decorators-fae22aa0abec