İşlev adını bu işlevin içinden (geri izleme kullanmadan) belirleme

Python'da, tracebackmodülü kullanmadan, bir işlevin adını o işlev içinden belirlemenin bir yolu var mı?

Diyelim ki bir işlev çubuğuna sahip bir modülüm var. Yürütürken foo.bar(), çubuğun çubuğunun adını bilmesi için bir yol var mı? Ya da daha iyisi, foo.baradı?

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

Python'un işleve veya işlevin kendi adındaki adına erişme özelliği yoktur. Bu edilmiştir önerilmiştir fakat reddedilmiştir. Yığınla kendiniz oynamak istemiyorsanız , bağlama göre "bar"veya kullanmalısınız bar.__name__.

Verilen ret bildirimi:

Bu PEP reddedildi. Nasıl uygulanacağı veya kesin anlambilimin uç durumlarda ne olması gerektiği açık değildir ve yeterli önemli kullanım durumu yoktur. cevap en iyi ihtimalle ılık.

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

Aynı sonucu almanın birkaç yolu vardır:

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)

Not inspect.stackçağrılar yavaş alternatiflerden daha binlerce kez şunlardır:

$ 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

@Andreas Jung'un gösterdiği yaklaşımı kullanarak tanımlandığı adı alabilirsiniz , ancak bu işlevin çağrıldığı ad olmayabilir:

import inspect

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

Foo2 = Foo

>>> Foo()
Foo

>>> Foo2()
Foo

Bu ayrımın sizin için önemli olup olmadığı söyleyemem.

functionNameAsString = sys._getframe().f_code.co_name

Çok benzer bir şey istedim çünkü kodumda birkaç yere giden bir günlük dizesine işlev adını koymak istedim. Muhtemelen bunu yapmanın en iyi yolu değil, ama şu anki fonksiyonun adını almanın bir yolu.

Bu kullanışlı yardımcı programı yakın tutuyorum:

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

Kullanımı:

myself()

Bunu inspectyapmanın en iyi yolu sanırım . Örneğin:

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

İşlev adını yazacak bir sarıcı buldum

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

Bu yazdırılacak

my_funky_name

TASLAK

Bu aslında sorunun diğer cevaplarından türetilmiştir.

İşte benim almam:

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

Bu sürümün inspect.stack () kullanımı üzerindeki olası avantajı, binlerce kat daha hızlı olması gerektiğidir [bkz. Alex Melihoff'un sys._getframe () kullanımına karşı gönderi ve zamanlamalarına karşılık inspect.stack () kullanılması].

print(inspect.stack()[0].function) çok işe yarıyor gibi görünüyor (Python 3.5).

İşte geleceğe dönük bir yaklaşım.

@ CamHart's ve @ Yuval'ın önerilerini @ RoshOxymoron'un kabul edilen cevabı ile birleştirmekten kaçınma avantajı vardır:

• _hidden ve potansiyel olarak kullanımdan kaldırılmış yöntemler
• Yığına endeksleme (gelecekteki pitonlarda yeniden sıralanabilir)

Bu yüzden gelecekteki python sürümleriyle (2.7.3 ve 3.3.2'de test edilmiş) güzel oynadığını düşünüyorum:

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

Ölçek:

a = A()
a.test_class_func_name()
test_func_name()

Çıktı:

test_class_func_name
test_func_name

İnsanların neden karmaşık hale getirdiğinden emin değilim:

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

IDE'de kod çıktıları

merhaba ben foo, baba

merhaba, ben barım, baba foo

merhaba, ben barım, baba

Bir dekoratör kullanabilirsiniz:

def my_function(name=None):
    return name

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

>>> get_function_name(my_function)
'my_function'

Birden fazla miras senaryosu içinde güvenlik ile süper çağırmak için kullanılan kendi yaklaşımımı yapıyorum (tüm kodu koydum)

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

örnek kullanımı:

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

test etmek:

a = C()
a.test()

çıktı:

called from C
called from A
called from B

Her @with_name dekore edilmiş yöntemin içinde, geçerli işlev adı olarak self .__ fname__ dosyasına erişebilirsiniz.

Geçenlerde bu fonksiyonun bağlamından bir fonksiyonun öğretisine erişmek için yukarıdaki cevapları kullanmaya çalıştım, ancak yukarıdaki sorular sadece isim dizesini döndürdüğü için işe yaramadı.

Neyse ki basit bir çözüm buldum. Eğer benim gibi, işlev adının dizesine eval () uygulayabileceğiniz adı temsil eden dizeyi almak yerine işleve başvurmak istersiniz.

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

Yığın öğelerine güvenmemeyi öneririm. Birisi kodunuzu farklı bağlamlarda kullanırsa (örneğin python yorumlayıcısı) yığınız dizini değiştirecek ve bozacaktır ([0] [3]).

Size böyle bir şey öneriyorum:

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

Bir dekoratörle bunu başarmak oldukça kolaydır.

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