पायथन में, tracebackमॉड्यूल का उपयोग किए बिना , क्या उस फ़ंक्शन के भीतर से फ़ंक्शन का नाम निर्धारित करने का एक तरीका है?
मान लें कि मेरे पास एक फ़ंक्शन बार के साथ एक मॉड्यूल फू है। निष्पादित करते समय foo.bar(), बार के नाम को जानने के लिए बार के लिए एक रास्ता है? या बेहतर अभी तक, foo.barनाम?
#foo.py
def bar():
print "my name is", __myname__ # <== how do I calculate this at runtime?जवाबों:
पायथन में फ़ंक्शन या इसके नाम को फ़ंक्शन के भीतर ही एक्सेस करने की सुविधा नहीं है। यह प्रस्तावित किया गया है लेकिन अस्वीकार कर दिया गया है। आप ढेर के साथ खुद को खेलने के लिए नहीं करना चाहते हैं, तो आप या तो उपयोग करना चाहिए "bar"या bar.__name__संदर्भ के आधार पर।
दी गई अस्वीकृति सूचना है:
यह पीईपी खारिज कर दिया जाता है। यह स्पष्ट नहीं है कि इसे कैसे लागू किया जाना चाहिए या किनारे के मामलों में सटीक शब्दार्थ क्या होना चाहिए, और दिए गए महत्वपूर्ण उपयोग के मामले नहीं हैं। प्रतिक्रिया गुनगुना रही है।
inspect.currentframe()ऐसा ही एक तरीका है।
print(inspect.currentframe().f_code.co_name)
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[1][3]कॉलर का नाम लेने के लिए भी कर सकते हैं ।
print(inspect.currentframe().f_code.co_name)या कॉलर का नाम पाने के लिए print(inspect.currentframe().f_back.f_code.co_name):। मुझे लगता है कि यह तेजी से होना चाहिए क्योंकि आप सभी स्टैक फ़्रेमों की सूची प्राप्त नहीं करते हैं inspect.stack()।
inspect.currentframe().f_back.f_code.co_nameजबकि एक सजाया विधि के साथ काम नहीं inspect.stack()[0][3]करता है ...
समान परिणाम प्राप्त करने के कुछ तरीके हैं:
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)ध्यान दें कि inspect.stackकॉल विकल्प की तुलना में हजारों गुना धीमी हैं:
$ 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 loopinspect.currentframe()निजी सदस्यों के निष्पादन समय और उपयोग के बीच एक अच्छा व्यापार है
0.100 usecया 0.199 usecतो होना चाहिए था, लेकिन विकल्प 1 और 2 की तुलना में सैकड़ों गुना तेजी से, विकल्प 4 के साथ तुलनीय (हालांकि एंटनी हैचकिंस ने विकल्प 3 को विकल्प 4 की तुलना में 3 गुना तेज पाया)।
sys._getframe().f_code.co_nameसे अधिक inspect.currentframe().f_code.co_nameबस क्योंकि मैं पहले से ही आयात किया है sysमॉड्यूल। क्या यह उचित निर्णय है? (गति को देखते हुए काफी समान है)
आप उस नाम को प्राप्त कर सकते हैं जिसे उस दृष्टिकोण का उपयोग करके परिभाषित किया गया था जो @Andreas जंग दिखाता है , लेकिन यह वह नाम नहीं हो सकता है जिसे फ़ंक्शन के साथ बुलाया गया था:
import inspect
def Foo():
print inspect.stack()[0][3]
Foo2 = Foo
>>> Foo()
Foo
>>> Foo2()
Fooचाहे वह अंतर आपके लिए महत्वपूर्ण हो या नहीं, मैं नहीं कह सकता।
.func_name। पायथन में वर्ग के नाम और समारोह के नाम को याद रखना एक बात है और चर उन का जिक्र है।
Foo2()प्रिंट करना चाह सकते हैं Foo। उदाहरण के लिए Foo2 = function_dict['Foo']; Foo2():। इस मामले में, Foo2 शायद कमांड लाइन पार्सर के लिए एक फ़ंक्शन पॉइंटर है।
functionNameAsString = sys._getframe().f_code.co_nameमैं एक बहुत ही समान चीज चाहता था क्योंकि मैं फ़ंक्शन नाम को एक लॉग स्ट्रिंग में रखना चाहता था जो मेरे कोड में कई स्थानों पर गया था। शायद ऐसा करने का सबसे अच्छा तरीका नहीं है, लेकिन यहां वर्तमान फ़ंक्शन का नाम प्राप्त करने का एक तरीका है।
fफ्रेम के लिए और coकोड के लिए ध्यान में रखने की कोशिश करूंगा । मैं इसे इतना बेहतर उपयोग नहीं करते हैं, अगर मैं बस कुछ स्निपेट में बचा
मैं इस उपयोगी उपयोगिता को पास में रखता हूँ:
import inspect
myself = lambda: inspect.stack()[1][3]उपयोग:
myself()मुझे एक रैपर मिला जो फ़ंक्शन नाम लिखेगा
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()यह छपेगा
my_funky_name
ठूंठ
my_funky_name.__name__। आप नए पैरामीटर के रूप में फंक .__ name__ को फंक्शन में पास कर सकते हैं। func (* args, ** kwargs, my_name = func .__ name__)। अपने सज्जाकार का नाम अपने कार्य के अंदर से प्राप्त करने के लिए, मुझे लगता है कि निरीक्षण का उपयोग करने की आवश्यकता होगी। लेकिन मेरे चल समारोह के भीतर मेरे फंक्शन को नियंत्रित करने वाले फ़ंक्शन का नाम प्राप्त करना ... अच्छी तरह से यह सिर्फ एक खूबसूरत मेम की शुरुआत की तरह लगता है :)
यह वास्तव में प्रश्न के अन्य उत्तरों से लिया गया है।
यहाँ मेरा ले लो:
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इंस्पेक्ट.स्टैक () का उपयोग करके इस संस्करण का संभावित लाभ यह है कि यह हजारों गुना तेज होना चाहिए [एलेक्स मेलहॉफ की पोस्ट देखें और sys._getframe () बनाम इंस्पेक्ट.स्टैक () का उपयोग करने के संबंध में समय।
print(inspect.stack()[0].function) काम भी लगता है (पायथन 3.5)।
यहाँ एक भविष्य-प्रूफ दृष्टिकोण है।
@ RoshOxymoron के स्वीकृत उत्तर के साथ @ CamHart's और @ युवल के सुझावों के संयोजन से बचने का लाभ है:
_hidden और संभावित रूप से हटाए गए तरीकेइसलिए मुझे लगता है कि यह भविष्य के अजगर संस्करणों (2.7.3 और 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())परीक्षा:
a = A()
a.test_class_func_name()
test_func_name()आउटपुट:
test_class_func_name
test_func_nameमुझे यकीन नहीं है कि लोग इसे जटिल क्यों बनाते हैं:
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()आईडीई में कोड आउटपुट
हैलो, मैं फू हूं, डैडी है
हैलो, मैं बार हूँ, डैडी फू है
हैलो, मैं बार हूँ, डैडी है
आप एक डेकोरेटर का उपयोग कर सकते हैं:
def my_function(name=None):
return name
def get_function_name(function):
return function(name=function.__name__)
>>> get_function_name(my_function)
'my_function'__name__एक फ़ंक्शन की विशेषता को प्राप्त करने के लिए एक जटिल तरीके की तरह दिखता है । उपयोग के लिए उस चीज़ को जानना आवश्यक है जिसे आप प्राप्त करने की कोशिश कर रहे हैं, जो मुझे साधारण मामलों में बहुत उपयोगी नहीं लगती है जहाँ फ़ंक्शंस को मक्खी पर परिभाषित नहीं किया गया है।
मैं अपने स्वयं के दृष्टिकोण का उपयोग कई विरासत परिदृश्य के अंदर सुरक्षा के साथ सुपर को कॉल करने के लिए करता हूं (मैंने सभी कोड डाल दिए हैं)
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नमूना उपयोग:
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)()इसका परीक्षण:
a = C()
a.test()उत्पादन:
called from C
called from A
called from Bप्रत्येक @with_name सजाया विधि के अंदर आप वर्तमान समारोह के नाम के रूप में स्वयं .__ fname__ तक पहुंच रखते हैं।
मैंने हाल ही में उस फ़ंक्शन के संदर्भ से किसी फ़ंक्शन के डॉकस्ट्रिंग तक पहुंचने के लिए उपरोक्त उत्तरों का उपयोग करने की कोशिश की, लेकिन जैसा कि उपरोक्त प्रश्न केवल नाम स्ट्रिंग लौटा रहे थे, यह काम नहीं करता था।
सौभाग्य से मुझे एक सरल समाधान मिला। अगर मेरी तरह, आप फ़ंक्शन को संदर्भित करना चाहते हैं, तो केवल उस स्ट्रिंग का नाम प्राप्त करें, जिसे आप फ़ंक्शन नाम के स्ट्रिंग में eval () लागू कर सकते हैं।
import sys
def foo():
"""foo docstring"""
print(eval(sys._getframe().f_code.co_name).__doc__)मेरा सुझाव है कि स्टैक तत्वों पर भरोसा न करें। यदि कोई आपके कोड का उपयोग विभिन्न संदर्भों (उदाहरण के लिए अजगर इंटरप्रेटर) के भीतर करता है, तो आपका स्टैक बदल जाएगा और आपके सूचकांक को तोड़ देगा ([0] [3])।
मैं आपको कुछ इस तरह का सुझाव देता हूं:
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')यह एक डेकोरेटर के साथ पूरा करने के लिए बहुत आसान है।
>>> 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')
traceback। जवाब और टिप्पणियों का समय भी नहीं लगता है।