天道酬勤,学无止境

字典中FIFO顺序的pythonic方式(pythonic way for FIFO order in Dictionary)

问题

我正在尝试在 python 中填充字典,但我想保留键进入时的顺序 - 完全像列表一样的 FIFO 可以做到。

例如,

我阅读了一个名为 animal.txt 的文件,其中包含以下信息:

animal\tconservation_status\n
dog\tdomesticated\n
tiger\tEN\n
panda\tEN\n

IE,

animals = {'dog':'dom','tiger':'EN', 'panda':'EN'}
>>> for el in animals:
...     print el
... 
tiger
dog
panda

在 FIFO 中应该是狗、老虎、熊猫,因为它们出来了……

当我将其读入字典时,将不会保留顺序。 我希望保留顺序,这样当我执行 for 循环时,FIRST IN 是 FIRST OUT。

即,狗,然后是老虎,然后是熊猫。

有没有一种很好的方法可以做到这一点而不必保留外部索引或更复杂的字典结构? 不确定,抱歉我在这里的天真......

回答1

是的。 您使用 collections.OrderedDict 而不是常规字典。

>>> d = OrderedDict((x,x) for x in reversed(range(10)) )
>>> d
OrderedDict([(9, 9), (8, 8), (7, 7), (6, 6), (5, 5), (4, 4), (3, 3), (2, 2), (1, 1), (0, 0)])
>>> regular = dict((x,x) for x in reversed(range(10)))
>>> regular
{0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9}

请注意, OrderedDict保留了顺序,而常规dict则没有。


>>> OrderedDict([('dog','dom'),('tiger','EN'), ('panda','EN')])
OrderedDict([('dog', 'dom'), ('tiger', 'EN'), ('panda', 'EN')])

另一个问题是您需要以保留顺序的方式将项目传递给构造函数(或.update )。 换句话说,您不能将关键字参数传递给构造函数并期望保留顺序:

>>> OrderedDict(dog='dom',tiger='EN',panda='EN')  #doesn't preserve order
OrderedDict([('tiger', 'EN'), ('panda', 'EN'), ('dog', 'dom')])

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • pythonic way for FIFO order in Dictionary
    I am trying to populate a dictionary in python but I would like to preserve the order of the keys as they get in - exactly FIFO like a list would do it. For example, I read a file called animals.txt containing the following information: animal\tconservation_status\n dog\tdomesticated\n tiger\tEN\n panda\tEN\n I.e., animals = {'dog':'dom','tiger':'EN', 'panda':'EN'} >>> for el in animals: ... print el ... tiger dog panda And in a FIFO SHOULD have been dog, tiger, panda as they come out... When I read it into a dictionary the order will not be preserved. I would like the order to be preserved
  • 从multiprocessing.Queue获得近LIFO行为的干净方法吗? (或什至只是*不是*近FIFO)(Clean way to get near-LIFO behavior from multiprocessing.Queue? (or even just *not* near-FIFO))
    问题 有谁知道一种干净的方法来从multiprocessing.Queue获得接近LIFO的行为,甚至不获得接近FIFO(例如,随机)的行为? 替代问题:有人可以指出我在multiprocessing.Queue之后管理实际存储结构的线程的代码吗? 提供大约LIFO访问似乎很简单,但是我迷失在试图找到它的兔子洞中。 笔记: 我相信multiprocessing.Queue不能保证顺序。 美好的。 但是它是近FIFO的,所以近LIFO会很棒。 我可以将所有当前项目从队列中拉出,并在使用它们之前颠倒顺序,但是如果可能的话,我宁愿避免混乱。 (编辑)澄清一下:我正在用multiprocessing进行CPU限制的仿真,因此不能使用Queue的专用队列。 由于几天没有看到任何答案,因此我在上面添加了替代问题。 万一这是一个问题,下面有一点证据表明multiprocessing.Queue是接近FIFO的。 它只是表明在一个简单的情况下(单线程),它在我的系统上是完美的FIFO: import multiprocessing as mp import Queue q = mp.Queue() for i in xrange(1000): q.put(i) deltas = [] while True: try: value1 = q.get(timeout=0.1) value2 = q
  • Python中的有序字典(Ordered Dictionary in Python)
    问题 我在Python中有一个这样的字典:dict = {'a':1,'q':1,'l':2,'m':1,'u':1,'i':1} 有什么方法可以保持此字典的顺序以这种方式表示。 我已经阅读了几个论坛,其中大多数建议使用OrderedDict()。 但正如这里解释的那样: Python OrderedDict不保持元素顺序 以该形式编写字典时,OrderedDict(dict)将不保留顺序。 我无法以特定方式手动创建字典(例如,元组列表),因为它是由其他地方的代码随机生成的。 非常感谢您的帮助! 回答1 当您写出dict = {'a':1, 'q':1, 'l':2, 'm':1, 'u':1, 'i':1} ,您已经丢失了订单的元素。 保持方式: 一种。 首先从您的数据创建OrderedDict 。 b。 将您的dict转换为元组列表,并以所需的方式进行排序,然后从中创建OrderedDict 。 总而言之,从您的问题还不清楚您要保留什么。 如果它是“随机”生成的,那么谁在乎,如果背后有某种逻辑,则可以使用该逻辑来重新创建该订单并使用它创建OrderedDict 。 如果在幕后发生了一些事情,这些事情是根据一些输入数据创建该字典的,那么,a,您看到它的顺序并不是它被创建的顺序。 附dict别叫你的dict 。 回答2 如果要订购的字典是在控件之外创建的
  • 字典中的键顺序(Order of keys in dictionary)
    问题 我有一本字典 {'a': 'first', 'b': 'second'} 但是,我需要字典的顺序不同: {'b': 'second', 'a': 'first'} 做这个的最好方式是什么? 回答1 字典没有顺序。 因此,没有办法做到这一点。 如果您使用的是python2.7 +,则可以使用collections.OrderedDict在这种情况下,您可以使用.items()检索商品列表,然后对其进行反转,并从反转的列表中创建一个新的OrderedDict : >>> od = OrderedDict((('a', 'first'), ('b', 'second'))) >>> od OrderedDict([('a', 'first'), ('b', 'second')]) >>> items = od.items() # list(od.items()) in Python3 >>> items.reverse() >>> OrderedDict(items) OrderedDict([('b', 'second'), ('a', 'first')]) 如果您使用的是较旧的python版本,则可以从http://code.activestate.com/recipes/576693/获得反向移植 回答2 字典没有顺序。 您可以获取键,按自己喜欢的顺序对其进行排序
  • 为什么字典中的项目顺序在Python中发生了变化? [复制](Why items order in a dictionary changed in Python? [duplicate])
    问题 这个问题已经在这里有了答案: 如何保持键/值与声明的顺序相同? (13个回答) 7年前关闭。 我正在尝试从一些教程中学习Python。 这是我遇到的一个简单例子,使我感到困惑。 >>> d={"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"} >>> d {'pwd': 'secret', 'database': 'master', 'uid': 'sa', 'server': 'mpilgrim'} >>> d.keys() ['pwd', 'database', 'uid', 'server'] >>> d.values() ['secret', 'master', 'sa', 'mpilgrim'] 如您在定义字典的第一行中所见,项目"pwd":"secret"是字典中的最后一个元素。 但是,当我输出字典时,它成为第一个元素。 字典的其余部分已重新排序。 我可以知道为什么会这样吗? 如果我使用dict.keys()从字典中提取密钥并按照我认为的顺序对其进行迭代,那会导致不匹配问题吗? 回答1 我可以知道为什么会这样吗? 这是因为dict是内部组织的方式。 简而言之,这通过哈希表进行工作,该哈希表根据密钥的hash()值将其放入存储桶中。 如果我使用dict.keys(
  • 是否可以保证Python列表的元素保持其插入顺序不变?(Is a Python list guaranteed to have its elements stay in the order they are inserted in?)
    问题 如果我有以下Python代码 >>> x = [] >>> x = x + [1] >>> x = x + [2] >>> x = x + [3] >>> x [1, 2, 3] 是否可以保证x始终为[1,2,3] ,还是可能对中间元素进行其他排序? 回答1 是的,python列表中元素的顺序是持久的。 回答2 简而言之,是的,顺序被保留。 总而言之: 通常,以下定义将始终应用于列表之类的对象: 列表是元素的集合,这些元素可以包含重复的元素,并且具有定义的顺序,除非明确进行更改,否则顺序通常不会更改。 堆栈和队列都是列表的两种类型,它们为添加和删除元素(堆栈为LIFO,队列为FIFO)提供特定(通常是有限的)行为。 列表是事物列表的实际表示。 可以将字符串视为字符列表,因为顺序很重要( "abc" != "bca" ),并且肯定允许字符串内容重复( "aaa"可以存在并且!= "a" )。 集合是元素的集合,这些元素不能包含重复项,并且具有不确定的顺序,该顺序可以随时间变化或可以不随时间变化。 集不代表事物列表,而是描述事物的某种选择的程度。 集合的内部结构及其元素之间的相对存储方式通常并不意味着传达有用的信息。 在某些实现中,集合始终在内部进行排序。 在其他情况下,顺序只是不确定的(通常取决于哈希函数)。 集合是一个通用术语,指的是用于存储(通常是可变的
  • Python 并且没有明显的方法可以从字典中获取特定元素(Python and no obvious way to get a specific element from a dictionary)
    问题 为什么我可以轻松地在 Python 中执行 for 循环以按照附加元素的顺序遍历字典的所有元素,但没有明显的方法来访问特定元素? 当我说元素时,我指的是键+值对。 我已经浏览了一些关于 Python 的基本教程在字典上说的内容,但没有一个回答我的问题,我也无法在 docs.python.org 中找到我的答案。 根据:访问 python 字典中的特定元素(Senderies 注释)一个 dict 应该是无序的,但是为什么 for 循环会按照我放入它们的顺序打印它们? 回答1 您可以通过键访问字典中的特定元素。 字典就是这样。 如果该行为不是您想要的,请使用字典以外的其他内容。 dict 应该是无序的,但是为什么 for 循环会按照我放入的顺序打印它们? 巧合:基本上,你碰巧按照 Python 喜欢的顺序排列它们。 这并不难做到,尤其是对于整数( int是它们自己的散列,并且倾向于以数字升序从 dict 中出来,尽管这是 CPython 的一个实现细节,在其他 Python 实现中可能并非如此),尤其是当您将它们按数字顺序排列时。 “无序”实际上意味着您无法控制顺序,并且它可能会因各种特定于实现的标准而改变,因此您不应依赖它。 当然,当您迭代字典时,元素会以某种顺序出现。 如果您需要能够通过数字索引访问字典元素,有很多方法可以做到这一点。 collections
  • 如何修复 Python 3 中字典处理的顺序?(How to fix the order of dictionary handling in Python 3?)
    问题 有没有办法可靠地修复 Python 3 中字典处理的顺序,即以可预测的顺序建立对键和值的迭代? 出于调试目的和重现失败,据说是基于 python 3.3 和 3.4 中的字典访问,我需要以某种方式使字典上的迭代可预测。 我的意思是我想修复在 Python 程序开始时执行任何迭代的方式。 这样多次启动程序,调用dict.items() , dict.keys() , dict.values()总是产生相同顺序的元素。 更重要的是,通过设置散列函数的某种种子值来改变这个顺序会很好。 我怎样才能做到这一点? 这仅用于调试,我不想也不能使用sorted(dict.keys())或OrderedDict 。 谢谢! 回答1 你应该看看PYTHONHASHSEED环境变量: https://docs.python.org/3/using/cmdline.html#envvar-PYTHONHASHSEED 将其设置为固定整数,然后您的哈希种子是确定性的。
  • 自定义排序Python字典(Custom Sorting Python Dictionary)
    问题 因此,我有一个字典在打印时看起来像这样: {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25} 我想以我定义的自定义方式对它们进行排序。 假设我希望按键排序的方式是ZT21, 10, WX21, UM, 5, 2 。 有人知道如何以预定义/自定义的方式整理字典吗? 我正在做的是从数据库中获取此词典,它可以带有20多个键,所有键都有特定的顺序。 总是设置顺序,但是有时某些键/值不会出现在字典中。 因此,这也可能发生: {'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25} 按键排序的是ZT21, 10, WX21, UM, 5, 2 。 因此,在此示例中不存在10,但是我需要的排序仍然相同,仅会缺少10。 有任何想法吗? 回答1 Python中的字典是无序的。 您可以获得list所需的结果 >>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25} >>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2'] >>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
  • 列表vs ArrayList vs字典vs哈希表vs堆栈vs队列? [关闭](List vs ArrayList vs Dictionary vs Hashtable vs Stack vs Queue? [closed])
    问题 关门了。 这个问题需要更加集中。 它当前不接受答案。 想要改善这个问题吗? 更新问题,使其仅通过编辑此帖子即可将重点放在一个问题上。 6年前关闭。 改善这个问题 我们可以使用其中任何一个(包括List,ArrayList,Dictionary,Hashtable,Stack,Queue)来保存值或保存对其他对象的引用作为集合。 但是,我的问题是何时使用哪个? 回答1 清单 列表允许重复项,可以通过索引访问,并支持线性遍历。 ArrayList-不支持通用类型的基于数组的列表。 它不增强类型安全性,通常应避免使用。 列表-支持通用类型并强制类型安全的数组列表。 由于它是非连续的,因此它的大小可以增加,而无需为整个列表重新分配内存。 这是更常用的列表集合。 散列 哈希是一种查找,您在其中为列表中的每个项目赋予一个“键”,该键将在以后用于检索它。 可以将哈希视为表索引,您可以在其中提出以下问题:“我将通过此字符串值找到该对象。不允许使用重复的键。 HashTable-基本的键值对映射,功能类似于索引列表。 字典-支持通用类型并强制类型安全的哈希表。 Queue列 队列控制如何访问列表中的项目。 通常,您可以按特定方向(从正面或背面)从队列中推送/弹出记录。 中间不用于随机访问。 堆栈-LIFO(后进先出)列表,您可以在其中相互推/弹出记录。 队列-FIFO(先进先出)列表
  • python按什么顺序显示字典键? [复制](In what order does python display dictionary keys? [duplicate])
    问题 这个问题已经在这里有了答案: 字典中的键顺序(3个答案) 6年前关闭。 >>> D = {'a': 1, 'b': 2, 'c': 3} >>> D {'a': 1, 'c': 3, 'b': 2} 我只是在Python shell中进行了此操作,我只是想知道为什么键“ c”会在键“ b”之后???? 回答1 顺序与它们在内部的工作方式以及它们在哈希表中的顺序有关。 这又取决于键的哈希值,它们的插入顺序以及所使用的Python实现。 该顺序是任意的(但不是随机的),知道它将是哪个顺序将永远不会有用。 要获取键的排序列表,只需使用sorted(D) ,您将返回['a', 'b', 'c'] 。 回答2 在Python 2.7中,您可以使用有序字典。 回答3 从文档中: 最好将字典视为无序的一组键:值对,并要求键是唯一的(在一个字典中)。 回答4 以任何顺序都可以。 这就是字典的性质。 如果要按特定顺序进行操作,则必须自己执行以下操作: >>> d = {'pax': 1, 'george': 2, 'guido' : 3} >>> d {'pax': 1, 'george': 2, 'guido': 3} >>> [(key,d[key]) for key in sorted(d)] [('george', 2), ('guido', 3), ('pax', 1)]
  • 从张量流中的文件队列访问文件名(Accessing filename from file queue in Tensor Flow)
    问题 我有一个图像目录,以及一个将图像文件名与标签匹配的单独文件。 所以图像目录有像“train/001.jpg”这样的文件,标签文件看起来像: train/001.jpg 1 train/002.jpg 2 ... 通过从文件名创建文件队列,我可以轻松地从 Tensor Flow 中的图像目录加载图像: filequeue = tf.train.string_input_producer(filenames) reader = tf.WholeFileReader() img = reader.read(filequeue) 但是我不知道如何将这些文件与标签文件中的标签结合起来。 似乎我需要在每一步访问队列中的文件名。 有没有办法得到它们? 此外,一旦我有了文件名,我就需要能够查找由文件名键入的标签。 似乎标准 Python 字典不起作用,因为这些计算需要在图中的每一步进行。 回答1 鉴于您的数据不是太大,您无法将文件名列表作为 python 数组提供,我建议只在 Python 中进行预处理。 创建文件名和标签的两个列表(相同顺序),并将它们插入到 randomshufflequeue 或队列中,然后从中出列。 如果您想要 string_input_producer 的“无限循环”行为,您可以在每个时期开始时重新运行“入队”。 一个非常玩具的例子: import
  • Python字典的顺序是否在迭代中得到保证?(Is the order of a Python dictionary guaranteed over iterations?)
    问题 我目前正在使用SciPy.integrate.ode在Python中实现一个复杂的微生物食物网。 我需要能够轻松地向系统中添加物种和反应的能力,因此我必须编写一些非常通用的东西。 我的计划看起来像这样: class Reaction(object): def __init__(self): #stuff common to all reactions def __getReactionRate(self, **kwargs): raise NotImplementedError ... Reaction subclasses that ... implement specific types of reactions class Species(object): def __init__(self, reactionsDict): self.reactionsDict = reactionsDict #reactionsDict looks like {'ReactionName':reactionObject, ...} #stuff common to all species def sumOverAllReactionsForThisSpecies(self, **kwargs): #loop over all the reactions and return the
  • Python 字典迭代顺序意外排序。 为什么? [复制](Python dictionary iteration order is unexpectedly sorted. Why? [duplicate])
    问题 这个问题在这里已经有了答案: 以整数为键的 Python dict 会自然排序吗? (6 个回答) 5年前关闭。 字典填充有连续的整数键,如下所示: d = dict() for i in range(0, 10): d[i] = 100-i 之后,字典项是这样迭代的: for k, v in d.items(): print k, v 结果显示项目按数字顺序迭代: 0 100 1 99 2 98 3 97 4 96 5 95 6 94 7 93 8 92 9 91 事实证明,这是我想要的行为,但不是我所期望的。 我希望以随机顺序进行字典迭代。 这里发生了什么,我可以依赖公开发布的代码中的这种行为吗? 回答1 字典不是随机排列的。 它们的顺序是任意的。 在这种情况下,你很幸运,它们被排序了。 明天,他们可能不会。 如果您需要随机性,请使用random 。 如果您需要排序,请使用sorted() 。 正如@BenjaminWohlwend 在评论中提到的,您可以使用collections.OrderedDict来跟踪插入顺序。 在这种情况下,我猜字典正在做某种小整数键优化,就像一个数组(例如hash(1) == 1 )。 这不是一个有保证的行为,在其他 Python 实现上可能会有不同的工作方式。 回答2 顺序不是随机的,它是任意的。 这意味着您不能依赖它以任何特定顺序进行迭代
  • 迭代字典按排序顺序返回键(Iterating over dictionary returns keys in sorted order)
    问题 我有一个关于 python 如何处理字典中的数据的问题。 假设我有一个简单的字典,以数字为键,以数字为值,如下所示: a = { 5: 3, 20: 1, 1: 1, 5: 2, 100: 3, 11: 6, 14: 1, 15: 2, 16: 4, 17: 2, 25: 1, 19: 1 } 我想遍历这本字典并打印出键。 每次我遍历字典时(如下所示),它都会按递增顺序打印键。 这就是我想要它做的,但我想知道,据我所知,为什么会发生这种情况? 它是否每次都按递增顺序自动排序? 正如您在上面的字典中看到的那样,键显然不是按升序排列的,但下面的输出按升序打印它们。 我只是想获得一个清晰的理解,任何帮助将不胜感激。 谢谢 例子 for i in a: print i 输出: 1 5 11 14 15 16 17 19 20 25 100 回答1 字典中的整数并不总是按键排序: a = {2:0, 9:0} print a.keys() # [9, 2] Python 字典是Hash Tables ,它是一种特殊的数组,其中存储值的单元格的索引是通过在key上应用特殊函数(我们称之为hash函数)来导出的。 这样,如果您想检索特定键的值,您可以再次计算该键的hash函数,它将返回与以前相同的结果,获取存储该值的索引。 hash函数将大多数类型的数据转换为整数: print hash
  • 谷歌应用引擎拉队列是否按先进先出顺序返回任务?(do google app engine pull queues return tasks in FIFO order?)
    问题 谷歌应用引擎拉队列是否按到达时间的 FIFO 顺序返回任务? 我在拉队列文档中阅读了以下内容: “API 按照最早的任务 ETA 的顺序返回指定数量的任务。” ETA =“预计到达时间”,在这种情况下我并不完全理解。 我正在尝试使用 python 按照它们在队列中的到达时间顺序获取任务。 回答1 队列中的每个任务都有一个 ETA,默认设置为任务入队的时间。 但是将来(甚至过去)可以使用 ETA 将任务排入队列。 来自 google.appengine.api.taskqueue 包,在taskqueue.add()参数之间: 倒计时 - 此任务应该运行或租用的时间(以秒为单位)。 默认为零。 如果您指定了 eta,请不要指定此参数。 eta -- 一个 datetime.datetime,指定任务应该运行的绝对最早时间。 如果指定了倒计时参数,则不能指定此参数。 此参数可以是时区感知或时区天真,或设置为过去的时间。 如果参数设置为 None,则默认值为 now。 对于 pull 任务,在 eta 参数指定的时间之前,没有工作人员可以租用任务。 只要您在排队任务时不使用这些参数覆盖默认 ETA,它们就会按 FIFO 顺序拉入。
  • 如何按定义的顺序迭代 Python 字典?(How to iterate over a Python dictionary in defined order?)
    问题 我试图迭代我以特定顺序定义的字典,但它总是以与我在代码中定义的顺序不同的顺序进行迭代。 这只是我正在尝试做的一个基本示例。 我正在迭代的字典要大得多,键名更复杂,而且不是按字母/数字顺序排列的。 level_lookup = \ { 'PRIORITY_1' : { 'level' : 'BAD', 'value' : '' }, 'PRIORITY_2' : { 'level' : 'BAD', 'value' : '' }, 'PRIORITY_3' : { 'level' : 'BAD', 'value' : '' }, 'PRIORITY_4' : { 'level' : 'BAD', 'value' : '' }, 'PRIORITY_5' : { 'level' : 'CHECK', 'value' : '' }, 'PRIORITY_6' : { 'level' : 'CHECK', 'value' : '' }, 'PRIORITY_7' : { 'level' : 'GOOD', 'value' : '' }, 'PRIORITY_8' : { 'level' : 'GOOD', 'value' : '' }, } for priority in level_lookup: if( level_lookup[ priority ][ 'value' ] ==
  • TensorFlow FIFOQueue 不是 FIFO?(TensorFlow FIFOQueue not FIFO?)
    问题 我正在以特定顺序将项目排入 TensorFlow FIFOQueue 并希望能够以相同的顺序将它们出列,但这不是我观察到的行为。 运行以下独立代码演示了该方法和行为。 这已在 Python 2.7(但可能适用于 Python 3)和 TensorFlow 1.1 上运行。 from __future__ import division, print_function, unicode_literals import math import numpy import tensorflow as tf from tensorflow.python.training import queue_runner from tensorflow.python.ops import control_flow_ops row_count, column_count = 7, 5 batch_size, step_size = 3, 2 # Create some random data data = numpy.arange(row_count * column_count).reshape( (row_count, column_count)) print(data) batch_count = int(math.ceil(row_count / batch_size)) step
  • 在 Python (2.4) 字典中排序(Ordering in Python (2.4) dictionary)
    问题 r_dict={'answer1': "value1",'answer11': "value11",'answer2': "value2",'answer3': "value3",'answer4': "value4",} for i in r_dict: if("answer" in i.lower()): print i Result is answer11,answer2,snswer4,answer3 我正在使用 Python 2.4.3。 我有什么办法可以得到它的填充顺序吗? 或者有没有办法通过正则表达式来做到这一点,因为我使用的是较旧的 Python 版本? 回答1 字典是无序的——也就是说,它们确实有一些顺序,但它以不明显的方式受到插入顺序和键的散列的影响。 但是,还有另一个实现可以记住插入的顺序,collections.OrderedDict。 编辑:对于 Python 2.4,有几个第三方实现。 我没有用过,但是因为来自 voidspace 的那个看起来很有希望。 回答2 字典在构造上是无序的。 如果你想要一个有序的,使用 collections.OrderedDict: import collections r_dict = collections.OrderedDict( [ ( 'answer1', "value1"), ('answer11',
  • 为什么字典排序不确定?(Why is dictionary ordering non-deterministic?)
    问题 我最近从Python 2.7切换到Python 3.3,似乎在Python 2中字典键的顺序是任意的,但是是一致的,而在Python 3中,使用vars()获得的字典键的顺序似乎是不确定的。 如果我运行: class Test(object): pass parameters = vars(Test) print(list(parameters.keys())) 在Python 2.7和Python 3.3中,则: Python 2.7一直给我['__dict__', '__module__', '__weakref__', '__doc__'] 使用Python 3.3,我可以获得任何随机顺序–例如: ['__weakref__', '__module__', '__qualname__', '__doc__', '__dict__'] ['__doc__', '__dict__', '__qualname__', '__module__', '__weakref__'] ['__dict__', '__module__', '__qualname__', '__weakref__', '__doc__'] ['__weakref__', '__doc__', '__qualname__', '__dict__', '__module__'] 这种不确定性来自何处?