Is it pythonic: naming lambdas

I’m beginning to appreciate the value of lambda expressions in python, particularly when it comes to functional programming, map, functions returning functions, etc. However, I’ve also been naming lambdas within functions because:

• I need the same functionality several times and don’t want to repeat code.
• The functionality is specific to the function in which it appears; its not needed elsewhere.

When I encounter a situation that meets the above criteria, I’ve been writing a named lambda expression in order to DRY and narrowly scope functionality. For example, I am writing a function that operates on some numpy arrays, and I need to do some moderately tedious indexing of all the arrays passed to the function (which can easily fit on a single line). I’ve written a named lambda expression to do the indexing instead of writing a whole other function or copy/pasting the indexing several times throughout the function definition.

def fcn_operating_on_arrays(array0, array1):
    indexer = lambda a0, a1, idx: a0[idx] + a1[idx]
    
    # codecodecode
    
    indexed = indexer(array0, array1, indices)
    
    # codecodecode in which other arrays are created and require `indexer`
    
    return the_answer

Is this an abuse of python’s lambdas? Should I just suck it up and define a separate function?

Edits

Probably worth linking function inside function.

Answers:

Thank you for visiting the Q&A section on Magenaut. Please note that all the answers may not help you solve the issue immediately. So please treat them as advisements. If you found the post helpful (or not), leave a comment & I’ll get back to you as soon as possible.

Method 1

This is not Pythonic and PEP8 discourages it:

Always use a def statement instead of an assignment statement that
binds a lambda expression directly to an identifier.

Yes:

def f(x): return 2*x

No:

f = lambda x: 2*x

The first form means that the name of the resulting function object is
specifically 'f' instead of the generic '<lambda>'. This is more
useful for tracebacks and string representations in general. The use
of the assignment statement eliminates the sole benefit a lambda
expression can offer over an explicit def statement (i.e. that it can
be embedded inside a larger expression)

A rule of thumb for this is to think on its definition: lambdas expressions are anonymous functions. If you name it, it isn’t anonymous anymore. 🙂

Method 2

I’ve written a named lambda expression to do the indexing instead of writing a whole other function

Well, you are writing a whole other function. You’re just writing it with a lambda expression.

Why not use def? You get nicer stack traces and more syntactical flexibility, and you don’t lose anything. It’s not like def can’t occur inside another function:

def fcn_operating_on_arrays(array0, array1):
    def indexer(a0, a1, idx):
        return a0[idx] + a1[idx]
    ...

Method 3

These are functionally (no pun intended) identical.

indexer = lambda a0, a1, idx: a0[idx] + a1[idx]

def indexer(a0, a1, idx):
    return a0[idx] + a1[idx]

If you have an aesthetic preference for one or the other, then use it.

All methods was sourced from stackoverflow.com or stackexchange.com, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0