A list comprehension is likely the cleanest way:

>>> L = [0, 23, 234, 89, None, 0, 35, 9
>>> [x for x in L if x is not None]
[0, 23, 234, 89, 0, 35, 9]

There is also a functional programming approach but it is more involved:

>>> from operator import is_not
>>> from functools import partial
>>> L = [0, 23, 234, 89, None, 0, 35, 9]
>>> list(filter(partial(is_not, None), L))
[0, 23, 234, 89, 0, 35, 9]

For python3 you can use None.__ne__ to only remove None, just filtering using None will remove any falsey values like [], {} 0 etc.. :

filter(None.__ne__, check(low, high, to_match))

for python2 you would need to add a lambda checking each element is not None:

filter(lambda x: x is not None,....)

If you are using python2 the stick to a list comp:

[ele for ele in check(low, high, match) if ele is not None]

Any performance gain of using filter will be offset by the lambda calls so it will actually end up slower.

Since the definition of filter() is to return a list of elements in which the function returns True

But not None is a not function, and so not callable. None is used as shorthand for the identity predicate (not just function), which in this case can be lambda x: bool(x) or simply bool. So instead of what you propose, you would do:

filter(lambda x: x is not None, iterable)

More so, the None shorthand is a generalization that applies to some other builtin functions in python: map, itertools.ifilter, itertools.imap, itertools.ifilterfalse among others.

A pythonic equivalent of filter (an iterator version from the docs) will look:

def filter(predicate, iterable):
    # filter(lambda x: x%2, range(10)) --> 1 3 5 7 9
    if predicate is None:
        predicate = bool # evaluates truth value of the object
    for x in iterable:
        if predicate(x):
            yield x