8

我在 python 2.7 中使用嵌套的类似 JSON 的数据结构，我与一些外国 perl 代码交换。我只想以更 Pythonic 的方式“使用”这些列表和字典的嵌套结构。

所以如果我有这样的结构......

a = {
    'x': 4,
    'y': [2, 3, { 'a': 55, 'b': 66 }],
}

...我希望能够在 python 脚本中处理它，就好像它是嵌套的 python 类/结构一样，如下所示：

>>> aa = j2p(a)  # <<- this is what I'm after.
>>> print aa.x
4
>>> aa.z = 99
>>> print a
{
    'x': 4,
    'y': [2, 3, { 'a': 55, 'b': 66 }],
    'z': 99
}

>>> aa.y[2].b = 999

>>> print a
{
    'x': 4,
    'y': [2, 3, { 'a': 55, 'b': 999 }],
    'z': 99
}

因此 aa 是原始结构的代理。这是我迄今为止提出的，受到优秀的什么是 Python 中的元类的启发？问题。

def j2p(x):
    """j2p creates a pythonic interface to nested arrays and
    dictionaries, as returned by json readers.

    >>> a = { 'x':[5,8], 'y':5}
    >>> aa = j2p(a)
    >>> aa.y=7
    >>> print a
    {'x': [5, 8], 'y':7}
    >>> aa.x[1]=99
    >>> print a
    {'x': [5, 99], 'y':7}

    >>> aa.x[0] = {'g':5, 'h':9}
    >>> print a
    {'x': [ {'g':5, 'h':9} , 99], 'y':7}
    >>> print aa.x[0].g
    5
    """
    if isinstance(x, list):
        return _list_proxy(x)
    elif isinstance(x, dict):
        return _dict_proxy(x)
    else:
        return x

class _list_proxy(object):
    def __init__(self, proxied_list):
        object.__setattr__(self, 'data', proxied_list)
    def __getitem__(self, a):
        return j2p(object.__getattribute__(self, 'data').__getitem__(a))
    def __setitem__(self, a, v):
        return object.__getattribute__(self, 'data').__setitem__(a, v)


class _dict_proxy(_list_proxy):
    def __init__(self, proxied_dict):
        _list_proxy.__init__(self, proxied_dict)
    def __getattribute__(self, a):
        return j2p(object.__getattribute__(self, 'data').__getitem__(a))
    def __setattr__(self, a, v):
        return object.__getattribute__(self, 'data').__setitem__(a, v)


def p2j(x):
    """p2j gives back the underlying json-ic json-ic nested
    dictionary/list structure of an object or attribute created with
    j2p.
    """
    if isinstance(x, (_list_proxy, _dict_proxy)):
        return object.__getattribute__(x, 'data')
    else:
        return x

现在我想知道是否有一种优雅的方式来映射一整套__*__特殊功能，比如__iter__，__delitem__？所以我不需要p2j()仅仅使用迭代或做其他pythonic的东西来打开东西。

# today:
for i in p2j(aa.y):
     print i
# would like to...
for i in aa.y:
     print i
4

3 回答 3

13

我认为你让这变得比它需要的更复杂。如果我理解正确，您需要做的就是：

import json

class Struct(dict):
    def __getattr__(self, name):
        return self[name]

    def __setattr__(self, name, value):
        self[name] = value

    def __delattr__(self, name):
        del self[name]

j = '{"y": [2, 3, {"a": 55, "b": 66}], "x": 4}'

aa = json.loads(j, object_hook=Struct)

for i in aa.y:
    print(i)

加载 JSON 时，该object_hook参数允许您指定一个可调用对象来处理它加载的对象。我刚刚用它把字典变成了一个对象，允许属性访问它的键。文档

于 2012-04-05T11:51:59.560 回答
4

有一个 attrdict 库以一种非常安全的方式做到这一点，但如果你愿意，这个答案中给出了一种快速而肮脏（可能泄漏内存）的方法：

class AttrDict(dict):
    def __init__(self, *args, **kwargs):
        super(AttrDict, self).__init__(*args, **kwargs)
        self.__dict__ = self

j = '{"y": [2, 3, {"a": 55, "b": 66}], "x": 4}'
aa = json.loads(j, object_hook=AttrDict)
于 2014-08-14T22:29:21.570 回答
1

我找到了答案： 故意没有办法自动映射 python 中的特殊方法，使用__getattribute__. 因此，为了实现我想要的，我需要__len__一个接一个地明确定义所有特殊方法。

于 2012-04-17T11:25:01.717 回答