जवाबों:
आप वास्तव में दो अलग-अलग चीजों को एक साथ मिला रहे हैं।
उपयोग करें dir(), vars()या inspectमॉड्यूल जो आप में रुचि रखते हैं पाने के लिए (मैं __builtins__एक उदाहरण के रूप में उपयोग करता हूं ; आप इसके बजाय किसी भी वस्तु का उपयोग कर सकते हैं)।
>>> l = dir(__builtins__)
>>> d = __builtins__.__dict__उस शब्दकोश को प्रिंट करें जिसे आप पसंद करते हैं:
>>> print l
['ArithmeticError', 'AssertionError', 'AttributeError',...या
>>> from pprint import pprint
>>> pprint(l)
['ArithmeticError',
'AssertionError',
'AttributeError',
'BaseException',
'DeprecationWarning',
...
>>> pprint(d, indent=2)
{ 'ArithmeticError': <type 'exceptions.ArithmeticError'>,
'AssertionError': <type 'exceptions.AssertionError'>,
'AttributeError': <type 'exceptions.AttributeError'>,
...
'_': [ 'ArithmeticError',
'AssertionError',
'AttributeError',
'BaseException',
'DeprecationWarning',
...एक कमांड के रूप में सुंदर डिबेट इंटरएक्टिव डिबगर में भी उपलब्ध है:
(Pdb) pp vars()
{'__builtins__': {'ArithmeticError': <type 'exceptions.ArithmeticError'>,
'AssertionError': <type 'exceptions.AssertionError'>,
'AttributeError': <type 'exceptions.AttributeError'>,
'BaseException': <type 'exceptions.BaseException'>,
'BufferError': <type 'exceptions.BufferError'>,
...
'zip': <built-in function zip>},
'__file__': 'pass.py',
'__name__': '__main__'}print re.compile(r'slots').search('No slots here either.').__slots__
inspectअपने उत्तर में मॉड्यूल के बारे में अधिक बात क्यों नहीं करते ? मुझे लगता है कि यह print_r या var_dump की निकटतम चीज़ है।
dir()? dir()केवल नामों की एक सूची देता है, और उन सभी में मौजूद नहीं है vars()या __dict__विशेषता में है।
आप के vars()साथ मिश्रित करना चाहते हैं pprint():
from pprint import pprint
pprint(vars(your_object))vars()बस __dict__अपनी दलील पर वापस लौटता है और dir()अगर कोई __dir__विधि नहीं है तो यह भी है। तो dir()पहली जगह में उपयोग करें , जैसा कि मैंने कहा।
dir()आपको उन सभी चीजों को देता है जिन्हें आप शायद पसंद नहीं करते हैं __str__और __new__। var()ऐसा नहीं करता।
__dict__विशेषता नहीं है ।
def dump(obj):
for attr in dir(obj):
print("obj.%s = %r" % (attr, getattr(obj, attr)))वहाँ कई 3-पार्टी फ़ंक्शंस हैं जो अपने लेखकों की वरीयताओं के अनुसार अपवाद हैंडलिंग, राष्ट्रीय / विशेष चरित्र मुद्रण, नेस्टेड ऑब्जेक्ट्स में पुनरावर्तन आदि चीजें जोड़ते हैं। लेकिन वे सभी मूल रूप से इसके लिए उबलते हैं।
getmembers()मानक inspectमॉड्यूल में फ़ंक्शन का उपयोग कर सकते हैं , लेकिन मुझे लगा कि यह अधिक उपयोगी होगा कि यह दिखाता है कि सामान्य रूप से आत्मनिरीक्षण कैसे किया जाए।
__dict__(जैसे __doc__और __module__) में नहीं पाए जाते हैं । इसके अलावा, __dict__घोषित वस्तुओं के लिए बिल्कुल भी काम नहीं करता है __slots__। सामान्य तौर पर, __dict__उपयोगकर्ता-स्तरीय गुण दिखाता है जो वास्तव में आंतरिक रूप से एक शब्दकोश में संग्रहीत होते हैं। dir () अधिक दिखाता है।
__dict__विशेषता / सदस्य नहीं होता है । मुझे पता है कि यह पागल है, लेकिन सच है। जैसे अंतर्निहित इन की intऔर strया re.MatchObjectरों सामान्य उदाहरण हैं। कोशिश करो 'hello'.__dict__, फिर कोशिश करोdir('hello')
dir का उल्लेख किया गया है, लेकिन यह आपको केवल विशेषताओं के नाम देगा। यदि आप उनके मूल्यों के साथ-साथ __dict__ भी चाहते हैं।
class O:
def __init__ (self):
self.value = 3
o = O()यहाँ उत्पादन है:
>>> o.__dict__
{'value': 3}setनहीं है __dict__, इसलिए उनके लिए यह असफल होगाAttributeError: 'set' object has no attribute '__dict__'
आप ऐसा करने के लिए "dir ()" फ़ंक्शन का उपयोग कर सकते हैं।
>>> import sys
>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__name__', '__stderr__', '__stdin__', '__stdo
t__', '_current_frames', '_getframe', 'api_version', 'argv', 'builtin_module_names', 'byteorder
, 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle', 'exc_clear', 'exc_info'
'exc_type', 'excepthook', 'exec_prefix', 'executable', 'exit', 'getcheckinterval', 'getdefault
ncoding', 'getfilesystemencoding', 'getrecursionlimit', 'getrefcount', 'getwindowsversion', 'he
version', 'maxint', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_
ache', 'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setprofile', 'setrecursionlimit
, 'settrace', 'stderr', 'stdin', 'stdout', 'subversion', 'version', 'version_info', 'warnoption
', 'winver']
>>>एक अन्य उपयोगी सुविधा मदद है।
>>> help(sys)
Help on built-in module sys:
NAME
sys
FILE
(built-in)
MODULE DOCS
http://www.python.org/doc/current/lib/module-sys.html
DESCRIPTION
This module provides access to some objects used or maintained by the
interpreter and to functions that interact strongly with the interpreter.
Dynamic objects:
argv -- command line arguments; argv[0] is the script pathname if knownऑब्जेक्ट की वर्तमान स्थिति को प्रिंट करने के लिए आप निम्न कर सकते हैं:
>>> obj # in an interpreterया
print repr(obj) # in a scriptया
print objअपनी कक्षाओं के लिए परिभाषित __str__या __repr__तरीके। से अजगर प्रलेखन :
__repr__(self)repr()अंतर्निहित फ़ंक्शन द्वारा और किसी वस्तु के "आधिकारिक" स्ट्रिंग प्रतिनिधित्व की गणना करने के लिए स्ट्रिंग रूपांतरण (रिवर्स उद्धरण) द्वारा कहा जाता है । यदि संभव हो तो, यह एक वैध पायथन अभिव्यक्ति की तरह दिखना चाहिए जिसका उपयोग किसी वस्तु को उसी मूल्य (एक उपयुक्त वातावरण दिया गया) को फिर से बनाने के लिए किया जा सकता है। यदि यह संभव नहीं है, तो फॉर्म का एक तार "<... कुछ उपयोगी विवरण ...>" लौटाया जाना चाहिए। वापसी मान एक स्ट्रिंग ऑब्जेक्ट होना चाहिए। यदि कोई वर्ग repr () को परिभाषित करता है__str__(), लेकिन तब__repr__()भी प्रयोग नहीं किया जाता है, जब उस वर्ग के उदाहरणों के "अनौपचारिक" स्ट्रिंग प्रतिनिधित्व की आवश्यकता होती है। यह आमतौर पर डिबगिंग के लिए उपयोग किया जाता है, इसलिए यह महत्वपूर्ण है कि प्रतिनिधित्व सूचना-समृद्ध और असंदिग्ध हो।
__str__(self)str()अंतर्निहित फ़ंक्शन द्वारा और किसी वस्तु के "अनौपचारिक" स्ट्रिंग प्रतिनिधित्व की गणना करने के लिए प्रिंट स्टेटमेंट द्वारा कहा जाता है । यह इस बात से भिन्न__repr__()है कि इसमें एक मान्य पायथन अभिव्यक्ति नहीं है: इसके बजाय अधिक सुविधाजनक या संक्षिप्त प्रतिनिधित्व का उपयोग किया जा सकता है। वापसी मान एक स्ट्रिंग ऑब्जेक्ट होना चाहिए।
print "DEBUG: object value: " + repr(obj)
हो सकता है इसे देखना महंगा न पड़े --
क्या पर्ल के डेटा के बराबर एक पायथन है :: डम्पर?
मेरी सिफारिश यह है -
https://gist.github.com/1071857
ध्यान दें कि पर्ल में डेटा :: डम्पर नामक एक मॉड्यूल होता है, जो ऑब्जेक्ट डेटा को perl सोर्स कोड में वापस ट्रांसलेट करता है (NB: यह कोड को सोर्स में वापस ट्रांसलेट नहीं करता है, और लगभग हमेशा आप आउटपुट में ऑब्जेक्ट मेथड फ़ंक्शन को नहीं चाहते हैं)। यह दृढ़ता के लिए इस्तेमाल किया जा सकता है, लेकिन आम उद्देश्य डिबगिंग के लिए है।
कई चीजें हैं मानक पायथन पाइंट हासिल करने में विफल रहता है, विशेष रूप से यह बस अवरोही बंद हो जाता है जब यह एक वस्तु का उदाहरण देखता है और आपको ऑब्जेक्ट का आंतरिक हेक्स पॉइंटर देता है (इर्र, वह सूचक पूरी तरह से उपयोग नहीं होता है) रास्ता)। तो संक्षेप में, अजगर इस महान ऑब्जेक्ट ओरिएंटेड प्रतिमान के बारे में है, लेकिन जो उपकरण आपको बॉक्स से बाहर निकलते हैं, उन्हें ऑब्जेक्ट्स के अलावा किसी अन्य चीज़ के साथ काम करने के लिए डिज़ाइन किया गया है।
पर्ल डेटा :: डम्पर आपको नियंत्रित करने की अनुमति देता है कि आप कितनी गहराई तक जाना चाहते हैं, और परिपत्र जुड़े संरचनाओं का भी पता लगाता है (यह वास्तव में महत्वपूर्ण है)। यह प्रक्रिया मूल रूप से पर्ल में हासिल करना आसान है क्योंकि वस्तुओं का उनके आशीर्वाद (एक सार्वभौमिक रूप से अच्छी तरह से परिभाषित प्रक्रिया) से परे कोई विशेष जादू नहीं है।
मैं उपयोग करने की सलाह देता हूं help(your_object)।
help(dir)
If called without an argument, return the names in the current scope. Else, return an alphabetized list of names comprising (some of) the attributes of the given object, and of attributes reachable from it. If the object supplies a method named __dir__, it will be used; otherwise the default dir() logic is used and returns: for a module object: the module's attributes. for a class object: its attributes, and recursively the attributes of its bases. for any other object: its attributes, its class's attributes, and recursively the attributes of its class's base classes.
help(vars)
Without arguments, equivalent to locals(). With an argument, equivalent to object.__dict__.
ज्यादातर मामलों में, आपके द्वारा वांछित जानकारी का उपयोग __dict__या dir()प्राप्त करेंगे। यदि आपको अधिक विवरण की आवश्यकता होती है, तो मानक पुस्तकालय में निरीक्षण मॉड्यूल शामिल होता है, जो आपको कुछ प्रभावशाली राशि प्राप्त करने की अनुमति देता है। जानकारी के कुछ वास्तविक नामों में शामिल हैं:
यदि आप सिर्फ "क्या विशेषता मान मेरी वस्तु है?" के लिए देख रहे हैं, तो dir()और __dict__शायद पर्याप्त हैं। यदि आप वास्तव में मनमानी वस्तुओं की वर्तमान स्थिति में खुदाई करना चाहते हैं (ध्यान में रखते हुए कि अजगर में लगभग सब कुछ एक वस्तु है), तो inspectविचार के योग्य है।
क्या किसी वस्तु के सभी वर्तमान गुणों और मूल्यों को प्रिंट करने के लिए एक अंतर्निहित फ़ंक्शन है?
नहीं। सबसे अधिक उत्तर दिया गया उत्तर कुछ प्रकार की विशेषताओं को बाहर करता है, और स्वीकृत उत्तर दिखाता है कि सभी विशेषताओं को कैसे प्राप्त किया जाए , जिसमें गैर-सार्वजनिक एपि के तरीके और भाग शामिल हैं। लेकिन इसके लिए कोई अच्छा पूर्ण बिल्टइन फ़ंक्शन नहीं है।
इसलिए छोटी कोरोलरी यह है कि आप अपना स्वयं का लिख सकते हैं, लेकिन यह संपत्तियों और अन्य गणना किए गए डेटा-डिस्क्रिप्टर की गणना करेगा जो सार्वजनिक एपीआई का हिस्सा हैं, और आप ऐसा नहीं चाहते हैं:
from pprint import pprint
from inspect import getmembers
from types import FunctionType
def attributes(obj):
disallowed_names = {
name for name, value in getmembers(type(obj))
if isinstance(value, FunctionType)}
return {
name: getattr(obj, name) for name in dir(obj)
if name[0] != '_' and name not in disallowed_names and hasattr(obj, name)}
def print_attributes(obj):
pprint(attributes(obj))विभिन्न प्रकार के डेटा सदस्यों के एक वर्ग के साथ वर्तमान में शीर्ष मतदान वाले उत्तर के आवेदन का निरीक्षण करें:
from pprint import pprint
class Obj:
__slots__ = 'foo', 'bar', '__dict__'
def __init__(self, baz):
self.foo = ''
self.bar = 0
self.baz = baz
@property
def quux(self):
return self.foo * self.bar
obj = Obj('baz')
pprint(vars(obj))केवल प्रिंट:
{'baz': 'baz'}क्योंकि vars केवल__dict__ एक वस्तु वापस आती है , और यह एक प्रति नहीं है, इसलिए यदि आप वेरिए द्वारा लौटाए गए हुक्म को संशोधित करते हैं, तो आप __dict__स्वयं वस्तु को संशोधित कर रहे हैं ।
vars(obj)['quux'] = 'WHAT?!'
vars(obj)रिटर्न:
{'baz': 'baz', 'quux': 'WHAT?!'}- जो बुरा है क्योंकि क्वक्स एक ऐसी संपत्ति है जिसे हमें स्थापित नहीं करना चाहिए और नामस्थान में नहीं होना चाहिए ...
वर्तमान में स्वीकृत उत्तर (और अन्य) में सलाह को लागू करना ज्यादा बेहतर नहीं है:
>>> dir(obj)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__slots__', '__str__', '__subclasshook__', 'bar', 'baz', 'foo', 'quux']जैसा कि हम देख सकते हैं, dirकेवल एक वस्तु से जुड़े नामों के सभी (वास्तव में सिर्फ सबसे) वापस करता है।
inspect.getmembersटिप्पणियों में उल्लिखित, समान रूप से त्रुटिपूर्ण है - यह सभी नामों और मूल्यों को लौटाता है ।
पढ़ाने के दौरान मेरे पास मेरे छात्र एक ऐसा कार्य करते हैं जो किसी वस्तु का शब्दार्थ सार्वजनिक एपीआई प्रदान करता है:
def api(obj):
return [name for name in dir(obj) if name[0] != '_']हम किसी वस्तु के शब्दार्थ नाम स्थान की एक प्रति प्रदान करने के लिए इसका विस्तार कर सकते हैं , लेकिन हमें __slots__यह निर्दिष्ट करने की आवश्यकता नहीं है कि हमें असाइन नहीं किया गया है, और यदि हम "वर्तमान गुणों" के लिए अनुरोध को गंभीरता से ले रहे हैं, तो हमें गणना किए गए गुणों को बाहर करने की आवश्यकता है (जैसा कि) वे महंगे हो सकते हैं, और "वर्तमान" नहीं के रूप में व्याख्या की जा सकती है:)
from types import FunctionType
from inspect import getmembers
def attrs(obj):
disallowed_properties = {
name for name, value in getmembers(type(obj))
if isinstance(value, (property, FunctionType))}
return {
name: getattr(obj, name) for name in api(obj)
if name not in disallowed_properties and hasattr(obj, name)}और अब हम संपत्ति की गणना या प्रदर्शन नहीं करते हैं:
>>> attrs(obj)
{'bar': 0, 'baz': 'baz', 'foo': ''}लेकिन शायद हम जानते हैं कि हमारे गुण महंगे नहीं हैं। हम उन्हें भी शामिल करने के लिए तर्क को बदलना चाहते हैं। और शायद हम इसके बजाय अन्य कस्टम डेटा डिस्क्रिप्टर को बाहर करना चाहते हैं ।
फिर हमें इस फ़ंक्शन को और अनुकूलित करने की आवश्यकता है। और इसलिए यह समझ में आता है कि हमारे पास एक अंतर्निहित फ़ंक्शन नहीं हो सकता है जो जादुई रूप से वास्तव में जानता है कि हम क्या चाहते हैं और इसे प्रदान करते हैं। यह कार्यशीलता है जिसे हमें स्वयं बनाने की आवश्यकता है।
कोई अंतर्निहित फ़ंक्शन नहीं है जो ऐसा करता है, और आपको वह करना चाहिए जो आपकी स्थिति के लिए सबसे उपयुक्त है।
FunctionType। लेकिन बहुत मददगार - धन्यवाद!
जादू के साथ एक मेटाप्रोग्रामिंग उदाहरण डंप ऑब्जेक्ट :
$ बिल्ली डंपडोम
#!/usr/bin/python
import sys
if len(sys.argv) > 2:
module, metaklass = sys.argv[1:3]
m = __import__(module, globals(), locals(), [metaklass])
__metaclass__ = getattr(m, metaklass)
class Data:
def __init__(self):
self.num = 38
self.lst = ['a','b','c']
self.str = 'spam'
dumps = lambda self: repr(self)
__str__ = lambda self: self.dumps()
data = Data()
print dataतर्क के बिना:
$ अजगर डंप-थ्रू
<__main__.Data instance at 0x00A052D8>सूक्ति बर्तन के साथ :
$ अजगर डंपडोम gnosis.magic MetaXMLPickler
<?xml version="1.0"?>
<!DOCTYPE PyObject SYSTEM "PyObjects.dtd">
<PyObject module="__main__" class="Data" id="11038416">
<attr name="lst" type="list" id="11196136" >
<item type="string" value="a" />
<item type="string" value="b" />
<item type="string" value="c" />
</attr>
<attr name="num" type="numeric" value="38" />
<attr name="str" type="string" value="spam" />
</PyObject>यह थोड़ा पुराना है लेकिन फिर भी काम कर रहा है।
यदि आप डिबगिंग के लिए इसका उपयोग कर रहे हैं, और आप बस हर चीज का एक पुनरावर्ती डंप चाहते हैं, तो स्वीकृत उत्तर असंतोषजनक है क्योंकि इसके लिए आवश्यक है कि आपकी कक्षाओं में __str__पहले से ही अच्छा कार्यान्वयन हो। अगर ऐसा नहीं है, तो यह बेहतर काम करता है:
import json
print(json.dumps(YOUR_OBJECT,
default=lambda obj: vars(obj),
indent=1))TypeError: vars() argument must have __dict__ attribute
कोशिश ppretty
from ppretty import ppretty
class A(object):
s = 5
def __init__(self):
self._p = 8
@property
def foo(self):
return range(10)
print ppretty(A(), show_protected=True, show_static=True, show_properties=True)आउटपुट:
__main__.A(_p = 8, foo = [0, 1, ..., 8, 9], s = 5)यह सभी वस्तु सामग्रियों को पुन: मुद्रित करता है, जो कि json या yaml इंडेंट फॉर्मेट में हैं:
import jsonpickle # pip install jsonpickle
import json
import yaml # pip install pyyaml
serialized = jsonpickle.encode(obj, max_depth=2) # max_depth is optional
print json.dumps(json.loads(serialized), indent=4)
print yaml.dump(yaml.load(serialized), indent=4)मैंने उस उत्तर को उकेरा है जिसमें केवल पदचिह्न का उल्लेख है। स्पष्ट होने के लिए, यदि आप एक जटिल डेटा संरचना के सभी मूल्यों को देखना चाहते हैं , तो कुछ ऐसा करें:
from pprint import pprint
pprint(my_var)जहाँ my_var आपकी रुचि का चर है। जब मैंने उपयोग किया तो pprint(vars(my_var))मुझे कुछ नहीं मिला, और यहाँ अन्य उत्तर मदद नहीं करते थे या विधि अनावश्यक रूप से लंबी लगती थी। वैसे, मेरे विशेष मामले में, जिस कोड का मैं निरीक्षण कर रहा था, उसमें शब्दकोशों का एक शब्दकोश था।
इस बात की ओर इशारा करते हुए कि कुछ कस्टम क्लासेस से आप अनचाहे <someobject.ExampleClass object at 0x7f739267f400>तरह के आउटपुट के साथ समाप्त हो सकते हैं । उस स्थिति में, आपको एक __str__विधि को लागू करना पड़ सकता है , या कुछ अन्य समाधानों की कोशिश कर सकते हैं। मैं अभी भी कुछ सरल ढूंढना चाहता हूं जो सभी परिदृश्यों में काम करता है, तीसरे पक्ष के पुस्तकालयों के बिना।
"MyObject" को डंप करने के लिए:
from bson import json_util
import json
print(json.dumps(myObject, default=json_util.default, sort_keys=True, indent=4, separators=(',', ': ')))मैंने vars () और dir () की कोशिश की; दोनों उस चीज के लिए असफल रहे जिसकी मुझे तलाश थी। vars () ने काम नहीं किया, क्योंकि ऑब्जेक्ट में __dict__ (अपवाद नहीं है। टाइप करें: vars () तर्क में __dict__ विशेषता होना चाहिए)। dir () वह नहीं था जो मैं देख रहा था: यह केवल फ़ील्ड नामों की एक सूची है, मान या ऑब्जेक्ट संरचना नहीं देता है।
मुझे लगता है कि json.dumps () डिफ़ॉल्ट के बिना अधिकांश ऑब्जेक्ट्स के लिए काम करेगा = json_util.default, लेकिन मेरे पास ऑब्जेक्ट में एक डेटाइम फ़ील्ड था, इसलिए मानक json क्रमांक विफल रहा। देखें कि अजगर में "डेटाइम लाइफटाइम नहीं JSON अनुक्रमिक" कैसे पार करें?
कुछ सरल क्यों नहीं:
for key,value in obj.__dict__.iteritems():
print key,valuefor key,value in obj.__dict__.iteritems(): print key,value?
pprint में आपके डेटा स्ट्रक्चर्स के सौंदर्यप्रद मनभावन अभ्यावेदन के निर्माण के लिए "सुंदर प्रिंटर" होता है। फ़ॉर्मेटर डेटा संरचनाओं का प्रतिनिधित्व करता है जो दुभाषिया द्वारा सही ढंग से पार्स किया जा सकता है, और मानव के लिए पढ़ना भी आसान है। आउटपुट को एक लाइन पर रखा जाता है, यदि संभव हो, और कई लाइनों में विभाजित होने पर इंडेंट किया जाता है।
बस beeprint की कोशिश करो ।
यह आपको न केवल मुद्रण ऑब्जेक्ट चर के साथ, बल्कि सुंदर आउटपुट के साथ भी मदद करेगा:
class(NormalClassNewStyle):
dicts: {
},
lists: [],
static_props: 1,
tupl: (1, 2)हर कोई संघर्ष कर रहा है
vars() सभी विशेषताओं को वापस नहीं। dir() विशेषताओं के मूल्यों को वापस नहीं।निम्नलिखित कोड उनके मूल्यों के साथ सभी विशेषताओं को प्रिंट objकरता है:
for attr in dir(obj):
try:
print("obj.{} = {}".format(attr, getattr(obj, attr)))
except AttributeError:
print("obj.{} = ?".format(attr))आप फ्लास्क डीबग टूलबार आज़मा सकते हैं।
https://pypi.python.org/pypi/Flask-DebugToolbar
from flask import Flask
from flask_debugtoolbar import DebugToolbarExtension
app = Flask(__name__)
# the toolbar is only enabled in debug mode:
app.debug = True
# set a 'SECRET_KEY' to enable the Flask session cookies
app.config['SECRET_KEY'] = '<replace with a secret key>'
toolbar = DebugToolbarExtension(app)मुझे पायथन ऑब्जेक्ट बिल्ट-इन टाइप कुंजियों या मूल्यों के साथ काम करना पसंद है ।
विशेषताओं के लिए भले ही वे तरीके या चर हों:
o.keys()उन विशेषताओं के मूल्यों के लिए:
o.values()इससे कोई फर्क नहीं पड़ता कि आपके वैरिएबल को __init__ के अंदर या बाहर किसी वर्ग में कैसे परिभाषित किया जाता है।
your_obj = YourObj()
attrs_with_value = {attr: getattr(your_obj, attr) for attr in dir(your_obj)}
__dict__सदस्य (re.MatchObjectउदाहरण के लिए) नहीं है, लेकिन बिलिनdir()सभी वस्तुओं के लिए काम करता है।