4

I know that if I write a class, I can definite a custom print function as below.

>>> class F:
...     def __str__(self):
...             return 'This describes the data of F.'
... 
>>> f = F()
>>> print f
This describes the data of F.

But, what if I want to do the same for a function object? For example, 

>>> def f():
...     pass
... 
>>> g = f
>>> print g
<function f at 0x7f738d6da5f0>

Instead of '<function f at 0x7f738d6da5f0>', I'd like to somehow specify what was printed. The motivation for doing this is that I'm going to store a bunch of function objects in a list, and I'd like to iterate over the list and print human-readable descriptions of the types of functions without adding additional complexity, e.g., tuples of function objects and strings.

Thanks in advance for any help you can provide.

Edit: I changed my example to reflect what I was trying to convey, unfortunately I typed 'f()' when I meant 'f'. I am interested in a custom label for the function object, not customizing the return (which it is obvious how to do). Sorry for any confusion this has caused.

Improve this question
10
  • g is the return value of f. Are you storing functions in the list, or their return values? Commented Dec 8, 2010 at 0:49
  • Do you mean the function object f? or the return value from f()? calling f() which passes actually returns None. Your example is not printing f, it is printing f(). Commented Dec 8, 2010 at 0:52
  • Hmmm... weirdly enough, changing the __repr__ and __str__ special methods of a function object seems to do nothing. It's surprising that Python doesn't allow these to be overridden while not also raising an error which it does, for example, if you try to override the __repr__ method of a list object. Commented Dec 8, 2010 at 0:56
  • @Chinmay Kanchi: See my answer. These are method-wrappers. Commented Dec 8, 2010 at 1:03
  • 1
    @Chinmay: overriding those methods won't help because it uses the object's type's __repr__ rather than the object's __repr__. So it uses <type 'function'>'s __repr__, not somefunc's __repr__ Commented Dec 8, 2010 at 3:01

5 Answers 5

Reset to default
9

Others have suggested doc strings, but a doc string should probably be more descriptive of what the function does. If you want a short attribute describing the function, one of the options below may be what you are looking for:

Option 1

Are you saying you want to change the default description of a function object?

>>> def f1(): pass
...
>>> def f2(): pass
...
>>> L = [f1,f2]
>>> print L
[<function f1 at 0x00AA72F0>, <function f2 at 0x00AA73B0>]

If you want to customize the description of the functions in the list above, use a decorator. The decorator below wraps each function decorated into an object that acts like the original function, but has a custom representation:

def doc(s):
    class __doc(object):
        def __init__(self,f):
            self.func = f
            self.desc = s
        def __call__(self,*args,**kwargs):
            return self.func(*args,**kwargs)
        def __repr__(self):
            return '<function {0} "{1}">'.format(self.func.func_name,self.desc)
    return __doc

@doc('a+b')
def sum(a,b):
    return a + b

@doc('a-b')
def diff(a,b):
    return a - b

L = [sum,diff]
print L
for f in L:
    print f(5,3)

Output

[<function sum "a+b">, <function diff "a-b">]
8
2

Option 2

Alternatively, you can store attributes in your functions and display them as needed:

def sum(a,b):
    return a + b
sum.desc = 'a+b'

def diff(a,b):
    return a-b
diff.desc = 'a-b'

L = [sum,diff]
for f in L:
    print f.desc,f(8,3)

Output

a+b 11
a-b 5

Option 3

You can do option 2 with a decorator also:

def doc(s):
    def __doc(f):
        f.desc = s
        return f
    return __doc

@doc('a+b')
def sum2(a,b):
    return a + b

@doc('a-b')
def diff2(a,b):
    return a - b

L = [sum2,diff2]
for f in L:
    print f.desc,f(8,3)

Output

a+b 11
a-b 5
Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

Although all this works, it's just a different way of adding documentation to a function after the creation of it. If he wanted to add documentation when the function was added to the list, he could just make the list contains tuples of functions and reasons why it was in the list.
@Lennart: True, but he specifically said he didn't want "tuples of function objects and strings."
Thank you. These are both viable approaches, but I think I am looking for something much simpler (doc strings). This is obviously a more powerful approach if more requirements need to be met.
3

Few errors:

>>> def f():
...     pass
... 
>>> g = f()     <---- g is the return value of running f
>>> print g
None

in the first case, when you call print, you are calling a string representation of f

>>> f = F()
>>> print f    <----- f is an instance of class F and 
               <----- print f tries to provide a suitable string representation
               <----- by calling f.__str__

You should use doc strings for your motives

>>> def f():
...     " some doc"
...     pass
... 
>>> 
>>> f.__doc__
' some doc'
>>>

What you are trying to do is override the method wrapper __str__. 

>>> def f():
...     "some documentation .."
...     pass
... 
>>> 
>>> f.__str__
<method-wrapper '__str__' of function object at 0x100430140>
>>>
Improve this answer

1 Comment

Thank you. I knew about this before but it was not obvious (to me) that all I needed to do was call "print g.__doc__".
2

You cant change what happens when you print a function, but you can make a class behave like a function:

class f(object):
    def __str__(self):
        return "I'm a function!"

    def __call__(self):
        print "who called?"


print f # I'm a function!
f() # who called?
Improve this answer

Comments

0

Functions return values. The value assigned to g variable is going to be printed. If you want to print something, just make sure the function f, returns a string.

>>> def f():
...     return "Print me"
... 
>>> g = f()
>>> print g
Print me
Improve this answer

Comments

0 
>>> g = f # no ()! That *calls* the function.
>>> print g
<function f at 0x########>
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.