পাইথনে, tracebackমডিউলটি ব্যবহার না করে , সেই ফাংশনের মধ্যে থেকেই কোনও ফাংশনের নাম নির্ধারণ করার কোনও উপায় আছে?
বলুন আমার একটি ফাংশন বার সহ একটি মডিউল ফু আছে। কার্যকর করার সময় foo.bar(), বারের নাম জানার জন্য কি কোনও উপায় আছে? বা আরও ভাল, foo.barএর নাম?
#foo.py
def bar():
print "my name is", __myname__ # <== how do I calculate this at runtime?
উত্তর:
পাইথনের ক্রিয়াকলাপটি অ্যাক্সেস করতে বা তার নামটির মধ্যেই এর বৈশিষ্ট্য নেই। এটি প্রস্তাবিত হলেও প্রত্যাখ্যান করা হয়েছে । আপনি যদি স্ট্যাকটি নিজে খেলতে না চান তবে আপনার উচিত হয় ব্যবহার করা উচিত "bar"বা bar.__name__প্রসঙ্গে on
প্রদত্ত প্রত্যাখ্যান বিজ্ঞপ্তিটি হ'ল:
এই পিইপি প্রত্যাখ্যান করা হয়। এটি কীভাবে বাস্তবায়ন করা উচিত বা প্রান্তের ক্ষেত্রে সুনির্দিষ্ট শব্দার্থকগুলি কী হওয়া উচিত তা পরিষ্কার নয়, এবং যথেষ্ট গুরুত্বপূর্ণ ব্যবহারের কেস দেওয়া হয়নি। প্রতিক্রিয়া সেরা এলোমেলো হয়েছে।
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 এর সাথে তুলনাযোগ্য (যদিও অ্যান্টনি হ্যাচকিন্স অপশন 4 এর চেয়ে তিনগুণ দ্রুত বিকল্প পেয়েছে)।
sys._getframe().f_code.co_nameউপর inspect.currentframe().f_code.co_nameকারণ আমি ইতিমধ্যে আমদানি করেছি sysমডিউল। এটা কি যুক্তিসঙ্গত সিদ্ধান্ত? (গতি বিবেচনা করে বেশ অনুরূপ প্রদর্শিত হয়)
আপনি নামটি পেতে পারেন যে এটি @ আন্দ্রেয়াস জং দেখায় এমন পদ্ধতির সাহায্যে সংজ্ঞায়িত হয়েছিল তবে ফাংশনটি যে নামটির সাথে ডাকা হয়েছিল এটি সেই নাম নাও হতে পারে:
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__। আপনি নতুন পরামিতি হিসাবে ফাংশনটিতে ফান .__ নাম__ পাস করতে পারেন। ফানক (* আরগস, ** কোয়ার্গস, আমার_নাম = ফানক __ নাম__)। আপনার ফাংশনটির অভ্যন্তর থেকে আপনার সাজসজ্জার নাম পেতে, আমি মনে করি এটির জন্য পরিদর্শন করা প্রয়োজন। তবে ফাংশনটির নামটি আমার চলমান ফাংশনটির মধ্যে আমার ফাংশনটিকে নিয়ন্ত্রণ করছে ... ভাল যে এটি কেবল একটি সুন্দর
এটি আসলে প্রশ্নের অন্যান্য উত্তর থেকে প্রাপ্ত।
এখানে আমার গ্রহণ:
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ইন্সপেক্ট.স্ট্যাক () ব্যবহার করে এই সংস্করণটির সম্ভবত সম্ভাব্য সুবিধাটি হ'ল এটি কয়েক হাজারগুণ দ্রুত হওয়া উচিত [অ্যালেক্স মেলিহফের পোস্ট এবং সাইন._জেটফ্রেম () বনাম ইন্সপেক্ট.স্ট্যাক () ব্যবহার করে সম্পর্কিত সময়গুলি]।
print(inspect.stack()[0].function) মনে হচ্ছে এটিও কাজ করে (পাইথন 3.5) 3.5
এখানে একটি ভবিষ্যত-প্রমাণ পদ্ধতির।
@ রোশঅক্সিমারনের স্বীকৃত উত্তরের সাথে @ ক্যামহার্ট এবং @ ইউভালের পরামর্শগুলি একত্রিত করার এড়ানোর সুবিধা রয়েছে:
_hidden এবং সম্ভাব্য হ্রাস পদ্ধতিসুতরাং আমি মনে করি এটি ভবিষ্যতের অজগর সংস্করণগুলির সাথে দুর্দান্ত খেলছে (২.7.৩ এবং ৩.৩.২ এ পরীক্ষিত):
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। এমনকি উত্তর এবং মন্তব্যের সময়গুলিও এর পিছনে ফিরে আসে বলে মনে হয় না।