Appending an attribute to a function in python

Question

I am not sure exactly what this means or how it is used, but i came across this functionality when it comes to a function. I am able to dynamically add attributes to a function. Can someone help me understand what is the use of this and how does it happen? I mean its a function name after all, how can we add attributes to it dynamically?

def impossible():
    print "Adding a bool"

impossible.enabled = True 
# i was able to just do this. And this is a function, how does this add up?

print(impossible.enabled) # No attribute error. o/p --> True

It’s not a function *name*; it’s a function, and it’s like any other value. Any type can permit or forbid new attributes. — Ry-, Apr 15 '18 at 07:07
The same which? =) Classes are also like any other values, and also are a type that permit new attributes, yes. Classes aren’t functions, though (try `isinstance(SomeClass, type(some_function))`). — Ry-, Apr 15 '18 at 07:11
Is there a way to print the definition of the function, in case i do that would i be able to see the new attribute appended to it? — Abhishek, Apr 15 '18 at 07:12
[There is](https://stackoverflow.com/questions/1562759/can-python-print-a-function-definition), but an attribute on a function isn’t part of a function’s definition anyway. You can use `dir(impossible)` to see all the names of attributes on it. — Ry-, Apr 15 '18 at 07:12
Let us [continue this discussion in chat](https://chat.stackoverflow.com/rooms/169013/discussion-between-abhishek-and-ry). — Abhishek, Apr 15 '18 at 07:59

score 1 · Answer 1 · answered Apr 15 '18 at 07:15

1

in python functions are objects, they have all sorts of inner attributes and they can also have the __dict__ attribute, and like any other object anything in __dict__ is a variable of that object.you can see it if you print it before and after impossible.enabled

def impossible():
    print "Adding a bool"

print(impossible.__dict__) #  {}
impossible.enabled = True 
print(impossible.__dict__) #  {'enabled': True}

this doesn't change the function in any way since most of the time __dict__ is empty and holds no special value in a function. in fact its a bit useful since you could use this in a function to store static variables without cluttering your global names

answered Apr 15 '18 at 07:15

AntiMatterDynamite

1,376
6
16

randomName = 'Jack' # Is this an object? ( As in randomName) – Abhishek Apr 15 '18 at 07:29
no strings, numbers, booleans and None are primitives not objects – AntiMatterDynamite Apr 15 '18 at 07:53
@AntiMatterDynamite: This is Python. Yes, strings, numbers, booleans, and `None` are objects – they’re just immutable. (`isinstance(True, object)`) – Ry- Apr 15 '18 at 08:45
@Abhishek: It *is* an object. Every value in Python is an object. – Ry- Apr 15 '18 at 08:46
So why can't we add attributes to a string object? Like randomName.Enabled = True – Abhishek Apr 15 '18 at 09:17
Is it because it's immutable? – Abhishek Apr 15 '18 at 09:17
@Ry they are literally objects but they behave differently because there is no way to recreate any of them in pure python – AntiMatterDynamite Apr 15 '18 at 09:32
@AntiMatterDynamite Can you elaborate? – Abhishek Apr 15 '18 at 09:38
@Abhishek: Yes, it’s because it’s immutable. – Ry- Apr 15 '18 at 10:01
@AntiMatterDynamite: They behave differently in what respect? – Ry- Apr 15 '18 at 10:05
@Ry︁ then what about lists? That's mutable – Abhishek Apr 15 '18 at 11:36
@Abhishek: Sorry, I thought “is it because it’s immutable?” was a follow-up to a different question. Something immutable can’t have attributes added to it, but things can prevent new attributes from being added without being immutable too. – Ry- Apr 16 '18 at 22:48

score 0 · Answer 2 · answered Apr 15 '18 at 07:15

The name impossible points to an object that represents the function. You're setting a property on this object (which python allows you to do on all objects by default):

>>> def foo():
...   print("test")
...
>>> dir(foo)
['__call__', ..., 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']
>>> foo.a = 'test'
>>> dir(foo)
['__call__', ..., 'a', ...]

Since this object implements __call__, it can be called as a function - you can implement your own class that defines __call__ and it'll also be allowed to be called as a function:

>>> class B:
...   def __call__(self, **kw):
...     print(kw)
...
>>> b = B()
>>> b()    
{}
>>> b(foo='bar')
{'foo': 'bar'}

If you create a new function, you can see that you haven't done anything to the definition of a function (its class), just the object that represents the original function:

>>> def bar():
...   print("ost")
...
>>> dir(bar)
['__call__', ..., 'func_closure', ...]

This new object does not have a property named a, since you haven't set one on the object bar points to.

score 0 · Answer 3 · answered Apr 15 '18 at 09:31

You can, for example, use a function attribute to implement a simple counter, like so:

def count():
    try:
        count.counter += 1
    except AttributeError:
        count.counter = 1
    return count.counter

Repeatedly calling "count()" yields: 1, 2, 3, ...

Appending an attribute to a function in python

3 Answers3