Lambda's take the same signature as regular functions, and you can give reg a default:

f = lambda X, model, reg=1e3: cost(X, model, reg=reg, sparse=np.random.rand(10,10))

What default you give it depends on what default the cost function has assigned to that same parameter. These defaults are stored on that function in the cost.__defaults__ structure, matching the argument names. It is perhaps easiest to use the inspect.getargspec() function to introspect that info:

from inspect import getargspec

spec = getargspec(cost)
cost_defaults = dict(zip(spec.args[-len(defaults:], spec.defaults))
f = lambda X, model, reg=cost_defaults['reg']: cost(X, model, reg=reg, sparse=np.random.rand(10,10))

Alternatively, you could just pass on any extra keyword argument:

f = lambda X, model, **kw: cost(X, model, sparse=np.random.rand(10,10), **kw)

Can this be done with lambda ?

No. What you have is syntactically valid, but the default value of curr_time ends up being the lambda function, not the datetime value it would return if it were called. This can be worked around as:

if callable(curr_time):
    curr_time = curr_time()

but at that point, you might as well just use the if curr_time is None: approach you included in your question.

(Note that the comparison should be made as is None, not == None.)

Pythons lambda are more restricted than normal def functions. Typically lambda requires an expression in the body ... but pass is just a statement. So the obvious solution would be to use:

lambda x: None  # or since you don't use x "lambda _: None"

As a rule of thumb: everything that can be assigned to a variable can also be in the body of a lambda. You can find out more about the grammar in the The Python Language Reference

6.13. Lambdas

lambda_expr        ::=  "lambda" [parameter_list] ":" expression
lambda_expr_nocond ::=  "lambda" [parameter_list] ":" expression_nocond

and similar for pass

7. Simple statements

simple_stmt ::=  expression_stmt
[...]
                 | pass_stmt
[...]

pass_stmt ::=  "pass"

Or in the more formal Full Grammar specification. Here you can use any test for assignment and lambda bodies, and a test can be an expr. Here is a (severly) shorted part:

pass_stmt: 'pass'

annassign: ':' test ['=' test]
lambdef: 'lambda' [varargslist] ':' test

test: or_test ['if' or_test 'else' test] | lambdef
or_test: and_test ('or' and_test)*
and_test: not_test ('and' not_test)*
not_test: 'not' not_test | comparison
comparison: expr (comp_op expr)*

The problem is that sometimes want to pass no argument to execute, so I want function to default to the empty function.

Works fine for me:

>>> def execute(function = lambda x: x, *args):
...   print function, args
...   function(args)
...
>>> execute()
<function <lambda> at 0x01DD1A30> ()
>>>

I do note that your example attempts to use f within the implementation, while you've called the parameter function. Could it really be that simple? ;)

That said, you need to understand that Python will have no way to tell that you want to skip the defaulted argument unless there are no arguments at all, so execute(0) cannot work as it attempts to treat 0 as a function.

According to PEP8, you should "Always use a def statement instead of an assignment statement that binds a lambda expression directly to a name." So, one thing I would change is:

def blank_fn(*args, **kwargs):
    pass

However, I think a more pythonic way to do this is:

def perform_task(callback=None):
    print 'doing stuff'
    if callback is not None:
        callback('x', 'y', z='z')

There shouldn't be any need to call a function that does nothing. Truth value testing is cheaper than function calling.

def do_nothing(*args, **kwargs): pass
def do_something(arg, callback=do_nothing):
    a = 1 + 2
    callback('z', z='z')
def do_something_else(arg, callback=None):
    a = 1 + 2
    if callback is not None:
        callback('z', z='z')

%timeit do_something(3)
1000000 loops, best of 3: 644 ns per loop

%timeit do_something_else(3)
1000000 loops, best of 3: 292 ns per loop