Python标准库中的类JavaScript对象？

Question

很多时候，我发现自己想要一个简单的 Python 中的“转储”对象，它的行为类似于 JavaScript 对象（即，可以使用 .member 或 ['member'] 访问其成员）。

通常我会把它贴在.py的顶部：

class DumbObject(dict):
    def __getattr__(self, attr):
        return self[attr]
    def __stattr__(self, attr, value):
        self[attr] = value

但这有点蹩脚，而且该实现至少存在一个错误（虽然我不记得它是什么）。

那么，标准库中是否有类似的东西？

并且，为了记录，简单地实例化 object 是行不通的：

>>> 对象 = 对象（） >>> obj.airspeed = 42 回溯（最近一次通话最后）： 文件“”，第 1 行，在 AttributeError：“对象”对象没有属性“空速”

编辑：（该死，早该看到这个）……别担心！我不是想用 Python 编写 JavaScript。我最常发现我想要这个的地方是在我还在试验的时候：我收集了一些“东西”，放在字典里不太合适，但拥有自己的类也不合适.

Answer 1

在 Python 3.3+ 中，您可以使用 SimpleNamespace，它完全符合您的要求：

from types import SimpleNamespace
obj = SimpleNamespace()
obj.airspeed = 42

https://docs.python.org/3.4/library/types.html#types.SimpleNamespace

Answer 2

你可以试试attrdict:

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

a = attrdict(x=1, y=2)
print a.x, a.y
print a['x'], a['y']

b = attrdict()
b.x, b.y  = 1, 2
print b.x, b.y
print b['x'], b['y']

Answer 3

这种对象没有“标准库”，但在 ActiveState 上有一个来自 Alex Martelli 的著名配方，称为 "bunch"。

注意：pypi 上还有一个名为 bunch 的包，它应该做同样的事情，但我不知道它的实现和质量。

Answer 4

您可能对collections.namedtuple感兴趣

Answer 5

如果我理解正确，您需要一个可以转储属性的对象。如果我是正确的，您所要做的就是创建一个空类。例如：

>>> class DumpObject: pass
... 
>>>#example of usage:
...
>>> a = DumpObject()
>>> a.airspeed = 420
>>> print a.airspeed
420

就是这样

Answer 6

我不太喜欢这个，因为你会陷入“如果你定义'键'会怎样”：

foo = DumbObject()
foo.moshe = 'here'
foo.keys # --> gives a callable, if you'll call it you'll get ['moshe']
foo.keys = 'front-door'
foo.keys # --> oh look, now it's a string 'front-door'

“键”是否应该是您对象上定义的方法，还是只是偶然？如果是，那么您最好将 DumbObject 定义为

class DumbObject(object):
    def __init__(self):
        self._dict = {}
    def __getitem__(self, key):
        return self._dict[key]
    __getattr__ = __getitem__
    # Ditto for set
def asDictionary(do):
    return do._dict

但是你为什么要这样做？你确定这是正确的答案吗？也许您应该使用正确类型的对象？

Answer 7

好吧，据我所知（如果我错了，请纠正我）这里的每个示例都不会将嵌套字典转换为新类型。所以我做了这个例子：

class DotDictionary(dict):

def __init__(self, init_value):
    if not isinstance(init_value, dict):
        raise TypeError('Expected dict, got {}'.format(type(init_value)))

    self._dict_to_self(init_value)

def __getattr__(self, name):
    return self[name]

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

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

def _dict_to_self(self, dct):
    for key, value in dct.items():
        if isinstance(value, dict):
            value = DotDictionary(value)
        if isinstance(value, (tuple, list)):
            for i, _ in enumerate(value):
                if isinstance(value[i], dict):
                    value[i] = DotDictionary(value[i])

        self[key] = value

ideone

我不能 100% 确定它是否绝对正确，所以这里不提供任何保证。

也许这不是pythonic方式，所以我准备好接受建议。

Answer 8

此方法适用于嵌套字典，非常简洁。

首先，定义一个空类。该类的实例可以设置任何属性。

class holder:
    pass

接下来，就用这个函数吧。

def dotted(object):

    if isinstance(object, dict):
        parent = holder()

        for key in object:

            child = object.get(key)
            setattr(parent, key, dotted(child))

        return parent

    return object

示例用法。

users = dotted(
{
    'john': {
        'fullname': 'John Doe'
        'age': 24,
        'hobbies': [
            'programming',
            'jogging'
        ]
    }
}

users.john.fullname # 'John Doe'
users.john.age      # 24
users.john.hobbies  # ['programming', 'jogging']

users.john.age = 25
users.john.age      # 25

Answer 9

DumbObject = lambda: "function is a first-class object And this sentence isn't necessary :), you could simply put None or Pass"

DumbObject.name = "Dumb"
DumbObject.speak = lambda word: print(word)
DumbObject.tell_name =  lambda : print(f"I am {DumbObject.name} and have no self")

DumbObject.speak("I speak not")
DumbObject.tell_name()

Answer 10

这个实现允许你任意嵌套dicts和SimpleNamespaces，并且兼容json.dumps，因为它继承自dict。

from types import SimpleNamespace
import json


class DictNamespace(dict):

    def __getattr__(self, key):
        return self[key]

    def __setattr__(self, key, value):
        self[key] = self.construct_namespace(value)

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

    @staticmethod
    def construct_namespace(maybe_dict):
        if isinstance(maybe_dict, dict):
            for key, value in maybe_dict.items():
                if isinstance(value, dict):
                    maybe_dict[key] = DictNamespace(**value)
                elif isinstance(value, SimpleNamespace):
                    maybe_dict[key] = DictNamespace(**value.__dict__)
                else:
                    maybe_dict[key] = value
        return maybe_dict

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        DictNamespace.construct_namespace(self)


thing = DictNamespace(
    one=1, 
    two=dict(three=3), 
    five=DictNamespace(six=6), 
    eight=SimpleNamespace(nine=9)
)

thing.eleven = 11
print(thing.one)
print(thing.two)
print(thing.two.three)
print(thing.five)
print(thing.five.six)
print(thing.eight)
print(thing.eight.nine)
print(thing["eight"]["nine"])
print(thing["eight"].nine)
print(thing.eleven)
del thing.eleven
assert thing.get("eleven", None) is None
print(json.dumps(thing))