Python 将元组列表中给定的坐标转换为复数

我编写了以下代码，用于计算平面中最近的一对。代码运行良好，但我有两个问题。首先，在第一个函数中，是否有一种更短/更好的方法将点的表示形式从元组转换为复数？第二，我把第一个函数传递给第二个函数的方法正确吗

import sys

x = [1, 4]
y = [1, 5]


def to_complex(hor, ver):
    list_of_points = list(zip(hor, ver))
    list_of_points.sort(key=lambda el: (el[0], el[1]))
    complex_points = [complex(item[0], item[1]) for item in list_of_points]
    return complex_points


# Brute force algorithm.


def brute_force(points=to_complex(x, y)):
    n = len(points)
    if n < 2:
        return sys.maxsize
    else:
        min_distance = sys.maxsize
        for i in range(n):
            for j in range(i + 1, n):
                if abs(points[i] - points[j]) < min_distance:
                    min_distance = abs(points[i] - points[j])
                    closest_pair = (points[i], points[j])

return min_distance, closest_pair


print(brute_force())

导入系统 x=[1,4] y=[1,5] def至_复合体（hor、ver）： 点列表=列表（zip（hor，ver）） 点的列表。排序（key=lambda el:（el[0]，el[1]）） 复杂_点=[复杂（项目[0]，项目[1]），用于_点列表中的项目] 返回复数u点 #蛮力算法。 def蛮力（点=到复合物（x，y））： n=长度（点） 如果n<2： 返回sys.maxsize 其他： 最小距离=sys.maxsize 对于范围（n）中的i： 对于范围（i+1，n）内的j： 如果abs（点[i]-点[j]）

较短版本的
复合体（项[0]，项[1]）
是
complex（*item）
，它将序列拆分为单独的参数。我认为这更好一点，因为它会在长度超过2项的元组上显式失败

但如果只写
item[0]+item[1]*1j
，可能会更清楚。除了看起来像你写复数的方式外，这还避免了隐式转换为
浮点
，这使得
复数（…）
可以安静地处理
十进制
对象或
sympy
常量值表达式。在第一种情况下，你会得到一个错误，第二个是一个
sympy
复数常值表达式。（当然，如果你想强制事情变成复杂的值，那是一个负值而不是正值。）
你可以按如下方式编写你的算法

# Brute force algorithm.
def brute_force(hor, ver):
    # Convert points to complex
    points = [complex(x, y) for x, y in zip(hor, ver)]
    n = len(points)

    min_distance = sys.maxsize
    closest_pair = None
    if n < 2: return min_distance
    else:
        for i in range(n):
            for j in range(i+1, n):
                temp = abs(points[i] - points[j])
                if temp < min_distance:
                    min_distance = temp
                    closest_pair = (points[i], points[j])
    return min_distance, closest_pair

x = [1, 4, 3, 1]
y = [1, 5, 1, 5]

brute_force(x,y)

#暴力算法。
def蛮力（hor，ver）：
#将点转换为复数
点=[zip（hor，ver）中x，y的复数（x，y）]
n=长度（点）
最小距离=sys.maxsize
最近的_对=无
如果n<2：返回最小距离
其他：
对于范围（n）中的i：
对于范围（i+1，n）内的j：
温度=绝对值（点[i]-点[j]）
如果温度<最小距离：
最小距离=温度
最近的_对=（点[i]，点[j]）
返回最小距离，最近的对
x=[1,4,3,1]
y=[1,5,1,5]
蛮力（x，y）
如果代码已经运行，那么发布它可能是一个更好的站点。但是请注意。附带说明：如果元素都是2元组，
（el[0]，el[1]）
的值与
el
的值相同，那么为什么要编写一个只将
el
转换为相同元组的键函数呢，在一行中调用列表的元素
el
，然后在下一行中调用同一列表的元素
item
，这有点混乱。它迫使读者停止并验证他们是否真的在迭代相同的东西，而不是看到您的代码实际在做什么。