Python 如何以字符串形式获取函数名?
在Python中,如何在不调用函数的情况下以字符串形式获取函数名Python 如何以字符串形式获取函数名?,python,string,function,Python,String,Function,在Python中,如何在不调用函数的情况下以字符串形式获取函数名 def my_function(): pass print get_function_name_as_string(my_function) # my_function is not in quotes 应输出“my_函数” Python中是否有这样的函数?如果没有,关于如何在Python中实现get\u function\u name\u as\u string,有什么想法吗 my_function.func_nam
def my_function():
pass
print get_function_name_as_string(my_function) # my_function is not in quotes
应输出“my_函数”
Python中是否有这样的函数?如果没有,关于如何在Python中实现get\u function\u name\u as\u string
,有什么想法吗
my_function.func_name
函数还有其他有趣的特性。键入dir(func\u name)
以列出它们func_name.func_code.co_code
是编译后的函数,存储为字符串
import dis
dis.dis(my_function)
将以几乎人类可读的格式显示代码。:)
使用\uuuu name\uuuu
是首选方法,因为它适用于统一的环境。与func_name不同,它还可以处理内置函数:
>>> import time
>>> time.time.func_name
Traceback (most recent call last):
File "<stdin>", line 1, in ?
AttributeError: 'builtin_function_or_method' object has no attribute 'func_name'
>>> time.time.__name__
'time'
导入时间
>>>time.time.func_名称
回溯(最近一次呼叫最后一次):
文件“”,第1行,是否在中?
AttributeError:“内置函数”或“方法”对象没有“函数名称”属性
>>>时间,时间,名字
“时间”
此外,双下划线向读者表明这是一个特殊属性。另外,类和模块也有一个
\uu name\uuu
属性,因此您只需记住一个特殊名称。要从其中获取当前函数或方法的名称,请考虑:
import inspect
this_function_name = inspect.currentframe().f_code.co_name
import inspect
import types
from typing import cast
this_function_name = cast(types.FrameType, inspect.currentframe()).f_code.co_name
sys.\u getframe
也可以代替inspect.currentframe
工作,尽管后者避免访问私有函数
< >获取调用函数的名称,请考虑<代码> fyRebug <代码>,如<代码>检查。
如果同时使用mypy,它可能会抱怨: 错误:“可选[FrameType]”的项“None”没有属性“f_code” 要抑制上述错误,请考虑:
import inspect
this_function_name = inspect.currentframe().f_code.co_name
import inspect
import types
from typing import cast
this_function_name = cast(types.FrameType, inspect.currentframe()).f_code.co_name
sys.\u getframe()
不能保证在Python()的所有实现中都可用,您可以使用回溯
模块来做同样的事情,例如
import traceback
def who_am_i():
stack = traceback.extract_stack()
filename, codeline, funcName, text = stack[-2]
return funcName
调用堆栈[-1]将返回当前进程的详细信息。此函数将返回调用方的函数名
def func_name():
import traceback
return traceback.extract_stack(None, 2)[0][2]
这就像Albert Vonpupp用友好的包装给出的答案一样。作为的扩展,我创建了一些实用程序函数,它们打印当前函数的名称和参数:
import inspect
import logging
import traceback
def get_function_name():
return traceback.extract_stack(None, 2)[0][2]
def get_function_parameters_and_values():
frame = inspect.currentframe().f_back
args, _, _, values = inspect.getargvalues(frame)
return ([(i, values[i]) for i in args])
def my_func(a, b, c=None):
logging.info('Running ' + get_function_name() + '(' + str(get_function_parameters_and_values()) +')')
pass
logger = logging.getLogger()
handler = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s [%(levelname)s] -> %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.INFO)
my_func(1, 3) # 2016-03-25 17:16:06,927 [INFO] -> Running my_func([('a', 1), ('b', 3), ('c', None)])
我喜欢使用函数装饰器。 我添加了一个类,它也乘以函数时间。假设gLog是标准python记录器:
class EnterExitLog():
def __init__(self, funcName):
self.funcName = funcName
def __enter__(self):
gLog.debug('Started: %s' % self.funcName)
self.init_time = datetime.datetime.now()
return self
def __exit__(self, type, value, tb):
gLog.debug('Finished: %s in: %s seconds' % (self.funcName, datetime.datetime.now() - self.init_time))
def func_timer_decorator(func):
def func_wrapper(*args, **kwargs):
with EnterExitLog(func.__name__):
return func(*args, **kwargs)
return func_wrapper
所以现在你所要做的就是装饰它,瞧
@func_timer_decorator
def my_func():
如果您也对类方法感兴趣,那么Python 3.3+除了有
\uuuuuu name\uuuu
之外,还有\uuuuu name\uuuu
def my_function():
pass
class MyClass(object):
def method(self):
pass
print(my_function.__name__) # gives "my_function"
print(MyClass.method.__name__) # gives "method"
print(my_function.__qualname__) # gives "my_function"
print(MyClass.method.__qualname__) # gives "MyClass.method"
您只需要获取函数名,这里有一个简单的代码。 假设您已经定义了这些函数
def function1():
print "function1"
def function2():
print "function2"
def function3():
print "function3"
print function1.__name__
输出将为功能1
现在假设您在列表中有这些函数
a = [function1 , function2 , funciton3]
获取函数的名称
for i in a:
print i.__name__
输出将是
功能1功能2
功能3
import inspect
def foo():
print(inspect.stack()[0][3])
在哪里
是调用方stack()[0]
是方法的字符串名称stack()[3]
def debug(func=None):
def wrapper(*args, **kwargs):
try:
function_name = func.__func__.__qualname__
except:
function_name = func.__qualname__
return func(*args, **kwargs, function_name=function_name)
return wrapper
@debug
def my_function(**kwargs):
print(kwargs)
my_function()
输出:
{'function_name': 'my_function'}
试一试
导入系统
fn_name=sys.\u getframe().f_code.co_name
进一步参考
或:
f.uuu name_uuu和f.func_uname之间有什么区别?山姆:名称是私有的,名称是特殊的,存在概念上的差异。如果有人对Matthew前面的答案感到困惑,注释系统会将一些双下划线解释为粗体代码。用反勾号转义,消息应该是:
\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu。不确定之前的双下划线是否有任何意义,无论是正式意义还是约定意义。func\u name
在python3中不再存在,因此您需要使用func。如果您想要兼容性+1:这是我想看到的答案。其他答案假设调用者已经知道函数名,这在这个问题的上下文中是毫无意义的。假设您在函数定义的同一范围内直接调用name或func_name,但通常情况并非如此。请记住,函数是对象——它们可以作为参数传递给其他函数,存储在列表/目录中以供以后查找或执行,等等。@paulus_万能的,深入堆栈帧对我来说并不是抽象的!事实上,这是抽象的反面。参见文档中的注释。并非所有Python的实现都将包含sys.\u getframe
——它直接连接到CPython的内部。这只在函数内部工作,但是问题指定不应该调用该函数。如果您想将函数包装成更有用、更容易记住的形式,则必须检索帧1,如sys.\u getframe(1).f\u code.co\u name
,这样您就可以定义函数,如get\u func\u name()
并期望获得调用函数的所需名称。因为在某些情况下,您会获得一些函数对象作为函数的参数,并且需要显示/存储/操作该函数的名称。也许您正在生成文档、帮助文本、操作历史记录等。因此,不,您并不总是硬编码函数名。@mgargiel:我的意思是:假设您有一个定义了100个方法的类,其中所有方法都只是包装器,它调用私有方法,并传递函数名
import sys
def my_second_function():
func_name = sys._getframe().f_code.co_name
print(func_name) # my_second_function