एक स्ट्रिंग के रूप में एक चर का नाम प्राप्त करना

Question

यह धागा चर्चा करता है कि पायथन में स्ट्रिंग के रूप में किसी फ़ंक्शन का नाम कैसे प्राप्त करें : स्ट्रिंग के रूप में फ़ंक्शन नाम कैसे प्राप्त करें?

मैं चर के लिए समान कैसे कर सकता हूं? कार्यों के विपरीत, पायथन चरों की __name__विशेषता नहीं है ।

दूसरे शब्दों में, अगर मेरे पास एक चर है जैसे:

foo = dict()
foo['bar'] = 2

मैं एक समारोह / विशेषता, जैसे रहा हूँ retrieve_name()क्रम में इस सूची से पांडा में एक DataFrame बनाने , जहां स्तंभ नाम वास्तविक शब्दकोशों के नाम से दिए गए हैं:

# List of dictionaries for my DataFrame
list_of_dicts = [n_jobs, users, queues, priorities]
columns = [retrieve_name(d) for d in list_of_dicts] 

Answer 1

python-varnameपैकेज का उपयोग करके , आप चर का नाम आसानी से प्राप्त कर सकते हैं

https://github.com/pwwang/python-varname

आपके मामले में, आप यह कर सकते हैं:

from varname import Wrapper

foo = Wrapper(dict())

# foo.name == 'foo'
# foo.value == {}
foo.value['bar'] = 2

या आप चर नाम को सीधे प्राप्त करने का भी प्रयास कर सकते हैं:

from varname import nameof

foo = dict()

fooname = nameof(foo)
# fooname == 'foo'

मैं इस पैकेज का लेखक हूं। कृपया मुझे बताएं कि क्या आपका कोई प्रश्न है या आप गितुब पर मुद्दे प्रस्तुत कर सकते हैं।

Comments

ठीक है, आखिरकार मिल गया! निम्नलिखित का उपयोग करके स्थापित pip3 install python-varname==0.1.5; आयातित का उपयोग करfrom varname import nameof

— enter_display_name_here

किसी तरह फंक्शन लूप में काम नहीं करता है: test = {} print(varname.nameof(test)) for i in [0]: print(varname.nameof(test))पहला प्रिंट देता है test, लूप में प्रिंट उठता हैVarnameRetrievingError: Callee's node cannot be detected.

— टिल्लस

@ टिलुस फिक्स्डv0.2.0

— पैवेन वैंग जूल

Answer 2

पायथन में एकमात्र वस्तुएं जिसमें कैनोनिकल नाम हैं, मॉड्यूल, फ़ंक्शंस और क्लासेस हैं, और निश्चित रूप से इस बात की कोई गारंटी नहीं है कि फ़ंक्शन या क्लास के परिभाषित होने या आयात किए गए मॉड्यूल के बाद इस कैनोनिकल नाम का किसी भी नामस्थान में कोई अर्थ है। वस्तुओं के बनने के बाद इन नामों को भी संशोधित किया जा सकता है, इसलिए वे हमेशा विशेष रूप से भरोसेमंद नहीं हो सकते हैं।

आप जो करना चाहते हैं वह नामांकित वस्तुओं के पेड़ पर पुनरावृत्ति के बिना संभव नहीं है ; एक नाम एक वस्तु के लिए एक तरह से संदर्भ है। एक आम या बगीचे-किस्म के पायथन ऑब्जेक्ट में इसके नामों का कोई संदर्भ नहीं है। कल्पना करें कि हर पूर्णांक, प्रत्येक तानाशाह, प्रत्येक सूची, प्रत्येक बूलियन को उन नामों की सूची को बनाए रखने के लिए आवश्यक है जो इसे संदर्भित नामों का प्रतिनिधित्व करते हैं! यह एक कार्यान्वयन दुःस्वप्न होगा, जिसमें प्रोग्रामर को बहुत कम लाभ होगा।

Comments

धन्यवाद। लेकिन पायथन ऐसा कार्यों के लिए क्यों करता है? (अर्थात एक प्रकार की पायथन वस्तुएं)

— एमिलियो वाज़केज़-रीना

@ मानव: मॉड्यूल मत भूलना: वे भी विहित नाम है। इसके अलावा, यह मत भूलो कि __name__हमेशा संशोधित किया जा सकता है, जिसका अर्थ है कि "विहित" नाम एक ऐसा नाम नहीं हो सकता है जिसका उपयोग ऑब्जेक्ट प्राप्त करने के लिए किया जा सकता है (उदाहरण के लिए गतिशील रूप से कक्षाएं बनाते समय)।

— nnonneo

जैसा कि @ scohe001 ने दिखाया है आपका कथन "यह केवल संभव नहीं है" गलत है । पायथन का चर नाम डेटाबेस किसी अन्य संबंधपरक डीबी की तरह है, आप हमेशा "रिवर्स" में संबंधित वस्तुओं की खोज कर सकते हैं और किसी भी दिए गए चर के लिए पहले पाए गए या मान्य चर नामों के पूरे सेट को वापस कर सकते हैं।

— होब्स

@ हब्स आप तकनीकी रूप से सही हैं ... सबसे सही तरह का। व्यवहार में, हालांकि, किसी वस्तु के लिए कई संभावित नाम हैं कि उन्हें पाने के लिए प्रयास करने की तुलना में यह अधिक परेशानी की बात है।

— किंडल

@ मानव मुझे लगता है कि आप सही हैं यदि आपकी "इसके लायक" सीमा ओ (1) है। scohe001 का लूप O (N) होगा।

— हॉब्स

Answer 3

यहां तक ​​कि अगर चर मान नाम पर वापस नहीं आते हैं, तो आपके पास प्रत्येक असाइन किए गए चर की सूची और उसके मूल्य तक पहुंच है, इसलिए मुझे आश्चर्य है कि केवल एक व्यक्ति ने आपके संस्करण का नाम देखने के लिए वहां से लूपिंग का सुझाव दिया है।

उस उत्तर पर किसी ने उल्लेख किया है कि आपको स्टैक पर चलना पड़ सकता है और खोजने के लिए हर किसी के स्थानीय और ग्लोबल्स की जांच कर सकते हैं foo, लेकिन यदि fooआप इस retrieve_nameफ़ंक्शन को उस दायरे में असाइन किया गया है, जहां आप उपयोग कर सकते हैं inspect।current frame आप उन स्थानीय चर के सभी प्राप्त करने के लिए ।

मेरी व्याख्या थोड़ी बहुत चिंताजनक हो सकती है (हो सकता है कि मुझे "फू" कम शब्दों का उपयोग करना चाहिए), लेकिन यहां यह कोड में कैसा दिखेगा ( ध्यान दें कि यदि एक से अधिक चर एक ही मान को सौंपा गया है, तो आप करेंगे उन दोनों चर नामों को प्राप्त करें ):

import inspect

x,y,z = 1,2,3

def retrieve_name(var):
    callers_local_vars = inspect.currentframe().f_back.f_locals.items()
    return [var_name for var_name, var_val in callers_local_vars if var_val is var]

print retrieve_name(y)

---

यदि आप इस फ़ंक्शन को किसी अन्य फ़ंक्शन से कॉल कर रहे हैं, तो कुछ इस तरह है:

def foo(bar):
    return retrieve_name(bar)

foo(baz)

और आप bazइसके बजाय चाहते हैं bar, आपको बस आगे एक गुंजाइश वापस जाने की आवश्यकता होगी। यह आरंभीकरण .f_backमें एक अतिरिक्त जोड़कर किया जा सकता है caller_local_vars।

यहाँ एक उदाहरण देखें: ideone

Comments

@theodox मैं बिल्कुल सहमत हैं, के रूप में यह शायद के साथ कार्य करेगा import hooks, ironpythonऔरjython

— scohe001

यह काम नहीं करेगा। परमाणु चर का एक विशेषता के रूप में उनका नाम नहीं है। तो अगर आपके पास a, b = 2, 2, retrieve_name(a)और retrieve_name(b)दोनों को वापसी ['a', 'b']या['b', 'a']

— टॉमस

@tomas वास्तव में, यह cPython के अनुकूलन का एक कार्यान्वयन विवरण है जिसमें 255 से नीचे पूर्णांक मूल रूप से एकल हैं, इसलिए किसी भी चर को निर्दिष्ट किए गए मान प्रभावी रूप से तुलना के trueलिए वापस आ जाएंगेis

— Toote

क्या इसका कोई मॉड पास किया गया नाम है? उदा। def foo(bar): retrieve_name(bar)हमेशा बार वापस आ जाएगा, लेकिन क्या होगा यदि आप foo(baz)वापस लौटना चाहते हैं baz) के बजाय bar?

— सुमिरोनॉन

@SumNeuron आपको बस उस लाइन को संशोधित callers_local_varsकरना होगा जो एक स्कोप को आगे पीछे करने के लिए असाइन करता है इसलिए यह जो भी कॉल कर रहा है उसके स्कोप को देखेगा foo। होने के लिए लाइन बदलें inspect.currentframe().f_back.f_back.f_locals.items()(अतिरिक्त नोटिस करें f_back)।

— scohe001

Answer 4

पायथॉन 3.8 के साथ एक बस एफ-स्ट्रिंग डिबगिंग सुविधा का उपयोग कर सकते हैं:

>>> foo = dict()
>>> f'{foo=}'.split('=')[0]
'foo' 

Comments

अच्छा लगा! और बस अगर आप किसी वस्तु के बदले एक संपत्ति का नाम लेना चाहते हैंf'{foo=}'.split('=')[0].split('.')[-1]

— मिकेल वी।

Answer 5

Python3 पर, इस फ़ंक्शन को स्टैक में बाहरी सबसे अधिक नाम मिलेगा:

import inspect


def retrieve_name(var):
        """
        Gets the name of var. Does it from the out most frame inner-wards.
        :param var: variable to get name from.
        :return: string
        """
        for fi in reversed(inspect.stack()):
            names = [var_name for var_name, var_val in fi.frame.f_locals.items() if var_val is var]
            if len(names) > 0:
                return names[0]

यह कोड पर कहीं भी उपयोगी है। पहले मैच की तलाश में उलटे हुए ढेर को ट्रेस करता है।

Comments

अच्छी नौकरी! हालांकि मैं कोशिश retrieve_name(SomeClass.some_attribute)करता हूं कि यह काम न करे। क्या आप उस पर और मदद कर सकते हैं?

— नाम जी वीयू

यह बूलियन चर के साथ संघर्ष करता है। मैं अंत मेंstop_on_error

— SumNeuron

Answer 6

मुझे विश्वास नहीं होता कि यह संभव है। निम्नलिखित उदाहरण पर विचार करें:

>>> a = []
>>> b = a
>>> id(a)
140031712435664
>>> id(b)
140031712435664

एक ही वस्तु की aऔर bइशारा करते हैं, लेकिन वस्तु यह नहीं जान सकती कि चर किस बिंदु पर हैं।

Comments

निश्चित रूप से संदर्भ की गिनती को बढ़ाकर रिश्ते को दो तरफा बनाया जा सकता है । यह उत्तर (और कुछ अन्य) भी एक कार्यान्वयन प्रदान करता है।

— शयन

Answer 7

def name(**variables):
    return [x for x in variables]

यह इस तरह प्रयोग किया जाता है:

name(variable=variable)

Comments

यह वांछित चर का नाम नहीं लौटाएगा, लेकिन "चर"। उदाहरण के लिए - का उपयोग कर name(variable=variable)इच्छा उत्पादन ['variable'], और का उपयोग कर name(variable=another_variable)होगा नहीं उत्पादन ['another_variable']बल्कि ['variable']।

— दलाली

वास्तव में यह उम्मीद के मुताबिक काम करता है। आपको बस अपने वेरिएबल के साथ दोनों «वैरिएबल» को बदलना होगा। यह पहले चर के नाम की एक स्ट्रिंग के साथ एक-तत्व सूची लौटाएगा । उदाहरण के लिए: >>> a = [] >>> b = a >>> name(a=b) ['a'] >>> name(b=a) ['b']`

— अलगेम मेगुला

Answer 8

यहाँ एक दृष्टिकोण है। मैं इसके लिए कुछ भी महत्वपूर्ण नहीं सुझाऊंगा, क्योंकि यह काफी भंगुर होगा। लेकिन यह किया जा सकता है।

एक फ़ंक्शन बनाएं inspectजो स्रोत कोड को खोजने के लिए मॉड्यूल का उपयोग करता है जो इसे कहते हैं। फिर आप उन चर नामों की पहचान करने के लिए स्रोत कोड को पार्स कर सकते हैं जिन्हें आप पुनः प्राप्त करना चाहते हैं। उदाहरण के लिए, यहां एक फ़ंक्शन कहा जाता है autodictजो चर की एक सूची लेता है और उनके मूल्यों के लिए एक शब्दकोश मानचित्रण चर नाम देता है। उदाहरण के लिए:

x = 'foo'
y = 'bar'
d = autodict(x, y)
print d

देना होगा:

{'x': 'foo', 'y': 'bar'}

स्रोत कोड का निरीक्षण करना स्वयं को खोजने के माध्यम से बेहतर है locals()या globals()क्योंकि उत्तरार्द्ध दृष्टिकोण आपको यह नहीं बताता है कि आप कौन से चर चाहते हैं।

किसी भी दर पर, यहाँ कोड है:

def autodict(*args):
    get_rid_of = ['autodict(', ',', ')', '\n']
    calling_code = inspect.getouterframes(inspect.currentframe())[1][4][0]
    calling_code = calling_code[calling_code.index('autodict'):]
    for garbage in get_rid_of:
        calling_code = calling_code.replace(garbage, '')
    var_names, var_values = calling_code.split(), args
    dyn_dict = {var_name: var_value for var_name, var_value in
                zip(var_names, var_values)}
    return dyn_dict

कार्रवाई लाइन के साथ होती है inspect.getouterframes, जो उस कोड के भीतर स्ट्रिंग लौटाती है जिसे कहा जाता हैautodict ।

जादू के इस प्रकार के लिए स्पष्ट नकारात्मक पहलू यह है कि यह इस बारे में धारणा बनाता है कि स्रोत कोड कैसे संरचित है। और निश्चित रूप से, अगर यह दुभाषिया के अंदर चलाया जाता है तो यह बिल्कुल भी काम नहीं करेगा।

Comments

नमस्कार, मेरे पास केवल तीन प्रश्न हैं: 1. "1" क्यों? 2. क्यों "4"? 3. क्यों "0"? :)

— पियोट वासिल्विक

Answer 9

मैंने इस तरह के जादू को जोरदार तरीके से करने के लिए पैकेज टोना लिखा । तुम लिख सकते हो:

from sorcery import dict_of

columns = dict_of(n_jobs, users, queues, priorities)

और डेटाफ़ॉर्म कंस्ट्रक्टर को पास करें। यह इसके बराबर है:

columns = dict(n_jobs=n_jobs, users=users, queues=queues, priorities=priorities)

Answer 10

>>> locals()['foo']
{}
>>> globals()['foo']
{}

यदि आप अपना स्वयं का कार्य लिखना चाहते हैं, तो यह ऐसा किया जा सकता है कि आप स्थानीय लोगों में परिभाषित एक चर की जांच कर सकते हैं, फिर ग्लोबल्स की जांच कर सकते हैं। यदि कुछ नहीं मिला है तो आप आईडी () पर तुलना कर सकते हैं यह देखने के लिए कि क्या चर स्मृति में उसी स्थान पर इंगित करता है।

यदि आपका चर एक वर्ग में है, तो आप className का उपयोग कर सकते हैं। dict .keys () या वार्स (स्वयं) अगर आपके चर परिभाषित किया गया है देखने के लिए।

Comments

क्या होगा अगर नाम एक कॉलर फ्रेम में है? तो फिर तुम ढेर चलने और सभी की जाँच की तरह मूर्खतापूर्ण बातें करना होगा localsऔर globals... और आप नाम गलत हो रही जोखिम अगर कोई वास्तव में मौजूद। यह बिना किसी वास्तविक उपयोगी लाभ के एक टन का काम है।

— nnonneo

पूरा सवाल मूर्खतापूर्ण है ... लेकिन अगर वह ऐसा कुछ करना चाहता है, तो यह संभव है। जहाँ तक अस्तित्व की जाँच करने के लिए आप ग्लोबल्स ()। सेटडफ़ॉल्ट (var, <new object of type (var)) का उपयोग तब कर सकते हैं जब कुछ भी न हो। मुझे बिल्कुल यकीन नहीं है कि वह इसके लिए क्या चाहता है, लेकिन शायद यह सीखकर कि चर को दायरे द्वारा रखा जाता है वह कुछ बेहतर समझ सकता है।

— ब्लेकवि

Answer 11

पायथन में, defऔर classकीवर्ड एक विशिष्ट नाम को उस वस्तु से बाँधेंगे जिसे वे परिभाषित करते हैं (फ़ंक्शन या वर्ग)। इसी तरह, मॉड्यूल को फ़ाइल सिस्टम में कुछ विशिष्ट कहे जाने के आधार पर एक नाम दिया जाता है। सभी तीन मामलों में, प्रश्न में ऑब्जेक्ट को "विहित" नाम निर्दिष्ट करने का एक स्पष्ट तरीका है।

हालाँकि, अन्य प्रकार की वस्तुओं के लिए, इस तरह के विहित नाम का कोई अस्तित्व नहीं है । उदाहरण के लिए, किसी सूची के तत्वों पर विचार करें। सूची में तत्वों को व्यक्तिगत रूप से नामित नहीं किया गया है, और यह पूरी तरह से संभव है कि किसी कार्यक्रम में उन्हें संदर्भित करने का एकमात्र तरीका सूची वाले सूचियों का उपयोग करके है। यदि इस तरह की वस्तुओं की सूची आपके फ़ंक्शन में दी गई थी, तो आप संभवतः मूल्यों को सार्थक पहचानकर्ता नहीं दे सकते हैं।

पायथन असाइन किए गए ऑब्जेक्ट में असाइनमेंट के बाएँ हाथ पर नाम नहीं बचाता है क्योंकि:

1. यह पता लगाने की आवश्यकता होगी कि कई परस्पर विरोधी वस्तुओं के बीच कौन सा नाम "विहित" था,
2. यह उन वस्तुओं के लिए कोई मतलब नहीं होगा जो एक स्पष्ट चर नाम को कभी नहीं सौंपे गए हैं,
3. यह बेहद अक्षम होगा,
4. वस्तुतः कोई अन्य भाषा अस्तित्व में नहीं है।

इसलिए, उदाहरण के लिए, परिभाषित फ़ंक्शन का उपयोग lambdaहमेशा <lambda>एक विशिष्ट फ़ंक्शन नाम के बजाय "नाम" होगा ।

सबसे अच्छा तरीका यह होगा कि कॉल करने वाले को नामों की सूची (वैकल्पिक) में पास करने के लिए कहा जाए। यदि टाइपिंग '...','...'बहुत बोझिल है, तो आप स्वीकार कर सकते हैं जैसे नामों की एक अल्पविराम से अलग सूची वाली एक स्ट्रिंग (जैसे namedtupleकरता है)।

Answer 12

>> my_var = 5
>> my_var_name = [ k for k,v in locals().items() if v == my_var][0]
>> my_var_name 
'my_var'

स्थानीय () - एक शब्दकोष जिसमें वर्तमान क्षेत्र के स्थानीय चर होते हैं। इस शब्दकोश के माध्यम से पुनरावृत्ति करके हम उस कुंजी की जांच कर सकते हैं जिसका मूल्य परिभाषित चर के बराबर है, बस कुंजी निकालने से हमें स्ट्रिंग प्रारूप में चर का पाठ मिलेगा।

से (थोड़े बदलाव के बाद) https://www.tutorialspoint.com/How-to-get-a-variable-name-as-a-string-in-Python

Answer 13

मुझे लगता है कि पाइथन में ऐसा करना बहुत मुश्किल है क्योंकि साधारण तथ्य यह है कि आप उस चर का नाम कभी नहीं जान पाएंगे जिसका आप उपयोग कर रहे हैं। तो, उनके उदाहरण में, आप कर सकते हैं:

के बजाय:

list_of_dicts = [n_jobs, users, queues, priorities]

dict_of_dicts = {"n_jobs" : n_jobs, "users" : users, "queues" : queues, "priorities" : priorities}

Answer 14

इनपुट चर की सामग्री के आधार पर ऐसा करने का दूसरा तरीका:

(यह पहले वैरिएबल का नाम देता है जो इनपुट वैरिएबल से मेल खाता है, अन्यथा कोई भी नहीं। कोई भी ऐसा परिवर्तन कर सकता है जो सभी वैरिएबल नाम को प्राप्त कर सके, जिसमें इनपुट वैरिएबल के समान सामग्री हो)

def retrieve_name(x, Vars=vars()):
    for k in Vars:
        if type(x) == type(Vars[k]):
            if x is Vars[k]:
                return k
    return None

Answer 15

यह फ़ंक्शन अपने मूल्य के साथ चर नाम प्रिंट करेगा:

import inspect

def print_this(var):
    callers_local_vars = inspect.currentframe().f_back.f_locals.items()
    print(str([k for k, v in callers_local_vars if v is var][0])+': '+str(var))

***Input & Function call:***
my_var = 10

print_this(my_var)

***Output**:*
my_var: 10

Answer 16

मेरे पास एक विधि है, और सबसे कुशल नहीं है ... यह काम करता है! (और इसमें कोई फैंसी मॉड्यूल शामिल नहीं है)।

मूल रूप से यह अपने तुलना चर की आईडी को वैश्विक () चर 'आईडी , तो मैच का नाम देता है।

def getVariableName(variable, globalVariables=globals().copy()):
    """ Get Variable Name as String by comparing its ID to globals() Variables' IDs

        args:
            variable(var): Variable to find name for (Obviously this variable has to exist)

        kwargs:
            globalVariables(dict): Copy of the globals() dict (Adding to Kwargs allows this function to work properly when imported from another .py)
    """
    for globalVariable in globalVariables:
        if id(variable) == id(globalVariables[globalVariable]): # If our Variable's ID matches this Global Variable's ID...
            return globalVariable # Return its name from the Globals() dict

Answer 17

यदि लक्ष्य आपको अपने चर का ट्रैक रखने में मदद करना है, तो आप एक साधारण फ़ंक्शन लिख सकते हैं जो चर को लेबल करता है और इसके मूल्य और प्रकार को लौटाता है। उदाहरण के लिए, मान लें कि i_f = 3.01 है और आप इसे एक पूर्णांक के लिए राउंड करते हैं, जिसे i_n कहा जाता है एक कोड में उपयोग करने के लिए, और फिर एक स्ट्रिंग i_s की आवश्यकता होती है जो एक रिपोर्ट में जाएगी।

def whatis(string, x):
    print(string+' value=',repr(x),type(x))
    return string+' value='+repr(x)+repr(type(x))
i_f=3.01
i_n=int(i_f)
i_s=str(i_n)
i_l=[i_f, i_n, i_s]
i_u=(i_f, i_n, i_s)

## make report that identifies all types
report='\n'+20*'#'+'\nThis is the report:\n'
report+= whatis('i_f ',i_f)+'\n'
report+=whatis('i_n ',i_n)+'\n'
report+=whatis('i_s ',i_s)+'\n'
report+=whatis('i_l ',i_l)+'\n'
report+=whatis('i_u ',i_u)+'\n'
print(report)

यह डीबगिंग उद्देश्यों के लिए प्रत्येक कॉल पर विंडो को प्रिंट करता है और लिखित रिपोर्ट के लिए एक स्ट्रिंग भी देता है। केवल नकारात्मक पक्ष यह है कि आपको हर बार फ़ंक्शन को कॉल करने के लिए चर को दो बार टाइप करना होगा।

मैं एक पायथन नौसिखिया हूं और मैंने अपने प्रयासों को कार्यक्रम के रूप में लॉग इन करने के लिए यह बहुत उपयोगी तरीका पाया और पायथन में सभी वस्तुओं के साथ सामना करने का प्रयास किया। एक दोष यह है कि यदि यह उस प्रक्रिया के बाहर वर्णित फ़ंक्शन को कॉल करता है जो इसका उपयोग किया जाता है, तो whatis () विफल रहता है। उदाहरण के लिए, int (i_f) केवल एक वैध फ़ंक्शन कॉल था क्योंकि int फ़ंक्शन पायथन के लिए जाना जाता है। आप whatis () को int (i_f ** 2) का उपयोग करके कॉल कर सकते हैं, लेकिन यदि किसी अजीब कारण से आप int_squared नामक फ़ंक्शन को परिभाषित करना चुनते हैं, तो इसे उस प्रक्रिया के अंदर घोषित किया जाना चाहिए जहां whatis () का उपयोग किया जाता है।

Answer 18

शायद यह उपयोगी हो सकता है:

def Retriever(bar):
    return (list(globals().keys()))[list(map(lambda x: id(x), list(globals().values()))).index(id(bar))]

फ़ंक्शन वैश्विक स्कोप से मानों की आईडी की सूची से गुजरता है (नाम स्थान संपादित किया जा सकता है), अपनी आईडी के आधार पर वांछित / आवश्यक संस्करण या फ़ंक्शन के सूचकांक का पता लगाता है, और फिर वैश्विक नामों की सूची से नाम लौटाता है अधिग्रहित सूचकांक पर।

Answer 19

निम्नलिखित विधि चर का नाम नहीं लौटाएगी लेकिन इस पद्धति का उपयोग करके आप आसानी से डेटा फ्रेम बना सकते हैं यदि चर वैश्विक दायरे में उपलब्ध है।

class CustomDict(dict):
    def __add__(self, other):
        return CustomDict({**self, **other})

class GlobalBase(type):
    def __getattr__(cls, key):
        return CustomDict({key: globals()[key]})

    def __getitem__(cls, keys):
        return CustomDict({key: globals()[key] for key in keys})

class G(metaclass=GlobalBase):
    pass

x, y, z = 0, 1, 2

print('method 1:', G['x', 'y', 'z']) # Outcome: method 1: {'x': 0, 'y': 1, 'z': 2}
print('method 2:', G.x + G.y + G.z) # Outcome: method 2: {'x': 0, 'y': 1, 'z': 2}

A = [0, 1]
B = [1, 2]
pd.DataFrame(G.A + G.B) # It will return a data frame with A and B columns

Answer 20

स्थिरांक के लिए, आप एक एनम का उपयोग कर सकते हैं, जो इसके नाम को पुनः प्राप्त करने का समर्थन करता है।

Answer 21

मैं स्थानीय लोगों के निरीक्षण से नाम प्राप्त करने की कोशिश करता हूं, लेकिन यह var पसंद नहीं कर सकता है [1], b.val। इसके बाद, मुझे एक नया विचार मिला --- कोड से var नाम प्राप्त करें, और मैं इसे करने की कोशिश करता हूं! नीचे दिए गए कोड की तरह:

#direct get from called function code
def retrieve_name_ex(var):
    stacks = inspect.stack()
    try:
        func = stacks[0].function
        code = stacks[1].code_context[0]
        s = code.index(func)
        s = code.index("(", s + len(func)) + 1
        e = code.index(")", s)
        return code[s:e].strip()
    except:
        return ""

Answer 22

आप अपने द्वारा परिभाषित किसी फ़ंक्शन का नाम प्राप्त करने के लिए निम्नलिखित प्रयास कर सकते हैं (हालांकि अंतर्निहित कार्यों के लिए काम नहीं करता है):

import re
def retrieve_name(func):
    return re.match("<function\s+(\w+)\s+at.*", str(func)).group(1)

def foo(x):
    return x**2

print(retrieve_name(foo))
# foo