Python 连接列表并删除重叠

我想要两张名单

A = [ 1,2,3,4,5]
B = [4,5,6,7]

结果 C=[1,2,3,4,5,6,7]

如果我指定重叠为2

迄今为止的代码：

concat_list = []
word_overlap = 2

for lst in [lst1, lst2, lst3]:
  if (len(concat_list) != 0):

    if  (concat_list[-word_overlap:] != lst[:word_overlap]):
        concat_list += lst
    elif ([concat_list[-word_overlap:]] == lst[:word_overlap]): 

        raise SystemExit

  else:
    concat_list += lst

对字符串列表执行此操作，但应该是一样的

编辑：

我想让我的代码做的是，首先检查是否有重叠（1、2等），然后连接列表，消除重叠（这样我就不会得到双元素）

[1,2,3,4,5]+[4,5,6,7]=[1,2,3,4,5,6,7]

但是

[1,2,3]+[4,5,6]=[1,2,3,4,5,6]

---

我希望它也检查任何重叠小于我设置的单词重叠

不确定我是否正确解释了你的问题，但你可以这样做：

A = [ 1,2,3,4,5]
B = [4,5,6,7]

overlap = 2

print A[0:-overlap] + B

def concatenate_list(a,b):
    max_a = a[len(a)-1]
    min_b = b[0]
    if max_a >= min_b:
        print 'overlap exists'
        b = b[(max_a - min_b) + 1:]
    else:
        print 'no overlap'
    return a + b

如果您想确保它们具有相同的值，您可以按照以下方式进行检查：

if(A[-overlap:] == B[:overlap]):
   print A[0:-overlap] + B
else:
   print "error"

---

不确定我是否正确解释了你的问题，但你可以这样做：

A = [ 1,2,3,4,5]
B = [4,5,6,7]

overlap = 2

print A[0:-overlap] + B

如果您想确保它们具有相同的值，您可以按照以下方式进行检查：

if(A[-overlap:] == B[:overlap]):
   print A[0:-overlap] + B
else:
   print "error"

---

假设两个列表都是连续的，并且列表a的值总是比列表b的值小。我想出了这个解决办法。 这也将帮助您检测重叠

def concatenate_list(a,b):
    max_a = a[len(a)-1]
    min_b = b[0]
    if max_a >= min_b:
        print 'overlap exists'
        b = b[(max_a - min_b) + 1:]
    else:
        print 'no overlap'
    return a + b

对于字符串，您也可以这样做

def concatenate_list_strings(a,b):
    count = 0
    for i in xrange(min(len(a),len(b))):
        max_a = a[len(a) - 1 - count:]
        min_b = b[0:count+1]

        if max_a == min_b:
            b = b[count +1:]
            return 'overlap count ' + str(count), a+b
        count += 1
    return a + b

---

假设两个列表都是连续的，并且列表a的值总是比列表b的值小。我想出了这个解决办法。 这也将帮助您检测重叠

def concatenate_list(a,b):
    max_a = a[len(a)-1]
    min_b = b[0]
    if max_a >= min_b:
        print 'overlap exists'
        b = b[(max_a - min_b) + 1:]
    else:
        print 'no overlap'
    return a + b

对于字符串，您也可以这样做

def concatenate_list_strings(a,b):
    count = 0
    for i in xrange(min(len(a),len(b))):
        max_a = a[len(a) - 1 - count:]
        min_b = b[0:count+1]

        if max_a == min_b:
            b = b[count +1:]
            return 'overlap count ' + str(count), a+b
        count += 1
    return a + b

你可以使用和联合

s、 并集（t）：包含s和t元素的新集合

但是你不能得到准确的数字，你需要以这种方式重叠

要回答您的问题，您必须使用策略和集合：

• 获取包含a和B元素的新列表
• 获取包含A和B共有的元素的新列表
• 使用切片仅获取此列表中所需的元素数

• 获取包含A或B元素的新列表，但不能同时包含这两个元素

  OVERLAP = 1
  
  A = [1, 2, 3, 4, 5]
  B = [4, 5, 6, 7]
  
  C = list(set(A) | set(B)) # [1, 2, 3, 4, 5, 6, 7]
  D = list(set(A) & set(B)) # [4, 5]
  D = D[OVERLAP:] # [5]
  
  
  print list(set(C) ^ set(D)) # [1, 2, 3, 4, 6, 7]
  

只是为了好玩，一艘邮轮可以提供：

list((set(A) | set(B)) ^ set(list(set(A) & set(B))[OVERLAP:])) # [1, 2, 3, 4, 6, 7]

其中，

重叠

是需要重新组合的常量。

可以使用和联合

s、 并集（t）：包含s和t元素的新集合

但是你不能得到准确的数字，你需要以这种方式重叠

要回答您的问题，您必须使用策略和集合：

• 获取包含a和B元素的新列表
• 获取包含A和B共有的元素的新列表
• 使用切片仅获取此列表中所需的元素数

• 获取包含A或B元素的新列表，但不能同时包含这两个元素

  OVERLAP = 1
  
  A = [1, 2, 3, 4, 5]
  B = [4, 5, 6, 7]
  
  C = list(set(A) | set(B)) # [1, 2, 3, 4, 5, 6, 7]
  D = list(set(A) & set(B)) # [4, 5]
  D = D[OVERLAP:] # [5]
  
  
  print list(set(C) ^ set(D)) # [1, 2, 3, 4, 6, 7]
  

只是为了好玩，一艘邮轮可以提供：

list((set(A) | set(B)) ^ set(list(set(A) & set(B))[OVERLAP:])) # [1, 2, 3, 4, 6, 7]

---

其中，

重叠

是你需要重新聚在一起的常数。

这里有一个天真的变体：

def concat_nooverlap(a,b):
    maxoverlap=min(len(a),len(b))
    for overlap in range(maxoverlap,-1,-1):
        # Check for longest possible overlap first
        if a[-overlap:]==b[:overlap]:
            break  # Found an overlap, don't check any shorter
    return a+b[overlap:]

使用支持按引用切片的类型（如缓冲区或numpy数组）会更有效

一件非常奇怪的事情是，当达到overlap=0时，它将整个a（切片，这是列表的副本）与b的空切片进行比较。除非它们为空，否则该比较将失败，但它仍然保留overlap=0，因此返回值是正确的。我们只需稍加重写即可专门处理此情况：

def concat_nooverlap(a,b):
    maxoverlap=min(len(a),len(b))
    for overlap in range(maxoverlap,0,-1):
        # Check for longest possible overlap first
        if a[-overlap:]==b[:overlap]:
            return a+b[overlap:]
    else:
        return a+b

---

这里有一个天真的变体：

def concat_nooverlap(a,b):
    maxoverlap=min(len(a),len(b))
    for overlap in range(maxoverlap,-1,-1):
        # Check for longest possible overlap first
        if a[-overlap:]==b[:overlap]:
            break  # Found an overlap, don't check any shorter
    return a+b[overlap:]

使用支持按引用切片的类型（如缓冲区或numpy数组）会更有效

一件非常奇怪的事情是，当达到overlap=0时，它将整个a（切片，这是列表的副本）与b的空切片进行比较。除非它们为空，否则该比较将失败，但它仍然保留overlap=0，因此返回值是正确的。我们只需稍加重写即可专门处理此情况：

def concat_nooverlap(a,b):
    maxoverlap=min(len(a),len(b))
    for overlap in range(maxoverlap,0,-1):
        # Check for longest possible overlap first
        if a[-overlap:]==b[:overlap]:
            return a+b[overlap:]
    else:
        return a+b

---

lst1=[1,2,3,4,5]

lst2=[4,5,6,7]

c=lst1+lst2

print list（set（c））

连接列表的简单方法

lst1=[1,2,3,4,5]

lst2=[4,5,6,7]

c=lst1+lst2

连接列表的简单方法您想使用上述相同的概念和假设连接字符串吗？字符串列表，是的，字符串是指数字字符串（['1'，'2'.'3']）或单词字符串['abc'，'def']？[“some”，“string”，“go”，“in”，“this”，“list”]，像这样的列表。你想用上面提到的相同概念和假设来定义字符串吗？字符串列表，是的，字符串你指的是数字字符串（['1'，'2'.'3']）或单词字符串['abc'，'def']？[“some”，“string”，“goes”，“in”，“this”，“list”]，类似的列表。我刚刚意识到也许我偏离了主题，如果我的回答对你有任何帮助，你能准确地回答吗？thx@QubixI刚刚意识到我可能离题了，如果我的回答对你有任何帮助，你能准确地回答吗？thx@Qubix