通过重复查找下一个列表中的下一个号in，可以大大简化代码。

def find( list_of_lists ):
    for element in list_of_lists[0]:
        start = element
        next = element
        for list in list_of_lists[1:]:
            next+=1
            print( "looking for {} in {}".format(next,list))
            if not next in list:
                return 'fail'
    return [x for x in range(start,next+1)]

a = [[143],[144,210,270],[145]]

find(a)
looking for 144 in [144,270]
looking for 145 in [145]

[143,144,145]

编辑：更正的版本

def find( list_of_lists ):
    num = len(list_of_lists)
    for start in list_of_lists[0]:
        try:
            print( "starting with",start )
            next = start
            last = start + num - 1
            for list in list_of_lists[1:]:
                next+=1
                print( "looking for {} in {}".format(next,list))
                if not next in list:
                    raise KeyError()
                elif next == last:
                    return [x for x in range(start,next+1)]
          except KeyError:
              pass
    return 'fail'

find(a)
starting with 1
looking for 2 in [3,2,6]
looking for 3 in [5,7,4]
starting with 3
looking for 4 in [3,6]
starting with 5
looking for 6 in [3,6]
looking for 7 in [5,4]

[5,6,7]

您可以使用chain来平整列表。

from itertools import chain


def find_consecutive():
    my_list = [[143],[145]]

    flatten_list = list(chain.from_iterable(my_list))

    for idx,item in enumerate(flatten_list):
        current = item
        preserved_items = [item]

        for _idx,_item in enumerate(flatten_list[idx + 1:]):
            if current + 1 == _item:
                current = _item
                preserved_items.append(_item)

        if len(preserved_item) > 1:
            return preserved_items

    return 'fail'


if __name__ == '__main__':
    print(f"consecutive: {find_consecutive()}")

输出：

consecutive: [143,145]

使用itertools.product获取所有子列表的叉积，并测试它们中的任何一个是否为连续序列。

import itertools as it

def pattern(example):
    for l in it.product(*example):
        if is_consecutive(l):
            return l
    return 'fail'

def is_consecutive(l):
    return all(l[i] == l[i+1] - 1 for i in range(len(l)-1))

我喜欢不使用导入的库作为学习体验而尝试。

我采用了这种方法。首先，我简化了您的初始列表，所以只有一个列表可以处理。

然后，我比较了列表中的项目，看它们之间的差异是否为1。我遇到的问题是，我得到了重复的内容（例如144个），并使用dict函数将其删除了。

x = [[133],134,136],[135]]
y = []
z = []

def isOne(itm,lst):
    pos = 0
    for stuff in lst:
        sm = stuff - itm
        if sm == 1:
            return pos
        else:
            pos = pos + 1
    return 0



for itms in x:
    for itms2 in itms:
        y.append(itms2)


for itms in y:
    x = isOne(itms,y)
    if x > 0:
      z.append(itms)
      z.append(y[x])

z = list(dict.fromkeys(z))


print(z)

您可以使用函数chain()：

from itertools import chain

it = chain.from_iterable(lst)
# add the first item from the iterator to the list
result = [next(it)]

for i in it:
    if result[-1] == i - 1:
        result.append(i)