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

Question

I am writing a function route. This function has a mandatory parameter points that takes a list of points. The function must return the total distance traveled if each of the points in the given list is visited in turn. Apart from the mandatory parameter, the function also has two optional parameters:

cycle: takes a Boolean value that indicates whether the end of the route is equal to its starting point (True) or not (False); the default value of this parameter is False

distance: takes a distance function that is used for the calculation of the total distance between two consecutive points in the given route; if no explicit value is passed to this parameter, the Euclidean distance must be used

Problem: Anybody knows with the last definition route() how to solve it for the case:

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

correct answer : 146.31

Part of my code I refer to:

 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)

In this part I got stuck at the first rule and further.

Complete code which works fine (except for the part above):

  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

I Agree with Duncan. You have way too much duplication. Here a more direct approach:

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

Any metric funtion can be passed and is then used instead of the euclidean metric.