python - 有没有理由不发送 super().__init__() 字典而不是 **kwds？

Question

我昨天刚开始构建一个基于文本的游戏作为学习 Python 的练习(我使用的是 3.3)。我说的是“基于文本的游戏”，但我的意思更多的是 MUD 而不是选择你自己的冒险。不管怎样，当我昨天弄清楚如何使用 super() 处理继承和多重继承时，我真的很兴奋，但我发现参数传递确实使代码变得困惑，并且需要处理很多小问题松变量。此外，创建保存文件似乎是一场噩梦。

所以，我想，“如果某些类层次结构只接受一个参数，一个字典，然后把字典传回去呢？”举个例子，这里有两个类被简化为它们的 init 方法:

class Actor:
    def __init__(self, in_dict,**kwds):
        super().__init__(**kwds)
        self._everything = in_dict
        self._name = in_dict["name"]
        self._size = in_dict["size"]
        self._location = in_dict["location"]
        self._triggers = in_dict["triggers"]
        self._effects = in_dict["effects"]
        self._goals = in_dict["goals"]
        self._action_list = in_dict["action list"] 
        self._last_action = ''
        self._current_action = '' # both ._last_action and ._current_action get updated by .update_action()

class Item(Actor):
    def __init__(self,in_dict,**kwds)
        super().__init__(in_dict,**kwds)
        self._can_contain = in_dict("can contain") #boolean entry
        self._inventory = in_dict("can contain") #either a list or dict entry

class Player(Actor):
    def __init__(self, in_dict,**kwds):
        super().__init__(in_dict,**kwds)
        self._inventory = in_dict["inventory"] #entry should be a Container object
        self._stats = in_dict["stats"]

将传递的示例字典:

playerdict = {'name' : '', 'size' : '0', 'location' : '', 'triggers' : None, 'effects' : None, 'goals' : None, 'action list' = None, 'inventory' : Container(), 'stats' : None,}

(一旦字典通过，None 将被替换为 {}。)

因此，in_dict 被传递给上一个类，而不是巨大的 **kwds 负载。我喜欢这个因为:

1. 它使我的代码更简洁、更易于管理。
2. 只要字典至少有一些调用键的条目，它就不会破坏代码。此外，给定的参数是否从未被使用也没关系。
3. 文件 IO 似乎变得更容易了(玩家数据字典存储为字典，元素数据字典存储为字典等)

我明白了 **kwds 的要点(编辑:显然我没有)，并且在传递较少的参数时它似乎并不麻烦。这只是似乎是一种在创建每个实例时处理大量属性需求的舒适方式。

也就是说，我仍然是一个主要的 Python 菜鸟。所以，我的问题是:是否存在一个潜在的原因，为什么通过 super() 将相同的字典重复传递给基类会比仅仅用讨厌的(大而杂乱的)**kwds 传递来强硬它更糟糕?(例如，我这个级别的人可能不知道的口译员问题。)

编辑:

以前，创建一个新的 Player 可能看起来像这样，为每个属性传递一个参数。

bob = Player('bob', Location = 'here', ... etc.)   

所需的参数数量激增，我只包含了真正需要存在的属性，以免中断来自 Engine 对象的方法调用。

到目前为止，这是我从答案和评论中得到的印象:

发送同一本词典并没有什么“错误”，只要没有机会修改其内容(Kirk Strauser)并且词典始终具有它应该具有的内容(goncalopp)。真正的答案是问题不对，使用 in_dict 而不是 **kwds 是多余的。

这是正确的吗？ (另外，感谢您提供的各种反馈!)

Answer 1

我不确定我是否完全理解您的问题，因为在您更改为使用 in_dict 之前我看不到代码的样子。听起来你已经在对 super 的调用中列出了几十个关键字(这不是你想要的，这是可以理解的)，但这不是必需的。如果您的子类有一个包含所有这些信息的字典，当您使用 **in_dict 进行调用时，它可以变成 kwargs。所以:

class Actor:
    def __init__(self, **kwds):

class Item(Actor):
    def __init__(self, **kwds)
        self._everything = kwds
        super().__init__(**kwds)

我看不出有什么理由为此添加另一个字典，因为无论如何您都可以操作并传递为 kwds 创建的字典

编辑:

关于使用dict的**扩展与显式列出参数的效率问题，我用这段代码做了一个非常不科学的计时测试:

import time

def some_func(**kwargs):
    for k,v in kwargs.items():
        pass

def main():
    name = 'felix'
    location = 'here'
    user_type = 'player'

    kwds = {'name': name,
            'location': location,
            'user_type': user_type}

    start = time.time()
    for i in range(10000000):
        some_func(**kwds)

    end = time.time()
    print 'Time using expansion:\t{0}s'.format(start - end)
    start = time.time()
    for i in range(10000000):
        some_func(name=name, location=location, user_type=user_type)

    end = time.time()
    print 'Time without expansion:\t{0}s'.format(start - end)


if __name__ == '__main__':
    main()

运行这 10,000,000 次会在传递字典和使用 ** 时获得轻微(并且可能在统计上毫无意义)的优势。

Time using expansion:   -7.9877269268s
Time without expansion: -8.06108212471s

如果我们打印 dict 对象的 ID(函数外部的 kwds 和函数内部的 kwargs)，你会看到 python 创建了一个新的字典供函数在任何一种情况下使用，但实际上函数永远只会得到一个字典.在函数的初始定义(创建 kwargs dict 的地方)之后，所有后续调用都只是更新属于该函数的 dict 的值，无论您如何调用它。 (另请参阅 this 关于 python 中如何处理可变默认参数的启发性 SO 问题，这有点相关)

因此，从性能的角度来看，您可以选择对您有意义的一个。它不应该对 python 在幕后的运行方式产生有意义的影响。