Adding lambda functions with the same operator in python

In Python, you'll normally only use a lambda for very short, simple functions that easily fit inside the line that's creating them. (Some languages have other opinions.)

As @DSM hinted in their comment, lambdas are essentially a shortcut to creating functions when it's not worth giving them a name.

If you're doing more complex things, or if you need to give the code a name for later reference, a lambda expression won't be much of a shortcut for you -- instead, you might as well define a plain old function.

So instead of assigning the lambda expression to a variable:

y = lambda u: u**(-2) + 8

You can define that variable to be a function:

def y(u):
    return u**(-2) + 8

Which gives you room to explain a bit, or be more complex, or whatever you need to do:

def y(u):
    """
    Bloopinate the input

    u should be a positive integer for fastest results.
    """
    offset = 8
    bloop = u ** (-2)
    return bloop + offset

Functions and lambdas are both "callable", which means they're essentially interchangable as far as scipy.integrate.quad() is concerned.

To combine callables, you can use several different techniques.

def triple(x):
   return x * 3

def square(x):
   return x * x

def triple_square(x):
   return triple(square(x))

def triple_plus_square(x):
    return triple(x) + square(x)

def triple_plus_square_with_explaining_variables(x):
    tripled = triple(x)
    squared = square(x)
    return tripled + squared

There are more advanced options that I would only consider if it makes your code clearer (which it probably won't). For example, you can put the callables in a list:

 all_the_things_i_want_to_do = [triple, square]

Once they're in a list, you can use list-based operations to work on them (including applying them in turn to reduce the list down to a single value).

But if your code is like most code, regular functions that just call each other by name will be the simplest to write and easiest to read.