extensionsToCheck = ('.pdf', '.doc', '.xls')

'test.doc'.endswith(extensionsToCheck)   # returns True

'test.jpg'.endswith(extensionsToCheck)   # returns False

def myfun(str,list):
   for a in list:
      if not a in str:
         return False
   return True

return true must be outside the for loop, not just after the if statement, otherwise it will return true just after the first letter has been checked. this solves your code's problem :)

I don't really understand your question, but the easiest to understand solution is probably

if len(set(sub) - set(super)) > 0:

Another one, straightforward, but more complex, is

if all(el in sub for el in super):

Answering @TekhenyGhemor's follow-up question: is there a way to check if no numerical strings are in a list. For example: ["one", "two", "3"] would return false

Yes. You can convert the string to a number and make sure that it raises an exception:

def isfloatstr(x):
    try: 
        float(x)
        return True
    except ValueError:
        return False

def valid_list(L):
    return all((isinstance(el, str) and not isfloatstr(el)) for el in L)

Checking:

>>> valid_list(["one", "two", "3"])
False

>>> valid_list(["one", "two", "3a"])
True

>>> valid_list(["one", "two", 0])
False

In [5]: valid_list(["one", "two", "three"]) Out[5]: True

If no overlap is allowed, this problem becomes much harder than it looks at first. As far as I can tell, no other answer is correct (see test cases at the end).

Recursion is needed because if a substring appears more than once, using one occurence instead of the other could prevent other substrings to be found.

This answer uses two functions. The first one finds every occurence of a substring in a string and returns an iterator of strings where the substring has been replaced by a character which shouldn't appear in any substring.

The second function recursively checks if there's any way to find all the numbers in the string:

def find_each_and_replace_by(string, substring, separator='x'):
    """
    list(find_each_and_replace_by('8989', '89', 'x'))
    # ['x89', '89x']
    list(find_each_and_replace_by('9999', '99', 'x'))
    # ['x99', '9x9', '99x']
    list(find_each_and_replace_by('9999', '89', 'x'))
    # []
    """
    index = 0
    while True:
        index = string.find(substring, index)
        if index == -1:
            return
        yield string[:index] + separator + string[index + len(substring):]
        index += 1


def contains_all_without_overlap(string, numbers):
    """
    contains_all_without_overlap("45892190", [89, 90])
    # True
    contains_all_without_overlap("45892190", [89, 90, 4521])
    # False
    """
    if len(numbers) == 0:
        return True
    substrings = [str(number) for number in numbers]
    substring = substrings.pop()
    return any(contains_all_without_overlap(shorter_string, substrings)
               for shorter_string in find_each_and_replace_by(string, substring, 'x'))

Here are the test cases:

tests = [
    ("45892190", [89, 90], True),
    ("8990189290", [89, 90, 8990], True),
    ("123451234", [1234, 2345], True),
    ("123451234", [2345, 1234], True),
    ("123451234", [1234, 2346], False),
    ("123451234", [2346, 1234], False),
    ("45892190", [89, 90, 4521], False),
    ("890", [89, 90], False),
    ("8989", [89, 90], False),
    ("8989", [12, 34], False)
]

for string, numbers, should in tests:
    result = contains_all_without_overlap(string, numbers)
    if result == should:
        print("Correct answer for %-12r and %-14r (%s)" % (string, numbers, result))
    else:
        print("ERROR : %r and %r should return %r, not %r" %
              (string, numbers, should, result))

And the corresponding output:

Correct answer for '45892190'   and [89, 90]       (True)
Correct answer for '8990189290' and [89, 90, 8990] (True)
Correct answer for '123451234'  and [1234, 2345]   (True)
Correct answer for '123451234'  and [2345, 1234]   (True)
Correct answer for '123451234'  and [1234, 2346]   (False)
Correct answer for '123451234'  and [2346, 1234]   (False)
Correct answer for '45892190'   and [89, 90, 4521] (False)
Correct answer for '890'        and [89, 90]       (False)
Correct answer for '8989'       and [89, 90]       (False)
Correct answer for '8989'       and [12, 34]       (False)

Just throwing this out there: if you happen to need to match against more than one string, for example abc and def, you can combine two comprehensions as follows:

matchers = ['abc','def']
matching = [s for s in my_list if any(xs in s for xs in matchers)]

Output:

['abc-123', 'def-456', 'abc-456']

I can't think of any other way to check a sequence than to check the sequence whether you do it explicitly with a for loop, or implicitly with a higher level construct. Given that, you might consider something like this if your intent is to "end the program" upon finding a non-numeric value in the list as stated.

Example:

my_list = [1,2,3,4,6,7,"8"]

for value in my_list:
    if not isinstance(value, (int, float)):
        raise TypeError(f"Expected only numeric types, found {type(value)} in sequence.")

Output:

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-7-791ea7c7a43e> in <module>
      3 for value in my_list:
      4     if not isinstance(value, (int, float)):
----> 5         raise TypeError(f"Expected only numeric types, found {type(value)} in sequence.")

TypeError: Expected only numeric types, found <class 'str'> in sequence.