Question

我有来自不同类的对象，它们共同执行某项任务。该任务需要很多参数，由用户提供（通过配置文件）。参数在系统内部深处使用。

我可以选择让控制器对象读取配置文件，然后根据需要将参数分配给下一层对象，依此类推。但是唯一的对象本身知道它们需要哪些参数，因此控制器对象需要学习关于每个其他对象的大量细节。

另一种选择是将所有参数捆绑到一个集合中，并将整个集合传递给每个函数调用（等效地，创建一个存储它们的全局对象，并且每个人都可以访问）。这看起来很丑陋，会引起各种小问题（例如，我不能允许两个对象使用同名的参数等等）。

怎么办？

Answer 1

我过去曾使用过“全球收藏”替代品。

如果您关心命名：您将如何在配置文件中处理此问题？我看到它的方式，你的全局集合是一个数据结构，代表你在配置文件中的相同信息，所以如果你有办法解决或避免你的cfg文件中的名称冲突，你可以在全局集合中做同样的事情

Answer 2

我希望你不要觉得我在追问你 - 你所询问的内容类似于我在物业聚合方面的想法，以避免你想要避免的模型。

我也刻画了Elixir让我转向的声明性氛围。

我很好奇堆栈溢出的Python专家对它的看法以及可能存在的更好的替代方案。我不喜欢大kwargs，如果我可以避免我喜欢的大型施工人员。

#!/usr/bin/python

import inspect
from itertools import chain, ifilter
from pprint import pprint
from abc import ABCMeta

class Property(object):

    def __init__(self, value=None):
        self._x = value

    def __repr__(self):
        return str(self._x)

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    value = property(getx, setx, delx, "I'm the property.")

class BaseClass(object):

    unique_baseclass_thing = Property()

    def get_prop_tree(self):
        mro = self.__class__.__mro__
        r = []
        for i in xrange( 0, len(mro) - 1 ):

            child_prop_names = set(dir(mro[i]))
            parent_prop_names = set(dir(mro[i+1]))

            l_k = list( chain( child_prop_names - parent_prop_names ) )
            l_n = [ (x, getattr(mro[i],x,None)) for x in l_k ]
            l_p = list( ifilter(lambda y: y[1].__class__ == Property, l_n))

            r.append(
                (mro[i],
                    (dict
                        ( l_p )
                    )
                )
            )
        return r

    def get_prop_list(self):
        return list( chain(* [ x[1].items() for x in reversed( self.get_prop_tree() ) ] ) )


class SubClass(BaseClass):
    unique_subclass_thing = Property(1)

class SubSubClass(SubClass):
    unique_subsubclass_thing_one = Property("blah")
    unique_subsubclass_thing_two = Property("foo")

if __name__ == '__main__':

    a = SubSubClass()

    for b in a.get_prop_tree():
        print '---------------'
        print b[0].__name__
        for prop in b[1].keys():
            print "\t", prop, "=", b[1][prop].value
        print

    for prop in a.get_prop_list():

当你运行它..

SubSubClass
    unique_subsubclass_thing_one = blah
    unique_subsubclass_thing_two = foo

---------------
SubClass
    unique_subclass_thing = 1

---------------
BaseClass
    unique_baseclass_thing = None

unique_baseclass_thing None
unique_subclass_thing 1
unique_subsubclass_thing_one blah
unique_subsubclass_thing_two foo

如何为整个系统提供大量参数？

2 个答案: