Проверка подсписка в списке

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

def n_slices(n, list_):
    for i in xrange(len(list_) + 1 - n):
        yield list_[i:i+n]

def isSublist(list_, sub_list):
    for slice_ in n_slices(len(sub_list), list_):
        if slice_ == sub_list:
            return True
    return False

Прикрыть вопрос заказа. Список по определению упорядочен. Если мы хотим игнорировать порядок, вы можете сделать наборы:

def isSubset(list_, sub_list):
    return set(sub_list) <= set(list_)

Если нам нужно покрыть повторяющиеся элементы и игнорировать порядок, вы теперь находитесь в области мультимножеств:

def isSubset(list_, sub_list):
    for item in sub_list:
        if sub_list.count(item) > list_.count(item):
            return False
    return True

>>> def isSublist(originallist,sublist,biglist):
    if not sublist:
        return True
    if not biglist:
        return False
    if sublist[0]==biglist[0]:
        return isSublist(originallist,sublist[1:],biglist[1:]) or isSublist(originallist,sublist,biglist[1:])
    return isSublist(originallist,originallist,biglist[1:])

тестовый вывод:

>>> isSublist([1,2,4],[1,2,4],[1,2,3,4])
False
>>> isSublist([1,2,3],[1,2,3],[1,2,3,4])
True
>>> 

Отредактировано для подсписков, а не для подмножества. Уродливее, но работает. Можно добавить обертку, чтобы избежать путаницы параметров.

def sublist(a,b):
    isSublist(a,a,b)

Часть вашей проблемы заключается в том, что в Python(0,1,2,3,4,5,6,7,8,9)технически не alist, а atuple, который по сути является неизменным (неизменяемым)list. Кроме того, вы должны избегать называть вещи в своей программе так же, как встроенные функции и типы, потому что иногда вам нужно ссылаться на них, и ваше собственное определение будет скрывать имена, предоставленные системой.

Один простой способ обойти это — просто добавить an_ в конец имени, как это сделано в следующем примере, который пытается преобразовать аргумент в alist, если он изначально не был таковым. Он не проверяет тип аргумента thesublist, но подобная проверка может подойти и для него.

def isSublist(list_, sublist):
    if not isinstance(list_, list):
        list_ = list(list_)
    sublen = len(sublist)
    for i in xrange(len(list_)-sublen+1):
        if list_[i:i+sublen] == sublist:
            return True
    return False

list_ = (0,1,2,3,4,5,6,7,8,9)
print subfunc(list_, [0,1])  # --> True
print subfunc(list_, [1,2,3])  # --> True
print subfunc(list_, [4,6,7])  # --> False
print subfunc(list_, [4,5])  # --> True

Я только что написал рецепт для этого (это работает для непрерывного подсписка):

def is_sublist(sublist, superlist):  
    ''''' 
    Checks whether 'sublist' is a sublist of 'superlist'. 
    Both arguments must be typed list or tuple. 
    '''  
    if not isinstance(sublist, (list, tuple)) or not isinstance(sublist, (list,tuple)):  
        raise TypeError("Both 'sublist' and 'superlist' must be lists or tuples.")  
    # Return early if candidate sublist is longer than superlist  
    if len(sublist) > len(superlist):  
        return False  
    else:  
        for chunk in (superlist[i:i+len(sublist)] for i in range(0, len(superlist)-len(sublist)+1)):   
            if chunk == sublist:  
                return True  
        return False

Идея состоит в том, чтобы смещающееся окно (имеющее ту же ширину, что и подсписок кандидатов) сканировало суперсписок и проверяло равенство между фрагментом и подсписком на каждой итерации.

Это метод грубой силы.