The concept of callbacks and passing functions around may be foreign to you. If so, it is definitely worth digging into so that you understand it well enough to use it, or at the very least, understand what is going on when you see it being used. In Python, functions are “first class,” which means that you can pass them around and treat them as objects—because they really are objects. See Example A-1.
In [1]: def foo(): ...: print foo ...: ...: In [2]: foo Out[2]: <function foo at 0x1233270> In [3]: type(foo) Out[3]: <type 'function'> In [4]: dir(foo) Out[4]: ['__call__', '__class__', '__delattr__', '__dict__', '__doc__', '__get__', '__getattribute__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']
Simply referring to a function, such as foo
in the previous example, does not call it.
Referring to a function’s name lets you get at any attributes the function
has and to even refer to the function by a different name later. See Example A-2.
In [1]: def foo(): ...: """this is a docstring""" ...: print "IN FUNCTION FOO" ...: ...: In [2]: foo Out[2]: <function foo at 0x8319534> In [3]: foo.__doc__ Out[3]: 'this is a docstring' In [4]: bar = foo In [5]: bar Out[5]: <function foo at 0x8319534> In [6]: bar.__doc__ Out[6]: 'this is a docstring' In [7]: foo.a = 1 In [8]: bar.a Out[8]: 1 In [9]: foo() IN FUNCTION FOO In [10]: bar() IN FUNCTION FOO
We created a new function foo
so
that it contained a docstring. We then stated that bar
was going to point to the function foo
that we just created. In Python, what you
usually think of as variables are typically just names that point at (or
refer to) some object. The process of associating a name with an object is
called “name binding.” So, when we created the function foo
, we really created a function object and
then bound the name foo
to that new
function. Using the IPython prompt to see the basic information it can
tell us about foo
, it reported back
that it was a foo
function.
Interestingly, it said the same thing about the name bar
, namely that it was a foo
function. We set an attribute a
on the function named foo
and were able to access it from bar
. And, calling both foo
and bar
produced the same result.
One of the places in this book that we use callbacks is in the chapter on networking, Chapter 5. Passing functions around as in the FTP example in that chapter allows for runtime dynamism and code-time flexibility and can even improve code reuse. Even if you don’t think you’ll ever use it, it’s a thought process worth putting in your brain’s catalog.
3.139.240.244