Ordenar una lista de tuplas por segundo elemento (valor entero)

Tengo una lista de tuplas que se parece a esto:

[('abc', 121),('abc', 231),('abc', 148), ('abc',221)] 

Quiero ordenar esta lista en orden ascendente por el valor entero dentro de las tuplas. ¿Es posible?

Intente usar la palabra key clave con sorted() .

 sorted([('abc', 121),('abc', 231),('abc', 148), ('abc',221)], key=lambda x: x[1]) 

key debe ser una función que identifique cómo recuperar el elemento comparable de su estructura de datos. En su caso, es el segundo elemento de la tupla, por lo que accedemos a [1] .

Para la optimización, vea la respuesta de itemgetter(1) usando itemgetter(1) , que es esencialmente una versión más rápida de lambda x: x[1] .

 >>> from operator import itemgetter >>> data = [('abc', 121),('abc', 231),('abc', 148), ('abc',221)] >>> sorted(data,key=itemgetter(1)) [('abc', 121), ('abc', 148), ('abc', 221), ('abc', 231)] 

IMO usando itemgetter es más legible en este caso que la solución de @cheeken. También es más rápido, ya que casi todos los cálculos se realizarán en el lado c (sin juego de palabras) en lugar de a través del uso de lambda .

 >python -m timeit -s "from operator import itemgetter; data = [('abc', 121),('abc', 231),('abc', 148), ('abc',221)]" "sorted(data,key=itemgetter(1))" 1000000 loops, best of 3: 1.22 usec per loop >python -m timeit -s "data = [('abc', 121),('abc', 231),('abc', 148), ('abc',221)]" "sorted(data,key=lambda x: x[1])" 1000000 loops, best of 3: 1.4 usec per loop 

Como neófita de python, solo quería mencionar que si los datos se vieran así:

 data = [('abc', 121),('abc', 231),('abc', 148), ('abc',221)] 

luego sorted() ordenaría automáticamente por el segundo elemento de la tupla, ya que los primeros elementos son todos idénticos.

Agregando a la respuesta de Cheeken, esta es la forma en que clasifica una lista de tuplas por el segundo elemento en orden descendente .

 sorted([('abc', 121),('abc', 231),('abc', 148), ('abc',221)],key=lambda x: x[1], reverse=True) 

De la wiki de python:

 >>> from operator import itemgetter, attrgetter >>> sorted(student_tuples, key=itemgetter(2)) [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] >>> sorted(student_objects, key=attrgetter('age')) [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] 

Para una clasificación in situ, use

 foo = [(list of tuples)] foo.sort(key=lambda x:x[0]) #To sort by first element of the tuple 

Para un método de evitación de lambda, primero defina su propia función:

 def MyFn(a): return a[1] 

entonces:

 sorted([('abc', 121),('abc', 231),('abc', 148), ('abc',221)], key=MyFn) 

Para Python 2.7+ , esto funciona lo que hace que la respuesta aceptada sea un poco más legible:

 sorted([('abc', 121),('abc', 231),('abc', 148), ('abc',221)], key=lambda (k, val): val) 

El hecho de que los valores de ordenación en el OP sean enteros no es relevante para la pregunta en sí. En otras palabras, la respuesta aceptada funcionaría si el valor de clasificación fuera texto. Lo menciono también para señalar que la clasificación se puede modificar durante la clasificación (por ejemplo, para tener en cuenta mayúsculas y minúsculas).

 >>> sorted([(121, 'abc'), (231, 'def'), (148, 'ABC'), (221, 'DEF')], key=lambda x: x[1]) [(148, 'ABC'), (221, 'DEF'), (121, 'abc'), (231, 'def')] >>> sorted([(121, 'abc'), (231, 'def'), (148, 'ABC'), (221, 'DEF')], key=lambda x: str.lower(x[1])) [(121, 'abc'), (148, 'ABC'), (231, 'def'), (221, 'DEF')]