如何在 python 中对 dict 使用点符号？

Question

我是 python 的新手，我希望我能做到. 访问dict值的符号。

可以说我有这样的test ：

>>> test = dict()
>>> test['name'] = 'value'
>>> print(test['name'])
value

但我希望我可以做test.name来获得value 。 事实上，我是通过重写 class 中的__getattr__方法来实现的，如下所示：

class JuspayObject:

    def __init__(self,response):
        self.__dict__['_response'] = response

    def __getattr__(self,key): 
        try:
            return self._response[key]
        except KeyError,err:
            sys.stderr.write('Sorry no key matches')

这有效：当我这样做时：

test.name // I get value.

但问题是当我单独打印test时，我得到的错误是：

'Sorry no key matches'

为什么会这样？

Answer 1

此功能已存在于标准库中，因此我建议您只使用它们的类。

>>> from types import SimpleNamespace
>>> d = {'key1': 'value1', 'key2': 'value2'}
>>> n = SimpleNamespace(**d)
>>> print(n)
namespace(key1='value1', key2='value2')
>>> n.key2
'value2'

添加、修改和删除值是通过常规属性访问实现的，即您可以使用诸如n.key = val和del n.key类的语句。

再次回到字典：

>>> vars(n)
{'key1': 'value1', 'key2': 'value2'}

dict 中的键应该是字符串标识符，以便属性访问正常工作。

在 Python 3.3 中添加了简单命名空间。 对于旧版本的语言， argparse.Namespace具有类似的行为。

Answer 2

我假设您对 Javascript 很熟悉并想借用这种语法……我可以根据个人经验告诉您，这不是一个好主意。

它确实看起来不那么冗长和整洁； 但从长远来看，它只是晦涩难懂。 字典就是字典，试图让它们表现得像具有属性的对象可能会导致（坏的）意外。

如果您需要像操作字典一样操作对象的字段，您可以随时在需要时使用内部的__dict__属性，然后清楚地知道您在做什么。 或者使用getattr(obj, 'key')来考虑继承结构和类属性。

但是通过阅读您的示例，您似乎正在尝试不同的东西......因为点运算符已经在__dict__属性中查找而无需任何额外代码。

Answer 3

除了这个答案之外，还可以添加对嵌套字典的支持：

from types import SimpleNamespace

class NestedNamespace(SimpleNamespace):
    def __init__(self, dictionary, **kwargs):
        super().__init__(**kwargs)
        for key, value in dictionary.items():
            if isinstance(value, dict):
                self.__setattr__(key, NestedNamespace(value))
            else:
                self.__setattr__(key, value)

nested_namespace = NestedNamespace({
    'parent': {
        'child': {
            'grandchild': 'value'
        }
    },
    'normal_key': 'normal value',
})


print(nested_namespace.parent.child.grandchild)  # value
print(nested_namespace.normal_key)  # normal value

请注意，这不支持列表中某处的字典的点表示法。

Answer 4

你可以使用命名元组吗？

from collections import namedtuple
Test = namedtuple('Test', 'name foo bar')
my_test = Test('value', 'foo_val', 'bar_val')
print(my_test)
print(my_test.name)

---

Answer 5

当所有其他属性查找规则都失败时， __getattr__用作后备。 当你尝试“打印”你的对象时，Python 会寻找一个__repr__方法，并且由于你没有在你的类中实现它，它最终会调用__getattr__ （是的，在 Python 中方法也是属性）。 您不应该假设将使用哪个键getattr来调用，最重要的是，如果__getattr__无法解析key ，它必须引发 AttributeError 。

作为旁注：不要使用self.__dict__进行普通属性访问，只需使用普通属性表示法：

class JuspayObject:

    def __init__(self,response):
        # don't use self.__dict__ here
        self._response = response

    def __getattr__(self,key):
        try:
            return self._response[key]
        except KeyError,err:
            raise AttributeError(key)

现在，如果您的班级没有其他责任（并且您的 Python 版本 >= 2.6，并且您不需要支持旧版本），您可以只使用命名元组：http: //docs.python.org/2/library/ collections.html#collections.namedtuple

Answer 6

您可以使用内置方法argparse.Namespace() ：

import argparse

args = argparse.Namespace()
args.name = 'value'

print(args.name)
# 'value'

您还可以通过vars(args)获取原始字典。

Answer 7

使用__getattr__时必须小心，因为它用于许多内置的 Python 功能。

尝试这样的事情......

class JuspayObject:

    def __init__(self,response):
        self.__dict__['_response'] = response

    def __getattr__(self, key):
        # First, try to return from _response
        try:
            return self.__dict__['_response'][key]
        except KeyError:
            pass
        # If that fails, return default behavior so we don't break Python
        try:
            return self.__dict__[key]
        except KeyError:
            raise AttributeError, key

>>> j = JuspayObject({'foo': 'bar'})
>>> j.foo
'bar'
>>> j
<__main__.JuspayObject instance at 0x7fbdd55965f0>

Answer 8

这是一个使用嵌套项的简单、方便的点表示法帮助器示例：

def dict_get(data:dict, path:str, default = None):
    pathList = re.split(r'\.', path, flags=re.IGNORECASE)
    result = data
    for key in pathList:
        try:
            key = int(key) if key.isnumeric() else key 
            result = result[key]
        except:
            result = default
            break
    
    return result

使用示例：

my_dict = {"test1": "str1", "nested_dict": {"test2": "str2"}, "nested_list": ["str3", {"test4": "str4"}]}
print(dict_get(my_dict, "test1"))
# str1
print(dict_get(my_dict, "nested_dict.test2"))
# str2
print(dict_get(my_dict, "nested_list.1.test4"))
# str4

Answer 9

class convert_to_dot_notation(dict):
    """
    Access dictionary attributes via dot notation
    """

    __getattr__ = dict.get
    __setattr__ = dict.__setitem__
    __delattr__ = dict.__delitem__


test = {"name": "value"}
data = convert_to_dot_notation(test)
print(data.name)

Answer 10

对这个答案做一点补充，你也可以支持列表：

class NestedNamespace(SimpleNamespace):
def __init__(self, dictionary, **kwargs):
    super().__init__(**kwargs)
    for key, value in dictionary.items():
        if isinstance(value, dict):
            self.__setattr__(key, NestedNamespace(value))
        elif isinstance(value, list):
            self.__setattr__(key, map(NestedNamespace, value))
        else:
            self.__setattr__(key, value)

Answer 11

我使用dotted_dict包：

>>> from dotted_dict import DottedDict
>>> test = DottedDict()
>>> test.name = 'value'
>>> print(test.name)
value

Answer 12

向类添加__repr__()方法，以便您可以自定义要显示的文本

print text

在这里了解更多信息： https ://web.archive.org/web/20121022015531/http://diveintopython.net/object_orient_framework/special_class_methods2.html

Answer 13

#!/usr/bin/env python3


import json
from sklearn.utils import Bunch
from collections.abc import MutableMapping


def dotted(inpt: MutableMapping,
           *args,
           **kwargs
           ) -> Bunch:
    """
    Enables recursive dot notation for ``dict``.
    """

    return json.loads(json.dumps(inpt),
                      object_hook=lambda x:
                      Bunch(**{**Bunch(), **x}))

Answer 14

2022 回答：我创建了dotwiz包——这是一个快速、小巧的库，在大多数情况下似乎表现得非常好。

>>> from dotwiz import DotWiz
>>> test = DotWiz(hello='world')
>>> test.works = True
>>> test
✫(hello='world', works=True)
>>> test.hello
'world'
>>> assert test.works

Answer 15

此功能已嵌入到OmegaConf 中：

from omegaconf import OmegaConf

your_dict = {"k" : "v", "list" : [1, {"a": "1", "b": "2", 3: "c"}]}
adot_dict = OmegaConf.create(your_dict)

print(adot_dict.k)
print(adot_dict.list)

安装是：

pip install omegaconf

这个库对于配置很方便，它实际上是为：

from omegaconf import OmegaConf
cfg = OmegaConf.load('config.yml')
print(cfg.data_path)

Answer 16

您可以使向 Dicts 添加点符号的 hacks 大部分工作，但总是存在名称空间问题。 比如，这是做什么的？

x = DotDict()
x["values"] = 1989
print(x. values)

我使用pydash ，它是 JS 的 lodash 的 Python 端口，当嵌套变得太丑陋时，我会以不同的方式做这些事情。