Thread by @treyhunner

Another fundamental Python term for #TerminologyTuesday

callable: an object which can be called

The classical "callable" is a function, but in #Python classes are also callables.

In many programming languages (e.g. JS, PHP, C++) creating a new "instance" of a class (an object whose type is that class) involves the "new" keyword:

let eol = new Date(2020, 1, 1);

But in #Python to make a new class instance we just call the class:

eol = date(2020, 1, 1)

The fact that classes are callables means the distinction between a function and a class is often quite subtle. All of these "functions" are actually implemented as classes:

n = float("4.5")
m = int(n)
s = str(m)
b = bool(m)
t = tuple('abcd')
e = enumerate(t)
r = reversed(t)

When you call a function, you get the return value of that function.

When you call a class, you get back an "instance" of that class.

class Thing:
def __init__(self, name):
self.name = name

thing = Thing() # Thing instance

"Function" is a fuzzy term in the Python world because we often use it to refer to non-functions.

The phrases "the reversed function" or "the int function" might be technically incorrect but colloquially they're a-okay.

https://twitter.com/treyhunner/status/1468080015564705798

When teaching I sometimes use these terms:

- enumerate function
- type function
- reversed function
- map function

Those are *technically* incorrect terms but that's okay!

Whether those "functions" are defined using a function or a class is an implementation detail.

Python itself even uses the word "function" loosely: the docs for map and filter say they accept a function (but they mean "callable").

Also functools.partial claims to accept a function and return a function. But partial is a class, so it actually returns a class instance!

While the fuzziness of the term "function" is perfectly acceptable, it's sometimes useful to use a more generic term.

In @PythonMorsels exercises we often say "create a callable which..."

Thinking in callables reminds us that there are multiple ways to implement the same thing.

@PythonMorsels So why not say "function or class"? Well, there's a bit more to callability than that.

Any object with a __call__ method is a callable.

class Silly:
def __init__(self, m): self.m = m
def __call__(self): print(self.m)

Silly("Hi")()

Try it out: pym.dev/p/2y2kg/

@PythonMorsels Wait... but if callables are "callable objects", are classes and functions objects? 😮

They are!

You pass them around, just like any other object. Everything is an object in Python (except for variables, which just point to "things").

pym.dev/everything-is-…

@PythonMorsels For more on...

➡️ Variables as pointers to objects in Python: pym.dev/pointers/
➡️ Class instances: pythonmorsels.com/terms/#instance
➡️ Classes and functions being "callables" in python: pym.dev/class-function…

Follow me for more #Python tips 🌠