在Python3中对压缩对象进行排序

我有一个

zip

对象，我想对它进行排序（基于特定键）

我已经看到了，但公认的答案在python 3.6中不再适用

比如说

In [6]: a = [3,9,2,24,1,6]

In [7]: b = ['a','b','c','d','e']

In [8]: c = zip(a,b)

In [9]: c
Out[9]: <zip at 0x108f59ac8>

In [11]: type(c)
Out[11]: zip

In [12]: c.sort()
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-12-a21727fa8976> in <module>()
----> 1 c.sort()

AttributeError: 'zip' object has no attribute 'sort'

# Wanted this to be sorted by the first element
In [13]: for l,r in c: print(l,r)
3 a
9 b
2 c
24 d
1 e

[6]中的

a=[3,9,2,24,1,6]
在[7]中：b=['a'，'b'，'c'，'d'，'e']
在[8]中：c=zip（a，b）
在[9]：c中
出[9]：
In[11]：类型（c）
Out[11]：拉链
在[12]：c.sort（）中
---------------------------------------------------------------------------
AttributeError回溯（最近一次呼叫上次）
在（）
---->1 c.排序（）
AttributeError:“zip”对象没有属性“sort”
#希望按第一个元素对其进行排序
In[13]：对于c中的l，r:print（l，r）
3A
9 b
2 c
24天
1 e

换句话说，我如何使zip迭代顺序与排序顺序一致。

---

我知道将zip转换为元组列表可以解决这个问题，但我想保留zip对象（就像在python2.7的好日子里一样）

你不能在zip对象上使用

sort

，

zip

对象没有这样的属性。但是，您可以将

zip

对象转换为具有

list（zip\u对象）

的列表，然后在其上应用

sort

，以进行就地排序

但是，由于zipped对象也是一个iterable，我的建议是使用。它还允许您编写一个排序函数，根据该函数对集合进行排序

这里，我根据每个

（x，y）

对中

y

的值对其进行排序

>>> a = [3,9,2,24,1,6]
>>> b = ['a','b','c','d','e']
>>> c = zip(a,b)
>>> 
>>> sorted(c, key = lambda x:x[1])
[(3, 'a'), (9, 'b'), (2, 'c'), (24, 'd'), (1, 'e')]

请注意，

sorted

将返回一个新的排序列表，而

sort

将就地对集合进行排序

Python3中的

zip（）

返回迭代器；输入在您向其请求元素时被压缩。迭代器是不可排序的

您可以使用“绘制”元素并从中返回排序列表：

sorted(zip(a, b))

您还可以通过调用

list（）

将

zip（）

对象转换为列表，然后使用

list.sort（）

方法对结果进行排序，但这比仅使用

sorted（）

函数要复杂得多

sorted（）

演示：

另请参见
好的，python3.2.7中链接问题的第二个答案没有“zip对象”：
zip（）
在Python2中返回了一个列表。因此，如果在Python3中将代码更改为
c=list（zip（a，b））
，它的行为将与Python2中的行为完全相同。@anoop除了公认的答案之外，还有其他答案可以解决您的问题，因此我将此作为重复关闭。
>>> a = [3, 9, 2, 24, 1, 6]
>>> b = ['a', 'b', 'c', 'd', 'e']
>>> sorted(zip(a, b))
[(1, 'e'), (2, 'c'), (3, 'a'), (9, 'b'), (24, 'd')]
>>> sorted(zip(a, b), key=lambda x: x[1])
[(3, 'a'), (9, 'b'), (2, 'c'), (24, 'd'), (1, 'e')]