Treating function as an object in Python

Question

I am not sure if the title will match the question I am about to ask but please feel free to update it if you know a better title which can help everyone.

So let's say we have the following definition:

>>> def helloFunction():
        name = "Hello World"

so when I type in the following code, that returns an empty dictionary.

>>> helloFunction.__dict__
{}

I am not sure if this is how it should be but let's continue. Interestingly, I can do the following:

>>> helloFunction.hello = "world"
>>> helloFunction.__dict__
{'hello': 'world'}

and when I type in the following code, it tells me helloFunction is indeed a function.

>>> type(helloFunction)
<type 'function'>

I am coming from C# and this behavior is little odd to me. How come Python works like this? Is a function an object? How should I interpret this situation? And also where would I need this type of functionality?

Update

While I was composing this question, I realized __class__ is defined on helloFunction.

>>> helloFunction.__class__
<type 'function'>

So it seems like function is indeed a class type?

Functions in Python are considered first-class objects, meaning they are objects. In fact, if x.__call__ method exists then x() is a legitimate call. — dilbert
– dilbert, Commented May 1, 2014 at 0:22

roippi · Accepted Answer · 2014-05-01 00:40:25Z

Pep 232 added "function attributes" to the language. You can read that if you want all the official reasoning. The reality of the situation boils down to this sentence in the intro:

func_doc has the interesting property that there is special syntax in function (and method) definitions for implicitly setting the attribute. This convenience has been exploited over and over again, overloading docstrings with additional semantics.

Emphasis mine. People were using the __doc__ attribute to smuggle all sorts of function metadata; it seemed more natural to provide a real place to do that.

As for some more specific questions:

Is a function an object?

Oh yes. Functions are first-class objects in python. You can pass references to them as arguments to other functions all you like. Were they not first-class, I couldn't do this:

def increment(x):
    return x+1

map(increment,[1,2,3]) # python2 `map`, for brevity
Out[3]: [2, 3, 4]

And also where would I need this type of functionality?

You generally don't. Not often. But it can be useful when you want to store metadata about a function.

Say I wanted to wrap a function with a decorator that records how many times it's been called. That's easy since we can plop that info into the function's __dict__.

def count_calls(func):
    def _inner(*args, **kwargs):
        before = getattr(func,'times_called',0)
        func.times_called = before + 1
        print('func has now been called {} times'.format(func.times_called))
        return func(*args,**kwargs)
    return _inner

@count_calls
def add(x,y):
    return x+y

add(3,4)
func has now been called 1 times
Out[7]: 7

add(2,3)
func has now been called 2 times
Out[8]: 5

Matthew Trevor · Accepted Answer · 2014-05-01 00:30:34Z

A function is an object and - like most objects in Python - it has a dictionary. One usage example I've seen in the wild is with the web framework CherryPy, where it's used to indicate which methods are to web access:

import cherrypy
class HelloWorld(object):
    def index(self):
        return "Hello World!"
    index.exposed = True

When a path is accessed, the dispatcher can check that the corresponding handler method has its exposed attribute set to True and respond to it, allowing for both accessible and private methods to be safely defined on the controller.

Another use I've seen was a decorator that counted the number of times a function was called:

def call_counter(fn):
    fn.count = 0
    def _fn(*args, **kwargs):
        fn.count += 1
        return fn(*arg, **kwargs)
    return _fn

NorthCat · Accepted Answer · 2014-05-01 00:30:40Z

0

Partly quote from Learning Python (Mark Lutz):

Like everything else in Python, functions are just objects; they are recorded explicitly in memory at program execution time. In fact, besides calls, functions allow arbitrary attributes to be attached to record information for later use.

def func(): ... # Create function object
func() # Call object
func.attr = value # Attach attributes

edited May 1, 2014 at 0:30

answered May 1, 2014 at 0:20

NorthCat

10k16 gold badges51 silver badges56 bronze badges

Collectives™ on Stack Overflow

Treating function as an object in Python

Update

3 Answers 3

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

Update

3 Answers 3

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related