Python 除了处理计算之外，其他都是可读的

我有一个程序，我需要做很多计算，但输入可能不完整（因此我们不能总是计算所有结果），这本身是好的，但会给代码的可读性带来问题：

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）也可以通过预处理字典来处理，以确保键的可用性，但这仍然不会留下任何错误（TypeError）和ZeroDivisionError，因此我认为这没有任何好处

我的问题: -我是否错过了其他选择？ -我想用这种方式解决这个问题，是不是完全疯了？ -有没有更像蟒蛇的方法？

---

-您认为最好的解决方案是什么？为什么？

将您的计算存储为lambda如何？然后，您可以循环遍历所有这些对象，只需使用一个try-except块

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'])

---

因为dict是无序的，所以不能保证第一个等式会在第二个之前执行。因此，可以使用

a['3']

的新值计算

a['5']

，也可以使用旧值。（这与问题中的计算无关，因为从未分配过键1到键6，也从未在计算中使用键10到键15。）

与Kevin的稍有不同，您不需要预先存储计算，而是使用装饰器和

lambda来处理错误，例如：

from functools import wraps

def catcher(f):
    @wraps
    def wrapper(*args):
        try:
            return f(*args)
        except (ZeroDivisionError, KeyError, TypeError, ValueError):
            return None
    return wrapper

a = {'1': 100, '2': 200, '3': 0, '4': -1, '5': None, '6': 'a'}

print catcher(lambda: a['1'] * a['5'])()

正如我在评论中提到的，您也可以将通用作为您的第二个示例：

import operator

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

a['10'] = do_op([a['1'], a['2']], operator.mul) 
# etc...

我有两个解决方案，一个比另一个稍微快一点

更具可读性：

def try_calc():
    a = {'1': 100, '2': 200, '3': 0, '4': -1, '5': None, '6': 'a'}

    fn_map = {
        '*': operator.mul,
        '/': operator.div,
    }

    def calc(x, fn, y):
        try:
            return float(fn_map[fn](a[x], a[y]))
        except (ZeroDivisionError, KeyError, TypeError, ValueError):
            return None

    a['10'] = calc('1', '*', '2')
    a['11'] = calc('1', '*', '5')
    a['12'] = calc('1', '*', '6')
    a['13'] = calc('1', '/', '2')
    a['14'] = calc('1', '/', '3')
    a['15'] = calc(calc('1', '*', '2', '/', calc('3', '*', '4'))
    return a

稍微快一点：

from operator import mul, div

def try_calc():
    a = {'1': 100, '2': 200, '3': 0, '4': -1, '5': None, '6': 'a'}

    def calc(x, fn, y):
        try:
            return float(fn(a[x], a[y]))
        except (ZeroDivisionError, KeyError, TypeError, ValueError):
            return None

    a['10'] = calc('1', mul, '2')
    a['11'] = calc('1', mul, '5')
    a['12'] = calc('1', mul, '6')
    a['13'] = calc('1', div, '2')
    a['14'] = calc('1', div, '3')
    a['15'] = calc(calc('1', mul, '2', div, calc('3', mul, '4'))
    return a

您可以将
div/mul/add
调整为更通用的
reduce\u列表（参数列表，op）
，并传入
操作符。add
&co。因为
op
…函数样式可以提高可读性，但函数调用在Python中非常昂贵…为什么不能消除所有异常<代码>类型错误

异常通过

isinstance

如前所述，通过将计算结果除以0设置为

None

异常，而不尝试执行实际计算。您好，问题是，我不认为它会提高可读性或功能理解，而是为每个计算创建大量“if-then-elif-then-else”语句。另请参见：这实际上是一个非常好的解决方案，性能非常高（介于当前解决方案和选项1之间）！Hmmm无法编辑我以前的评论。关于顺序，这很重要，但我们可以通过制作一个元组列表来解决这个问题：[（'10'，lambda:float（a['1']*a['2']），（'11'，等等]@Carst只需注意-你只能在发布评论后5分钟内编辑评论：）这也是一个非常好的、绝对可读的解决方案；我想我更喜欢你的第一个解决方案而不是第二个，因为“（a['1']*a['2']）/（a['3']*a['4']）示例在第一个解决方案中仍然是完全可读的，理解起来可能有点头疼。谢谢你的意见，处理这个问题的方法真的很有趣！