解决这个问题的一个经典方法是使用“装饰，排序，不装饰”习语，使用python内置的zip函数尤其简单:

>>> list1 = [3,2,4,1, 1]
>>> list2 = ['three', 'two', 'four', 'one', 'one2']
>>> list1, list2 = zip(*sorted(zip(list1, list2)))
>>> list1
(1, 1, 2, 3, 4)
>>> list2 
('one', 'one2', 'two', 'three', 'four')

这些当然不再是列表，但如果重要的话，很容易补救:

>>> list1, list2 = (list(t) for t in zip(*sorted(zip(list1, list2))))
>>> list1
[1, 1, 2, 3, 4]
>>> list2
['one', 'one2', 'two', 'three', 'four']

值得注意的是，上述方法可能会为了简洁而牺牲速度;in-place版本占用3行，在我的机器上处理小列表时稍微快一点:

>>> %timeit zip(*sorted(zip(list1, list2)))
100000 loops, best of 3: 3.3 us per loop
>>> %timeit tups = zip(list1, list2); tups.sort(); zip(*tups)
100000 loops, best of 3: 2.84 us per loop

另一方面，对于更大的列表，单行版本可能更快:

>>> %timeit zip(*sorted(zip(list1, list2)))
100 loops, best of 3: 8.09 ms per loop
>>> %timeit tups = zip(list1, list2); tups.sort(); zip(*tups)
100 loops, best of 3: 8.51 ms per loop

正如Quantum7所指出的，JSF的建议还是快了一点，但它可能只会快一点点，因为Python在内部对所有基于键的排序使用了完全相同的DSU习惯用法。只是发生在离裸露的金属更近的地方。(这显示了zip例程优化得多么好!)

我认为基于zip的方法更灵活，可读性更强，所以我更喜欢它。

注意，当list1的元素相等时，此方法将最终比较list2的元素。如果list2的元素不支持比较，或者在比较时不产生布尔值(例如，如果list2是NumPy数组的列表)，这将失败，如果list2的元素比较代价非常高，那么避免比较可能会更好。

在这种情况下，你可以按照jfs的答案对索引进行排序，或者你可以给排序一个键函数，以避免比较list2的元素:

result1, result2 = zip(*sorted(zip(list1, list2), key=lambda x: x[0]))

同样，当输入为空时，使用zip(*…)作为转置也会失败。如果输入可能为空，则必须单独处理这种情况。

一种方法是通过对单位[0,1,2，..n]进行排序来跟踪每个索引的去向。

这适用于任何数量的列表。

然后移动每个项目到它的位置。使用拼接是最好的。

list1 = [3,2,4,1, 1]
list2 = ['three', 'two', 'four', 'one', 'one2']

index = list(range(len(list1)))
print(index)
'[0, 1, 2, 3, 4]'

index.sort(key = list1.__getitem__)
print(index)
'[3, 4, 1, 0, 2]'

list1[:] = [list1[i] for i in index]
list2[:] = [list2[i] for i in index]

print(list1)
print(list2)
'[1, 1, 2, 3, 4]'
"['one', 'one2', 'two', 'three', 'four']"

注意，我们可以在不排序的情况下迭代列表:

list1_iter = (list1[i] for i in index)

你可以在sorted()方法中使用key参数，除非你在list2中有两个相同的值。

代码如下:

sorted(list2, key = lambda x: list1[list2.index(x)]) 

它根据list1中的对应值对list2进行排序，但请确保在使用此方法时，list2中的任何两个值都不相等，因为list.index()函数给出了第一个值

你可以使用zip()和sort()函数来实现:

Python 2.6.5 (r265:79063, Jun 12 2010, 17:07:01)
[GCC 4.3.4 20090804 (release) 1] on cygwin
>>> list1 = [3,2,4,1,1]
>>> list2 = ['three', 'two', 'four', 'one', 'one2']
>>> zipped = zip(list1, list2)
>>> zipped.sort()
>>> slist1 = [i for (i, s) in zipped]
>>> slist1
[1, 1, 2, 3, 4]
>>> slist2 = [s for (i, s) in zipped]
>>> slist2
['one', 'one2', 'two', 'three', 'four']

希望这能有所帮助

Schwartzian变换。内置的Python排序是稳定的，所以两个1不会造成问题。

>>> l1 = [3, 2, 4, 1, 1]
>>> l2 = ['three', 'two', 'four', 'one', 'second one']
>>> zip(*sorted(zip(l1, l2)))
[(1, 1, 2, 3, 4), ('one', 'second one', 'two', 'three', 'four')]

你可以使用值作为键对索引进行排序:

indexes = range(len(list1))
indexes.sort(key=list1.__getitem__)

要获得给定已排序索引的已排序列表:

sorted_list1 = map(list1.__getitem__, indexes)
sorted_list2 = map(list2.__getitem__, indexes)

在你的例子中，你不应该有list1, list2，而是一个单独的对列表:

data = [(3, 'three'), (2, 'two'), (4, 'four'), (1, 'one'), (1, 'one2')]

它很容易创造;在Python中很容易排序:

data.sort() # sort using a pair as a key

仅按第一个值排序:

data.sort(key=lambda pair: pair[0])