You can use the filter method:

>>> lst = [1, 2, 3, 4, 5]
>>> filter(lambda x: x % 2 == 0, lst)
[2, 4]

or a list comprehension:

>>> lst = [1, 2, 3, 4, 5]
>>> [x for x in lst if x %2 == 0]
[2, 4]

to find a single element, you could try:

>>> next(x for x in lst if x % 2 == 0)
2

Though that would throw an exception if nothing matches, so you'd probably want to wrap it in a try/catch. The () brackets make this a generator expression rather than a list comprehension.

Personally though I'd just use the regular filter/comprehension and take the first element (if there is one).

These raise an exception if nothing is found

filter(lambda x: x % 2 == 0, lst)[0]
[x for x in lst if x %2 == 0][0]

These return empty lists

filter(lambda x: x % 2 == 0, lst)[:1]
[x for x in lst if x %2 == 0][:1]

Using lambda here isn't necessary. Lambda isn't something magical, it's just a shorthand for writing a simple function. It's less powerful than an ordinary way of writing a function, not more. (That's not to say sometimes it isn't very handy, just that it doesn't have superpowers.)

Anyway, you can use a generator expression with the default argument. Note that here I'm returning the object itself, not 20, because that makes more sense to me.

>>> somelist = [{"id": 10, "x": 1}, {"id": 20, "y": 2}, {"id": 30, "z": 3}]
>>> desired_val = next((item for item in somelist if item['id'] == 20), None)
>>> print(desired_val)
{'y': 2, 'id': 20}
>>> desired_val = next((item for item in somelist if item['id'] == 21), None)
>>> print(desired_val)
None

lambda is a function by itself. Putting it into a def formal function as the sole output make no sense.

If you want to multiply by 2 for an entire list, lambda will not be enough, you'll also need an iterator. The following:

func = lambda x: x*2

Simply means this is an lambda function that will return input*2, it is equivalent to:

def func(x): return x*2

If you want to make it apply to an entire list, you'll need to do:

list(map(lambda x: x*2, mylist))

map will map the function to each element of the list, but that will also work for a named function.

In order to make your purpose, assuming both value and time are list of same length.

lambda t: value[time.index(t)]

is the function you need. Call it like this:

(lambda t: value[time.index(t)])(t)
# OR:
func = lambda t: value[time.index(t)] # assign it name and then
func(t)