How to replace __str__ with a function

Question

I want to change the string representation of a python function as the name of a function.

For example, for some function

def blah(x): ... 

str(blah) currently gives

 <function blah at 0x10127b578> 

So, I replace __str__ as follows:

 blah.__str__=lambda: 'blah' 

but it is not called str(blah) .

Is it possible to change __str__ for a function?

Answer 1

As Joran said:

 class NamedFunction: def __init__(self, name, f): self.f = f self.name = name def __call__(self, *args, **kwargs): return self.f(*args, **kwargs) def __str__(self): return self.name f = NamedFunction("lambda: 'blah'", lambda: 'blah') print(f()) print(f) 

Answer 2

Replacing __str__ as never works on any type of object. The type of inline function is not special:

 >>> class Foo(object): pass >>> f = Foo() >>> f.__str__ = lambda: 'f' >>> str(f) '<__main__.Foo object at 0x0000000002D13F28>' >>> f.__str__() 'f' 

The built-in str does not look for __str__ through the normal search protocol, it passes directly to the class of its argument. Thus, you cannot "override" the __str__ method for a single object; you must set it in the class to apply to all objects of this class. ¹

But then again, the built-in function type is not special. You can create a class that behaves basically like a function, and use:

 class Function(object): def __init__(self, raw_function): self.raw_function = raw_function def __call__(self, *args, **kwargs): return self.raw_function(*args, **kwargs) def __str__(self): return self.raw_function.__name__ 

The __call__ method means that you can call objects of this class exactly as if they were functions. This simply passes all the arguments that it receives directly to the main raw function, and returns everything it returns (or throws all the exceptions that it throws). And since this class takes one function as an argument, it is also suitable for a decorator template:

 @Function def blah(x): return x + 1 

With this:

 >>> blah <__main__.Function object at 0x0000000002D13EB8> >>> str(blah) 'blah' >>> blah(33) 34 

---

^{1 The} built-in type of a function is special in some respects (I lied), one of which is that you cannot assign its attributes (that is, the attributes of the class itself, not the attributes of any particular function object). So, before you think, it might be great if you could secure the built-in type of the function so that str works the way you want for all functions that don't work. This is probably the best; modifying things both global and fundamental, since the built-in type of a function will be a great way to come up with some really bizarre errors.

Answer 3

 class FNMagic: def __init__(self,fn,fn_name): self.fn = fn self.fn_name = fn_name def __call__(self,*args,**kwargs): return self.fn(*args,**kwargs) def __str__(self): return self.fn_name def blah(x): return x blah = FNMagic(blah,"blah!") print blah 

you can make a simple decorator

 class NamedFn: def __init__(self,name): self.fn_name = name def __call__(self,fn): return FNMagic(fn,self.fn_name) @NamedFn("some_name!!!") def blah2(x,y): return x*y print blah2 

Answer 4

As already noted, the answer is no. If you just want to get the function name as a string, you can use blah.__name__ .