सभी परिभाषित चर देखकर

Question

मैं वर्तमान में पायथन खोल में गणना पर काम कर रहा हूं। जो मैं चाहता हूं वह मैटलैब शैली सूची है जहां आप एक बिंदु तक परिभाषित सभी चर देख सकते हैं (इसलिए मुझे पता है कि मैंने कौन से नामों का उपयोग किया है, उनके मूल्य और ऐसे)।

क्या कोई तरीका है, और मैं यह कैसे कर सकता हूं?

Answer 1

नाम प्राप्त करने के लिए:

for name in vars().keys(): 
    print(name) 

मूल्यों को प्राप्त करने के लिए:

for value in vars().values(): 
    print(value) 

वार्स() एक वैकल्पिक तर्क लेता जो वार्स एक वस्तु के भीतर ही परिभाषित कर रहे हैं पता लगाने के लिए।

Answer 2

प्रिंट स्थानीय लोगों()

संपादित टिप्पणी से जारी रखा।

जब मुद्रण यह एक छोटे खूबसूरत लग रही करने के लिए:

import sys, pprint 
sys.displayhook = pprint.pprint 
locals() 

कि आप एक अधिक ऊर्ध्वाधर प्रिंटआउट देना चाहिए।

Answer 3

चीजों की युगल आप इस्तेमाल कर सकते हैं:

globals() आप वैश्विक चर का एक शब्दकोश

locals() आप का एक शब्दकोश दे देंगे दे देंगे:

• dir() आप गुंजाइश चर में की सूची दे देंगे स्थानीय चर

Answer 4

ग्लोबल्स(), स्थानीय(), vars(), और dir() सभी आपकी इच्छित चीज़ों में आपकी सहायता कर सकते हैं।

Answer 5

ध्यान में रखें डीआईआर() सभी मौजूदा आयात, और चर वापस कर देगा।

अगर आप सिर्फ अपने चर चाहते हैं, मैं एक नामकरण योजना इस तरह के varScore, varNames, आदि

के रूप में, dir से निकालने के लिए उस तरह से आसान है कि सुझाव है, तो आप बस यह कर सकते हैं:

for vars in dir(): 
if vars.startswith("var"): 
    print vars 

संपादित

आप सभी चर सूची, लेकिन इस तरह के रूप में आयात मॉड्यूल और चर बाहर करना चाहते हैं:

__builtins__ 

तुम इतनी तरह कुछ का उपयोग कर सकते हैं:

import os 
import re 

x = 11 
imports = "os","re" 

for vars in dir(): 
    if vars.startswith("__") == 0 and vars not in imports: 
     print vars 

जैसा कि आप देख सकते हैं, यह, चर "आयात" दिखाने हालांकि, क्योंकि यह एक चर (अच्छी तरह से, एक टपल) है जाएगा। एक त्वरित कामकाज आयात में "आयात" शब्द को जोड़ना है!

Answer 6

यह आपके लिए एक विकल्प है, तो आप IPython को देखने के लिए चाहते हो सकता है:

सभी वर्तमान में परिभाषित चर की एक सूची प्राप्त करने के लिए, प्रकार who:

In [1]: foo = 'bar' 

In [2]: who 
foo 

आप और अधिक के लिए whos टाइप कर सकते हैं विवरण:

In [3]: whos 
Variable Type Data/Info 
---------------------------- 
foo  str  bar 

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

आप कुछ ही मिनटों है, तो बाहर Jeff Rush's excellent IPython demonstration screencasts:

मैं टीम के साथ जुड़े किसी भी तरह से कर रहा हूँ की जाँच आईपीथॉन के पीछे, बस एक संतुष्ट उपयोगकर्ता।

Answer 7

def MyWho(): 
    print [v for v in globals().keys() if not v.startswith('_')] 

इसे इंटरैक्टिव खोल में परिभाषित किया जाना है।

आयात ओएस, एक = 10, आयात सिस, MyWho() तो

देता है [, 'एक', 'MyWho', 'सिस' 'ओएस']

Answer 8

में थोड़ा और अधिक स्मार्ट (अजगर 3) रास्ता:

def printvars(): 

    tmp = globals().copy() 
    [print(k,' : ',v,' type:' , type(v)) for k,v in tmp.items() if not k.startswith('_') and k!='tmp' and k!='In' and k!='Out' and not hasattr(v, '__call__')] 

Answer 9

मेरी अजगर 2.7 दुभाषिया में, एक ही whos आदेश है कि मौजूद है MATLAB अजगर में मौजूद है। यह MATLAB एनालॉग (चर नाम, प्रकार, और मूल्य/डेटा) के समान विवरण दिखाता है।

पायथन दुभाषिया में, whos "इंटरैक्टिव नेमस्पेस" में सभी चर सूचीबद्ध करता है।

Answer 10

RedBlueThing के रूप में और एनालॉग ने कहा:

• dir()
• globals() वैश्विक चर
• locals() का एक शब्दकोश देता गुंजाइश चर में की एक सूची देता है स्थानीय चर का एक शब्दकोश देता

चर बनाने के बाद इंटरैक्टिव शैल (संस्करण 2.6.9) का उपयोग करना a = 1 और b = 2, dir() चल

['__builtins__', '__doc__', '__name__', '__package__', 'a', 'b'] 

चल locals()

{'a': 1, 'b': 2, '__builtins__': <module '__builtin__' (built-in)>, '__package__': None, '__name__': '__main__', '__doc__': None} 

globals() वास्तव में इस मामले में locals() रूप में एक ही जवाब देता है चल रहा है देता है देता है।

मुझे किसी भी मॉड्यूल में नहीं मिला है, इसलिए सभी चर स्थानीय और वैश्विक दोनों चर के रूप में उपलब्ध हैं।locals() और globals() चर के साथ-साथ नामों के मूल्यों को सूचीबद्ध करें; dir() केवल नाम सूचीबद्ध करता है।

यदि मैं मॉड्यूल के अंदर एक मॉड्यूल आयात करता हूं और locals() या globals() चलाता हूं, तो dir() अभी भी केवल कुछ ही चर देता है; यह ऊपर सूचीबद्ध चर के लिए __file__ जोड़ता है। locals() और globals() भी वही चर सूचीबद्ध करते हैं, लेकिन __builtin__ के लिए शब्दकोश मान को प्रिंट करने की प्रक्रिया में, यह चर की एक बड़ी संख्या सूचीबद्ध करता है: अंतर्निहित फ़ंक्शंस, अपवाद और प्रकार जैसे कि 'type': <type 'type'> " ऊपर दिखाए गए अनुसार <module '__builtin__' (built-in)> संक्षिप्त करें।

dir() के बारे में अधिक जानकारी के लिए Python 2.7 quick reference न्यू मेक्सिको टेक या the dir() function पर ibiblio.org पर देखें।

locals() और globals() अधिक के बारे में के लिए गोता में अजगर और न्यू मैक्सिको टेक में globals बारे में एक पृष्ठ पर locals and globals देखते हैं।

[टिप्पणी: @ कर्ट: आपने enumerate-or-list-all-variables-in-a-program-of-your-favorite-language-here पर एक लिंक दिया है लेकिन उस उत्तर में इसकी कोई गलती है। समस्या यह है कि उस उदाहरण में type(name) हमेशा <type 'str'> लौटाएगा। आपको वेरिएबल की एक सूची मिलती है, जो प्रश्न का उत्तर देती है, लेकिन उनके बगल में सूचीबद्ध गलत प्रकारों के साथ। यह आपके उदाहरण में स्पष्ट नहीं था क्योंकि सभी चर किसी भी तरह तारों के साथ हुआ; हालांकि, यह वापस लौटने वाला चर के प्रकार के बजाय चर के नाम का प्रकार है। इसे ठीक करने के लिए: print type(name) के बजाय print eval('type(' + name + ')') का उपयोग करें। मैं उत्तर अनुभाग में एक टिप्पणी पोस्ट करने के लिए क्षमा चाहता हूं लेकिन मेरे पास टिप्पणी पोस्टिंग विशेषाधिकार नहीं हैं, और दूसरा प्रश्न बंद है।]