在这篇文章中，我们将带领您了解覆盖{…}表示法，以便获得OrderedDict的全貌，包括而不是dict的相关情况。同时，我们还将为您介绍有关Angular的$q.reject（）与deferred.

在这篇文章中，我们将带领您了解覆盖{…}表示法，以便获得OrderedDict的全貌，包括而不是dict的相关情况。同时，我们还将为您介绍有关Angular的$ q.reject（）与deferred.reject（）、JPA EntityManager：为什么使用persist（）而不是merge（）？、multiprocessing.Manager（）dict（）setdefault（）是否损坏？、multiprocessing.Manager（）。dict（）。setdefault（）是否损坏？的知识，以帮助您更好地理解这个主题。

• 覆盖{…}表示法，以便获得OrderedDict（）而不是dict（）？（覆盖equals）
• Angular的$ q.reject（）与deferred.reject（）
• JPA EntityManager：为什么使用persist（）而不是merge（）？
• multiprocessing.Manager（）dict（）setdefault（）是否损坏？
• multiprocessing.Manager（）。dict（）。setdefault（）是否损坏？

覆盖{…}表示法，以便获得OrderedDict（）而不是dict（）？（覆盖equals）

更新：Python 3.7+可确保保留插入顺序的字典

我想使用.py文件，例如配置文件。因此，使用这种{...}表示法，我可以使用字符串作为键来创建字典，但是在标准的python字典中定义顺序会丢失。

我的问题：是否可以重写{...}表示法，以便我得到OrderedDict()而不是dict()？

我希望仅使用OrderedDict（dict = OrderedDict）覆盖dict构造函数即可，但事实并非如此。

例如：

dict = OrderedDictdictname = {   ''B key'': ''value1'',   ''A key'': ''value2'',   ''C key'': ''value3''   }print dictname.items()

输出：

[(''B key'', ''value1''), (''A key'', ''value2''), (''C key'', ''value3'')]

答案1

这几乎可以为您提供所需的语法：

class _OrderedDictMaker(object):    def __getitem__(self, keys):        if not isinstance(keys, tuple):            keys = (keys,)        assert all(isinstance(key, slice) for key in keys)        return OrderedDict([(k.start, k.stop) for k in keys])ordereddict = _OrderedDictMaker()from nastyhacks import ordereddictmenu = ordereddict[   "about" : "about",   "login" : "login",   ''signup'': "signup"]

编辑：
有人独立发现了这一点，并odictliteral在PyPI上发布了该软件包，该软件包提供了更为彻底的实现-
改用该软件包

Angular的$ q.reject（）与deferred.reject（）

var deferred = $q.defer()

...(and then from console inspection)...

$q: Object {defer: function,reject: function,when: function,all: function}

deferred: Object {resolve: function,notify: function,promise: Object}

deferred.promise: Object {then: function,catch: function,finally: function}

JPA EntityManager：为什么使用persist（）而不是merge（）？

multiprocessing.Manager（）dict（）setdefault（）是否损坏？

>>> import multiprocessing
>>> mgr = multiprocessing.Manager()
>>> d = mgr.dict()
>>> d.setdefault('foo',[]).append({'bar': 'baz'})
>>> print d.items()
[('foo',[])]         <-- Where did the dict go?

>>> e = mgr.dict()
>>> e['foo'] = [{'bar': 'baz'}]
>>> print e.items()
[('foo',[{'bar': 'baz'}])]

>>> sys.version
'2.7.2+ (default,Jan 20 2012,23:05:38) \n[GCC 4.6.2]'

>>> sys.version
'3.2.2rc1 (default,Aug 14 2011,21:09:07) \n[GCC 4.6.1]'

>>> e['foo'] = [{'bar': 'baz'}]
>>> print(e.items())
[('foo',[{'bar': 'baz'}])]

>>> id(type(e['foo']))
137341152
>>> id(type([]))
137341152

>>> e['foo'].append({'asdf': 'fdsa'})
>>> print(e.items())
[('foo',[{'bar': 'baz'}])]

multiprocessing.Manager（）。dict（）。setdefault（）是否损坏？

其后期且可能是愚蠢的部门提出：

>>> import multiprocessing>>> mgr = multiprocessing.Manager()>>> d = mgr.dict()>>> d.setdefault(''foo'', []).append({''bar'': ''baz''})>>> print d.items()[(''foo'', [])]         <-- Where did the dict go?

鉴于：

>>> e = mgr.dict()>>> e[''foo''] = [{''bar'': ''baz''}]>>> print e.items()[(''foo'', [{''bar'': ''baz''}])]

版：

>>> sys.version''2.7.2+ (default, Jan 20 2012, 23:05:38) \n[GCC 4.6.2]''

虫子还是臭虫？

编辑：更多相同，在python 3.2上：

>>> sys.version''3.2.2rc1 (default, Aug 14 2011, 21:09:07) \n[GCC 4.6.1]''>>> e[''foo''] = [{''bar'': ''baz''}]>>> print(e.items())[(''foo'', [{''bar'': ''baz''}])]>>> id(type(e[''foo'']))137341152>>> id(type([]))137341152>>> e[''foo''].append({''asdf'': ''fdsa''})>>> print(e.items())[(''foo'', [{''bar'': ''baz''}])]

字典代理中的列表如何不包含其他元素？

答案1

这是一些非常有趣的行为，我不确定它是如何工作的，但我会弄清楚为什么是这样的行为。

首先，请注意multiprocessing.Manager().dict()不是dict，而是一个DictProxy对象：

>>> d = multiprocessing.Manager().dict()>>> d<DictProxy object, typeid ''dict'' at 0x7fa2bbe8ea50>

DictProxy该类的目的是为您提供一个dict可以在进程之间共享的安全对象，这意味着它必须在常规dict功能之上实现一些锁定。

显然，此处实现的一部分是不允许您直接访问嵌套在内的可变对象DictProxy，因为如果允许，您将能够以绕过所有使DictProxy安全使用的锁定的方式修改共享对象。

这是一些您无法访问可变对象的证据，这与发生的情况类似setdefault()：

>>> d[''foo''] = []>>> foo = d[''foo'']>>> id(d[''foo''])140336914055536>>> id(foo)140336914056184

使用普通字典，您会期望d[''foo'']并foo指向同一个列表对象，而对一个字典的修改会修改另一个。如您所见，DictProxy由于多处理模块强加了额外的过程安全性要求，因此该类并非如此。

编辑：
以下来自多处理文档的注释阐明了我在上面试图说的内容：

注意：
对dict和list代理中的可变值或项的修改不会通过管理器传播，因为代理无法知道何时修改其值或项。要修改此类项目，可以将修改后的对象重新分配给容器代理：

# create a list proxy and append a mutable object (a dictionary)lproxy = manager.list()lproxy.append({})# now mutate the dictionaryd = lproxy[0]d[''a''] = 1d[''b''] = 2# at this point, the changes to d are not yet synced, but by# reassigning the dictionary, the proxy is notified of the changelproxy[0] = d

根据上述信息，以下是您如何重写原始代码以与一起使用的方法DictProxy：

# d.setdefault(''foo'', []).append({''bar'': ''baz''})d[''foo''] = d.get(''foo'', []) + [{''bar'': ''baz''}]

正如Edward Loper在评论中建议的那样，对以上代码进行了编辑，以 get() 代替 setdefault()。

今天的关于覆盖{…}表示法，以便获得OrderedDict和而不是dict的分享已经结束，谢谢您的关注，如果想了解更多关于Angular的$ q.reject（）与deferred.reject（）、JPA EntityManager：为什么使用persist（）而不是merge（）？、multiprocessing.Manager（）dict（）setdefault（）是否损坏？、multiprocessing.Manager（）。dict（）。setdefault（）是否损坏？的相关知识，请在本站进行查询。