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.

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. :)

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]
    ...