වස්තුවක වර්තමාන ගුණාංග සහ අගයන් මුද්‍රණය කිරීම සඳහා සාදන ලද ශ්‍රිතයක් තිබේද?

ඉතින් මම මෙහි සොයන්නේ PHP හි print_r ශ්‍රිතය වැනි දෙයක් .

ප්‍රශ්නයක් ඇති වස්තුවේ තත්වය කුමක්දැයි බැලීමෙන් මට මගේ පිටපත් නිදොස්කරණය කළ හැකිය.

ඔබ සැබවින්ම වෙනස් කරුණු දෙකක් එකට මිශ්‍ර කරයි.

භාවිතය 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__'}

ඔබට මෙය vars()මිශ්‍ර කිරීමට අවශ්‍යයි pprint():

from pprint import pprint
pprint(vars(your_object))

def dump(obj):
  for attr in dir(obj):
    print("obj.%s = %r" % (attr, getattr(obj, attr)))

තෙවන පාර්ශවීය කාර්යයන් බොහෝමයක් ඇත, ඒවායේ කර්තෘවරුන්ගේ මනාපයන් අනුව ව්‍යතිරේක හැසිරවීම, ජාතික / විශේෂ අක්ෂර මුද්‍රණය, කැදැලි වස්තූන් වෙත පුනරාවර්තනය කිරීම වැනි දෑ එකතු වේ. නමුත් ඔවුන් සියල්ලන්ම මූලික වශයෙන් මේ සඳහා තම්බා ගනී.

dir සඳහන් කර ඇත, නමුත් එය ඔබට ලබා දෙන්නේ ගුණාංගවල නම් පමණි. ඔබට ඒවායේ අගයන් අවශ්‍ය නම් __dict__ උත්සාහ කරන්න.

class O:
   def __init__ (self):
      self.value = 3

o = O()

ප්‍රතිදානය මෙන්න:

>>> o.__dict__

{'value': 3}

මෙය සිදු කිරීම සඳහා ඔබට "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__ක්‍රම. සිට Python ප්රලේඛනය :

__repr__(self)repr()වස්තුවක “නිල” නූල් නිරූපණය ගණනය කිරීම සඳහා සාදන ලද ශ්‍රිතය සහ නූල් පරිවර්තනයන් (ප්‍රතිලෝම උපුටා දැක්වීම්) මගින් කැඳවනු ලැබේ . හැකි නම්, මෙය වලංගු පයිතන් ප්‍රකාශනයක් මෙන් විය යුතු අතර එය එකම වටිනාකමක් ඇති වස්තුවක් ප්‍රතිනිර්මාණය කිරීමට භාවිතා කළ හැකිය (සුදුසු පරිසරයක් ලබා දී ඇත). මෙය කළ නොහැකි නම්, "<... ප්‍රයෝජනවත් විස්තරයක් ...>" ආකෘතියේ නූලක් ආපසු ලබා දිය යුතුය. ප්‍රතිලාභ අගය නූල් වස්තුවක් විය යුතුය. පංතියක් repr () නිර්වචනය කළත් එසේ නොවේ __str__()නම්__repr__() එම පන්තියේ අවස්ථාවන්හි “අවිධිමත්” සංගීත නිරූපණයක් අවශ්‍ය වූ විට ද භාවිතා වේ. මෙය සාමාන්‍යයෙන් නිදොස්කරණය සඳහා භාවිතා කරයි, එබැවින් නිරූපණය තොරතුරු පොහොසත් හා නිසැක ය.

__str__(self)str()වස්තුවක “අවිධිමත්” නූල් නිරූපණය ගණනය කිරීම සඳහා සාදන ලද ශ්‍රිතය සහ මුද්‍රණ ප්‍රකාශය මගින් කැඳවනු ලැබේ . මෙය __repr__()වලංගු පයිතන් ප්‍රකාශනයක් විය යුතු බවට වඩා වෙනස් වේ : ඒ වෙනුවට වඩාත් පහසු හෝ සංක්ෂිප්ත නිරූපණයක් භාවිතා කළ හැකිය. ප්‍රතිලාභ අගය නූල් වස්තුවක් විය යුතුය.

පරීක්ෂා කිරීම වටී -

පර්ල්ගේ දත්ත :: ඩම්පර්ට සමාන පයිතන් තිබේද?

මගේ නිර්දේශය මෙයයි -

https://gist.github.com/1071857

පර්ල්හි දත්ත :: ඩම්පර් නමින් මොඩියුලයක් ඇති බව සලකන්න. එය වස්තු දත්ත නැවත පර්ල් ප්‍රභව කේතයට පරිවර්ථනය කරයි (සැ.යු: එය කේතය නැවත ප්‍රභවයට පරිවර්තනය නොකරයි, සෑම විටම පාහේ ප්‍රතිදානයේ වස්තු ක්‍රමය ක්‍රියාත්මක වීමට ඔබට අවශ්‍ය නැත). මෙය නොපසුබට උත්සාහය සඳහා භාවිතා කළ හැකි නමුත් පොදු අරමුණ නිදොස්කරණය සඳහා ය.

සම්මත පයිතන් මුද්‍රණය සාක්ෂාත් කර ගැනීමට අපොහොසත් වන කරුණු ගණනාවක් තිබේ, විශේෂයෙන් එය වස්තුවක නිදසුනක් දුටු විට බැසයාම නවත්වන අතර වස්තුවේ අභ්‍යන්තර හෙක්ස් දර්ශකය ඔබට ලබා දෙයි (වැරදියි, එම දර්ශකය භාවිතා කිරීමෙන් විශාල ප්‍රමාණයක් නොවේ මාර්ගය). කෙටියෙන් කිවහොත්, පයිතන් යනු මෙම ශ්‍රේෂ් object වස්තු දිශානත ආදර්ශයයි, නමුත් ඔබ කොටුවෙන් පිටතට ගන්නා මෙවලම් නිර්මාණය කර ඇත්තේ වස්තූන් හැර වෙනත් දෙයක් සමඟ වැඩ කිරීම සඳහා ය.

පර්ල් දත්ත :: ඩම්පර් ඔබට කොපමණ ගැඹුරට යා යුතුද යන්න පාලනය කිරීමට ඉඩ ලබා දෙන අතර රවුම් සම්බන්ධිත ව්‍යුහයන්ද හඳුනා ගනී (එය ඇත්තෙන්ම වැදගත්). මෙම ක්‍රියාවලිය පර්ල් වලින් සාක්ෂාත් කර ගැනීම පහසුය, මන්ද වස්තූන්ට ඔවුන්ගේ ආශිර්වාදයෙන් ඔබ්බට විශේෂිත මැජික් නොමැති නිසාය (විශ්වීයව මනාව අර්ථ දක්වා ඇති ක්‍රියාවලියක්).

භාවිතා කිරීමට මම නිර්දේශ කරමි 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__.

වස්තුවක වර්තමාන ගුණාංග සහ අගයන් මුද්‍රණය කිරීම සඳහා සාදන ලද ශ්‍රිතයක් තිබේද?

නැත. වඩාත්ම උඩු යටිකුරු කරන ලද පිළිතුර සමහර වර්ගවල ගුණාංග බැහැර කරන අතර පිළිගත් පිළිතුර මඟින් ක්‍රම සහ පොදු නොවන API හි කොටස් ඇතුළුව සියලු ගුණාංග ලබා ගන්නේ කෙසේද යන්න පෙන්වයි . නමුත් මේ සඳහා හොඳ සම්පුර්ණ බිල්ඩින් ශ්‍රිතයක් නොමැත.

එබැවින් කෙටි සහසම්බන්ධය නම් ඔබට ඔබේම දෑ ලිවිය හැකි නමුත් එය පොදු API හි කොටසක් වන දේපල සහ වෙනත් ගණනය කළ දත්ත විස්තර කරන්නන් ගණනය කරනු ඇති අතර ඔබට එය අවශ්‍ය නොවනු ඇත:

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__අතර එය පිටපතක් නොවේ, එබැවින් ඔබ වර්ස් විසින් ආපසු ලබා දුන් ආ ict __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, අදහස් දැක්වීමේදී සඳහන් කර ඇති ආකාරයටම දෝෂ සහිතය - එය සියලු නම් සහ අගයන් ලබා දෙයි.

පන්තියේ සිට

උගන්වන විට මගේ සිසුන්ට වස්තුවක අර්ථකථන පොදු API සපයන ශ්‍රිතයක් නිර්මාණය කර ඇත:

def api(obj):
    return [name for name in dir(obj) if name[0] != '_']

වස්තුවක අර්ථකථන නාම අවකාශයේ පිටපතක් සැපයීම සඳහා අපට මෙය දීර් extend කළ හැකිය , නමුත් __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)}

දැන් අපි දේපල ගණනය කිරීම හෝ පෙන්වීම සිදු නොකරමු, quux:

>>> attrs(obj)
{'bar': 0, 'baz': 'baz', 'foo': ''}

ගුහා

නමුත් සමහර විට අපි දන්නවා අපේ දේපල මිල අධික නොවන බව. ඒවා ඇතුළත් කිරීම සඳහා තර්කනය වෙනස් කිරීමට අපට අවශ්‍ය විය හැකිය. සමහර විට අපට ඒ වෙනුවට වෙනත් අභිරුචි දත්ත විස්තර කරන්නන් බැහැර කිරීමට අවශ්‍ය වනු ඇත .

එවිට අපි මෙම ශ්‍රිතය තවදුරටත් අභිරුචිකරණය කළ යුතුය. ඒ නිසා අපට අවශ්‍ය දේ ඉන්ද්‍රජාලිකව දන්නා සහ එය සපයන බිල්ට් ශ්‍රිතයක් අපට තිබිය නොහැකි බව එයින් හැඟේ. මෙය අප විසින්ම නිර්මාණය කළ යුතු ක්‍රියාකාරිත්වයයි.

නිගමනය

මෙය සිදු කරන කිසිදු කාර්යයක් නොමැති අතර, ඔබේ තත්වයට වඩාත් අර්ථාන්විතව සුදුසු දේ ඔබ කළ යුතුය.

බොහෝ අවස්ථාවන්හීදී, ඔබට අවශ්‍ය තොරතුරු භාවිතා කිරීම __dict__හෝ dir()ලබා ගැනීම. ඔබ වැඩි විස්තර අවශ්ය සිදු කල යුතු නම්, සම්මත පුස්තකාලය ඇතුළත් පරීක්ෂා ඔබ විස්තර මනරම් ප්රමාණය ලබා ගැනීමට ඉඩ මොඩියුලය. තොරතුරු වල සැබෑ නවකතාවලට ඇතුළත් වන්නේ:

• ශ්‍රිතයේ නම් සහ ක්‍රම පරාමිතීන්
• පන්ති ධූරාවලිය
• ශ්‍රිත / පන්ති වස්තු ක්‍රියාත්මක කිරීමේ ප්‍රභව කේතය
• රාමු වස්තුවකින් දේශීය විචල්යයන්

ඔබ සොයන්නේ නම් "කුමක් විශේෂණය වටිනාකම් මගේ වස්තුව කුමක්ද?", එවිට dir()හා __dict__බොහෝ විට ප්රමාණවත් වේ. ඔබ අත්තනෝමතික වස්තූන්ගේ වර්තමාන තත්වය හාරා බැලීමට සැබවින්ම උත්සාහ කරන්නේ නම් (පයිතන්හි සෑම දෙයක්ම පාහේ වස්තුවක් බව මතක තබා ගන්න), එවිට inspectසලකා බැලීම වටී.

රූපක උදාහරණය මැජික් සමඟ වස්තුව දමන්න :

$ cat dump.py

#!/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

තර්ක නොමැතිව:

$ python dump.py

<__main__.Data instance at 0x00A052D8>

Gnosis Utils සමඟ :

y python dump.py 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))

Pppretty උත්සාහ කරන්න

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)

from pprint import pprint

def print_r(the_object):
    print ("CLASS: ", the_object.__class__.__name__, " (BASE CLASS: ", the_object.__class__.__bases__,")")
    pprint(vars(the_object))

මෙය සියලු වස්තු අන්තර්ගතයන් පුනරාවර්තව json හෝ yaml indented ආකෘතියෙන් මුද්‍රණය කරයි:

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__ක්‍රමවේදයක් ක්‍රියාත්මක කිරීමට සිදු විය හැකිය , නැතහොත් වෙනත් විසඳුම් කිහිපයක් උත්සාහ කරන්න. තෙවන පාර්ශවීය පුස්තකාල නොමැතිව, සෑම අවස්ථාවකම ක්‍රියාත්මක වන සරල දෙයක් සොයා ගැනීමට මම තවමත් කැමතියි.

මට සමහර ලොග් වල DEBUG තොරතුරු මුද්‍රණය කිරීමට අවශ්‍ය වූ අතර එය බිඳ දැමිය හැකි බැවින් මුද්‍රණය භාවිතා කිරීමට නොහැකි විය. ඒ වෙනුවට මම මෙය කළ අතර පාහේ එකම දේ ලබා ගත්තා.

DO = DemoObject()

itemDir = DO.__dict__

for i in itemDir:
    print '{0}  :  {1}'.format(i, itemDir[i])

"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_util.default නොමැතිව json.dumps () බොහෝ වස්තු සඳහා ක්‍රියා කරනු ඇතැයි මම සිතමි, නමුත් මට වස්තුව තුළ දිවා කාල ක්ෂේත්‍රයක් ඇති බැවින් සම්මත json අනුක්‍රමිකකරණය අසමත් විය. පයිතන්හි "datetime.datetime JSON අනුක්‍රමික නොවේ" ජය ගන්නේ කෙසේදැයි බලන්න.

සරල දෙයක් නොවන්නේ ඇයි:

for key,value in obj.__dict__.iteritems():
    print key,value

ඔබේ දත්ත ව්‍යුහයන්ගේ සෞන්දර්යාත්මක ප්‍රසන්න නිරූපණයන් නිෂ්පාදනය කිරීම සඳහා “ලස්සන මුද්‍රණ යන්ත්‍රයක්” pprint හි අඩංගු වේ. පරිවර්තකයා විසින් නිවැරදිව විග්‍රහ කළ හැකි දත්ත ව්‍යුහයන්ගේ නිරූපණයන් ආකෘතිකරණය මඟින් නිපදවන අතර මිනිසෙකුට කියවීමට පහසුය. ප්‍රතිදානය හැකි නම් තනි පේළියක තබා ඇති අතර බහු පේළි හරහා බෙදී ගිය විට ඉන්ඩෙන්ට් කර ඇත.

බීප්රින්ට් උත්සාහ කරන්න .

එය ඔබට වස්තු විචල්‍යයන් මුද්‍රණය කිරීමට පමණක් නොව, අලංකාර නිමැවුමටද උපකාරී වනු ඇත:

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))

ඔබට Flask Debug Toolbar උත්සාහ කළ හැකිය.
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)}