imp*_*roc 0 python algorithm comparison
我有 2 个数字列表，它们代表笛卡尔图中的点坐标。
我的目标是将 10 点范围内的许多点视为 1 点。
第一个例子：
坐标列表：
#(1)
x = [1,2,3, 80]
Y = [2,3,4, 90 ]
我想删除 10 范围内最近的点（在 x 和 y 中），我们可以将前三个数字视为一个。
结果是：
x = [1, 80] and y = [2, 90] or
x = [2,80] and y = [3, 90] or
x = [3,80] and y = [4, 90]
如果坐标列表是：
#(2)
x = [1,2,3, 80]
Y = [2,3,70, 90 ]
我们可以将前 2 个数字视为一个
结果是：
x = [1, 80] and y = [2, 90] or
x = [2,80] and y = [3, 90] or
如果它们是：
#(3)
x = [1,2, 75, 78 , 80, 101]
Y = [2,3, 81, 86, 90 , 91]
结果：
x = [1,75, 101] and y = [2,81, 91] or
x = [1,78, 101] and y = [2,86, 91] or
x = [1,80, 101] and y = [2,90, 91] or
x = [2,75, 101] and y = [3,81, 91] or
x = [2,78, 101] and y = [3,86, 91] or
x = [2,80, 101] and y = [3,90, 91] or
我只需要这 6 个解决方案中的一个。我是否有x = [1,75]或并不重要x = [1,78]。重要的是只有一个接近的数字。
最后一个例子：
x = [ 95, 154, 161, 135, 138, 116]
y = [158, 166, 168, 170, 170, 171]
在这种情况下，仅剩 3 分。
171 - 170 = 1 => 138 - 116 = 22 both results are in the range of 25 i choose to delete 116 and 171
170 - 170 = 0 => 138 - 135 = 3 both result are in the range of 25 i delete 170 and 138
170 - 168 = 2 => 135 - 161 = 26 i cannot delete
168 - 166 = 2 => 161 - 154 = 7 i delete 168 and 161
166 - 158 = 8 => 154 - 95 = 59 i cannot delete
x = [95, 154, 161, 135]
Y = [158, 166, 168, 170]
我重复操作，然后删除 x 中的 161 和 y 中的 168，因为： 168 - 166 = 2 => 161 - 154 = 7
x = [95, 154, 135]
Y = [158, 166, 170]
y 列表按升序排列。
比较它们的最快方法是什么？
一般来说，过滤列表比就地删除更容易。
但要轻松过滤，您需要一个列表，而不是其中的两个。
这正是zip它的目的。
我不确定我是否完全理解您的要求，因为从描述来看，除了 161 / 168 之外，一切都应该保持不变。我将展示听起来像您所描述的规则。
xy = zip(x, y)
new_xy = ((a, b) for a, b in xy if abs(a-b) <= 10)
x, y = zip(*new_xy)
无论您的实际目标是什么，只需将 替换if abs(a-b) <= 10为“是否应保留这对值”的正确规则，您就完成了。
要了解这是如何工作的，您应该尝试打印出xy（或者，如果您使用的是 Python 3.x，list(xy)）和其他中间位。
（如果您使用的是 Python 2.x，并且您的列表非常大，那么您可能应该import itertools然后使用xy = itertools.izip(x, y)以避免无缘无故地创建额外的列表。如果您使用的是 Python 3.x，这不是一个问题，因为zip不再创建额外的列表。）
从进一步的评论，好像也许你要检查x[i]针对x[i-1]，不反对y[i]，实际上你不会在看y值在所有它只是如果x[i]去，也是如此y[i]。
为了简化事情，让我们y完全去掉等式，只处理过滤x。我们可以回到y后面。
有两种方法可以解决这个问题。第一个是分解并构建一个显式循环，我们last_value在循环中每次都跟踪一个。第二个是获取 内相邻对的列表x。
答案再次是zip：
x_pairs = zip(x, x[1:])
唯一的问题是这并没有给你任何东西来比较第一个元素。例如：
>>> x = [95, 154, 161, 135, 138, 116]
>>> list(zip(x, x[1:]))
[(95, 154), (154, 161), (161, 135), (135, 138), (138, 116)]
这会告诉您是否保留 154、161、135、138 和 116……但是那 95 呢？好吧，你从来没有解释过这个规则。如果要将其与 进行比较0，请执行zip([0]+x, x). 如果您想始终保留它……您可以将其与自身进行比较，因此zip(x[:1]+x, x). 等等。你想要的任何规则都很容易编写。我将采用“比较0”规则。
所以，现在我们得到了这些相邻的值对(95, 95)then (95, 154)，依此类推。在每种情况下，如果两个相邻值之间的距离为<= 10，我们希望保留后一个值。这很容易：
x_pairs = zip([0]+x, x)
new_x = [pair[1] for pair in x_pairs if abs(pair[0]-pair[1]) <= 10]
将y放入那里与我们最初使用的技巧相同：将其放入zip对中，然后zip再退出。为了让事情更简单一些，而不是先压缩成对然后再压缩y，我们将zip一次性全部完成：
x_pairs_y = zip([0]+x, x, y)
new_xy = (xxy[1:] for xxy in x_pairs_y if abs(xxy[0]-xxy[1]) <= 10)
new_x, new_y = zip(*new_xy)
在您的某些解释中，听起来您想比较相邻的x值，也比较相邻的y值，如果有一个不同的值大于 10，则将它们过滤掉。
如果是这样，那只是更多相同：
xy_pairs = zip([0]+x, [0]+y, x, y)
new_xy = (xyxy[2:] for xyxy in xy_pairs
if abs(xyxy[0]-xyxy[2]) <= 10 and abs(xyxy[1]-xyxy[3]) <= 10)
new_x, new_y = zip(*new_xy)
但是，当事情变得如此复杂以致于您的简单单行无法放在一条线上时，您应该考虑将事情分解一下。例如，与其拥有一个x值列表和一个y值列表，为什么不创建一个Point类呢？
class Point(object):
def __init__(self, x, y):
self.x, self.y = x, y
def long_diff(self, other):
return max(abs(self.x-other.x), abs(self.y-other.y))
points = (Point(x, y) for x, y in zip(x, y))
point_pairs = zip([Point(0, 0)]+points, points)
new_points = (pair[1] for pair in point_pairs if pair[0].long_diff(pair[1]) <= 10)
new_x, new_y = zip(*((point.x, point.y) for point in points))
它有点长，但更容易理解。
如果您首先使用Point对象列表，而不是单独的x和y值列表，则会更容易理解。
从进一步的评论来看，听起来您想要的条件与我最后两个示例中显示的条件完全相反，而且您不知道如何否定条件。
首先，not接受任何表达式并返回相反的真值。所以：
new_xy = (xyxy[2:] for xyxy in xy_pairs
if not(abs(xyxy[0]-xyxy[2]) <= 10 and abs(xyxy[1]-xyxy[3]) <= 10))
或者，“如果 x 距离 <= 10 且 y 距离 <= 10，则删除”与“如果 x 距离 > 10 或 y 距离 > 10 则保留”相同，对吗？所以：
new_xy = (xyxy[2:] for xyxy in xy_pairs
if abs(xyxy[0]-xyxy[2]) > 10 or abs(xyxy[1]-xyxy[3]) > 10)
此外，如果您确定您的序列总是单调递增（即，任何元素总是比它之前的元素大），那么您实际上并不需要abs此处（只要您确保获得操作数顺序对）。