¿Cómo ordenar una lista / tupla de listas / tuplas por elemento en un índice dado?

Tengo algunos datos en una lista de listas o en una lista de tuplas, como esta:

data = [[1,2,3], [4,5,6], [7,8,9]]
data = [(1,2,3), (4,5,6), (7,8,9)]

Y quiero ordenar por el segundo elemento en el subconjunto. Es decir, ordenar por 2,5,8 de dónde 2es (1,2,3), 5es de (4,5,6). ¿Cuál es la forma común de hacer esto? ¿Debo almacenar tuplas o listas en mi lista?

sorted_by_second = sorted(data, key=lambda tup: tup[1])

o:

data.sort(key=lambda tup: tup[1])  # sorts in place

from operator import itemgetter
data.sort(key=itemgetter(1))

Solo quiero agregar a la respuesta de Stephen si desea ordenar la matriz de mayor a menor, otra forma que no sea en los comentarios anteriores es agregar esto a la línea:

reverse = True

y el resultado será el siguiente:

data.sort(key=lambda tup: tup[1], reverse=True)

Para ordenar por múltiples criterios, es decir, por ejemplo, por el segundo y el tercer elemento en una tupla, dejemos

data = [(1,2,3),(1,2,1),(1,1,4)]

y así definir una lambda que devuelve una tupla que describe la prioridad, por ejemplo

sorted(data, key=lambda tup: (tup[1],tup[2]) )
[(1, 1, 4), (1, 2, 1), (1, 2, 3)]

La respuesta de Stephen es la que usaría. Para completar, aquí está el patrón DSU (decorar-ordenar-decorar) con listas de comprensión:

decorated = [(tup[1], tup) for tup in data]
decorated.sort()
undecorated = [tup for second, tup in decorated]

O, más brevemente:

[b for a,b in sorted((tup[1], tup) for tup in data)]

Como se señaló en Python Sorting HowTo , esto ha sido innecesario desde Python 2.4, cuando las funciones clave estuvieron disponibles.

Para ordenar una lista de tuplas (<word>, <count>), counten orden descendente y worden orden alfabético:

data = [
('betty', 1),
('bought', 1),
('a', 1),
('bit', 1),
('of', 1),
('butter', 2),
('but', 1),
('the', 1),
('was', 1),
('bitter', 1)]

Yo uso este método:

sorted(data, key=lambda tup:(-tup[1], tup[0]))

y me da el resultado:

[('butter', 2),
('a', 1),
('betty', 1),
('bit', 1),
('bitter', 1),
('bought', 1),
('but', 1),
('of', 1),
('the', 1),
('was', 1)]

Sin lambda:

def sec_elem(s):
    return s[1]

sorted(data, key=sec_elem)

itemgetter()es algo más rápido que lambda tup: tup[1], pero el aumento es relativamente modesto (alrededor del 10 al 25 por ciento).

(Sesión de IPython)

>>> from operator import itemgetter
>>> from numpy.random import randint
>>> values = randint(0, 9, 30000).reshape((10000,3))
>>> tpls = [tuple(values[i,:]) for i in range(len(values))]

>>> tpls[:5]    # display sample from list
[(1, 0, 0), 
 (8, 5, 5), 
 (5, 4, 0), 
 (5, 7, 7), 
 (4, 2, 1)]

>>> sorted(tpls[:5], key=itemgetter(1))    # example sort
[(1, 0, 0), 
 (4, 2, 1), 
 (5, 4, 0), 
 (8, 5, 5), 
 (5, 7, 7)]

>>> %timeit sorted(tpls, key=itemgetter(1))
100 loops, best of 3: 4.89 ms per loop

>>> %timeit sorted(tpls, key=lambda tup: tup[1])
100 loops, best of 3: 6.39 ms per loop

>>> %timeit sorted(tpls, key=(itemgetter(1,0)))
100 loops, best of 3: 16.1 ms per loop

>>> %timeit sorted(tpls, key=lambda tup: (tup[1], tup[0]))
100 loops, best of 3: 17.1 ms per loop

¡La respuesta de @Stephen es al grano! Aquí hay un ejemplo para una mejor visualización,

¡Grita a los fanáticos de Ready Player One! =)

>>> gunters = [('2044-04-05', 'parzival'), ('2044-04-07', 'aech'), ('2044-04-06', 'art3mis')]
>>> gunters.sort(key=lambda tup: tup[0])
>>> print gunters
[('2044-04-05', 'parzival'), ('2044-04-06', 'art3mis'), ('2044-04-07', 'aech')]

keyes una función que se llamará para transformar los elementos de la colección para comparación ... como compareTométodo en Java.

El parámetro pasado a la clave debe ser algo invocable. Aquí, el uso de lambdacrea una función anónima (que es invocable).
La sintaxis de lambda es la palabra lambda seguida de un nombre iterable y luego un solo bloque de código.

Debajo del ejemplo, estamos ordenando una lista de tuplas que contiene la información sobre el tiempo de cierto evento y el nombre del actor.

Estamos ordenando esta lista por hora de ocurrencia del evento, que es el elemento 0 de una tupla.

Nota: s.sort([cmp[, key[, reverse]]]) ordena los elementos de s en su lugar

Ordenar una tupla es bastante simple:

tuple(sorted(t))