求解测量点列表 (x, y) 中点之间距离的函数

Question

我正在写一个函数路由。 这个函数有一个强制参数points，它接受一个点列表。 如果依次访问给定列表中的每个点，则该函数必须返回行进的总距离。 除了强制参数外，该函数还有两个可选参数：

循环：取一个布尔值，指示路线的终点是否等于其起点（真）或不等于（假）； 此参数的默认值为 False

distance：采用距离函数，用于计算给定路径中两个连续点之间的总距离； 如果没有明确的值传递给这个参数，则必须使用欧几里德距离

问题：任何人都知道最后一个定义 route() 如何解决这个问题：

route([(41.79, 13.59), (41.68, 14.65), (21.16, -4.79)], distance=lambda p1, p2: abs(p1[0] + p2[0]))

正确答案：146.31

我引用的部分代码：

 if cycle == False and distance is λ(p1, p2): abs(p1[0] + p2[0]):

            l = list()
            count = 0

            for items in range(len(points)-1):
                a = points[items]
                b = points[items+1]
                d = euclidean(a[0], b[0])
                l.append(d)
                count += 1

            return sum(l)

在这部分中，我陷入了第一条规则和更远的地方。

工作正常的完整代码（除了上面的部分）：

  def euclidean(a, b):
    '''
    >>> euclidean((42.36, 56.78), (125.65, 236.47))
    198.05484139500354
    '''

    from math import sqrt

    return sqrt(sum((a - b)**2 for a, b in zip(a, b)))




def manhattan(c, d):
    '''
    >>> manhattan((42.36, 56.78), (125.65, 236.47))
    262.98
    '''

    return sum(abs(c - d) for c, d in zip(c, d))



def chessboard(e, f):
    '''
    >>> chessboard((42.36, 56.78), (125.65, 236.47))
    179.69
    '''

    return max(abs(e - f) for e, f in zip(e, f))



def route(points, cycle=False, distance=None):
    '''
    >>> route([(6.59, 6.73), (4.59, 5.54), (5.33, -13.98)])
    21.861273201261746
    >>> route(cycle=True, points=[(6.59, 6.73), (4.59, 5.54), (5.33, -13.98)])
    42.60956710702662
    >>> route([(6.59, 6.73), (4.59, 5.54), (5.33, -13.98)], distance=manhattan)
    23.45
    >>> route([(6.59, 6.73), (4.59, 5.54), (5.33, -13.98)], cycle=True, distance=manhattan)
    45.42
    '''



    if cycle == False and distance is None: 

        l = list()
        count = 0

        for items in range(len(points)-1):
            a = points[items]
            b = points[items+1]
            d = euclidean(a, b)
            l.append(d)
            count += 1

        return sum(l)


    if cycle == False and distance is euclidean:

        l = list()
        count = 0

        for items in range(len(points)-1):
            a = points[items]
            b = points[items+1]
            d = euclidean(a, b)
            l.append(d)
            count += 1

        return sum(l)


    if cycle == False and distance is λ(p1, p2): abs(p1[0] + p2[0]):

        l = list()
        count = 0

        for items in range(len(points)-1):
            a = points[items]
            b = points[items+1]
            d = euclidean(a[0], b[0])
            l.append(d)
            count += 1

        return sum(l)



    if cycle == True and distance is None:

        l = list()
        count = 0

        for items in range(len(points)-1):
            a = points[items]
            b = points[items+1]
            d = euclidean(a, b)
            l.append(d)
            count += 1

        f = points[0]
        g = points[-1] 
        r = euclidean(g, f)

        k = sum(l) + r

        return k


    if cycle == True and distance is euclidean:

        l = list()
        count = 0

        for items in range(len(points)-1):
            a = points[items]
            b = points[items+1]
            d = euclidean(a, b)
            l.append(d)
            count += 1

        f = points[0]
        g = points[-1] 
        r = euclidean(g, f)

        k = sum(l) + r

        return k



    if cycle is False and distance is manhattan:

        l = list()
        count = 0

        for items in range(len(points)-1):
            a = points[items]
            b = points[items+1]
            d = manhattan(a, b)
            l.append(d)
            count += 1

        return sum(l)


    if cycle is True and distance is manhattan:

        l = list()
        count = 0

        for items in range(len(points)-1):
            a = points[items]
            b = points[items+1]
            d = manhattan(a, b)
            l.append(d)
            count += 1

        f = points[0]
        g = points[-1] 
        r = manhattan(g, f)

        k = sum(l) + r

        return k

Answer 1

我同意邓肯。 你有太多的重复。 这里有一个更直接的方法：

euclidean = lambda p1, p2: sqrt(sum((p1_i - p2_i)**2 for p1_i, p2_i in zip(p1, p2)))
manhattan = lambda p1, p2: sum(abs(p1_i - p2_i) for p1_i, p2_i in zip(p1, p2))
chessboard = lambda p1, p2: max(abs(p1_i - p2_i) for p1_i, p2_i in zip(p1, p2))

def route(points, cycle=False, metric=euclidean):
    l = 0.0
    for i in range(len(points) - 1):
        l += metric(points[i], points[i + 1])

    if cycle:
        l += metric(points[-1], points[0])

    return l

可以传递任何度量函数，然后使用它来代替欧几里德度量。