This is a really old answer but since Python 3.3, there exists the casefold() method which is more aggressive than lower() and is the more natural caseless string matching. So something like the following is an option:

filename.casefold().endswith(ext)

On a tangential note, any() short-circuits, meaning it stops at the first True, so it is much faster if any() is called on a generator expression instead of a list (especially if the matching string is towards the beginning of a long list) because with genexpr, we can stop the endswith check right away while with list, we have to perform the endswith check for every string before the any() evaluation.

So instead of

any([filename.lower().endswith(ext) for filename in filenames])
#   ^                                                        ^  <--- list

use

any(filename.lower().endswith(ext) for filename in filenames)
#  ^                                                        ^   <--- genexpr

Finally, since this question is tagged regex, here's a regex solution as well. Simply compile a pattern that ignores case and search whether the pattern matches.

import re
pat = re.compile(fr"({'|'.join(re.escape(e) for e in ext)})$", re.I)
for folder, subfolders, filenames in os.walk('.'):
    if any(pat.search(filename) for filename in filenames):
        # do something

I think this is what you were actually trying to do:

def end_other ( a, b ):
    a = a.lower()
    b = b.lower()
    if a == b:
        return True
    elif len( a ) > len( b ):
        return b == a[-len( b ):]
    else:
        return a == b[-len( a ):]

You had a couple of mistakes in your solution:

• s1[-len(s2)] or generally s1[x] just gets a single character. So if anything, you are just comparing a single character, but not an actual sequence of characters. You splice a sequence out of a string by s[x:y] (see the manual).
• s2[-len(s2)], even with the colon as explained above, doesn't make much sense. You are accessing s2 using its own length. But as s2 is already the smaller string, you can compare it as a whole.
• When one of your outer ifs matches a situation, there is no way any other of the outer situations can follow. For example if a is longer than b, there is no way that a will be shorter or of the same length as b later on. As such you should make your if structure support that. Instead of if ... if ... if ... else make a chain: if ... elif ... elif ... else. Then one automatically knows that only one of those cases can apply.
• When you do that, you can also leave off the last if expression. Because when neither x < y nor y < x equals to true, then x is equal to y.
• You also need to change the way you return from within the function. As of now you have a conditional exit within each of your outer if cases. Now if the first if case applies (i.e. s1 is longer than s2) and the inner if does not apply (s1 does not end with s2), then you already know that the function should return False. Because there is no way that any other condition later in the code says otherwise, so you should return False immediately there (especially when there is other code that might execute later). And when you have if x: return True else: return False then you can just return x.
• s1[-len(s1)]==s2[-len(s2)]: As other as already said you will have a problem when s1 and s2 are empty strings. len( "" ) = 0 and if both strings are empty, then both lengths are identical. And then your code tries to use an index range on an empty string, which will always fail (as there is not a single character). Instead, when you already know that two strings are of the same size, just compare both as a whole. This also helps against empty strings.

Anyway, if you didn't need to implement it on your own, you should really use str.endswith instead.