Xác định tên hàm từ bên trong hàm đó (không sử dụng truy nguyên)

Trong Python, không sử dụng tracebackmô-đun, có cách nào để xác định tên của hàm từ bên trong hàm đó không?

Nói rằng tôi có một mô-đun foo với một thanh chức năng. Khi thực hiện foo.bar(), có cách nào để thanh biết tên của thanh không? Hoặc tốt hơn, foo.bartên của?

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

Python không có tính năng để truy cập hàm hoặc tên của nó trong chính hàm đó. Nó đã được đề xuất nhưng bị từ chối. Nếu bạn không muốn tự chơi với ngăn xếp, bạn nên sử dụng "bar"hoặc bar.__name__tùy theo ngữ cảnh.

Thông báo từ chối đưa ra là:

PEP này bị từ chối. Không rõ nó nên được thực hiện như thế nào hoặc ngữ nghĩa chính xác nên là gì trong các trường hợp cạnh và không có đủ các trường hợp sử dụng quan trọng được đưa ra. phản ứng đã được ấm áp tốt nhất.

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

Có một số cách để có được kết quả tương tự:

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)

Lưu ý rằng các inspect.stackcuộc gọi chậm hơn hàng ngàn lần so với các lựa chọn thay thế:

$ 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

Bạn có thể lấy tên mà nó được xác định bằng cách sử dụng cách tiếp cận mà @Andreas Jung hiển thị , nhưng đó có thể không phải là tên mà hàm được gọi với:

import inspect

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

Foo2 = Foo

>>> Foo()
Foo

>>> Foo2()
Foo

Cho dù sự khác biệt đó có quan trọng với bạn hay không tôi không thể nói.

functionNameAsString = sys._getframe().f_code.co_name

Tôi muốn một điều tương tự vì tôi muốn đặt tên hàm trong chuỗi nhật ký đã đi vào một số vị trí trong mã của tôi. Có lẽ không phải là cách tốt nhất để làm điều đó, nhưng đây là một cách để có được tên của hàm hiện tại.

Tôi giữ tiện ích tiện dụng này gần đây:

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

Sử dụng:

myself()

Tôi đoán inspectlà cách tốt nhất để làm điều này. Ví dụ:

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

Tôi tìm thấy một trình bao bọc sẽ viết tên hàm

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

Cái này sẽ in

my_funky_name

SƠ KHAI

Điều này thực sự bắt nguồn từ các câu trả lời khác cho câu hỏi.

Đây là của tôi:

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

Ưu điểm có khả năng của phiên bản này so với việc sử dụng notify.stack () là nó sẽ nhanh hơn hàng nghìn lần [xem bài đăng và thời gian của Alex Melihoff về việc sử dụng sys._getframe () so với sử dụng notify.stack ()].

print(inspect.stack()[0].function) dường như cũng hoạt động (Python 3.5).

Đây là một cách tiếp cận bằng chứng trong tương lai.

Kết hợp các đề xuất của @ CamHart và @ Yuval với câu trả lời được chấp nhận của @ RoshOxymoron có lợi ích là tránh:

• _hidden và các phương pháp có khả năng không dùng nữa
• lập chỉ mục vào ngăn xếp (có thể được sắp xếp lại trong các con trăn trong tương lai)

Vì vậy, tôi nghĩ rằng điều này chơi tốt với các phiên bản python trong tương lai (được thử nghiệm trên 2.7.3 và 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())

Kiểm tra:

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

Đầu ra:

test_class_func_name
test_func_name

Tôi không chắc tại sao mọi người làm cho nó phức tạp:

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

Trong IDE, đầu ra mã

xin chào, tôi là bố, bố là

xin chào, tôi là quán bar, bố là foo

xin chào, tôi là quán bar, bố là

Bạn có thể sử dụng một trang trí:

def my_function(name=None):
    return name

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

>>> get_function_name(my_function)
'my_function'

Tôi thực hiện phương pháp của riêng mình được sử dụng để gọi siêu với sự an toàn bên trong nhiều kịch bản thừa kế (tôi đặt tất cả mã)

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

sử dụng mẫu:

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

kiểm tra nó:

a = C()
a.test()

đầu ra:

called from C
called from A
called from B

Bên trong mỗi phương thức trang trí @with_name, bạn có quyền truy cập vào chính mình .__ fname__ làm tên hàm hiện tại.

Gần đây tôi đã cố gắng sử dụng các câu trả lời ở trên để truy cập chuỗi doc của hàm từ ngữ cảnh của hàm đó nhưng vì các câu hỏi trên chỉ trả về chuỗi tên nên nó không hoạt động.

May mắn thay tôi tìm thấy một giải pháp đơn giản. Nếu giống như tôi, bạn muốn tham khảo hàm chứ không chỉ đơn giản là lấy chuỗi đại diện cho tên mà bạn có thể áp dụng eval () cho chuỗi của tên hàm.

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

Tôi đề nghị không dựa vào các yếu tố ngăn xếp. Nếu ai đó sử dụng mã của bạn trong các bối cảnh khác nhau (ví dụ trình thông dịch python), ngăn xếp của bạn sẽ thay đổi và phá vỡ chỉ mục của bạn ([0] [3]).

Tôi đề nghị bạn một cái gì đó như thế:

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

Điều này là khá dễ dàng để thực hiện với một trang trí.

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