Python 如何去掉列表中的子元组？
由于Python 如何去掉列表中的子元组？,python,remove,Python,Remove,由于（0,2）和（4,6）都在（0,6）的索引中，因此我想删除它们。由此产生的清单将是： list_of_tuple = [(0,2), (0,6), (4,6), (6,7), (8,9)] 似乎我需要以某种方式对这个列表元组进行排序，以使其更容易删除。但是如何对元组列表进行排序呢 给定两个数组索引元组，[m，n]和[a，b]，如果： list_of_tuple = [(0,6), (6,7), (8,9)] m>=a&n您可以尝试以下方法来检查（半开放）间隔的两端是否包含在另一个间隔内：
（0,2）（4,6）（0,6）list_of_tuple = [(0,2), (0,6), (4,6), (6,7), (8,9)]
[m，n][a，b]list_of_tuple = [(0,6), (6,7), (8,9)]
m>=a&n您可以尝试以下方法来检查（半开放）间隔的两端是否包含在另一个间隔内：
m >=a & n<=b
注意：这假设您的元组是半开区间，即[0,6]，其中0是包含的，但6是独占的，类似于range
处理start
和stop
参数的方式。对于完全关闭区间的情况，必须进行一些小的更改：
范围（*o）
->范围（o[0]，o[1]+1）
及
如果r中的t[0]和r中的（t[1]-1:
->如果r中的t[0]和r中的t[1:
您可以尝试类似的方法来检查（半开）间隔的两端是否包含在另一个间隔中：
m >=a & n<=b
注意：这假设您的元组是半开区间，即[0,6]，其中0是包含的，但6是独占的，类似于range
处理start
和stop
参数的方式。对于完全关闭区间的情况，必须进行一些小的更改：
范围（*o）
->范围（o[0]，o[1]+1）
及
如果r中的t[0]和r中的（t[1]-1）：
->如果r中的t[0]和r中的t[1:
这是一个非常简单的解决方案，但它是O（n2）：
interval=[（0,2），（0,6），（4,6），（6,7），（8,9）]#列表#
结果=[
t表示t的间隔
如果不是任何（t！=u和t[0]>=u[0]和t[1]这里有一个非常简单的解决方案，但它是O（n2）：
interval=[（0,2），（0,6），（4,6），（6,7），（8,9）]#列表#
结果=[
t表示t的间隔
如果没有任何（t！=u和t[0]>=u[0]和t[1]，那么这是在O（n log（n））中实现解决方案的第一步：
def非连续（批次）：
s=已排序（批次，键=λt:（t[0]，-t[1]））
i=1
而我def非连续（批次）：
s=已排序（批次，键=λt:（t[0]，-t[1]））
i=1
而我元组列表
中删除指定元组范围以外的所有元组：
def non_cont_on(lot):
s = sorted(lot, key = lambda t: (t[0], -t[1]))
i = 1
result = s[:1]
for i in s:
if not (i[0] >= result[-1][0] and i[1] <= result[-1][1]):
result.append(i)
return result
要从元组列表中删除范围超出指定元组的所有元组，请执行以下操作：
def non_cont_on(lot):
s = sorted(lot, key = lambda t: (t[0], -t[1]))
i = 1
result = s[:1]
for i in s:
if not (i[0] >= result[-1][0] and i[1] <= result[-1][1]):
result.append(i)
return result
如果您想保留包含结构的相关信息（原始集合的一个间隔的封闭间隔被使用），您可以构建一个“一级树”：
包含的def（tpl1、tpl2）：
返回tpl1[0]>=tpl2[0]和tpl1[1]如果要保留包含结构的信息（使用原始集合的间隔的封闭间隔），可以构建“一级树”：
包含的def（tpl1、tpl2）：
返回tpl1[0]>=tpl2[0]和tpl1[1]似乎您正在尝试合并重叠的区间。例如，（9,11）、（10,12）在下面的第二个示例中合并生成（9,12）
在这种情况下，使用sorted
的简单排序将自动处理元组
方法：存储要添加的下一个间隔。继续延长间隔的结尾，直到遇到一个值，该值的“开始”位于下一个要添加的值的“结束”之后（>=）。此时，存储的下一个间隔可以追加到结果中。在结尾追加以说明处理所有值
def contained(tpl1, tpl2):
return tpl1[0] >= tpl2[0] and tpl1[1] <= tpl2[1]
def interval_hierarchy(lst):
if not lst:
return
root = lst.pop()
children_dict = {root: []}
while lst:
t = lst.pop()
curr_children = list(children_dict.keys())
for k in curr_children:
if contained(k, t):
children_dict[t] = (children_dict[t] if t in children_dict else []) +\
[k, *children_dict[k]]
children_dict.pop(k)
elif contained(t, k):
children_dict[k].append(t)
if t in children_dict:
children_dict[k] += children_dict[t]
children_dict.pop(t)
else:
if not t in children_dict:
children_dict[t] = []
# return whatever information you might want to use
return children_dict, list(children_dict.keys())
输出：
list_of_tuple = [(0,2), (0,6), (4,6), (6,7), (8,9)]
def rm(lst,tup):
return [tup]+[t for t in lst if t[0] < tup[0] or t[1] > tup[1]]
print(rm(list_of_tuple,(0,6)))
def merge_intervals(val_input):
if not val_input:
return []
vals_sorted = sorted(val_input) # sorts by tuple values "natural ordering"
result = []
x0, x1 = vals_sorted[0] # store next interval to be added as (x0, x1)
for start, end in vals_sorted[1:]:
if start >= x1: # reached next separate interval
result.append((x0, x1))
x0, x1 = (start, end)
elif end > x1:
x1 = end # extend length of next interval to be added
result.append((x0, x1))
return result
print(merge_intervals([(0,2), (0,6), (4,6), (6,7), (8,9)]))
print(merge_intervals([(1,2), (9,11), (10,12), (1,7)]))
您似乎正在尝试合并重叠的间隔。例如，在下面的第二个示例中，（9,11）、（10,12）被合并以生成（9,12）
在这种情况下，使用sorted
的简单排序将自动处理元组
方法：存储要添加的下一个间隔。继续延长间隔的结尾，直到遇到一个值，该值的“开始”位于下一个要添加的值的“结束”之后（>=）。此时，存储的下一个间隔可以追加到结果中。在结尾追加以说明处理所有值
def contained(tpl1, tpl2):
return tpl1[0] >= tpl2[0] and tpl1[1] <= tpl2[1]
def interval_hierarchy(lst):
if not lst:
return
root = lst.pop()
children_dict = {root: []}
while lst:
t = lst.pop()
curr_children = list(children_dict.keys())
for k in curr_children:
if contained(k, t):
children_dict[t] = (children_dict[t] if t in children_dict else []) +\
[k, *children_dict[k]]
children_dict.pop(k)
elif contained(t, k):
children_dict[k].append(t)
if t in children_dict:
children_dict[k] += children_dict[t]
children_dict.pop(t)
else:
if not t in children_dict:
children_dict[t] = []
# return whatever information you might want to use
return children_dict, list(children_dict.keys())
输出：
list_of_tuple = [(0,2), (0,6), (4,6), (6,7), (8,9)]
def rm(lst,tup):
return [tup]+[t for t in lst if t[0] < tup[0] or t[1] > tup[1]]
print(rm(list_of_tuple,(0,6)))
def merge_intervals(val_input):
if not val_input:
return []
vals_sorted = sorted(val_input) # sorts by tuple values "natural ordering"
result = []
x0, x1 = vals_sorted[0] # store next interval to be added as (x0, x1)
for start, end in vals_sorted[1:]:
if start >= x1: # reached next separate interval
result.append((x0, x1))
x0, x1 = (start, end)
elif end > x1:
x1 = end # extend length of next interval to be added
result.append((x0, x1))
return result
print(merge_intervals([(0,2), (0,6), (4,6), (6,7), (8,9)]))
print(merge_intervals([(1,2), (9,11), (10,12), (1,7)]))
似乎是滥用reduce（）
和Python的逻辑运算符的机会！解决方案假设列表按照OP的示例进行排序，主要在每个元组的第二个元素上，其次在第一个元素上：
[(0, 6), (6, 7), (8, 9)]
[(1, 7), (9, 12)]
似乎是滥用reduce（）
和Python的逻辑运算符的机会！解决方案假设列表按照OP的示例进行排序，主要在每个元组的第二个元素上，其次在第一个元素上：
[(0, 6), (6, 7), (8, 9)]
[(1, 7), (9, 12)]
你用来删除它们的确切标准是什么？似乎你把它们当作区间来处理，对吗？因此，如果任何区间包含在另一个区间中，它应该被删除？你可以用O（n^2）中的范围
来做这件事时间很容易。是的。但是怎么做呢？我需要先排序？这回答了你的问题吗？你用来删除它们的确切标准是什么？你似乎把它们当作间隔，对吗？所以如果任何间隔包含在另一个间隔中，它应该被删除？你可以用O（n^2）中的范围来完成时间很容易。是的。但是怎么做呢？我需要先排序？这回答了你的问题吗？它实际上比声明好。它也会删除重复项，如果元组相等的话就是这样@wjandrea@JeffH它不会删除重复项。例如，如果您添加另一个（0,6）
，它将包含在结果中。如果要删除重复项，只需将间隔
转换为一个集合即可