Określ nazwę funkcji w obrębie tej funkcji (bez użycia traceback)

Czy w Pythonie, bez użycia tracebackmodułu, istnieje sposób na określenie nazwy funkcji z poziomu tej funkcji?

Powiedzmy, że mam moduł foo z paskiem funkcji. Czy podczas wykonywania foo.bar()paska można poznać jego nazwę? A może jeszcze lepiej foo.bar?

#foo.py  
def bar():
    print "my name is", __myname__ # <== how do I calculate this at runtime?

Python nie ma funkcji dostępu do funkcji lub jej nazwy w samej funkcji. Zostało zaproponowane, ale odrzucone. Jeśli nie chcesz sam grać ze stosem, powinieneś użyć "bar"albo w bar.__name__zależności od kontekstu.

Podane powiadomienie o odrzuceniu to:

Ten PEP został odrzucony. Nie jest jasne, w jaki sposób powinien zostać zaimplementowany ani jaka powinna być precyzyjna semantyka w przypadkach skrajnych, i nie podano wystarczającej liczby ważnych przypadków użycia. odpowiedź była co najwyżej letnia.

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

Istnieje kilka sposobów na uzyskanie tego samego wyniku:

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)

Pamiętaj, że inspect.stackpołączenia są tysiące razy wolniejsze niż alternatywy:

$ 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

Nazwę, którą zdefiniowano, można uzyskać, stosując podejście pokazane przez @Andreas Jung , ale może to nie być nazwa, z którą funkcja została wywołana:

import inspect

def Foo():
   print inspect.stack()[0][3]

Foo2 = Foo

>>> Foo()
Foo

>>> Foo2()
Foo

Czy to rozróżnienie jest dla ciebie ważne, czy nie, nie mogę powiedzieć.

functionNameAsString = sys._getframe().f_code.co_name

Chciałem bardzo podobną rzecz, ponieważ chciałem umieścić nazwę funkcji w ciągu dziennika, który poszedł w wielu miejscach w moim kodzie. Prawdopodobnie nie jest to najlepszy sposób, aby to zrobić, ale oto sposób na uzyskanie nazwy bieżącej funkcji.

Trzymam to przydatne narzędzie w pobliżu:

import inspect
myself = lambda: inspect.stack()[1][3]

Stosowanie:

myself()

Myślę, że inspectto najlepszy sposób na zrobienie tego. Na przykład:

import inspect
def bar():
    print("My name is", inspect.stack()[0][3])

Znalazłem opakowanie, które zapisze nazwę funkcji

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 "STUB"

my_funky_name()

To zostanie wydrukowane

my_funky_name

KIKUT

Wynika to z innych odpowiedzi na pytanie.

Oto moje zdanie:

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

Prawdopodobną zaletą tej wersji w porównaniu z użyciem inspect.stack () jest to, że powinna być tysiące razy szybsza [zobacz post Alexa Melihoffa i terminy dotyczące korzystania z sys._getframe () w porównaniu z użyciem inspect.stack ()].

print(inspect.stack()[0].function) wydaje się również działać (Python 3.5).

Oto podejście przyszłościowe.

Połączenie sugestii @ CamHart i @ Yuval z zaakceptowaną odpowiedzią @ RoshOxymoron ma tę zaletę, że pozwala uniknąć:

• _hidden i potencjalnie przestarzałe metody
• indeksowanie do stosu (które można zmienić w przyszłych pythonach)

Myślę więc, że gra to dobrze w przyszłych wersjach Pythona (testowanych na 2.7.3 i 3.3.2):

from __future__ import print_function
import inspect

def bar():
    print("my name is '{}'".format(inspect.currentframe().f_code.co_name))

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()

Wynik:

test_class_func_name
test_func_name

Nie jestem pewien, dlaczego ludzie to komplikują:

import sys 
print("%s/%s" %(sys._getframe().f_code.co_filename, sys._getframe().f_code.co_name))

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()

W IDE kod wychodzi

cześć, jestem foo, tata jest

cześć, jestem barem, tata jest głupcem

cześć, jestem barem, tata jest

Możesz użyć dekoratora:

def my_function(name=None):
    return name

def get_function_name(function):
    return function(name=function.__name__)

>>> get_function_name(my_function)
'my_function'

Robię swoje własne podejście używane do wywoływania super z bezpieczeństwem w scenariuszu wielokrotnego dziedziczenia (umieszczam cały kod)

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

przykładowe użycie:

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)()

testowanie:

a = C()
a.test()

wynik:

called from C
called from A
called from B

Wewnątrz każdej dekorowanej metody @with_name masz dostęp do siebie .__ fname__ jako bieżąca nazwa funkcji.

Niedawno próbowałem użyć powyższych odpowiedzi, aby uzyskać dostęp do dokumentacji funkcji z kontekstu tej funkcji, ale ponieważ powyższe pytania zwracały tylko ciąg nazwy, nie działało.

Na szczęście znalazłem proste rozwiązanie. Jeśli tak jak ja, chcesz odwoływać się do funkcji zamiast po prostu uzyskać ciąg reprezentujący nazwę, którą możesz zastosować eval () do ciągu nazwy funkcji.

import sys
def foo():
    """foo docstring"""
    print(eval(sys._getframe().f_code.co_name).__doc__)

Sugeruję, aby nie polegać na elementach stosu. Jeśli ktoś użyje twojego kodu w różnych kontekstach (na przykład interpreter Pythona), twój stos zmieni się i zepsuje Twój indeks ([0] [3]).

Sugeruję coś takiego:

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')

Jest to dość łatwe do osiągnięcia dzięki dekoratorowi.

>>> from functools import wraps

>>> def named(func):
...     @wraps(func)
...     def _(*args, **kwargs):
...         return func(func.__name__, *args, **kwargs)
...     return _
... 

>>> @named
... def my_func(name, something_else):
...     return name, something_else
... 

>>> my_func('hello, world')
('my_func', 'hello, world')