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

qué son las tuplas en python

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo ordenar (lista / tupla) de listas / tuplas? 10 respuestas

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?

Answer 1

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)

Answer 2

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.

Answer 3

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

Answer 4

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. Subo esto para señalar también 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'')]

Answer 5

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

Answer 6

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)

Answer 7

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)

Answer 8

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

Answer 9

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