Is it conventional to say that functions are called and methods are invoked?

Question

I’m reading Think Python: How to Think Like a Computer Scientist. The author uses “invoke” with methods and “call” with functions.

Is it a convention? And, if so, why is this distinction made? Why are functions said to be called, but methods are said to be invoked?

Answer 1

Not really, maybe it is easier for new readers to make an explicit distinction in order to understand that their invocation is slightly different. At least that why I suspect the author might have chosen different wording for each.

There doesn't seem to be a convention that dictates this in the Reference Manual for the Python language. What I seem them doing is choosing invoke when the call made to a function is implicit and not explicit.

For example, in the Callables section of the Standard Type Hierarchy you see:

[..] When an instance method object is called, the underlying function (__func__) is called, inserting the class instance (__self__) in front of the argument list. [...]

^{(Emphasis mine) Explicit call}

Further down in Basic Customization and specifically for __new__ you can see:

Called to create a new instance of class cls. __new__() is a static method [...]

^{(Emphasis mine) Explicit call}

While just a couple of sentences later you'll see how invoked is used because __new__ implicitly calls __init__:

If __new__() does not return an instance of cls, then the new instance’s __init__() method will not be invoked.

^{(Emphasis mine) Implicitly called}

So no, no convention seems to be used, at least by the creators of the language. Simple is better than complex, I guess :-).

Answer 2

One good source for this would be the Python documentation. A simple text search through the section on Classes reveals the word "call" being used many times in reference to "calling methods", and the word "invoke" being used only once.

In my experience, the same is true: I regularly hear "call" used in reference to methods and functions, while I rarely hear "invoke" for either. However, I assume this is mainly a matter of personal preference and/or context (is the setting informal?, academic?, etc.).

You will also see places in the documentation where the word "invoke" is used in refernce to functions:

void Py_FatalError(const char *message)

Print a fatal error message and kill the process. No cleanup is performed. This function should only be invoked when a condition is detected that would make it dangerous to continue using the Python interpreter; e.g., when the object administration appears to be corrupted. On Unix, the standard C library function abort() is called which will attempt to produce a core file.

And from here:

void Py_DECREF(PyObject *o)

Decrement the reference count for object o. The object must not be NULL; if you aren’t sure that it isn’t NULL, use Py_XDECREF(). If the reference count reaches zero, the object’s type’s deallocation function (which must not be NULL) is invoked.

Although both these references are from the Python C API, so that may be significant.

To summerize:

I think it is safe to use either "invoke" or "call" in the context of functions or methods without sounding either like a noob or a showoff.

Note that I speak only of Python, and what I know from my own experience. I cannot speak to the difference between these terms in other languages.