Проверьте, есть ли список списка в списке [дубликат]

Простой способ проверить, находятся ли все элементы списка в другом, преобразовывая оба набора:

def sublist(lst1, lst2):
    return set(lst1) <= set(lst2)

Эффективное решение для памяти, основанное на ответе М. Моргана. Принимает во внимание, что для того, чтобы быть подсписком, подсписок должен быть найден в том же порядке в супер-списке.

Переменная k отслеживает длину совпадающих символов. Когда это соответствует длине нашего подсписок, мы можем вернуть true.

Переменная s отслеживает начальное значение. Я отслеживаю это, так что тестовый пример, например sublist(["1", "1", "2"],["0", "1", "1", "1", "2", "1", "2"]) с посторонними повторами первой записи, не влияет на текущий сброс индекса, когда он не имеет аналогов. Как только начальное значение изменяется s, становится неуместным, поэтому этот случай не срабатывает в середине шаблона.

def sublist(sublist, lst):
    if not isinstance(sublist, list):
        raise ValueError("sublist must be a list")
    if not isinstance(lst, list):
        raise ValueError("lst must be a list")

    sublist_len = len(sublist)
    k=0
    s=None

    if (sublist_len > len(lst)):
        return False
    elif (sublist_len == 0):
        return True

    for x in lst:
        if x == sublist[k]:
            if (k == 0): s = x
            elif (x != s): s = None
            k += 1
            if k == sublist_len:
                return True
        elif k > 0 and sublist[k-1] != s:
            k = 0

    return False

Еще один простой способ - использовать понимание list и использовать встроенную функцию all , чтобы убедиться, что все элементы в списке1 содержатся в списке2.

Пример:

list1 = ['1','2']
list2 = ['1','2',3]

all(i in list2 for i in list1)

Другой способ, которым мы это делаем, - collections.Counter. Второй ответ L3viathan - самый эффективный и быстрый способ сделать это.

def sublist1(lst1, lst2):
    ls1 = [element for element in lst1 if element in lst2]
    ls2 = [element for element in lst2 if element in lst1]
    return ls1 == ls2


def sublist2(lst1, lst2):
    def get_all_in(one, another):
        for element in one:
            if element in another:
                yield element
    for x1, x2 in zip(get_all_in(lst1, lst2), get_all_in(lst2, lst1)):
        if x1 != x2:
            return False
    return True


def sublist3(lst1, lst2):
    from collections import Counter
    c1 = Counter(lst1)
    c2 = Counter(lst2)
    for item, count in c1.items():
        if count > c2[item]:
            return False
    return True


l1 = ["a", "b", "c", "c", "c", "d", "e"]
l2 = ["c", "a", "c", "b", "c", "c", "d", "d", "f", "e"]

s1 = lambda: sublist1(l1, l2)
s2 = lambda: sublist2(l1, l2)
s3 = lambda: sublist3(l1, l2)

from timeit import Timer
t1, t2, t3 = Timer(s1), Timer(s2), Timer(s3)
print(t1.timeit(number=10000))  # => 0.034193423241588035
print(t2.timeit(number=10000))  # => 0.012621842119714115
print(t3.timeit(number=10000))  # => 0.12714286673722477

Его второй способ быстрее на порядок, но я хотел упомянуть вариант Counter из-за его распространенности и использования вне этого сценария.

Я нашел, что все выше всего найдено ['a', 'b', 'd'] как подсловитель ['a', 'b', 'c', 'e', ​​'d'], который может быть неверным, несмотря на то, что все элементы подсписчика присутствуют в списке. Поэтому, чтобы поддерживать порядок, и я придумал:

def sublist4(sublist,lst):
    #Define an temp array to populate 
    sub_list=[]
    comparable_sublist=[]
    #Define two constants to iterate in the while loop
    i=0
    k=0
    #Loop the length of lst
    while i < len(lst):
        #If the element is in the sublist append to temp array, 
        if k < len(sublist) and lst[i] == sublist[k]:
            sub_list.append(lst[i])
            #set a comparable array to the value of temp array
            comparable_sublist = sub_list
            k += 1
            #If the comparable array is the same as the sublist, break
            if len(comparable_sublist) == len(sublist):
                break

        #If the element is not in the sublist, reset temp array
        else:
            sub_list = []


        i += 1

    return comparable_sublist == sublist

Хотя это не очень эффективно для памяти, я нахожу, что он отлично работает с небольшими списками.

def sublist(l1,l2):
    s1=" ".join(str(i) for i in l1)
    s2=" ".join(str(i) for i in l2)
    if s1 in s2:
        return True
    else:
        return False

Легко с итераторами.

>>> a = [0,1,2]
>>> b = [item for item in range(10)]
>>> b
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a
[0, 1, 2]
>>> [False, True][set([item in b for item in a]) == set([True])]
True
>>> a = [11, 12, 13]
>>> [False, True][set([item in b for item in a]) == set([True])]
False

Попробуйте это! sublist y не пропускает последовательность списка x.

x = list

y = подписок

if ([i for i,j in enumerate(y) for k,l in enumerate(x) if i == k and j!=l]):
    print("True")
else:
    print("False")