Difference between matlab function 'handle' and python function 'object'

It was suggested in this comment that there is a difference between how Matlab and Python pass around functions. From what I can tell by looking and using the two, there is no difference between the two, but maybe I'm missing something?

In Matlab, you would create a quick function handle like this:

fun = @(x) x.^2 + 1;

In Python, using a lambda function, you could create a similar function like this:

def fun(x):
    return x^2

In both languages, it's possible to send the term 'fun' to another function as an argument - but the commenter I linked to insinuated that they are not the same and/or need to be used differently.

What am I missing?

Solution

The first comment seems to simply reiterate the idea that you can pass a MATLAB function handle as an argument (although the answer didn't state anything that would make me think otherwise). The second comment seemed to interpret this to mean that the first commenter thought that you couldn't do this in Python and responded to state that you can use either a lambda or pass the function directly.

Regardless, assuming that you use them correctly, a function handle in MATLAB is functionally equivalent to using either a lambda or function object as an input argument in Python.

In python, if you don't append the () to the end of the function, it doesn't execute the function and instead yields the function object which can then be passed to another function.

# Function which accepts a function as an input
def evalute(func, val)
    # Execute the function that's passed in
    return func(val)

# Standard function definition
def square_and_add(x):
    return x**2 + 1

# Create a lambda function which does the same thing. 
lambda_square_and_add = lambda x: x**2 + 1

# Now pass the function to another function directly
evaluate(square_and_add, 2)

# Or pass a lambda function to the other function
evaluate(lambda_square_and_add, 2)

In MATLAB, you have to use a function handle because MATLAB attempts to execute a function even if you omit the ().

function res = evaluate(func, val)
    res = func(val)
end

function y = square_and_add(x)
    y = x^2 + 1;
end

%// Will try to execute square_and_add with no inputs resulting in an error
evaluate(square_and_add)

%// Must use a function handle
evaluate(@square_and_add, 2)