Come ordinare un elenco / tupla di elenchi / tuple dall'elemento in un determinato indice?

Ho alcuni dati in un elenco di elenchi o in un elenco di tuple, come questo:

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

E voglio ordinare in base al secondo elemento nel sottoinsieme. Il significato, l'ordinamento per 2,5,8 da dove 2viene (1,2,3), 5viene da (4,5,6). Qual è il modo comune per farlo? Devo memorizzare tuple o elenchi nella mia 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))

Voglio solo aggiungere alla risposta di Stephen se vuoi ordinare l'array da alto a basso, un altro modo diverso da quello nei commenti sopra è solo quello di aggiungere questo alla riga:

reverse = True

e il risultato sarà il seguente:

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

Per l'ordinamento in base a più criteri, vale a dire, ad esempio, per il secondo e il terzo elemento in una tupla, let

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

e quindi definire un lambda che restituisca una tupla che descriva la priorità, per esempio

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

La risposta di Stephen è quella che userei. Per completezza, ecco il modello DSU (decorate-ordina-undecorate) con la comprensione dell'elenco:

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

O, più tersamente:

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

Come notato nell'ordinamento Python , ciò non è stato necessario da Python 2.4, quando sono diventate disponibili le funzioni chiave.

Per ordinare un elenco di tuple (<word>, <count>), countin ordine decrescente e wordin ordine alfabetico:

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

Io uso questo metodo:

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

e mi dà il risultato:

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

Senza lambda:

def sec_elem(s):
    return s[1]

sorted(data, key=sec_elem)

itemgetter()è leggermente più veloce di lambda tup: tup[1], ma l'aumento è relativamente modesto (dal 10 al 25 percento circa).

(Sessione 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 risposta di @Stephen è al punto! Ecco un esempio per una migliore visualizzazione,

Grida per i fan di 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')]

keyè una funzione che verrà chiamata per trasformare gli oggetti della collezione per il confronto .. come il compareTometodo in Java.

Il parametro passato alla chiave deve essere qualcosa che può essere richiamato. Qui, l'uso di lambdacrea una funzione anonima (che è richiamabile).
La sintassi di lambda è la parola lambda seguita da un nome iterabile quindi da un singolo blocco di codice.

Sotto l'esempio, stiamo ordinando un elenco di tuple che contiene le informazioni al momento giusto di un determinato evento e il nome dell'attore.

Stiamo ordinando questo elenco in base al momento in cui si verifica l'evento - che è il nono elemento di una tupla.

Nota: s.sort([cmp[, key[, reverse]]]) ordina gli elementi di s in atto

Ordinare una tupla è abbastanza semplice:

tuple(sorted(t))