Per history of python blog, everything in python are first class objects, that means
all objects that could be named in the language (e.g., integers, strings, functions, classes, modules, methods, etc.) to have equal status. Th:at is, they can be assigned to variables, placed in lists, stored in dictionaries, passed as arguments, and so forth..
Essentially, functions return a value based on the given arguments. In Python, functions are first-class objects as well. This means that functions can be passed around, and used as arguments, just like any other value (e.g, string, int, float).
Internally, python use a common C data structure that are used everywhere in the interpreter to represent all objects, either it is a python function or a integer.
However, when it comes to python function as first class, there are subtle things to think about when doing design.
Think about the following function definition:
class A: def __init__(self, x): self.x = x def foo(self, bar): print self.x, bar
What would happen if you assign
A.foo to a variable:
b = A.foo. The first argument of the function would have to be the instance itself. To handle this problem, python 2 returns a
unbound method, which is a warper around the original function, but it restrict that the first argument of the function has to be the object instance:
a = A(), b(a). In python 3, however, this restriction is removed as the author found this is not very useful.
Let’s think about the second condition, when you have a instance of a class:
a = A(1), b = a.foo. In this case, python would return a
bound method which is a thin wrapper around the original function. Bound method stores the instance as a internal object and this object would be the default first argument when calling this function.