The Simple

您可以使用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解析器和工具，例如this answer。

卷积

简单地说（不要太认真），您可以创建一个允许使用属性访问的 Package 器：

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'

型

一方面，您的示例采用了正确的方法，使用get_config_value('mysql.user.pass', config)而不是使用属性解决点式访问。我不确定你是否意识到你不是故意要做更直观的事情：

print(config.mysql.user.pass)

字符串
即使重载了__getattr__，也不能让它工作，因为pass是一个Python语言元素。
但是，您的示例只描述了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文件，而不仅仅是那些由字符串标量作为键的递归Map组成的文件。
1.如图所示，您可以直接调用config.string_access( mysql.user.pass)，而不用定义和使用get_config_value()
1.这将字符串和整数用作Map键，但是可以容易地扩展以支持其他键类型（布尔、日期、日期-时间）。
¹这是使用ruamel.yaml一个YAML 1.2解析器完成的，我是它的作者。

最后我使用了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中有更多的例子。

这是一个相当古老的问题，但我来到这里寻找答案，但寻找更简单的解决方案。最后，提出了自己的解决方案，使用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))

型

不久前我遇到了同样的问题，并构建了这个getter：

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中查找配置值。如果您在为您的案例调整此功能时遇到困难，请随时寻求进一步的帮助。

我通常遵循的最佳实践是将config**（任何类型，不仅仅是yaml）转换为内存中的对象。
通过这种方式，基于文本的配置被1个函数打开，文本被丢弃，提供了一个漂亮的对象来处理，而不是让每个函数处理配置的内部**。这样所有函数只知道一个内部对象接口。如果从配置文件中添加/重命名/删除任何新参数，唯一要更改的函数是加载器函数，该函数将配置加载到内存对象中。
下面是一个示例我做的加载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'

型

Meta/Facebook的hydra库在这里可能太复杂了。Meta/Facebook的hydra库的基础是omegaconf，它可能满足您的需求。它的战斗测试和准备去和存储一切在ConfDict的，我猜这是哈希Map，因此轻量级和快速。

from omegaconf import OmegaConf

conf = OmegaConf.load(floyd_yaml_path)

print(conf.mysql.user.pass)

字符串