blocks|key|96389|text|您必须创建一个新的OrderedDict实例。如果你的密钥是唯一的：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|96390|d1=OrderedDict([("a",1),("b",2)])
d2=OrderedDict([("c",3),("d",99)])
both=OrderedDict(list(d2.items())+%2B+list(d1.items()))
print(both)

#OrderedDict([('c',+3),+('d',+99),+('a',+1),+('b',+2)])|code-block|syntax|javascript|96391|但如果不是，请注意此行为可能是您所需的，也可能不是：|96392|d1=OrderedDict([("a",1),("b",2)])
d2=OrderedDict([("c",3),("b",99)])
both=OrderedDict(list(d2.items())+%2B+list(d1.items()))
print(both)

#OrderedDict([('c',+3),+('b',+2),+('a',+1)])|96393|entityMap^0|9|B|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

You have to make a new instance of <code>OrderedDict</code>. If your keys are unique:

<pre><code>d1=OrderedDict([("a",1),("b",2)])
d2=OrderedDict([("c",3),("d",99)])
both=OrderedDict(list(d2.items()) + list(d1.items()))
print(both)

#OrderedDict([('c', 3), ('d', 99), ('a', 1), ('b', 2)])
</code></pre>

But if not, beware as this behavior may or may not be desired for you:

<pre><code>d1=OrderedDict([("a",1),("b",2)])
d2=OrderedDict([("c",3),("b",99)])
both=OrderedDict(list(d2.items()) + list(d1.items()))
print(both)

#OrderedDict([('c', 3), ('b', 2), ('a', 1)])
</code></pre>

blocks|key|96445|text|如果你知道你想要一个'c‘键，但是不知道它的值，那么在你创建字典的时候插入一个带有虚拟值的'c’。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|96446|d1+=+OrderedDict([('c',+None),+('a',+'1'),+('b',+'2')])|code-block|syntax|javascript|96447|并在以后更改该值。|96448|d1['c']+=+3|96449|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you know you will want a 'c' key, but do not know the value, insert 'c' with a dummy value when you create the dict.

<pre><code>d1 = OrderedDict([('c', None), ('a', '1'), ('b', '2')])
</code></pre>

and change the value later.

<pre><code>d1['c'] = 3
</code></pre>

blocks|key|96409|text|现在，使用move_to_end(key，last=True)可以做到这一点|type|unstyled|depth|inlineStyleRanges|entityRanges|data|96410|>>>+d+=+OrderedDict.fromkeys('abcde')
>>>+d.move_to_end('b')
>>>+''.join(d.keys())
'acdeb'
>>>+d.move_to_end('b',+last=False)
>>>+''.join(d.keys())
'bacde'|code-block|syntax|javascript|96411|https://docs.python.org/3/library/collections.html#collections.OrderedDict.move_to_end|offset|length|96412|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|2E|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|T|8|@]|9|@$I|U|J|V|1|W]]|A|$]]|$1|K|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|H]]]]

This is now possible with move_to_end(key, last=True)

<pre><code>&gt;&gt;&gt; d = OrderedDict.fromkeys('abcde')
&gt;&gt;&gt; d.move_to_end('b')
&gt;&gt;&gt; ''.join(d.keys())
'acdeb'
&gt;&gt;&gt; d.move_to_end('b', last=False)
&gt;&gt;&gt; ''.join(d.keys())
'bacde'
</code></pre>

<a href="https://docs.python.org/3/library/collections.html#collections.OrderedDict.move_to_end" rel="noreferrer">https://docs.python.org/3/library/collections.html#collections.OrderedDict.move_to_end</a>

blocks|key|313396|text|这里的FWIW是我编写的用于插入到任意索引位置的快速n脏代码。不一定有效，但它可以在适当的地方工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|313397|class+OrderedDictInsert(OrderedDict):
++++def+insert(self,+index,+key,+value):
++++++++self[key]+=+value
++++++++for+ii,+k+in+enumerate(list(self.keys())):
++++++++++++if+ii+>=+index+and+k+!=+key:
++++++++++++++++self.move_to_end(k)|code-block|syntax|javascript|313398|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

FWIW Here is a quick-n-dirty code I wrote for inserting to an arbitrary index position. Not necessarily efficient but it works in-place.

<pre><code>class OrderedDictInsert(OrderedDict):
 def insert(self, index, key, value):
 self[key] = value
 for ii, k in enumerate(list(self.keys())):
 if ii &gt;= index and k != key:
 self.move_to_end(k)
</code></pre>

blocks|key|96309|text|如果你需要不存在的功能，只需用你想要的东西扩展这个类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|96310|from+collections+import+OrderedDict

class+OrderedDictWithPrepend(OrderedDict):
++++def+prepend(self,+other):
++++++++ins+=+[]
++++++++if+hasattr(other,+'viewitems'):
++++++++++++other+=+other.viewitems()
++++++++for+key,+val+in+other:
++++++++++++if+key+in+self:
++++++++++++++++self[key]+=+val
++++++++++++else:
++++++++++++++++ins.append((key,+val))
++++++++if+ins:
++++++++++++items+=+self.items()
++++++++++++self.clear()
++++++++++++self.update(ins)
++++++++++++self.update(items)|code-block|syntax|javascript|96311|效率不是很高，但很有效：|96312|o+=+OrderedDictWithPrepend()

o['a']+=+1
o['b']+=+2
print+o
#+OrderedDictWithPrepend([('a',+1),+('b',+2)])

o.prepend({'c':+3})
print+o
#+OrderedDictWithPrepend([('c',+3),+('a',+1),+('b',+2)])

o.prepend([('a',11),('d',55),('e',66)])
print+o
#+OrderedDictWithPrepend([('d',+55),+('e',+66),+('c',+3),+('a',+11),+('b',+2)])|96313|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you need functionality that isn't there, just extend the class with whatever you want:

<pre><code>from collections import OrderedDict

class OrderedDictWithPrepend(OrderedDict):
 def prepend(self, other):
 ins = []
 if hasattr(other, 'viewitems'):
 other = other.viewitems()
 for key, val in other:
 if key in self:
 self[key] = val
 else:
 ins.append((key, val))
 if ins:
 items = self.items()
 self.clear()
 self.update(ins)
 self.update(items)
</code></pre>

Not terribly efficient, but works:

<pre><code>o = OrderedDictWithPrepend()

o['a'] = 1
o['b'] = 2
print o
# OrderedDictWithPrepend([('a', 1), ('b', 2)])

o.prepend({'c': 3})
print o
# OrderedDictWithPrepend([('c', 3), ('a', 1), ('b', 2)])

o.prepend([('a',11),('d',55),('e',66)])
print o
# OrderedDictWithPrepend([('d', 55), ('e', 66), ('c', 3), ('a', 11), ('b', 2)])
</code></pre>

blocks|key|96353|text|我建议在这个纯Python+ActiveState+recipe中添加一个prepend()方法，或者从它派生一个子类。考虑到用于排序的底层数据结构是链表，这样做的代码可能是相当有效的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|96354|更新|96355|为了证明这种方法是可行的，下面是执行建议的代码。作为奖励，我还做了一些额外的小改动，以便在Python+2.7.15和3.7.1中都能工作。|96356|一个prepend()方法被添加到配方中的类中，并通过另一个名为move_to_end()的方法实现，该方法是在Python3.2中添加到OrderedDict中的。|96357|prepend()也可以直接实现，几乎与@Ashwini+Chaudhary的answer-and开头所示完全一样，这样做可能会使它稍微快一点，但这已经留给有动机的读者作为练习……|96358|#+Ordered+Dictionary+for+Py2.4+from+https://code.activestate.com/recipes/576693

#+Backport+of+OrderedDict()+class+that+runs+on+Python+2.4,+2.5,+2.6,+2.7+and+pypy.
#+Passes+Python2.7's+test+suite+and+incorporates+all+the+latest+updates.

try:
++++from+thread+import+get_ident+as+_get_ident
except+ImportError:++#+Python+3
#++++from+dummy_thread+import+get_ident+as+_get_ident
++++from+_thread+import+get_ident+as+_get_ident++#+Changed+-+martineau

try:
++++from+_abcoll+import+KeysView,+ValuesView,+ItemsView
except+ImportError:
++++pass

class+MyOrderedDict(dict):
++++'Dictionary+that+remembers+insertion+order'
++++#+An+inherited+dict+maps+keys+to+values.
++++#+The+inherited+dict+provides+__getitem__,+__len__,+__contains__,+and+get.
++++#+The+remaining+methods+are+order-aware.
++++#+Big-O+running+times+for+all+methods+are+the+same+as+for+regular+dictionaries.

++++#+The+internal+self.__map+dictionary+maps+keys+to+links+in+a+doubly+linked+list.
++++#+The+circular+doubly+linked+list+starts+and+ends+with+a+sentinel+element.
++++#+The+sentinel+element+never+gets+deleted+(this+simplifies+the+algorithm).
++++#+Each+link+is+stored+as+a+list+of+length+three:++[PREV,+NEXT,+KEY].

++++def+__init__(self,+*args,+**kwds):
++++++++'''Initialize+an+ordered+dictionary.++Signature+is+the+same+as+for
++++++++regular+dictionaries,+but+keyword+arguments+are+not+recommended
++++++++because+their+insertion+order+is+arbitrary.

++++++++'''
++++++++if+len(args)+>+1:
++++++++++++raise+TypeError('expected+at+most+1+arguments,+got+%25d'+%25+len(args))
++++++++try:
++++++++++++self.__root
++++++++except+AttributeError:
++++++++++++self.__root+=+root+=+[]++#+sentinel+node
++++++++++++root[:]+=+[root,+root,+None]
++++++++++++self.__map+=+{}
++++++++self.__update(*args,+**kwds)

++++def+prepend(self,+key,+value):++#+Added+to+recipe.
++++++++self.update({key:+value})
++++++++self.move_to_end(key,+last=False)

++++####+Derived+from+cpython+3.2+source+code.
++++def+move_to_end(self,+key,+last=True):++#+Added+to+recipe.
++++++++'''Move+an+existing+element+to+the+end+(or+beginning+if+last==False).

++++++++Raises+KeyError+if+the+element+does+not+exist.
++++++++When+last=True,+acts+like+a+fast+version+of+self[key]=self.pop(key).
++++++++'''
++++++++PREV,+NEXT,+KEY+=+0,+1,+2

++++++++link+=+self.__map[key]
++++++++link_prev+=+link[PREV]
++++++++link_next+=+link[NEXT]
++++++++link_prev[NEXT]+=+link_next
++++++++link_next[PREV]+=+link_prev
++++++++root+=+self.__root

++++++++if+last:
++++++++++++last+=+root[PREV]
++++++++++++link[PREV]+=+last
++++++++++++link[NEXT]+=+root
++++++++++++last[NEXT]+=+root[PREV]+=+link
++++++++else:
++++++++++++first+=+root[NEXT]
++++++++++++link[PREV]+=+root
++++++++++++link[NEXT]+=+first
++++++++++++root[NEXT]+=+first[PREV]+=+link
++++####

++++def+__setitem__(self,+key,+value,+dict_setitem=dict.__setitem__):
++++++++'od.__setitem__(i,+y)+<==>+od[i]=y'
++++++++#+Setting+a+new+item+creates+a+new+link+which+goes+at+the+end+of+the+linked
++++++++#+list,+and+the+inherited+dictionary+is+updated+with+the+new+key/value+pair.
++++++++if+key+not+in+self:
++++++++++++root+=+self.__root
++++++++++++last+=+root[0]
++++++++++++last[1]+=+root[0]+=+self.__map[key]+=+[last,+root,+key]
++++++++dict_setitem(self,+key,+value)

++++def+__delitem__(self,+key,+dict_delitem=dict.__delitem__):
++++++++'od.__delitem__(y)+<==>+del+od[y]'
++++++++#+Deleting+an+existing+item+uses+self.__map+to+find+the+link+which+is
++++++++#+then+removed+by+updating+the+links+in+the+predecessor+and+successor+nodes.
++++++++dict_delitem(self,+key)
++++++++link_prev,+link_next,+key+=+self.__map.pop(key)
++++++++link_prev[1]+=+link_next
++++++++link_next[0]+=+link_prev

++++def+__iter__(self):
++++++++'od.__iter__()+<==>+iter(od)'
++++++++root+=+self.__root
++++++++curr+=+root[1]
++++++++while+curr+is+not+root:
++++++++++++yield+curr[2]
++++++++++++curr+=+curr[1]

++++def+__reversed__(self):
++++++++'od.__reversed__()+<==>+reversed(od)'
++++++++root+=+self.__root
++++++++curr+=+root[0]
++++++++while+curr+is+not+root:
++++++++++++yield+curr[2]
++++++++++++curr+=+curr[0]

++++def+clear(self):
++++++++'od.clear()+->+None.++Remove+all+items+from+od.'
++++++++try:
++++++++++++for+node+in+self.__map.itervalues():
++++++++++++++++del+node[:]
++++++++++++root+=+self.__root
++++++++++++root[:]+=+[root,+root,+None]
++++++++++++self.__map.clear()
++++++++except+AttributeError:
++++++++++++pass
++++++++dict.clear(self)

++++def+popitem(self,+last=True):
++++++++'''od.popitem()+->+(k,+v),+return+and+remove+a+(key,+value)+pair.
++++++++Pairs+are+returned+in+LIFO+order+if+last+is+true+or+FIFO+order+if+false.

++++++++'''
++++++++if+not+self:
++++++++++++raise+KeyError('dictionary+is+empty')
++++++++root+=+self.__root
++++++++if+last:
++++++++++++link+=+root[0]
++++++++++++link_prev+=+link[0]
++++++++++++link_prev[1]+=+root
++++++++++++root[0]+=+link_prev
++++++++else:
++++++++++++link+=+root[1]
++++++++++++link_next+=+link[1]
++++++++++++root[1]+=+link_next
++++++++++++link_next[0]+=+root
++++++++key+=+link[2]
++++++++del+self.__map[key]
++++++++value+=+dict.pop(self,+key)
++++++++return+key,+value

++++#+--+the+following+methods+do+not+depend+on+the+internal+structure+--

++++def+keys(self):
++++++++'od.keys()+->+list+of+keys+in+od'
++++++++return+list(self)

++++def+values(self):
++++++++'od.values()+->+list+of+values+in+od'
++++++++return+[self[key]+for+key+in+self]

++++def+items(self):
++++++++'od.items()+->+list+of+(key,+value)+pairs+in+od'
++++++++return+[(key,+self[key])+for+key+in+self]

++++def+iterkeys(self):
++++++++'od.iterkeys()+->+an+iterator+over+the+keys+in+od'
++++++++return+iter(self)

++++def+itervalues(self):
++++++++'od.itervalues+->+an+iterator+over+the+values+in+od'
++++++++for+k+in+self:
++++++++++++yield+self[k]

++++def+iteritems(self):
++++++++'od.iteritems+->+an+iterator+over+the+(key,+value)+items+in+od'
++++++++for+k+in+self:
++++++++++++yield+(k,+self[k])

++++def+update(*args,+**kwds):
++++++++'''od.update(E,+**F)+->+None.++Update+od+from+dict/iterable+E+and+F.

++++++++If+E+is+a+dict+instance,+does:+++++++++++for+k+in+E:+od[k]+=+E[k]
++++++++If+E+has+a+.keys()+method,+does:+++++++++for+k+in+E.keys():+od[k]+=+E[k]
++++++++Or+if+E+is+an+iterable+of+items,+does:+++for+k,+v+in+E:+od[k]+=+v
++++++++In+either+case,+this+is+followed+by:+++++for+k,+v+in+F.items():+od[k]+=+v

++++++++'''
++++++++if+len(args)+>+2:
++++++++++++raise+TypeError('update()+takes+at+most+2+positional+'
++++++++++++++++++++++++++++'arguments+(%25d+given)'+%25+(len(args),))
++++++++elif+not+args:
++++++++++++raise+TypeError('update()+takes+at+least+1+argument+(0+given)')
++++++++self+=+args[0]
++++++++#+Make+progressively+weaker+assumptions+about+"other"
++++++++other+=+()
++++++++if+len(args)+==+2:
++++++++++++other+=+args[1]
++++++++if+isinstance(other,+dict):
++++++++++++for+key+in+other:
++++++++++++++++self[key]+=+other[key]
++++++++elif+hasattr(other,+'keys'):
++++++++++++for+key+in+other.keys():
++++++++++++++++self[key]+=+other[key]
++++++++else:
++++++++++++for+key,+value+in+other:
++++++++++++++++self[key]+=+value
++++++++for+key,+value+in+kwds.items():
++++++++++++self[key]+=+value

++++__update+=+update++#+let+subclasses+override+update+without+breaking+__init__

++++__marker+=+object()

++++def+pop(self,+key,+default=__marker):
++++++++'''od.pop(k[,d])+->+v,+remove+specified+key+and+return+the+corresponding+value.
++++++++If+key+is+not+found,+d+is+returned+if+given,+otherwise+KeyError+is+raised.

++++++++'''
++++++++if+key+in+self:
++++++++++++result+=+self[key]
++++++++++++del+self[key]
++++++++++++return+result
++++++++if+default+is+self.__marker:
++++++++++++raise+KeyError(key)
++++++++return+default

++++def+setdefault(self,+key,+default=None):
++++++++'od.setdefault(k[,d])+->+od.get(k,d),+also+set+od[k]=d+if+k+not+in+od'
++++++++if+key+in+self:
++++++++++++return+self[key]
++++++++self[key]+=+default
++++++++return+default

++++def+__repr__(self,+_repr_running={}):
++++++++'od.__repr__()+<==>+repr(od)'
++++++++call_key+=+id(self),+_get_ident()
++++++++if+call_key+in+_repr_running:
++++++++++++return+'...'
++++++++_repr_running[call_key]+=+1
++++++++try:
++++++++++++if+not+self:
++++++++++++++++return+'%25s()'+%25+(self.__class__.__name__,)
++++++++++++return+'%25s(%25r)'+%25+(self.__class__.__name__,+self.items())
++++++++finally:
++++++++++++del+_repr_running[call_key]

++++def+__reduce__(self):
++++++++'Return+state+information+for+pickling'
++++++++items+=+[[k,+self[k]]+for+k+in+self]
++++++++inst_dict+=+vars(self).copy()
++++++++for+k+in+vars(MyOrderedDict()):
++++++++++++inst_dict.pop(k,+None)
++++++++if+inst_dict:
++++++++++++return+(self.__class__,+(items,),+inst_dict)
++++++++return+self.__class__,+(items,)

++++def+copy(self):
++++++++'od.copy()+->+a+shallow+copy+of+od'
++++++++return+self.__class__(self)

++++@classmethod
++++def+fromkeys(cls,+iterable,+value=None):
++++++++'''OD.fromkeys(S[,+v])+->+New+ordered+dictionary+with+keys+from+S
++++++++and+values+equal+to+v+(which+defaults+to+None).

++++++++'''
++++++++d+=+cls()
++++++++for+key+in+iterable:
++++++++++++d[key]+=+value
++++++++return+d

++++def+__eq__(self,+other):
++++++++'''od.__eq__(y)+<==>+od==y.++Comparison+to+another+OD+is+order-sensitive
++++++++while+comparison+to+a+regular+mapping+is+order-insensitive.

++++++++'''
++++++++if+isinstance(other,+MyOrderedDict):
++++++++++++return+len(self)==len(other)+and+self.items()+==+other.items()
++++++++return+dict.__eq__(self,+other)

++++def+__ne__(self,+other):
++++++++return+not+self+==+other

++++#+--+the+following+methods+are+only+used+in+Python+2.7+--

++++def+viewkeys(self):
++++++++"od.viewkeys()+->+a+set-like+object+providing+a+view+on+od's+keys"
++++++++return+KeysView(self)

++++def+viewvalues(self):
++++++++"od.viewvalues()+->+an+object+providing+a+view+on+od's+values"
++++++++return+ValuesView(self)

++++def+viewitems(self):
++++++++"od.viewitems()+->+a+set-like+object+providing+a+view+on+od's+items"
++++++++return+ItemsView(self)

if+__name__+==+'__main__':

++++d1+=+MyOrderedDict([('a',+'1'),+('b',+'2')])
++++d1.update({'c':'3'})
++++print(d1)++#+->+MyOrderedDict([('a',+'1'),+('b',+'2'),+('c',+'3')])

++++d2+=+MyOrderedDict([('a',+'1'),+('b',+'2')])
++++d2.prepend('c',+100)
++++print(d2)++#+->+MyOrderedDict([('c',+100),+('a',+'1'),+('b',+'2')])|code-block|syntax|javascript|96359|entityMap|0|LINK|mutability|MUTABLE|url|https://code.activestate.com/recipes/576693/|1|https://docs.python.org/3/library/collections.html#collections.OrderedDict.move_to_end|2|https://stackoverflow.com/a/16664932/355230^0|11|9|E|I|0|0|0|0|2|9|W|D|1X|B|W|D|1|0|0|9|13|6|2|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@$9|17|A|18|1|19]]|E|$]]|$1|F|3|G|5|6|7|1A|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1B|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]]|D|@$9|1J|A|1K|1|1L]]|E|$]]|$1|L|3|M|5|6|7|1M|8|@$9|1N|A|1O|B|C]]|D|@$9|1P|A|1Q|1|1R]]|E|$]]|$1|N|3|O|5|P|7|1S|8|@]|D|@]|E|$Q|R]]|$1|S|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|V|W|X|E|$Y|11]]|12|$5|V|W|X|E|$Y|13]]]]

I would suggest adding a <code>prepend()</code> method to this pure Python <a href="https://code.activestate.com/recipes/576693/" rel="nofollow noreferrer">ActiveState recipe</a> or deriving a subclass from it. The code to do so could be a fairly efficient given that the underlying data structure for ordering is a linked-list.
<h3>Update</h3>
To prove this approach is feasible, below is code that does what's suggested. As a bonus, I also made a few additional minor changes to get to work in both Python 2.7.15 and 3.7.1.
A <code>prepend()</code> method has been added to the class in the recipe and has been implemented in terms of another method that's been added named <a href="https://docs.python.org/3/library/collections.html#collections.OrderedDict.move_to_end" rel="nofollow noreferrer"><code>move_to_end()</code></a>, which was added to <code>OrderedDict</code> in Python 3.2.
<code>prepend()</code> can also be implemented directly, almost exactly as shown at the beginning of @Ashwini Chaudhary's <a href="https://stackoverflow.com/a/16664932/355230">answer</a>—and doing so would likely result in it being slightly faster, but that's been left as an exercise for the motivated reader...
<pre><code># Ordered Dictionary for Py2.4 from https://code.activestate.com/recipes/576693

# Backport of OrderedDict() class that runs on Python 2.4, 2.5, 2.6, 2.7 and pypy.
# Passes Python2.7's test suite and incorporates all the latest updates.

try:
 from thread import get_ident as _get_ident
except ImportError: # Python 3
# from dummy_thread import get_ident as _get_ident
 from _thread import get_ident as _get_ident # Changed - martineau

try:
 from _abcoll import KeysView, ValuesView, ItemsView
except ImportError:
 pass

class MyOrderedDict(dict):
 'Dictionary that remembers insertion order'
 # An inherited dict maps keys to values.
 # The inherited dict provides __getitem__, __len__, __contains__, and get.
 # The remaining methods are order-aware.
 # Big-O running times for all methods are the same as for regular dictionaries.

 # The internal self.__map dictionary maps keys to links in a doubly linked list.
 # The circular doubly linked list starts and ends with a sentinel element.
 # The sentinel element never gets deleted (this simplifies the algorithm).
 # Each link is stored as a list of length three: [PREV, NEXT, KEY].

 def __init__(self, *args, **kwds):
 '''Initialize an ordered dictionary. Signature is the same as for
 regular dictionaries, but keyword arguments are not recommended
 because their insertion order is arbitrary.

 '''
 if len(args) &gt; 1:
 raise TypeError('expected at most 1 arguments, got %d' % len(args))
 try:
 self.__root
 except AttributeError:
 self.__root = root = [] # sentinel node
 root[:] = [root, root, None]
 self.__map = {}
 self.__update(*args, **kwds)

 def prepend(self, key, value): # Added to recipe.
 self.update({key: value})
 self.move_to_end(key, last=False)

 #### Derived from cpython 3.2 source code.
 def move_to_end(self, key, last=True): # Added to recipe.
 '''Move an existing element to the end (or beginning if last==False).

 Raises KeyError if the element does not exist.
 When last=True, acts like a fast version of self[key]=self.pop(key).
 '''
 PREV, NEXT, KEY = 0, 1, 2

 link = self.__map[key]
 link_prev = link[PREV]
 link_next = link[NEXT]
 link_prev[NEXT] = link_next
 link_next[PREV] = link_prev
 root = self.__root

 if last:
 last = root[PREV]
 link[PREV] = last
 link[NEXT] = root
 last[NEXT] = root[PREV] = link
 else:
 first = root[NEXT]
 link[PREV] = root
 link[NEXT] = first
 root[NEXT] = first[PREV] = link
 ####

 def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
 'od.__setitem__(i, y) &lt;==&gt; od[i]=y'
 # Setting a new item creates a new link which goes at the end of the linked
 # list, and the inherited dictionary is updated with the new key/value pair.
 if key not in self:
 root = self.__root
 last = root[0]
 last[1] = root[0] = self.__map[key] = [last, root, key]
 dict_setitem(self, key, value)

 def __delitem__(self, key, dict_delitem=dict.__delitem__):
 'od.__delitem__(y) &lt;==&gt; del od[y]'
 # Deleting an existing item uses self.__map to find the link which is
 # then removed by updating the links in the predecessor and successor nodes.
 dict_delitem(self, key)
 link_prev, link_next, key = self.__map.pop(key)
 link_prev[1] = link_next
 link_next[0] = link_prev

 def __iter__(self):
 'od.__iter__() &lt;==&gt; iter(od)'
 root = self.__root
 curr = root[1]
 while curr is not root:
 yield curr[2]
 curr = curr[1]

 def __reversed__(self):
 'od.__reversed__() &lt;==&gt; reversed(od)'
 root = self.__root
 curr = root[0]
 while curr is not root:
 yield curr[2]
 curr = curr[0]

 def clear(self):
 'od.clear() -&gt; None. Remove all items from od.'
 try:
 for node in self.__map.itervalues():
 del node[:]
 root = self.__root
 root[:] = [root, root, None]
 self.__map.clear()
 except AttributeError:
 pass
 dict.clear(self)

 def popitem(self, last=True):
 '''od.popitem() -&gt; (k, v), return and remove a (key, value) pair.
 Pairs are returned in LIFO order if last is true or FIFO order if false.

 '''
 if not self:
 raise KeyError('dictionary is empty')
 root = self.__root
 if last:
 link = root[0]
 link_prev = link[0]
 link_prev[1] = root
 root[0] = link_prev
 else:
 link = root[1]
 link_next = link[1]
 root[1] = link_next
 link_next[0] = root
 key = link[2]
 del self.__map[key]
 value = dict.pop(self, key)
 return key, value

 # -- the following methods do not depend on the internal structure --

 def keys(self):
 'od.keys() -&gt; list of keys in od'
 return list(self)

 def values(self):
 'od.values() -&gt; list of values in od'
 return [self[key] for key in self]

 def items(self):
 'od.items() -&gt; list of (key, value) pairs in od'
 return [(key, self[key]) for key in self]

 def iterkeys(self):
 'od.iterkeys() -&gt; an iterator over the keys in od'
 return iter(self)

 def itervalues(self):
 'od.itervalues -&gt; an iterator over the values in od'
 for k in self:
 yield self[k]

 def iteritems(self):
 'od.iteritems -&gt; an iterator over the (key, value) items in od'
 for k in self:
 yield (k, self[k])

 def update(*args, **kwds):
 '''od.update(E, **F) -&gt; None. Update od from dict/iterable E and F.

 If E is a dict instance, does: for k in E: od[k] = E[k]
 If E has a .keys() method, does: for k in E.keys(): od[k] = E[k]
 Or if E is an iterable of items, does: for k, v in E: od[k] = v
 In either case, this is followed by: for k, v in F.items(): od[k] = v

 '''
 if len(args) &gt; 2:
 raise TypeError('update() takes at most 2 positional '
 'arguments (%d given)' % (len(args),))
 elif not args:
 raise TypeError('update() takes at least 1 argument (0 given)')
 self = args[0]
 # Make progressively weaker assumptions about &quot;other&quot;
 other = ()
 if len(args) == 2:
 other = args[1]
 if isinstance(other, dict):
 for key in other:
 self[key] = other[key]
 elif hasattr(other, 'keys'):
 for key in other.keys():
 self[key] = other[key]
 else:
 for key, value in other:
 self[key] = value
 for key, value in kwds.items():
 self[key] = value

 __update = update # let subclasses override update without breaking __init__

 __marker = object()

 def pop(self, key, default=__marker):
 '''od.pop(k[,d]) -&gt; v, remove specified key and return the corresponding value.
 If key is not found, d is returned if given, otherwise KeyError is raised.

 '''
 if key in self:
 result = self[key]
 del self[key]
 return result
 if default is self.__marker:
 raise KeyError(key)
 return default

 def setdefault(self, key, default=None):
 'od.setdefault(k[,d]) -&gt; od.get(k,d), also set od[k]=d if k not in od'
 if key in self:
 return self[key]
 self[key] = default
 return default

 def __repr__(self, _repr_running={}):
 'od.__repr__() &lt;==&gt; repr(od)'
 call_key = id(self), _get_ident()
 if call_key in _repr_running:
 return '...'
 _repr_running[call_key] = 1
 try:
 if not self:
 return '%s()' % (self.__class__.__name__,)
 return '%s(%r)' % (self.__class__.__name__, self.items())
 finally:
 del _repr_running[call_key]

 def __reduce__(self):
 'Return state information for pickling'
 items = [[k, self[k]] for k in self]
 inst_dict = vars(self).copy()
 for k in vars(MyOrderedDict()):
 inst_dict.pop(k, None)
 if inst_dict:
 return (self.__class__, (items,), inst_dict)
 return self.__class__, (items,)

 def copy(self):
 'od.copy() -&gt; a shallow copy of od'
 return self.__class__(self)

 @classmethod
 def fromkeys(cls, iterable, value=None):
 '''OD.fromkeys(S[, v]) -&gt; New ordered dictionary with keys from S
 and values equal to v (which defaults to None).

 '''
 d = cls()
 for key in iterable:
 d[key] = value
 return d

 def __eq__(self, other):
 '''od.__eq__(y) &lt;==&gt; od==y. Comparison to another OD is order-sensitive
 while comparison to a regular mapping is order-insensitive.

 '''
 if isinstance(other, MyOrderedDict):
 return len(self)==len(other) and self.items() == other.items()
 return dict.__eq__(self, other)

 def __ne__(self, other):
 return not self == other

 # -- the following methods are only used in Python 2.7 --

 def viewkeys(self):
 &quot;od.viewkeys() -&gt; a set-like object providing a view on od's keys&quot;
 return KeysView(self)

 def viewvalues(self):
 &quot;od.viewvalues() -&gt; an object providing a view on od's values&quot;
 return ValuesView(self)

 def viewitems(self):
 &quot;od.viewitems() -&gt; a set-like object providing a view on od's items&quot;
 return ItemsView(self)

if __name__ == '__main__':

 d1 = MyOrderedDict([('a', '1'), ('b', '2')])
 d1.update({'c':'3'})
 print(d1) # -&gt; MyOrderedDict([('a', '1'), ('b', '2'), ('c', '3')])

 d2 = MyOrderedDict([('a', '1'), ('b', '2')])
 d2.prepend('c', 100)
 print(d2) # -&gt; MyOrderedDict([('c', 100), ('a', '1'), ('b', '2')])
</code></pre>

blocks|key|96531|text|在Python+2.7中使用@Ashwini+Chaudhary+answer打印或保存字典时，我遇到了无限循环。但我设法减少了他的代码，并让它在这里工作：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|96532|def+move_to_dict_beginning(dictionary,+key):
++++"""
++++++++Move+a+OrderedDict+item+to+its+beginning,+or+add+it+to+its+beginning.
++++++++Compatible+with+Python+2.7
++++"""

++++if+sys.version_info[0]+<+3:
++++++++value+=+dictionary[key]
++++++++del+dictionary[key]
++++++++root+=+dictionary._OrderedDict__root

++++++++first+=+root[1]
++++++++root[1]+=+first[0]+=+dictionary._OrderedDict__map[key]+=+[root,+first,+key]
++++++++dict.__setitem__(dictionary,+key,+value)

++++else:
++++++++dictionary.move_to_end(+key,+last=False+)|code-block|syntax|javascript|96533|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/846892/ashwini-chaudhary^0|8|3|E|I|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

I got an infinity loop while trying to print or save the dictionary using <a href="https://stackoverflow.com/users/846892/ashwini-chaudhary">@Ashwini Chaudhary</a> answer with Python <code>2.7</code>. But I managed to reduce his code a little, and got it working here:

<pre><code>def move_to_dict_beginning(dictionary, key):
 """
 Move a OrderedDict item to its beginning, or add it to its beginning.
 Compatible with Python 2.7
 """

 if sys.version_info[0] &lt; 3:
 value = dictionary[key]
 del dictionary[key]
 root = dictionary._OrderedDict__root

 first = root[1]
 root[1] = first[0] = dictionary._OrderedDict__map[key] = [root, first, key]
 dict.__setitem__(dictionary, key, value)

 else:
 dictionary.move_to_end( key, last=False )
</code></pre>

blocks|key|96544|text|这是一个默认的有序字典，它允许在任何位置插入项目并使用。用于创建密钥的运算符：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|96545|from+collections+import+OrderedDict

class+defdict(OrderedDict):

++++_protected+=+["_OrderedDict__root",+"_OrderedDict__map",+"_cb"]++++
++++_cb+=+None

++++def+__init__(self,+cb=None):
++++++++super(defdict,+self).__init__()
++++++++self._cb+=+cb

++++def+__setattr__(self,+name,+value):
++++++++#+if+the+attr+is+not+in+self._protected+set+a+key
++++++++if+name+in+self._protected:
++++++++++++OrderedDict.__setattr__(self,+name,+value)
++++++++else:
++++++++++++OrderedDict.__setitem__(self,+name,+value)

++++def+__getattr__(self,+name):
++++++++if+name+in+self._protected:
++++++++++++return+OrderedDict.__getattr__(self,+name)
++++++++else:
++++++++++++#+implements+missing+keys
++++++++++++#+if+there+is+a+callable+_cb,+create+a+key+with+its+value
++++++++++++try:
++++++++++++++++return+OrderedDict.__getitem__(self,+name)
++++++++++++except+KeyError+as+e:
++++++++++++++++if+callable(self._cb):
++++++++++++++++++++value+=+self[name]+=+self._cb()
++++++++++++++++++++return+value
++++++++++++++++raise+e

++++def+insert(self,+index,+name,+value):
++++++++items+=+[(k,+v)+for+k,+v+in+self.items()]
++++++++items.insert(index,+(name,+value))
++++++++self.clear()
++++++++for+k,+v+in+items:
++++++++++++self[k]+=+v


asd+=+defdict(lambda:+10)
asd.k1+=+"Hey"
asd.k3+=+"Bye"
asd.k4+=+"Hello"
asd.insert(1,+"k2",+"New+item")
print+asd.k5+#+access+a+missing+key+will+create+one+when+there+is+a+callback
#+10
asd.k6+%2B=+5++#+adding+to+a+missing+key
print+asd.k6
#+15
print+asd.keys()
#+['k1',+'k2',+'k3',+'k4',+'k5',+'k6']
print+asd.values()
#+['Hey',+'New+item',+'Bye',+'Hello',+10,+15]|code-block|syntax|javascript|96546|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is a default, ordered dict which allows to insert items in any position and use the . operator to create keys:

<pre><code>from collections import OrderedDict

class defdict(OrderedDict):

 _protected = ["_OrderedDict__root", "_OrderedDict__map", "_cb"] 
 _cb = None

 def __init__(self, cb=None):
 super(defdict, self).__init__()
 self._cb = cb

 def __setattr__(self, name, value):
 # if the attr is not in self._protected set a key
 if name in self._protected:
 OrderedDict.__setattr__(self, name, value)
 else:
 OrderedDict.__setitem__(self, name, value)

 def __getattr__(self, name):
 if name in self._protected:
 return OrderedDict.__getattr__(self, name)
 else:
 # implements missing keys
 # if there is a callable _cb, create a key with its value
 try:
 return OrderedDict.__getitem__(self, name)
 except KeyError as e:
 if callable(self._cb):
 value = self[name] = self._cb()
 return value
 raise e

 def insert(self, index, name, value):
 items = [(k, v) for k, v in self.items()]
 items.insert(index, (name, value))
 self.clear()
 for k, v in items:
 self[k] = v


asd = defdict(lambda: 10)
asd.k1 = "Hey"
asd.k3 = "Bye"
asd.k4 = "Hello"
asd.insert(1, "k2", "New item")
print asd.k5 # access a missing key will create one when there is a callback
# 10
asd.k6 += 5 # adding to a missing key
print asd.k6
# 15
print asd.keys()
# ['k1', 'k2', 'k3', 'k4', 'k5', 'k6']
print asd.values()
# ['Hey', 'New item', 'Bye', 'Hello', 10, 15]
</code></pre>

I have this:

<pre><code>d1 = OrderedDict([('a', '1'), ('b', '2')])
</code></pre>

If I do this:

<pre><code>d1.update({'c':'3'})
</code></pre>

Then I get this:

<pre><code>OrderedDict([('a', '1'), ('b', '2'), ('c', '3')])
</code></pre>

but I want this:

<pre><code>[('c', '3'), ('a', '1'), ('b', '2')]
</code></pre>

without creating new dictionary.

How to add an element to the beginning of an OrderedDict?

数据结构

Python

我有这个：d1 = OrderedDict([('a', '1'), ('b', '2')])如果我这样做：d1.update({'c':'3'})然后我得到了这个：OrderedDict([('a', '1'), ('b', '2'), ('c', '3')])但我想要的是：[('c', '3'), ('a', '1'), ('b', '2')]而不创建新的字典。

问如何在OrderedDict的开头添加元素？
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在OrderedDict的开头添加元素？EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在OrderedDict的开头添加元素？
EN