python - 可读的尝试除了处理计算

Question

我有一个程序，我需要做很多计算，但输入可能不完整(因此我们不能总是计算所有结果)，这本身很好，但会导致可读性问题代码:

def try_calc():
    a = {'1': 100, '2': 200, '3': 0, '4': -1, '5': None, '6': 'a'}
    try:
        a['10'] = float(a['1'] * a['2'])
    except (ZeroDivisionError, KeyError, TypeError, ValueError) as e:
        a['10'] = None
    try:
        a['11'] = float(a['1'] * a['5'])
    except (ZeroDivisionError, KeyError, TypeError, ValueError) as e:
        a['11'] = None
    try:
        a['12'] = float(a['1'] * a['6'])
    except (ZeroDivisionError, KeyError, TypeError, ValueError) as e:
        a['12'] = None
    try:
        a['13'] = float(a['1'] / a['2'])
    except (ZeroDivisionError, KeyError, TypeError, ValueError) as e:
        a['13'] = None
    try:
        a['14'] = float(a['1'] / a['3'])
    except (ZeroDivisionError, KeyError, TypeError, ValueError) as e:
        a['14'] = None
    try:
        a['15'] = float((a['1'] * a['2']) / (a['3'] * a['4']))
    except (ZeroDivisionError, KeyError, TypeError, ValueError) as e:
        a['15'] = None
    return a

In [39]: %timeit try_calc()
100000 loops, best of 3: 11 µs per loop

所以这很好用，性能很高但真的不可读。我们想出了另外两种方法来处理这个问题。 1:使用内部处理问题的专门功能

import operator
def div(list_of_arguments):
    try:
        result = float(reduce(operator.div, list_of_arguments, 1))
    except (ZeroDivisionError, KeyError, TypeError, ValueError) as e:
        result = None
    return result

def mul(list_of_arguments):
    try:
        result = float(reduce(operator.mul, list_of_arguments, 1))
    except (ZeroDivisionError, KeyError, TypeError, ValueError) as e:
        result = None
    return result

def add(list_of_arguments):
    try:
        result = float(reduce(operator.add, list_of_arguments, 1))
    except (ZeroDivisionError, KeyError, TypeError, ValueError) as e:
        result = None
    return result

def try_calc2():
    a = {'1': 100, '2': 200, '3': 0, '4': -1, '5': None, '6': 'a'}
    a['10'] = mul([a['1'], a['2']])
    a['11'] = mul([a['1'], a['5']])
    a['12'] = mul([a['1'], a['6']])
    a['13'] = div([a['1'], a['2']])
    a['14'] = div([a['1'], a['3']])
    a['15'] = div([
        mul([a['1'], a['2']]), 
        mul([a['3'], a['4']])
        ])
    return a

In [40]: %timeit try_calc2()
10000 loops, best of 3: 20.3 µs per loop

老实说，速度慢了一倍，但仍然不那么可读。 选项 2:封装在 eval 语句中

def eval_catcher(term):
    try:
        result = float(eval(term))
    except (ZeroDivisionError, KeyError, TypeError, ValueError) as e:
        result = None
    return result

def try_calc3():
    a = {'1': 100, '2': 200, '3': 0, '4': -1, '5': None, '6': 'a'}
    a['10'] = eval_catcher("a['1'] * a['2']")
    a['11'] = eval_catcher("a['1'] * a['5']")
    a['12'] = eval_catcher("a['1'] * a['6']")
    a['13'] = eval_catcher("a['1'] / a['2']")
    a['14'] = eval_catcher("a['1'] / a['3']")
    a['15'] = eval_catcher("(a['1'] * a['2']) / (a['3'] * a['4'])")
    return a

In [41]: %timeit try_calc3()
10000 loops, best of 3: 130 µs per loop

非常慢(与其他替代方案相比)，但同时也是最具可读性的。 我知道一些问题(KeyError，ValueError)也可以通过预处理字典来处理以确保键的可用性但是无论如何仍然会留下 None(TypeError)和 ZeroDivisionErrors，所以我看不到任何优势

我的问题: - 我错过了其他选择吗？ - 尝试以这种方式解决问题，我是不是完全疯了？ - 是否有更 pythonic 的方法？ - 您认为最好的解决方案是什么？为什么？

Answer 1

如何将您的计算存储为 lambda？然后你可以遍历所有这些，只使用一个 try-except block 。

def try_calc():
    a = {'1': 100, '2': 200, '3': 0, '4': -1, '5': None, '6': 'a'}
    calculations = {
        '10': lambda: float(a['1'] * a['2']),
        '11': lambda: float(a['1'] * a['5']),
        '12': lambda: float(a['1'] * a['6']),
        '13': lambda: float(a['1'] / a['2']),
        '14': lambda: float(a['1'] / a['3']),
        '15': lambda: float((a['1'] * a['2']) / (a['3'] * a['4']))
    }
    for key, calculation in calculations.iteritems():
        try:
            a[key] = calculation()
        except (ZeroDivisionError, KeyError, TypeError, ValueError) as e:
            a[key] = None

---

顺便说一句，如果计算顺序很重要，我不建议这样做，比如如果你的原始代码中有这个:

a['3'] = float(a['1'] * a['2'])
a['5'] = float(a['3'] * a['4'])

由于口述是无序的，因此您无法保证第一个等式会在第二个等式之前执行。因此，a['5'] 可能使用 a['3'] 的新值进行计算，也可能使用旧值。 (这不是问题中计算的问题，因为从未分配过键 1 到 6，并且键 10 到 15 从未在计算中使用过。)