Python：使用“點表示法”訪問 YAML 值

Question

我正在使用 YAML 配置文件。 所以這是在 Python 中加載我的配置的代碼：

import os
import yaml
with open('./config.yml') as file:
    config = yaml.safe_load(file)

這段代碼實際上創建了一個字典。 現在的問題是，為了訪問我需要使用大量括號的值。

YAML：

mysql:
    user:
        pass: secret

Python：

import os
import yaml
with open('./config.yml') as file:
    config = yaml.safe_load(file)
print(config['mysql']['user']['pass']) # <--

我更喜歡這樣的東西（點符號）：

config('mysql.user.pass')

所以，我的想法是利用 PyStache render() 接口。

import os
import yaml
with open('./config.yml') as file:
    config = yaml.safe_load(file)

import pystache
def get_config_value( yml_path, config ):
    return pystache.render('{{' + yml_path + '}}', config)

get_config_value('mysql.user.pass', config)

這會是一個“好”的解決方案嗎？ 如果沒有，什么是更好的選擇？

補充問題 [已解決]

我決定使用 Ilja Everilä 的解決方案。 但現在我還有一個問題：如何圍繞 DotConf 創建包裝器 Config 類？

以下代碼不起作用，但我希望您明白我要做什么：

class Config( DotDict ):
    def __init__( self ):
        with open('./config.yml') as file:
            DotDict.__init__(yaml.safe_load(file))

config = Config()
print(config.django.admin.user)

錯誤：

AttributeError: 'super' object has no attribute '__getattr__'

解決方案

您只需要將self傳遞給超類的構造函數。

DotDict.__init__(self, yaml.safe_load(file))

更好的解決方案 (Ilja Everilä)

super().__init__(yaml.safe_load(file))

Answer 1

簡單

您可以使用reduce從配置中提取值：

In [41]: config = {'asdf': {'asdf': {'qwer': 1}}}

In [42]: from functools import reduce
    ...: 
    ...: def get_config_value(key, cfg):
    ...:     return reduce(lambda c, k: c[k], key.split('.'), cfg)
    ...: 

In [43]: get_config_value('asdf.asdf.qwer', config)
Out[43]: 1

如果您的YAML使用的語言子集非常有限，則此解決方案易於維護並且幾乎沒有新的邊緣情況。

正確的

使用適當的YAML解析器和工具，例如此答案 。

---

令人費解的

簡要說明一下（不要太在意），您可以創建一個包裝器，以允許使用屬性訪問：

In [47]: class DotConfig:
    ...:     
    ...:     def __init__(self, cfg):
    ...:         self._cfg = cfg
    ...:     def __getattr__(self, k):
    ...:         v = self._cfg[k]
    ...:         if isinstance(v, dict):
    ...:             return DotConfig(v)
    ...:         return v
    ...:     

In [48]: DotConfig(config).asdf.asdf.qwer
Out[48]: 1

請注意，這對於諸如“ as”，“ pass”，“ if”之類的關鍵字失敗。

最后，您可能會變得非常瘋狂（閱讀：可能不是一個好主意），並自定義dict以處理點綴字符串和元組鍵（作為特殊情況），並可以對混合中拋出的項進行屬性訪問（有其局限性）：

In [58]: class DotDict(dict):
    ...:     
    ...:     # update, __setitem__ etc. omitted, but required if
    ...:     # one tries to set items using dot notation. Essentially
    ...:     # this is a read-only view.
    ...:
    ...:     def __getattr__(self, k):
    ...:         try:
    ...:             v = self[k]
    ...:         except KeyError:
    ...:             return super().__getattr__(k)
    ...:         if isinstance(v, dict):
    ...:             return DotDict(v)
    ...:         return v
    ...:
    ...:     def __getitem__(self, k):
    ...:         if isinstance(k, str) and '.' in k:
    ...:             k = k.split('.')
    ...:         if isinstance(k, (list, tuple)):
    ...:             return reduce(lambda d, kk: d[kk], k, self)
    ...:         return super().__getitem__(k)
    ...:
    ...:     def get(self, k, default=None):
    ...:         if isinstance(k, str) and '.' in k:
    ...:             try:
    ...:                 return self[k]
    ...:             except KeyError:
    ...:                 return default
    ...:         return super().get(k, default=default)
    ...:     

In [59]: dotconf = DotDict(config)

In [60]: dotconf['asdf.asdf.qwer']
Out[60]: 1

In [61]: dotconf['asdf', 'asdf', 'qwer']
Out[61]: 1

In [62]: dotconf.asdf.asdf.qwer
Out[62]: 1

In [63]: dotconf.get('asdf.asdf.qwer')
Out[63]: 1

In [64]: dotconf.get('asdf.asdf.asdf')

In [65]: dotconf.get('asdf.asdf.asdf', 'Nope')
Out[65]: 'Nope'

Answer 2

一方面，您的示例通過使用get_config_value('mysql.user.pass', config)采取了正確的方法，而不是使用屬性來解決點分訪問。 我不確定您是否意識到您不是有意做更直觀的事情：

print(config.mysql.user.pass)

即使重載__getattr__ ，您也無法工作，因為pass是Python語言元素。

但是，您的示例僅描述了非常有限的YAML文件子集，因為它不涉及任何序列集合，也不涉及任何復雜的鍵。

如果您想覆蓋的范圍不只微小的子集，可以擴展ruamel.yaml的強大ruamel.yaml ：¹

import ruamel.yaml

def mapping_string_access(self, s, delimiter=None, key_delim=None):
    def p(v):
        try:
            v = int(v)
        except:
            pass
        return v
       # possible extend for primitives like float, datetime, booleans, etc.

    if delimiter is None:
        delimiter = '.'
    if key_delim is None:
        key_delim = ','
    try:
        key, rest = s.split(delimiter, 1)
    except ValueError:
        key, rest = s, None
    if key_delim in key:
        key = tuple((p(key) for key in key.split(key_delim)))
    else:
        key = p(key)
    if rest is None:
        return self[key]
    return self[key].string_access(rest, delimiter, key_delim)

ruamel.yaml.comments.CommentedMap.string_access = mapping_string_access


def sequence_string_access(self, s, delimiter=None, key_delim=None):
    if delimiter is None:
        delimiter = '.'
    try:
        key, rest = s.split(delimiter, 1)
    except ValueError:
        key, rest = s, None
    key = int(key)
    if rest is None:
        return self[key]
    return self[key].string_access(rest, delimiter, key_delim)

ruamel.yaml.comments.CommentedSeq.string_access = sequence_string_access

設置完成后，您可以運行以下命令：

yaml_str = """\
mysql:
    user:
        pass: secret
    list: [a: 1, b: 2, c: 3]
    [2016, 9, 14]: some date
    42: some answer
"""

yaml = ruamel.yaml.YAML()
config = yaml.load(yaml_str)

def get_config_value(path, data, **kw):
    return data.string_access(path, **kw)

print(get_config_value('mysql.user.pass', config))
print(get_config_value('mysql:user:pass', config, delimiter=":"))
print(get_config_value('mysql.list.1.b', config))
print(get_config_value('mysql.2016,9,14', config))
print(config.string_access('mysql.42'))

給予：

secret
secret
2
some date
some answer

這表明您只需花更多的精力和很少的額外工作，就可以靈活地對許多YAML文件進行點擴展訪問，而不僅僅是那些由以字符串標量作為鍵的遞歸映射組成的文件。

1. 如圖所示，您可以直接調用config.string_access( mysql.user.pass )而不是定義和使用get_config_value()
2. 這可以將字符串和整數用作映射鍵，但是可以輕松擴展以支持其他鍵類型（布爾，日期，日期時間）。

---

¹ _{這是使用ruamel.yaml（ YAML 1.2解析器）完成的，我是作者。}

Answer 3

我最終使用了python-box 。 這個包提供了多種讀取配置文件的方式（yaml、csv、json、...）。 不僅如此，它還允許您直接傳遞dict或字符串：

from box import Box
import yaml # Only required for different loaders

# Pass dict directly
movie_box = Box({ "Robin Hood: Men in Tights": { "imdb stars": 6.7, "length": 104 } })

# Load from yaml file
# Here it is also possible to use PyYAML arguments, 
# for example to specify different loaders e.g. SafeLoader or FullLoader
conf = Box.from_yaml(filename="./config.yaml", Loader=yaml.FullLoader) 

conf.mysql.user.pass

Wiki中提供了更多示例。

Answer 4

不久前我遇到了同樣的問題，並構建了這個吸氣劑：

 def get(self, key):
    """Tries to find the configuration value for a given key.
    :param str key: Key in dot-notation (e.g. 'foo.lol').
    :return: The configuration value. None if no value was found.
    """
    try:
        return self.__lookup(self.config, key)
    except KeyError:
        return None

def __lookup(self, dct, key):
    """Checks dct recursive to find the value for key.
    Is used by get() interanlly.
    :param dict dct: The configuration dict.
    :param str key: The key we are looking for.
    :return: The configuration value.
    :raise KeyError: If the given key is not in the configuration dict.
    """
    if '.' in key:
        key, node = key.split('.', 1)
        return self.__lookup(dct[key], node)
    else:
        return dct[key]

getter以遞歸方式（通過使用__lookup ）從self.config中查找配置值。 如果您無法根據自己的情況進行調整，請隨時尋求進一步的幫助。

Answer 5

這是一個很老的問題，但是我來這里是為了尋找答案，但是正在尋找更簡單的解決方案。 最后，使用easydict庫提出了自己的解決方案； 使用pip install easydict

  def yaml_load(fileName):
    import yaml
    from easydict import EasyDict as edict
    fc = None
    with open(fileName, 'r') as f:
      fc = edict(yaml.load(f))
      ## or use safe_load
      ## fc = edict(yaml.safe_load(f))

    return fc

現在，只需使用有效的yaml filename調用yaml_load即可：

config = yaml_load('./config.yml')

## assuming: config["mysql"]["user"]["pass"] is a valid key in config.yml
print("{}".format(config.mysql.user.pass))

Answer 6

我通常遵循將配置（任何類型，而不僅僅是 yaml）轉換為 in memory object的最佳實踐。

這樣基於文本的 config 被 1 個函數解開，文本被丟棄，提供一個漂亮的對象來處理，而不是讓每個函數來處理config的內部。 這樣所有的函數只知道那個內部對象接口。 如果在配置文件中添加/重命名/刪除任何新參數，唯一要更改的功能是加載器功能，它將配置加載到內存對象中。

下面是我為將 FloydHub 配置 yaml 文件加載到內存對象中所做的示例。 我覺得這是一個非常好的設計模式。

首先定義一個配置代表類，如下所示：

class FloydYamlConfig(object):
class Input:
    def __init__(self, destination, source):
        self.destination = destination
        self.source = source

def __init__(self, floyd_yaml_dict):
    self.machine = floyd_yaml_dict['machine']
    self.env = floyd_yaml_dict['env']
    self.description = floyd_yaml_dict['description']
    self.max_runtime = floyd_yaml_dict['max_runtime']
    self.command = floyd_yaml_dict['command']
    self.input = []
    for input_conf in floyd_yaml_dict['input']:
        input_obj = self.Input(destination=input_conf['destination'], source=input_conf['source'])
        self.input.append(input_obj)

def __str__(self):
    input_str = ''
    for input_obj in self.input:
        input_str += '\ndestination: {}\n source: {}'.format(input_obj.destination, input_obj.source)

    print_str = ('machine: {}\n'
                 'env: {}\n'
                 'input: {}\n'
                 'description: {}\n'
                 'max_runtime: {}\n'
                 'command: {}\n').format(
        self.machine, self.env, input_str, self.description, self.max_runtime, self.command)
    return print_str

然后將 yaml 加載到對象中以供進一步使用：

floyd_conf = read_floyd_yaml_config(args.floyd_yaml_path)

def read_floyd_yaml_config(floyd_yaml_path) -> FloydYamlConfig:
    with open(floyd_yaml_path) as f:
        yaml_conf_dict = yaml.safe_load(f)

    floyd_conf = FloydYamlConfig(yaml_conf_dict)
    # print(floyd_conf)
    return floyd_conf

示例 yaml

# see: https://docs.floydhub.com/floyd_config

machine: gpu2
env: tensorflow-1.0
input:
  - destination: data
    source: abc/datasets/my-data/6
  - destination: config
    source: abc/datasets/my-config/1
description: this is a test
max_runtime: 3600
command: >-
  echo 'hello world'