Determine function name from within that function without using traceback

Question

In Python  without using the traceback module  is there a way to determine a function s name from within that function   Say I have a module foo with a function bar   When executing foo bar    is there a way for bar to know bar s name   Or better yet  foo bar s name    foo py   def bar        print  my name is     myname      lt    how do I calculate this at runtime

User · Answer

functionNameAsString   sys  getframe   f code co name   I wanted a very similar thing because I wanted to put the function name in a log string that went in a number of places in my code  Probably not the best way to do that  but here s a way to get the name of the current function

User · Answer

import inspect  def foo       print inspect stack   0  3      print inspect stack   1  3    will give the caller of foos name  if something called foo

User · Answer

Python doesn t have a feature to access the function or its name within the function itself  It has been proposed but rejected  If you don t want to play with the stack yourself  you should either use  bar  or bar   name   depending on context   The given rejection notice is      This PEP is rejected  It is not clear how it should be implemented or what the precise semantics should be in edge cases  and there aren t enough important use cases given  response has been lukewarm at best

User · Answer

You can use a decorator   def my function name None       return name  def get function name function       return function name function   name      gt  gt  gt  get function name my function   my function

User · Answer

This is pretty easy to accomplish with a decorator    gt  gt  gt  from functools import wraps   gt  gt  gt  def named func            wraps func          def    args    kwargs               return func func   name     args    kwargs          return          gt  gt  gt   named     def my func name  something else           return name  something else        gt  gt  gt  my func  hello  world     my func    hello  world

User · Answer

I do my own approach used for calling super with safety inside multiple inheritance scenario  I put all the code   def safe super  class   inst          safe super call        try          return getattr super  class   inst    inst   fname        except          return  lambda  x   kx  None    def with name function       def wrap self   args    kwargs           self   fname     function   name           return function self   args    kwargs  return wrap   sample usage   class A object        def   init              super A  self    init           with name     def test self           print  called from A n          safe super A  self     class B object        def   init              super B  self    init           with name     def test self           print  called from B n          safe super B  self     class C A  B        def   init              super C  self    init           with name     def test self           print  called from C n          safe super C  self      testing it    a   C   a test     output   called from C called from A called from B   Inside each  with name decorated method you have access to self   fname   as the current function name

User · Answer

You can get the name that it was defined with using the approach that  Andreas Jung shows  but that may not be the name that the function was called with   import inspect  def Foo       print inspect stack   0  3   Foo2   Foo   gt  gt  gt  Foo   Foo   gt  gt  gt  Foo2   Foo   Whether that distinction is important to you or not I can t say

User · Answer

I suggest not to rely on stack elements  If someone use your code within different contexts  python interpreter for instance  your stack will change and break your index   0  3     I suggest you something like that   class MyClass       def   init   self           self function name   None      def  Handler self    kwargs           print  Calling function    with parameters     format self function name  kwargs           self function name   None      def   getattr   self  attr           self function name   attr         return self  Handler   mc   MyClass   mc test FirstParam  my   SecondParam  test   mc foobar OtherParam  foobar

User · Answer

Here s a future-proof approach   Combining  CamHart s and  Yuval s suggestions with  RoshOxymoron s accepted answer has the benefit of avoiding     hidden and potentially deprecated methods indexing into the stack  which could be reordered in future pythons    So I think this plays nice with future python versions  tested on 2 7 3 and 3 3 2    from   future   import print function import inspect  def bar        print  my name is       format inspect currentframe   f code co name

User · Answer

I keep this handy utility nearby   import inspect myself   lambda  inspect stack   1  3    Usage   myself

User · Answer

import sys  def func name                 return  name of caller             return sys  getframe 1  f code co name  class A object       def   init   self           pass     def test class func name self           print func name     def test func name        print func name      Test   a   A   a test class func name   test func name     Output   test class func name test func name

User · Answer

print inspect stack   0  function  seems to work too  Python 3 5

User · Answer

import inspect  def whoami        return inspect stack   1  3   def whosdaddy        return inspect stack   2  3   def foo        print  hello  I m  s  daddy is  s     whoami    whosdaddy        bar    def bar        print  hello  I m  s  daddy is  s     whoami    whosdaddy     foo   bar     In IDE the code outputs     hello  I m foo  daddy is       hello  I m bar  daddy is foo      hello  I m bar  daddy is

User · Answer

I am not sure why people make it complicated   import sys  print   s  s    sys  getframe   f code co filename  sys  getframe   f code co name

User · Answer

Use   name   attribute    foo py def bar        print f quot my name is  bar   name    quot    You can easily access function s name from within the function using   name   attribute   gt  gt  gt  def bar            print f quot my name is  bar   name    quot        gt  gt  gt  bar   my name is bar  I ve come across this question myself several times  looking for the ways to do it  Correct answer is contained in the Python s documentation  see Callable types section   Every function has a   name   parameter that returns its name and even   qualname   parameter that returns its full name  including which class it belongs to  see Qualified name

User · Answer

I recently tried to use the above answers to access the docstring of a function from the context of that function but as the above questions were only returning the name string it did not work   Fortunately I found a simple solution  If like me  you want to refer to the function rather than simply get the string representing the name you can apply eval   to the string of the function name   import sys def foo           foo docstring        print eval sys  getframe   f code co name    doc

User · Answer

I found a wrapper that will write the function name from functools import wraps  def tmp wrap func        wraps func      def tmp  args    kwargs           print func   name           return func  args    kwargs      return tmp   tmp wrap def my funky name        print  quot STUB quot   my funky name    This will print  my funky name STUB

User · Answer

I guess inspect is the best way to do this  For example   import inspect def bar        print  My name is   inspect stack   0  3

User · Answer

There are a few ways to get the same result   from   future   import print function import sys import inspect  def what is my name        print inspect stack   0  0  f code co name      print inspect stack   0  3       print inspect currentframe   f code co name      print sys  getframe   f code co name    Note that the inspect stack calls are thousands of times slower than the alternatives     python -m timeit -s  import inspect  sys   inspect stack   0  0  f code co name  1000 loops  best of 3  499 usec per loop   python -m timeit -s  import inspect  sys   inspect stack   0  3   1000 loops  best of 3  497 usec per loop   python -m timeit -s  import inspect  sys   inspect currentframe   f code co name  10000000 loops  best of 3  0 1 usec per loop   python -m timeit -s  import inspect  sys   sys  getframe   f code co name  10000000 loops  best of 3  0 135 usec per loop

User · Answer

This is actually derived from the other answers to the question   Here s my take   import sys    for current func name  specify 0 or no argument    for name of caller of current func  specify 1    for name of caller of caller of current func  specify 2  etc  currentFuncName   lambda n 0  sys  getframe n   1  f code co name   def testFunction        print  You are in function    currentFuncName       print  This function s caller was    currentFuncName 1        def invokeTest        testFunction     invokeTest      end of file   The likely advantage of this version over using inspect stack   is that it should be thousands of times faster  see Alex Melihoff s post and timings regarding using sys  getframe   versus using inspect stack

[python] Determine function name from within that function (without using traceback)

Examples related to python

Examples related to function

Examples related to introspection

Examples related to traceback