我的代码中有难闻的气味。也许我只是需要让它散播一下，但现在它让我很烦。

我需要创建三个不同的输入文件来运行三个辐射传输建模 (RTM) 应用程序，以便我可以比较它们的输出。将针对数千组输入重复此过程，因此我使用 Python 脚本将其自动化。

我想将输入参数存储为通用 python 对象，我可以将其传递给其他三个函数，每个函数都会将该通用对象转换为运行他们负责的 RTM 软件所需的特定参数。我认为这是有道理的，但请随时批评我的方法。

每个 RTM 软件都有许多可能的输入参数。其中许多重叠。它们中的大多数都保持合理的默认值，但应该很容易更改。

我从一个简单的 dict 开始

config = {
    day_of_year: 138,
    time_of_day: 36000, #seconds
    solar_azimuth_angle: 73, #degrees
    solar_zenith_angle: 17, #degrees
    ...
}

参数比较多，可以分门别类，所以想到了dict在 dict 内:

config = {
    day_of_year: 138,
    time_of_day: 36000, #seconds
    solar: {
        azimuth_angle: 73, #degrees
        zenith_angle: 17, #degrees
        ...
    },
    ...
}

我喜欢。但是有很多多余的属性。例如，如果已知太阳方位角和天顶角，则可以找到另一个，那么为什么要对两者进行硬编码呢？所以我开始研究 python 的内置 property .如果我将数据存储为对象属性，这让我可以用数据做一些漂亮的事情:

class Configuration(object):
    day_of_year = 138,
    time_of_day = 36000, #seconds
    solar_azimuth_angle = 73, #degrees
    @property
    def solar_zenith_angle(self):
        return 90 - self.solar_azimuth_angle
    ...

config = Configuration()

但现在我失去了第二个 dict 的结构示例。

请注意，有些属性没有我的 solar_zenith_angle 重要。例如，可能需要访问它所属的属性组之外的其他属性。例如我可以计算solar_azimuth_angle如果我知道一年中的第几天、一天中的时间、纬度和经度。

我在找什么:

一种存储配置数据的简单方法，其值都可以以统一的方式访问，结构良好，并且可以作为属性(实际值)或属性(从其他属性计算得出)存在。

有点无聊的可能性:

将所有内容存储在我之前概述的字典中，并让其他函数运行对象并计算可计算值？这听起来不好玩。或清洁。对我来说，这听起来既困惑又令人沮丧。

一个丑陋但有效的:

在尝试了很长时间不同的策略并且几乎一无所获之后，我想出了一个似乎可行的可能解决方案:

我的类(class):(闻起来有点 func-y，呃，funky。def-initely。)

class SubConfig(object):
    """
    Store logical groupings of object attributes and properties.

    The parent object must be passed to the constructor so that we can still
    access the parent object's other attributes and properties. Useful if we
    want to use them to compute a property in here.
    """
    def __init__(self, parent, *args, **kwargs):
        super(SubConfig, self).__init__(*args, **kwargs)
        self.parent = parent


class Configuration(object):
    """
    Some object which holds many attributes and properties.

    Related configurations settings are grouped in SubConfig objects.
    """
    def __init__(self, *args, **kwargs):
        super(Configuration, self).__init__(*args, **kwargs)
        self.root_config = 2

        class _AConfigGroup(SubConfig):
            sub_config = 3
            @property
            def sub_property(self):
                return self.sub_config * self.parent.root_config
        self.group = _AConfigGroup(self) # Stinky?!

我如何使用它们:(按我的意愿工作)

config = Configuration()

# Inspect the state of the attributes and properties.
print("\nInitial configuration state:")
print("config.rootconfig: %s" % config.root_config)
print("config.group.sub_config: %s" % config.group.sub_config)
print("config.group.sub_property: %s (calculated)" % config.group.sub_property)

# Inspect whether the properties compute the correct value after we alter
# some attributes.
config.root_config = 4
config.group.sub_config = 5

print("\nState after modifications:")
print("config.rootconfig: %s" % config.root_config)
print("config.group.sub_config: %s" % config.group.sub_config)
print("config.group.sub_property: %s (calculated)" % config.group.sub_property)

行为:(以上所有代码的执行输出，符合预期)

Initial configuration state:
config.rootconfig: 2
config.group.sub_config: 3
config.group.sub_property: 6 (calculated)

State after modifications:
config.rootconfig: 4
config.group.sub_config: 5
config.group.sub_property: 20 (calculated)

为什么我不喜欢它:

在主对象的 __init__() 内的类定义中存储配置数据不觉得优雅。特别是必须在这样的定义之后立即实例化它们。啊。当然，我可以为父类处理这个问题，但是在构造函数中进行...

在主要之外存储相同的类 Configuration object 也不优雅，因为内部类中的属性可能取决于 Configuration 的属性(或他们在里面的 sibling )。

我可以处理在一切之外定义函数，所以在里面有像这样的东西

@property
def solar_zenith_angle(self):
   return calculate_zenith(self.solar_azimuth_angle)

但我不知道如何做类似的事情

@property
def solar.zenith_angle(self):
    return calculate_zenith(self.solar.azimuth_angle)

(当我试图对此变得聪明时，我总是会遇到 <property object at 0xXXXXX> )

那么正确的做法是什么？我错过了一些基本的东西还是采取了非常错误的方法？有谁知道一个聪明的解决方案？

帮助!我的 python 代码不漂亮!我一定是做错了什么!

最佳答案

菲尔，

你对 func-y config 的犹豫对我来说很熟悉:)

我建议您不要将配置存储为 Python 文件，而应存储为结构化数据文件。我个人更喜欢 YAML，因为它看起来很干净，就像你一开始设计的那样。当然，您将需要为自动计算的属性提供公式，但除非您输入太多代码，否则还算不错。这是我使用 PyYAML 库实现的。

配置文件(config.yml):

day_of_year: 138
time_of_day: 36000 # seconds
solar:
  azimuth_angle: 73 # degrees
  zenith_angle: !property 90 - self.azimuth_angle

代码:

import yaml

yaml.add_constructor("tag:yaml.org,2002:map", lambda loader, node:
    type("Config", (object,), loader.construct_mapping(node))())

yaml.add_constructor("!property", lambda loader, node:
    property(eval("lambda self: " + loader.construct_scalar(node))))

config = yaml.load(open("config.yml"))

print "LOADED config.yml"
print "config.day_of_year:", config.day_of_year
print "config.time_of_day:", config.time_of_day
print "config.solar.azimuth_angle:", config.solar.azimuth_angle
print "config.solar.zenith_angle:", config.solar.zenith_angle, "(calculated)"
print

config.solar.azimuth_angle = 65
print "CHANGED config.solar.azimuth_angle = 65"
print "config.solar.zenith_angle:", config.solar.zenith_angle, "(calculated)"

输出:

LOADED config.yml
config.day_of_year: 138
config.time_of_day: 36000
config.solar.azimuth_angle: 73
config.solar.zenith_angle: 17 (calculated)

CHANGED config.solar.azimuth_angle = 65
config.solar.zenith_angle: 25 (calculated)

配置可以是任何深度，属性可以使用任何子组值。例如试试这个:

a: 1
b:
  c: 3
  d: some text
  e: true
  f:
    g: 7.01
x: !property self.a + self.b.c + self.b.f.g

假设你已经加载了这个配置:

>>> config
<__main__.Config object at 0xbd0d50>
>>> config.a
1
>>> config.b
<__main__.Config object at 0xbd3bd0>
>>> config.b.c
3
>>> config.b.d
'some text'
>>> config.b.e
True
>>> config.b.f
<__main__.Config object at 0xbd3c90>
>>> config.b.f.g
7.01
>>> config.x
11.01
>>> config.b.f.g = 1000
>>> config.x
1004

更新

让我们有一个属性 config.b.x，它在其公式中同时使用 self、parent 和 subgroup 属性:

a: 1
b:
  x: !property self.parent.a + self.c + self.d.e
  c: 3
  d:
    e: 5

然后我们只需要在子组中添加对父级的引用:

import yaml

def construct_config(loader, node):
    attrs = loader.construct_mapping(node)
    config = type("Config", (object,), attrs)()
    for k, v in attrs.iteritems():
        if v.__class__.__name__ == "Config":
            setattr(v, "parent", config)
    return config

yaml.add_constructor("tag:yaml.org,2002:map", construct_config)

yaml.add_constructor("!property", lambda loader, node:
    property(eval("lambda self: " + loader.construct_scalar(node))))

config = yaml.load(open("config.yml"))

让我们看看它是如何工作的:

>>> config.a
1
>>> config.b.c
3
>>> config.b.d.e
5
>>> config.b.parent == config
True
>>> config.b.d.parent == config.b
True
>>> config.b.x
9
>>> config.a = 1000
>>> config.b.x
1008

关于Python:结构化数据的惯用属性？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/10746740/