Question

我想在函数外部使用函数中定义的一堆局部变量。所以我在返回值中传递x=locals()。

如何将该字典中定义的所有变量加载到函数外部的命名空间中，这样我就可以使用x['variable']而不是使用variable来访问该值。

Answer 1

考虑Bunch替代方案：

class Bunch(object):
  def __init__(self, adict):
    self.__dict__.update(adict)

所以，如果你有一个字典d，并希望使用语法x.foo而不是笨拙的d['foo']来访问（读取）其值，只需执行

x = Bunch(d)

这适用于内部和外部功能 - 而且非常比向d注入globals()更清洁，更安全！记住Python的Zen的最后一行......：

>>> import this
The Zen of Python, by Tim Peters
   ...
Namespaces are one honking great idea -- let's do more of those!

Answer 2

这是导入变量的完全有效的案例只要一个局部空间进入另一个局部空间一个人知道他/她在做什么。我已经看到这样的代码多次以有用的方式使用。只需注意不要污染共同的全球空间。

您可以执行以下操作：

adict = { 'x' : 'I am x', 'y' : ' I am y' }
locals().update(adict)
blah(x)
blah(y)

Answer 3

您可以使用argparse.Namespace：

，而不是创建自己的对象

from argparse import Namespace
ns = Namespace(**mydict)

做反过来：

mydict = vars(ns)

Answer 4

将变量导入本地名称空间是一个有效的问题，通常用于模板框架。

从函数返回所有局部变量：

return locals()

然后导入如下：

r = fce()
for key in r.keys():
   exec(key + " = r['" + key + "']")

Answer 5

Bunch 答案是可以的，但缺乏递归，并且没有内置__repr__和__eq__内建函数来模拟您已经可以使用字典执行的操作。另外，递归的关键不仅在于对字典进行递归，而且还对列表进行递归，这样列表内的字典也将被转换。

我希望这两个选项可以满足您的需求（您可能需要调整__elt()中的类型检查以获取更复杂的对象；它们主要在json导入中进行了测试，因此核心类型非常简单）。

Bunch 方法（根据先前的答案）-对象接受一个dict并将其递归转换。 repr(obj)将返回Bunch({...})，可以重新解释为等效的对象。

class Bunch(object):
    def __init__(self, adict):
        """Create a namespace object from a dict, recursively"""
        self.__dict__.update({k: self.__elt(v) for k, v in adict.items()})

    def __elt(self, elt):
        """Recurse into elt to create leaf namepace objects"""
        if type(elt) is dict:
            return type(self)(elt)
        if type(elt) in (list, tuple):
            return [self.__elt(i) for i in elt]
        return elt

    def __repr__(self):
        """Return repr(self)."""
        return "%s(%s)" % (type(self).__name__, repr(self.__dict__))

    def __eq__(self, other):
        return self.__dict__ == other.__dict__

SimpleNamespace 方法-由于types.SimpleNamespace已经实现了__repr__和__eq__，因此，您需要实现的是递归__init__方法：< / li>

import types
class RecursiveNamespace(types.SimpleNamespace):
    # def __init__(self, /, **kwargs):  # better, but Python 3.8+
    def __init__(self, **kwargs):
        """Create a SimpleNamespace recursively"""
        self.__dict__.update({k: self.__elt(v) for k, v in kwargs.items()})

    def __elt(self, elt):
        """Recurse into elt to create leaf namepace objects"""
        if type(elt) is dict:
            return type(self)(**elt)
        if type(elt) in (list, tuple):
            return [self.__elt(i) for i in elt]
        return elt

RecursiveNamespace 类采用关键字参数，这些参数当然可以来自取消引用的dict（例如**mydict）

现在让他们进行测试：

adict = {'foo': 'bar', 'baz': [{'aaa': 'bbb', 'ccc': 'ddd'}]}
a = Bunch(adict)
b = RecursiveNamespace(**adict)
print('a:', str(a))
print('b:', str(b))
print('a == b :', str(a == b))

结果是：

a: Bunch({'foo': 'bar', 'baz': [Bunch({'aaa': 'bbb', 'ccc': 'ddd'})]})
b: RecursiveNamespace(baz=[RecursiveNamespace(aaa='bbb', ccc='ddd')], foo='bar')
a == b : True

尽管它们是不同的类，因为它们都已初始化为等效的名称空间，并且它们的__eq__方法仅比较名称空间（self.__dict__），比较两个名称空间对象将返回True

您可能还会注意到，我使用type(self)(...)而不是使用类名进行递归-这有两个优点：首先可以重命名该类，而不必更新递归调用；其次，如果该类被子类化，我们将使用子类名称递归。它也是__repr__（type(self).__name__）中使用的名称。

Answer 6

总是有这个选项，我不知道它是最好的方法，但确实有效。假设type（x）= dict

for key, val in x.items():  # unpack the keys from the dictionary to individual variables
    exec (key + '=val')

Answer 7

使用以下代码段（PY2）从我的dict（yaml）配置中创建递归名称空间：

class NameSpace(object):
    def __setattr__(self, key, value):
        raise AttributeError('Please don\'t modify config dict')


def dump_to_namespace(ns, d):
    for k, v in d.iteritems():
        if isinstance(v, dict):
            leaf_ns = NameSpace()
            ns.__dict__[k] = leaf_ns
            dump_to_namespace(leaf_ns, v)
        else:
            ns.__dict__[k] = v

config = NameSpace()
dump_to_namespace(config, config_dict)

Python：将dict中的变量加载到命名空间中

7 个答案: