Python，基于x的坐标拆分列表

我有一个坐标列表，我需要根据它们的x值将它们一分为二。大概是这样的：

l = [(0, 0), (1, 0), (2, 0), (3, 0), (0, 1), (1, 1), (2, 1), (3, 1)]
left = []
right = []
for i in l:
    if i[0] < 2:
        left.append(i)
    else:
        right.append(i)

print(left)
print(right)

有没有更快的方法可以做到这一点？

这不是更快（2n），但可能更优雅，如果使用二进制搜索对列表进行排序，您可以得到的最好结果是log n

>>> l = [(0, 0), (1, 0), (2, 0), (3, 0), (0, 1), (1, 1), (2, 1), (3, 1)]
>>> left = [ x for x in l if x[0] < 2]
>>> right = [ x for x in l if x[0] >= 2]

>>l=[（0,0）、（1,0）、（2,0）、（3,0）、（0,1）、（1,1）、（2,1）、（3,1）]
>>>左=[x代表l中的x，如果x[0]<2]
>>>右=[x代表l中的x，如果x[0]>=2]

这不是更快（2n），但可能更优雅，如果使用二进制搜索对列表进行排序，您可以得到的最好结果是log n

>>> l = [(0, 0), (1, 0), (2, 0), (3, 0), (0, 1), (1, 1), (2, 1), (3, 1)]
>>> left = [ x for x in l if x[0] < 2]
>>> right = [ x for x in l if x[0] >= 2]

>>l=[（0,0）、（1,0）、（2,0）、（3,0）、（0,1）、（1,1）、（2,1）、（3,1）]
>>>左=[x代表l中的x，如果x[0]<2]
>>>右=[x代表l中的x，如果x[0]>=2]

您可以在O（n）中执行此操作。如果对列表进行了排序，则可以在O（log（n））中进行排序，方法是使用二进制搜索来搜索pivot元素。仅仅为了使用二进制搜索而预先对其进行排序是没有好处的，因为排序是O（n*log（n））

另一方面。。。这真的重要吗？如果这是您的瓶颈，那么可以重新考虑整个算法或数据结构。例如，如果你有一个复杂的问题，你需要对某个区域的点进行操作，你可以考虑使用

你在O（n）中进行。如果对列表进行了排序，则可以在O（log（n））中进行排序，方法是使用二进制搜索来搜索pivot元素。仅仅为了使用二进制搜索而预先对其进行排序是没有好处的，因为排序是O（n*log（n））

---

另一方面。。。这真的重要吗？如果这是您的瓶颈，那么可以重新考虑整个算法或数据结构。例如，如果你有一个复杂的问题，你需要对某个区域的点进行操作，你可以考虑使用

如果你希望它更简洁、更快速、更易读，而不松动O（N）的性能，这可以是其中的一种方式-< /P>

right = []
left = [coord for coord in l if (lambda t: True if t[0] < 2 else right.append(t) and False)(coord)]

right=[]
左=[l if中的坐标（lambda t:True if t[0]<2，否则右。附加（t）和False）（坐标）]

仅在列表上迭代一次

>>> l = [(0, 0), (1, 0), (2, 0), (3, 0), (0, 1), (1, 1), (2, 1), (3, 1)]
>>> right = []
>>> left = [coord for coord in l if (lambda t: True if t[0] < 2 else right.append(t) and False)(coord)]
>>> print '\n'.join([str(left), str(right)])
[(0, 0), (1, 0), (0, 1), (1, 1)]
[(2, 0), (3, 0), (2, 1), (3, 1)]
>>> 

>>l=[（0,0）、（1,0）、（2,0）、（3,0）、（0,1）、（1,1）、（2,1）、（3,1）]
>>>右=[]
>>>左=[l if中的坐标（lambda t:True if t[0]<2，否则右。附加（t）和False）（坐标）]
>>>打印'\n'。连接（[str（左），str（右）]）
[(0, 0), (1, 0), (0, 1), (1, 1)]
[(2, 0), (3, 0), (2, 1), (3, 1)]
>>> 

如果您希望它更简洁、更通俗、更可读，同时又不损失O（n）性能，这可以是一种方法-

right = []
left = [coord for coord in l if (lambda t: True if t[0] < 2 else right.append(t) and False)(coord)]

right=[]
左=[l if中的坐标（lambda t:True if t[0]<2，否则右。附加（t）和False）（坐标）]

仅在列表上迭代一次

>>> l = [(0, 0), (1, 0), (2, 0), (3, 0), (0, 1), (1, 1), (2, 1), (3, 1)]
>>> right = []
>>> left = [coord for coord in l if (lambda t: True if t[0] < 2 else right.append(t) and False)(coord)]
>>> print '\n'.join([str(left), str(right)])
[(0, 0), (1, 0), (0, 1), (1, 1)]
[(2, 0), (3, 0), (2, 1), (3, 1)]
>>> 

>>l=[（0,0）、（1,0）、（2,0）、（3,0）、（0,1）、（1,1）、（2,1）、（3,1）]
>>>右=[]
>>>左=[l if中的坐标（lambda t:True if t[0]<2，否则右。附加（t）和False）（坐标）]
>>>打印'\n'。连接（[str（左），str（右）]）
[(0, 0), (1, 0), (0, 1), (1, 1)]
[(2, 0), (3, 0), (2, 1), (3, 1)]
>>> 

您可以在一个循环中完成，因此本质上我认为没有更快的方法。相关：可能也想看看这个：如果对列表进行排序，您可能会得到

log n

复杂性。你能影响坐标的生成方式吗？@phg yeah看起来我能在一个循环中完成，所以本质上我认为没有更快的方法。相关：可能也想看看这个：如果列表被排序，你可能会得到

log n

复杂性。你能影响坐标的生成吗？@phg-yeah看起来我能