Dadas las listas paralelas, ¿cómo puedo ordenar una mientras permuto (reorganizo) la otra de la misma manera?

Supongamos que tengo:

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

Vocación list1.sort() lo ordenará, resultando en [1, 1, 2, 3, 4]. Sin embargo, ¿puedo obtener list2 ser reorganizado en sincronía con eso, para obtener un resultado como este?

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

_{A veces, las personas expresan el problema de manera diferente: dadas dos listas, les gustaría usar una para determinar el orden de clasificación para la otra, es decir, ordenar list2 en el orden descrito por los valores correspondientes en list1. El truco es que esto es equivalente a ordenar los valores “clave” (list1), y luego reorganizar list2 del mismo modo. En otras palabras, exactamente lo que se describe aquí. Sin embargo, algunas respuestas para la otra pregunta descartan las “claves ordenadas”.}

Un enfoque clásico para este problema es usar el modismo “decorar, ordenar, desdecorar”, que es especialmente simple usando la función integrada de Python. zip función:

>>> 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')

Estas, por supuesto, ya no son listas, pero eso se soluciona fácilmente, si importa:

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

Vale la pena señalar que lo anterior puede sacrificar la velocidad por la brevedad; la versión in situ, que ocupa 3 líneas, es un poco más rápida en mi máquina para listas pequeñas:

>>> %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

Por otro lado, para listas más grandes, la versión de una línea podría ser más rápida:

>>> %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

Como señala Quantum7, la sugerencia de JSF es un poco más rápida aún, pero probablemente solo será un poco más rápida, porque Python usa el mismo idioma DSU internamente para todas las clasificaciones basadas en claves. Simplemente está sucediendo un poco más cerca del metal desnudo. (Esto muestra lo bien optimizado que está el zip las rutinas son!)

Pienso que el zipEl enfoque basado en es más flexible y es un poco más legible, así que lo prefiero.

Tenga en cuenta que cuando los elementos de list1 son iguales, este enfoque terminará comparando elementos de list2. Si elementos de list2 no admiten la comparación, o no producen un valor booleano cuando se comparan (por ejemplo, si list2 es una lista de arreglos NumPy), esto fallará, y si los elementos de list2 son muy caros de comparar, sería mejor evitar la comparación de todos modos.

En ese caso, puede ordenar los índices como se sugiere en la respuesta de jfs, o puede asignarle a la ordenación una función clave que evite comparar elementos de list2:

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

Asimismo, el uso de zip(*...) ya que una transposición falla cuando la entrada está vacía. Si sus entradas pueden estar vacías, tendrá que manejar ese caso por separado.

Puede ordenar índices usando valores como claves:

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

Para obtener listas ordenadas dados índices ordenados:

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

en tu caso no debiste list1, list2 sino más bien una sola lista de pares:

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

Es fácil de crear; es fácil de ordenar en Python:

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

Ordenar solo por el primer valor:

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

He usado la respuesta dada por senderle durante mucho tiempo hasta que descubrí np.argsort. Así es como funciona.

# idx works on np.array and not lists.
list1 = np.array([3,2,4,1])
list2 = np.array(["three","two","four","one"])
idx   = np.argsort(list1)

list1 = np.array(list1)[idx]
list2 = np.array(list2)[idx]

Esta solución me parece más intuitiva y funciona muy bien. El rendimiento:

def sorting(l1, l2):
    # l1 and l2 has to be numpy arrays
    idx = np.argsort(l1)
    return l1[idx], l2[idx]

# list1 and list2 are np.arrays here...
%timeit sorting(list1, list2)
100000 loops, best of 3: 3.53 us per loop

# This works best when the lists are NOT np.array
%timeit zip(*sorted(zip(list1, list2)))
100000 loops, best of 3: 2.41 us per loop

# 0.01us better for np.array (I think this is negligible)
%timeit tups = zip(list1, list2); tups.sort(); zip(*tups)
100000 loops, best for 3 loops: 1.96 us per loop

A pesar de np.argsort no es el más rápido, me resulta más fácil de usar.

Esto se puede hacer usando lo que los programadores de Perl llaman el Transformada Schwartziana, también conocido como el idioma decorar-clasificar-desdecorar. La ordenación integrada de Python es estable, por lo que los dos 1s no causan un problema.

>>> 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')]

Puedes usar el zip() y sort() funciones para lograr esto:

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']

Espero que esto ayude

Una forma es rastrear a dónde va cada índice ordenando la identidad [0,1,2,..n]

Esto funciona para cualquier número de listas.

Luego mueva cada elemento a su posición. Usar empalmes es lo mejor.

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']"

Tenga en cuenta que podríamos haber iterado las listas sin siquiera ordenarlas:

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

Qué pasa:

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

sortedRes = sorted(zip(list1, list2), key=lambda x: x[0]) # use 0 or 1 depending on what you want to sort
>>> [(1, 'one'), (1, 'one2'), (2, 'two'), (3, 'three'), (4, 'four')]