There are several different answers I can give here, from your specific question to more general concerns. So from most specific to most general:

Q. Can you put multiple statements in a lambda?

A. No. But you don't actually need to use a lambda. You can put the statements in a def instead. i.e.:

def second_lowest(l):
    l.sort()
    return l[1]

map(second_lowest, lst)

Q. Can you get the second lowest item from a lambda by sorting the list?

A. Yes. As alex's answer points out, sorted() is a version of sort that creates a new list, rather than sorting in-place, and can be chained. Note that this is probably what you should be using - it's bad practice for your map to have side effects on the original list.

Q. How should I get the second lowest item from each list in a sequence of lists?

A. sorted(l)[1] is not actually the best way for this. It has O(N log(N)) complexity, while an O(n) solution exists. This can be found in the heapq module.

>>> import  heapq
>>> l = [5,2,6,8,3,5]
>>> heapq.nsmallest(l, 2)
[2, 3]

So just use:

map(lambda x: heapq.nsmallest(x,2)[1],  list_of_lists)

It's also usually considered clearer to use a list comprehension, which avoids the lambda altogether:

[heapq.nsmallest(x,2)[1] for x in list_of_lists]

One option is to use a boto3 paginator.

Alternatively, you could use a loop rather than a recursive function.

It would be something like:

response = api_call()
<do stuff with response>
while response['NextToken']:
    response=api_call(NextToken=response['NextToken'])
    <do stuff with response>

You can probably avoid having to double-up the <do stuff> bit by improving on the while statement.

sys.stdout.write("second") is not part of the lambda.

'second' is always printed even if you don't call X. In other words calling X only prints 'first'.

Your code can be rewritten as;

import sys
X = lambda: sys.stdout.write('first')
sys.stdout.write("second")
print X()

If you want two statements executed by the lambda place them in a tuple;

lambda: (sys.stdout.write('first'),sys.stdout.write("second"))

In your lambda expression you've got an i which is from your loop through idx, and a d which is from your loop through dates. The both these values in your lambda expression aren't evaluated at function definition but rather when the function is called, so each time you're doing print(d + '_' + i), the function just looks up the current value of d and i, which is just the value of the last thing in for d in dates and for i in idx, which is why you're getting the same value each time.

You can work around this with a hack like:

dic_funcs[d + '_' + i] = lambda a=i, b=d:printt(b + '_' + a)

Which gives you your intended behavior

Based on the comments.

The issue was caused because my_function function was not called inside the lambda handler.

The solution was to add my_function() into the handler lambda_handler so that the my_function is actually called.