This might be a silly question, but is it possible to check whether the
elements in a tuple1 are a subset of another tuple2 in the same sequence
as they appear in tuple1? I tried to do this with .issubset, but this does
not look at whether the sequence of tuple1 is in tuple 2:
 
tuple1 = ([1, 2, 3])
tuple2 = ([1, 2, 3, 4, 5])
set(tuple1).issubset(tuple2)
True
 
tuple1 = ([1, 2, 3])
tuple2 = ([1, 3, 2, 4, 5])
set(tuple1).issubset(tuple2)
True                         # Only membership is considered, not sequence
What I would like is:
 
tuple1 = ([1, 2, 3])
tuple2 = ([1, 2, 3, 4, 5])
(tuple1).sequenceisin(tuple2)
True
 
tuple1 = ([1, 2, 3])
tuple2 = ([1, 3, 2, 4, 5])
(tuple1).sequenceisin(tuple2)
False
Is there a simple way to do this?

a = "23"
b = "123"
a in b # True

x = [1,23] 
y = [str(i) for i in x] #in strings umwandeln
",".join(y) # "1,23"

tuple1 = ([1, 2, 3])
tuple2 = ([1, 2, 3, 4, 5])
str(tuple1)[1:-1] in str(tuple2)
True
 
tuple1 = ([1, 2, 3])
tuple2 = ([1, 3, 2, 4, 5])
str(tuple1)[1:-1] in str(tuple2)
False

def ck_tpl(a, b):
    k = len(a)
    t = len(b)
    tpl_ab = []
    ct = 0
    if t >= k:
        for i in range(0, t-k):
            if b[i:k+i] == a[0:k]:
                tpl_ab = b[i:k + i]
                ct = i
        if ct == 0:
            tpl_ab = 'not in'
    return tpl_ab, b, ct
 
 
a = [4, 5, 6, 47, 11, 7, 8]
b = [1, 2, 3, 4, 5, 6, 7, 8, 9, 4, 5, 6, 47, 11, 7, 8, 9, 10, 11]
 
print(ck_tpl(a, b))

def is_sub_sequence(short,long):
    i,j = 0,0
    while i < len(short):
        if j >= len(long):
            return False
        if short[i] == long[j]:
            i += 1
        j += 1
    return True
 
def is_sub_sequence_iter(short,long):
    long_iter = iter(long)
    for i in short:
        b = False
        for j in long_iter:
            if i == j:
                b = True
                break
        if not b:
            return False
    return True
 

def ck_tpl_2(sht, lng):
    return [True for i in lng if sht[0: len(sht)] == lng[i: len(sht)+i]]

# Find starting indeces of short in long
# e.g.: findSubsequence([2,3],[1,2,3,4,2,3]) -> [1,4]
def findSubsequence(short,long):
    states = [(0,0)]
    indices = []
    for i in range(len(long)):
        _states = []
        for j,k in states:
            if long[i] == short[k]:
                if k == len(short)-1:
                    indices.append(j)
                else:
                    _states.append((j,k+1))
        _states.append((i+1,0))
        states = _states
    return indices
 
def findSubsequenceNaive(short,long):
    indices = []
    for i in range(len(long)-len(short)+1):
        if all(long[i+j]==short[j] for j in range(len(short))):
            indices.append(i)
    return indices
 
def hasSubsequenceNaive(short,long):
    return any(all(long[i+j]==short[j] \
        for j in range(len(short))) \
            for i in range(len(long)-len(short)+1))
 
 
from random import randint
 
def buildTestData(n,k,r):
    long = [randint(1,r) for i in range(n)]
    short = [randint(1,r) for i in range(k)]
    return short,long
 
from timeit import timeit
 
short, long = buildTestData(10000,10,2)
 
for f in [findSubsequenceNaive,hasSubsequenceNaive,findSubsequence]:
    t=timeit(f"f(short,long)",globals=globals(),number=100)
    print(f"{f.__name__:20} took {t:.3f}s to calculate {f(short,long)}")
 
 
findSubsequenceNaive took 23.584s to calculate [1436, 1472, 3276, 4921, 5229, 6539, 7977, 8191, 8625, 8689, 8739]
hasSubsequenceNaive  took 5.194s to calculate True
findSubsequence      took 2.160s to calculate [1436, 1472, 3276, 4921, 5229, 6539, 7977, 8191, 8625, 8689, 8739]

ck_tpl_3             took 2.890s to calculate [32499]
findSubsequenceNaive took 2.580s to calculate [32499]
hasSubsequenceNaive  took 2.320s to calculate True
findSubsequence      took 1.781s to calculate [32499]

def ck_tpl_3(sht, lng):
    return [i for i in lng if sht[0: len(sht)] == lng[i: len(sht)+i]]