Tentukan nama fungsi dari dalam fungsi itu (tanpa menggunakan traceback)

Dalam Python, tanpa menggunakan tracebackmodul, apakah ada cara untuk menentukan nama fungsi dari dalam fungsi itu?

Katakanlah saya punya modul foo dengan bilah fungsi. Saat menjalankan foo.bar(), apakah ada cara bagi bar untuk mengetahui nama bar? Atau lebih baik lagi, foo.barnama?

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

Python tidak memiliki fitur untuk mengakses fungsi atau namanya di dalam fungsi itu sendiri. Telah diusulkan tetapi ditolak. Jika Anda tidak ingin bermain sendiri dengan tumpukan, Anda harus menggunakan "bar"atau bar.__name__bergantung pada konteks.

Pemberitahuan penolakan yang diberikan adalah:

PEP ini ditolak. Tidak jelas bagaimana itu harus diimplementasikan atau apa semantik yang tepat harus dalam kasus tepi, dan tidak ada cukup kasus penggunaan penting yang diberikan. responsnya paling suam-suam kuku.

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

Ada beberapa cara untuk mendapatkan hasil yang sama:

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)

Perhatikan bahwa inspect.stackpanggilan ribuan kali lebih lambat daripada alternatif:

$ 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

Anda bisa mendapatkan nama yang didefinisikan dengan menggunakan pendekatan yang ditunjukkan oleh @Andreas Jung , tapi itu mungkin bukan nama yang dipanggil dengan fungsi:

import inspect

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

Foo2 = Foo

>>> Foo()
Foo

>>> Foo2()
Foo

Apakah perbedaan itu penting bagi Anda atau tidak, saya tidak bisa mengatakannya.

functionNameAsString = sys._getframe().f_code.co_name

Saya menginginkan hal yang sangat mirip karena saya ingin memasukkan nama fungsi dalam string log yang masuk ke sejumlah tempat dalam kode saya. Mungkin bukan cara terbaik untuk melakukan itu, tetapi inilah cara untuk mendapatkan nama fungsi saat ini.

Saya menyimpan utilitas praktis ini di dekat:

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

Pemakaian:

myself()

Saya kira inspectadalah cara terbaik untuk melakukan ini. Sebagai contoh:

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

Saya menemukan pembungkus yang akan menulis nama fungsi

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

Ini akan dicetak

my_funky_name

STUB

Ini sebenarnya berasal dari jawaban lain untuk pertanyaan itu.

Inilah pendapat saya:

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

Kemungkinan keuntungan dari versi ini daripada menggunakan inspect.stack () adalah bahwa itu harus ribuan kali lebih cepat [lihat posting dan waktu Alex Melihoff mengenai penggunaan sys._getframe () dibandingkan menggunakan inspect.stack ()].

print(inspect.stack()[0].function) tampaknya berfungsi juga (Python 3.5).

Berikut ini adalah pendekatan yang terbukti di masa depan.

Menggabungkan saran @ CamHart dan @ Yuval dengan jawaban yang diterima @ RoshOxymoron memiliki manfaat menghindari:

• _hidden dan metode yang berpotensi usang
• pengindeksan ke dalam tumpukan (yang dapat disusun kembali dalam ular piton masa depan)

Jadi saya pikir ini bagus untuk versi python masa depan (diuji pada 2.7.3 dan 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())

Uji:

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

Keluaran:

test_class_func_name
test_func_name

Saya tidak yakin mengapa orang membuatnya rumit:

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

Dalam IDE output kode

halo, aku foo, ayah

halo, saya bar, ayah foo

halo, saya bar, ayah

Anda dapat menggunakan dekorator:

def my_function(name=None):
    return name

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

>>> get_function_name(my_function)
'my_function'

Saya melakukan pendekatan saya sendiri yang digunakan untuk memanggil super dengan aman di dalam beberapa skenario warisan (saya meletakkan semua kode)

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

penggunaan sampel:

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

mengujinya:

a = C()
a.test()

keluaran:

called from C
called from A
called from B

Di dalam setiap metode dihiasi @with_name Anda memiliki akses ke self .__ fname__ sebagai nama fungsi saat ini.

Saya baru-baru ini mencoba menggunakan jawaban di atas untuk mengakses dokumen dari suatu fungsi dari konteks fungsi itu tetapi karena pertanyaan di atas hanya mengembalikan string nama itu tidak berfungsi.

Untungnya saya menemukan solusi sederhana. Jika seperti saya, Anda ingin merujuk ke fungsi daripada hanya mendapatkan string yang mewakili nama yang dapat Anda terapkan eval () ke string nama fungsi.

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

Saya sarankan untuk tidak mengandalkan elemen stack. Jika seseorang menggunakan kode Anda dalam konteks yang berbeda (misalnya interpreter python) tumpukan Anda akan berubah dan menghancurkan indeks Anda ([0] [3]).

Saya menyarankan Anda sesuatu seperti itu:

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

Ini sangat mudah dilakukan dengan dekorator.

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