Question

需要有关最简单方法的指导。我有多个资产，每个资产都有多个数据点。我希望基于对每个数据点的决策为每个资产分配值。例如，每个资产都是一栋房屋，包括窗户，车库门，破损的围栏等在内的数据点，每个房屋都会得到一个分数。

除了数百条if语句并从分数中减去/添加之外，是否还有建议的编码方式？

我打算如何执行此操作的示例

import math

def make_circle(center, radius, num_points=40):
    """returns a sequence of points on the circumference
    """ 
    points = [center]
    d_theta = 2 * math.pi / num_points
    cx, cy = center
    for idx in range(num_points + 1):
        theta = idx * d_theta
        points.append((cx + math.cos(theta) * radius, cy + math.sin(theta) * radius))
    return points

Answer 1

我认为您的方法很好，不值得尝试执行其他操作。您可能希望通过定义如下函数来对其进行组织：

def add_score(x, score): 
    score += x
    return score

还有一个dictionary：

sdict = {windows: 10, garage: 10, broken_fence: 10}

这样您就可以像这样调用函数了：

def score_house(house):
    # score house
    score = 0
    if (house.windows > 2): add_score(sdict[windows])
    if (house.garage): add_score(sdict[garage])
    if (house.fence == 'broken'): add_score(sdict[broken_fence])
    return score

并且可以轻松地从单个dictionary更改得分。

您还可以（现在考虑一下，也许应该）使用Enums：

from enum import Enum
class Scoring(Enum):
   WINDOWS = 10
   ...

def score_house(house):
    # score house
    score = 0
    if (house.windows > 2): add_score(Scoring.WINDOWS)
    ...

Answer 2

我认为您也可以在此处使用“责任链”模式：

该模式允许多个对象处理请求，而无需将发送者类耦合到接收者的具体类。该链可以在运行时与遵循标准处理程序接口的任何处理程序一起动态组成。

使用此模式的好处是，您可以在不同的模块中定义和扩展不同的计分器，并根据问题情况在运行时动态地将它们组合。这是您的操作方法。首先，定义一个父计分器类：

.timeline__item::before { right: 0; }

然后，定义各种计分器类，例如：

from functools import reduce


class BaseScorer(object):

    def __init__(self):
        self._next_scorer = None

    def set_next(self, scorer):
        self._next_scorer = scorer

        return scorer

    def _call_next(self, house, score):

        if self._next_scorer is None:
            return score

        return self._next_scorer.score(house, score)

    def score(self, house, score=0):
        raise NotImplementedError

    @staticmethod
    def chain(scorers):
        reduce(lambda x, y: x.set_next(y), scorers)

        return scorers[0]

这是如何使用它：

class WindowScorer(BaseScorer):

    def score(self, house, score=0):

        if house.windows > 2:
            score = score + 10

        return self._call_next(house, score)


class GarageScorer(BaseScorer):

    def score(self, house, score=0):

        if house.garage:
            score = score + 10

        return self._call_next(house, score)


class FenceScorer(BaseScorer):

    def score(self, house, score=0):

        if house.fence == 'broken':
            score = score - 5

        return self._call_next(house, score)

python-基于多个数据点的评分

2 个答案: