Question

我已经编写了一些代码来找出两个时间序列的差异彼此之间有多接近，并通过找到距离最近的实际变化的预期差异位置的距离并根据距离它的距离来分配分数来做到这一点是

在该代码中，我有一些看起来像这样的东西：

nearest_change = np.abs(actual_changes[actual_changes == change].index - time).min()

minutes_off = nearest_change.seconds/60
if minutes_off < 15:
  sum += 1
elif minutes_off < 30:
  sum += .8
elif minutes_off < 45:
  sum += .6
elif minutes_off < 60:
  sum += .4
elif minutes_off < 65:
  sum += .2

return sum / count

是否有更多的pythonic和简洁的方法来实现这种评分？

Answer 1

如果您的映射是离散的，并且无法通过简单的公式进行描述，那么您可以使用OrderedDict创建它们：

from collections import OrderedDict
d = OrderedDict([(15,1),(30,.8),(45,.6),(60,.4),(65,.2)])
for key,value in d.items():
    if minutes_off < key:
            s += value
            break

注意，我将sum重命名为s，以避免与Python内置函数发生冲突。

Answer 2

你可以遍历每个阈值，每次增加0.2。

thresholds = [15, 30, 45, 60, 65]
for time_diff in thresholds:
    if minutes_off < time_diff:
        sum += .2
    else:
        break

根据您需要的数量，动态创建阈值列表可能是值得的。

Answer 3

是的，有。我猜这个更好，虽然它使用更多的代码来达到相同的效果并且速度更慢。但它确实避免了重复。

class ScoreAccessDict(dict):
    def __init__(self, *args, f, **kwargs):
        self.f = f
        super().__init__(*args, **kwargs)

    def __getitem__(self, item):
        iterator = iter(self.keys())

        try:
            best = next(iterator)
        except StopIteration:
            raise KeyError(item)

        for k in iterator:
            if self.f(best, item) < self.f(k, item):
                best = k

        return super().__getitem__(best)

    def get(self, key, default=None):
        try:
            return self[key]
        except KeyError:
            return default

并使用它：

nearest_change = np.abs(actual_changes[actual_changes == change].index - time).min()

minutes_off = nearest_change.seconds / 60  # spaces between operands and the operator

d = ScoreAccessDict({15: 1, 30: 0.8, 45: 0.6, 60: 0.4, 65: 0.2, float('inf'): 0}, f = lambda x, y: x if x < y else -x)

return s + d[minutes_off]  # sum shouldn't be shadowed

但从您的代码判断，无论如何都应使用连续函数计算所添加的值。这将是最蟒蛇的方式。

压缩几个elif语句

3 个答案: