You'll have to wrap the map around a filter around the list:

example_map = map(lambda x: x*2, filter(lambda x: x*2/6. != 1, range(5)))

>>> lst = [1,2,4,5]
>>> map(lambda x: 'lower' if x < 3 else 'higher', lst)
['lower', 'lower', 'higher', 'higher']

Aside: It's usually preferred to use a list comprehension for this

>>> ['lower' if x < 3 else 'higher' for x in lst]
['lower', 'lower', 'higher', 'higher']

The syntax you're looking for:

lambda x: True if x % 2 == 0 else False

But you can't use print or raise in a lambda.

map always produces one output item for each input item, it can not remove elements. Furthermore, map should not be used to mutate objects, that's not its job, and because it's lazy the results can be unexpected.

filter is designed to create an output with less elements than the input, although it's mostly useful if you already have a ready-made predicate (filtering) function.

Since you do not, you can and should use comprehensions which provide a relatively terse way to perform iteration, filtering, mapping and collection in a single construct:

Copywordlist = ['hello','world','Tom']
checklist = ['hello','world']

print('before')
print(wordlist)

wordlist = [word for word in wordlist if word not in checklist]
print('after')
print(wordlist)

ps: if you want to modify things in-place, use a regular loop

Try

lambda x: 1 if x == "C" else 0

possible duplicate of Is there a way to perform "if" in python's lambda

Example :

map(lambda x: True if x % 2 == 0 else False, range(1, 11))

result will be - [False, True, False, True, False, True, False, True, False, True]

because the lambda function needs to be created len(data) times, thus inefficient.

Not true, in the example the lambda definition is evaluated only once at compile time and not len(data) times - there is no need to assign it to a name for performance reasons. Look at Sergey's answer, he proves lambda is not expensive at all for this case.

If you do want to give it a name for the sake of clarity, you should just use a def statement instead. Assigning a lambda to a name is considered bad style: according to PEP-8 Programming Recommendations you should "Always use a def statement instead of an assignment statement that binds a lambda expression directly to an identifier". Quoting from the official style guide:

Yes:

def f(x): return 2*x

No:

f = lambda x: 2*x:

The only difference between lambda and the one-line def is that def will give it a name (probably an extra LOAD_CONST):

>>> import dis

>>> def _(x):
        return f(x, 30)

>>> dis.dis(_)
  2           0 LOAD_GLOBAL              0 (f)
              2 LOAD_FAST                0 (x)
              4 LOAD_CONST               1 (30)
              6 CALL_FUNCTION            2
              8 RETURN_VALUE

>>> dis.dis(lambda x: f(x, 30))
  1           0 LOAD_GLOBAL              0 (f)
              2 LOAD_FAST                0 (x)
              4 LOAD_CONST               1 (30)
              6 CALL_FUNCTION            2
              8 RETURN_VALUE

As you can see above, both forms compile to the same bytecode.

The lisp inspired functions map, filter and reduce always felt a bit alien in Python. Since the introduction of list comprehensions (at version 2.0 IINM) they became the idiomatic way to achieve the same result. So this:

new_data = map(lambda x: f(x, 30), data)

Is often written as:

new_data = [f(x, 30) for x in data]

If data is big and you are just iterating over it, generator expressions trade memory for cpu:

for value in (f(x, 30) for x in data):
    do_something_with(value)

The lispy constructs like map, filter and reduce are likely to be retired (moved to the functools module) and I recommend the use of list comprehensions and generator expressions in new code.

Last, Python is surprisingly counterintuitive regarding performance. You should always profile in order to put your beliefs about performance in check.

Bottom line: never worry about "optimizing" a damn thing until you have profiled it and know for sure it's a relevant bottleneck.

pass is a statement, but inline if, being an operator, needs its operands to be expressions. map can’t actually remove elements from the sequence, but filter (returns a new list with only the values for which the function returns True) can:

print filter(lambda x: str(x)[-1] == '2', even)

This is an XY problem. You're using a map when it asks for a list comprehension. It's essentially asking for a filter, not a map.

>>> [x1+x2 for x1, x2 in zip(L1, L2) if x1>10 and x2<5]
[18, 57, 103]

You could do it in a functional style, but it's so ugly. Don't do this.

L3 = list(map(
    lambda t: t[0]+t[1],
    filter(
        lambda t: t[0]>10 and t[1]<5,
        zip(L1, L2)
        )
    ))
print(L3)  # -> [18, 57, 103]