python - 试图让 dict 表现得像一个干净的类/方法结构

Question

我正在尝试制作一本字典(从 yaml 数据中读取)，使其表现得像一个类。因此，如果我调用 class.key，我将检索他的值。代码如下:

import errno
import sys
import yaml

backup_conf="""
loglevel: INFO
username: root
password: globalsecret
destdir: /dsk/bckdir/
avoidprojects: 

matchregex: /bkp/

depots:
    server1:
        password: asecret

    server2:
        username: root

    server3:

    server4:
        destdir: /disk2/bkp/

projects:
    proj1:
        matchregex: 
            - /backups/
            - /bkp/
"""

class Struct:
    def __init__(self, **entries): 
        self.__dict__.update(entries)

class Config:

    def __init__(self, filename="backup.cfg", data=None):
        self.cfg = {}
        if data is None:
            try:
                fd = open(filename,'r')
                try:
                    yamlcfg = yaml.safe_load(fd)
                except yaml.YAMLError as e:
                    sys.exit(e.errno)
                finally:
                    fd.close()
            except ( IOError, OSError ) as e:
                sys.exit(e.errno)
        else:
            try:
                yamlcfg = yaml.safe_load(data)
            except yaml.YAMLError as e:
                sys.exit(e.errno)

        self.cfg = Struct(**yamlcfg)

    def __getattribute__(self, name):
        try:
            return object.__getattribute__(self, name)
        except AttributeError:
            return self.cfg.__getattribute__(name)


    def get_depot_param(self,depot,param):
        try:
            self.depot_param = self.cfg.depots[depot][param]
        except ( TypeError, KeyError) as e:
            try:
                self.depot_param = getattr(self.cfg, param)
            except KeyError as e:
                    sys.exit(e.errno)

        return self.depot_param

    def get_project_param(self,project,param):
        try:
            self.project_param = self.cfg.projects[project][param]
        except ( TypeError, KeyError) as e:
            try:
                self.project_param = getattr(self.cfg, param)
            except KeyError as e:
                sys.exit(e.errno)

        return self.project_param

    def get_project_matches(self,project):
        try:
            self.reglist = self.cfg.projects[project]['matchregex']
        except KeyError as e:
            try:
                self.reglist = self.cfg.matchregex
            except KeyError as e:
                    print "Error in configuration file: {0}: No default regex defined. Please add a matchregex entry on conf file".format(e)
                    sys.exit(e.errno)

        if isinstance(self.reglist, str):
            self.reglist = self.reglist.split()

        return self.reglist

    def get_depots(self):
        return self.cfg.depots.keys()                                                        

if __name__ == '__main__':
    # Read config file to cfg
    config = Config(data=backup_conf)

代码运行良好，我能够获取如下数据:config.cfg.loglevel，按预期返回 INFO。但我想知道如何调用 as config.loglevel 删除 cleary 来 self 的 self.cfg 实例变量的 cfg。 (当然欢迎任何增强代码的技巧)。

Answer 1

嗯，最简单的解决方案是使用 PYYaml 构造函数，即将一个类映射到一个 yaml 类型。

① 使用构造函数

你所要做的就是让你的类成为yaml.YAMLObject的 child ，添加yaml_tag成员来告诉yaml什么时候使用那个类来构造一个实例那个类(而不是字典)，你就设置好了:

class Config(yaml.YAMLObject):
    yaml_tag = '!Config'

    @classmethod
    def load(self, filename="backup.cfg", data=None):
        self.cfg = {}
        if data is None:
            with open(filename,'r') as f:
                yamlcfg = yaml.load(f)
        else:
            yamlcfg = yaml.load(data)
        return yamlcfg

backup_conf="""
!Config
loglevel: INFO
username: root
password: globalsecret
destdir: /dsk/bckdir/
avoidprojects:

matchregex: /bkp/

depots:
    server1:
        password: asecret

    server2:
        username: root

    server3:

    server4:
        destdir: /disk2/bkp/

projects:
    proj1:
        matchregex:
            - /backups/
            - /bkp/
"""


if __name__ == '__main__':
    # Read config file to cfg
    config = Config.load(data=backup_conf)

如您所见，我使用工厂方法加载数据并创建实例，这就是 load 类方法的用途。

该方法的优点之一是，您可以通过在 yaml 数据中写入类型标签来直接键入所有元素。因此，如果您愿意，您也可以使用类似的方法键入您的服务器，使您的 yaml 类似于:

depots:
   server1: !Server
     password: asecret
   server2: !Server
     username: root
   server3: !Server
   server4: !Server
     destdir: /disk2/bkp

对项目键中的每个项目都采用相同的方式。

② 使用namedtuple

如果你不想改变你的 yaml，那么你可以让 Config 类成为 namedtuple 的子类，当你加载 yaml 数据时，你可以创建namedtuple 来自字典。

为此，在下面的代码片段中，我创建了一个递归函数(嵌套在加载类方法中)，遍历所有 dict(和嵌套的 dicts) 并将它们转换为 namedtuples.

import yaml
from collections import namedtuple

class Config:
    @classmethod
    def load(self, filename='backup.cfg', data=None):
        """Load YAML document"""

        def convert_to_namedtuple(d):
            """Convert a dict into a namedtuple"""
            if not isinstance(d, dict):
                raise ValueError("Can only convert dicts into namedtuple")
            for k,v in d.iteritems():
                if isinstance(v, dict):
                    d[k] = convert_to_namedtuple(v)
            return namedtuple('ConfigDict', d.keys())(**d)

        if data is None:
            with open(filename, 'r') as f:
                yamlcfg = yaml.load(f)
        else:
            yamlcfg = yaml.load(data)
        return convert_to_namedtuple(yamlcfg)

当你运行它时:

>>> cfg = Config.load(data=backup_conf)
>>> print cfg.username, cfg.destdir
root /dsk/bckdir/
>>> print cfg.depots.server4.destdir
/disk2/bkp/
>>> print cfg.depots.server2.username
root

③ 使用自定义yaml.Loader 构建namedtuple

我试图找出一种方法来做到这一点，但经过一些尝试和错误后，我明白我会花太多时间来弄清楚它，而且它会变得太复杂以至于无法作为一种易于理解的方式可行解决方案。 只是为了好玩，以下是难以实现的原因。

有一种方法可以制作您自己的默认加载器，并更改默认节点的转换方式。在默认加载器中，您可以覆盖创建 dict 的方法，使其创建 namedtuple:

class ConfigLoader(yaml.Loader):
    def construct_mapping(self, node, deep=False):
        # do whatever it does per default to create a dict, i.e. call the ConfigLoader.construct_mapping() method
        mapping = super(ConfigLoader, self).construct_mapping(node, deep)
        # then convert the returned mapping into a namedtuple
        return namedtuple('ConfigDict', mapping.keys())(**mapping)

唯一的问题是 another method calling that one期望首先构建 dict 树，然后才用值更新它:

def construct_yaml_map(self, node):
    data = {}
    yield data ## the object is returned here, /before/ it is being populated
    value = self.construct_mapping(node)
    data.update(value)

因此，正如我所说，肯定有解决方法，但如果我花了太多时间来弄清楚，那么就没有必要向您展示如何去做，因为这会让您(以及 future 的读者)感到困难)了解。 如我所见@user1340544's answer ，您可能需要考虑使用 EasyDict而不是 collections.namedtuple (如果你没问题 与外部包)。

结论

因此，正如您在此处看到的那样，data 字段构建为一个空字典，该 dict 是yield给调用者的，之前添加到其中的值。因此，只有在构建字典后才会添加这些值。 但是 namedtuple 需要一步构建(即:您需要事先知道所有键)，因此无法使用该方法。

我个人更喜欢选项①，使用标签，因为您可以使用它映射到的类来验证配置(并在缺少配置项、输入错误或额外的配置项时发出警报)。 您还可以为每种类型使用不同的名称，从而在解析配置文件时轻松报告错误，并且只需最少的额外代码即可完成所有这些工作。当然，选项 ② 的效果很好。

HTH