Pythonic подход, позволяющий избежать вложенных циклов для объединения строк

Вы можете переписать его для работы с произвольным количеством списков следующим образом:

Сначала поместите элементы последнего списка в подсписки по 1 элементу (это упростит дальнейшую обработку).

ps = [[c] for c in l2]
print(ps) # [['348'], ['551'], ['399']]

Далее для каждого из оставшихся списков проверяем, какие элементы соответствуют элементам в ps, и добавляем их в начало совпадающих элементов.

for l in [l1, l0]:
    ps = [[a] + p for a in l for p in ps if is_successor(a, p[0])]

print(ps) # [['123', '234', '348'], ['123', '239', '399']]

Теперь соберите последнюю строку из списков.

pres = []
for p in ps:
    pres.append(p[0]) # add entire element from l0
    for el in p[1:]:
        pres[-1] += el[-1] # add last character from following lists

print(pres) # ['12348', '12399']

Поскольку единственное место, где мы напрямую ссылаемся на входные списки, — это for l in [l1, l0]: и создание исходного списка из последнего, это будет работать для любого количества списков, если эти строки будут обновлены.

Я бы использовал продукт itertools для определения функции, которая будет выполнять проверку и добавлять данные:

import itertools

def get_list(l1,l2):
    #THIS FUNCTION WILL TEST ALL THE PRODUCTS AND RETURN ONLY THE CORRECT ONES
    return [a+b[2:] for a,b in list(itertools.product(l1,l2)) if a[1:] == b[:2]]

то вы можете вложить функцию следующим образом:

get_list(l0,get_list(l1,l2))

вы получите ожидаемый результат: ['12348', '12399']

Обновлено: для длинного списка используйте сокращение.

назовем l списком входных данных. В вашем конкретном случае l = list([l0,l1,l2])

Чтобы подать заявку, поменяйте местами список с конца до начала l.reverse()

и окончательный код:

from functools import reduce 
reduce(lambda x,y:get_list(x,y),l)

Примечание: в этом случае вы хотите изменить входные данные функции «get_list», так как она будет сначала l2, затем l1, затем l0. Просто измените определение get_list следующим образом: def get_list(l2,l1)

Если списки содержат больше элементов, я бы предложил создать словари-преемники для всех элементов в списке. Затем вы можете напрямую объединить этих преемников, не повторяя и не проверяя все комбинации.

from collections import defaultdict

l0=["123","567","451"]
l1=["234","239","881"]
l2=["348","551","399"]

def make_succ_dict(lst):
    d = defaultdict(list)
    for s in lst:
        d[s[:2]].append(s)
    return d

s1 = make_succ_dict(l1)
s2 = make_succ_dict(l2)

res = [a + b[2:] + c[2:] for a in l0 for b in s1[a[1:]] for c in s2[b[1:]]]
print(res)  # ['12348', '12399']

(При этом по-прежнему используются вложенные циклы, но недопустимая комбинация не будет зацикливаться.)

Просто простой цикл:

l0=["123","567","451"]
l1=["234","239","881"]
l2=["348","551","399"]

pres = l2[:]
for L in l1, l0:
    pres = [s[0] + p
            for s in L
            for p in pres
            if s[1:] == p[:2]]

print(pres)

Попробуйте это онлайн!