python - 如果列表中的点非常接近并且可以视为单个点，如何从列表中删除点的坐标？

Question

我有两个数字列表，它们表示python中笛卡尔图中的点坐标
我的目标是把10分范围内的许多点都当作1分
第一个例子：
第一点（1,2）
第二点（2,3）
第三点（3,4）
第4点（80,90）
坐标列表：

#(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 ]

我们可以把前两个数字看作一个
结果是：

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列表按升序排列。
比较它们最快的方法是什么？

Answer 1

一般来说，筛选列表比就地删除列表更容易。
但是为了便于过滤，你需要一个列表，而不是其中的两个。
这正是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)）和其他中间位。
（如果您使用的是Python2.x，并且您的列表非常大，那么您可能应该import itertools，然后使用xy = itertools.izip(x, y)，以避免无正当理由创建额外的列表如果您使用的是Python3.x，这不是问题，因为zip不再创建额外的列表。）
从进一步的评论来看，似乎你想对照x[i]检查x[i-1]，而不是对照y[i]，实际上你根本不看y值，只是如果x[i]去了，那么y[i]也去了。
为了简化问题，让我们把y完全从方程中去掉，只处理过滤x我们可以稍后返回y。
有两种方法可以解决这个问题第一种方法是分解并构建一个显式循环，在这个循环中我们每次都跟踪一个last_value第二个是获取x内相邻对的列表。
答案再次是：

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)]

它告诉你是否要保留154161135138和116…但那95呢好吧，你从来没有解释过这个规则。如果要将其与zip进行比较，请执行0如果你想一直保存它…你可以把它和它自己比较，所以zip([0]+x, x)。等等。你想要什么规则都很容易写。我将使用“compare tozip(x[:1]+x, x)”规则。
现在我们得到了这对相邻的值，然后是，等等在每种情况下，如果两个相邻值之间的距离0，我们希望保留后一个值很简单：

x_pairs = zip([0]+x, x)
new_x = [pair[1] for pair in x_pairs if abs(pair[0]-pair[1]) <= 10]

把(95, 95)放进去和我们最初使用的技巧是一样的：只需把(95, 154)放在成对的人身上，然后再把<= 10放回去。为了让事情简单一点，我们不需要先压缩对，然后再压缩y就可以了：

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)

在您的一些解释中，听起来您希望比较相邻的zip值，也希望比较相邻的zip值，并在其中一个值大于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)

然而，当事情变得如此复杂以至于你的简单的一行代码不适合一行代码时，你应该考虑把事情分解一下。例如，与其有一个y值列表和一个zip值列表，为什么不创建一个x类？

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))

有点长，但更容易理解。
而且，如果首先使用y对象列表，而不是单独的x和y值列表，则更容易理解。
从进一步的评论来看，听起来你想要的条件与我最后两个例子中所示的条件完全相反，你不知道如何否定一个条件。
首先，Point接受任何表达式并返回相反的真值。所以：

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)

另外，如果您确定序列总是单调递增（即，任何元素总是比它前面的元素大），那么您实际上不需要这里的Point（只要确保操作数顺序正确）。