Devolviendo los 6 nombres más altos en una lista de tuplas en Python

Question

Por favor, quiero devolver los primeros 6 nombres (solo los nombres) con los números enteros más altos correspondientes de la lista de tuplas a continuación. He podido devolver todos los nombres desde el más alto (sms) al más bajo (jefe).

[('sms', 10), ('bush', 9), ('michaels', 7), ('operations', 6), ('research', 5), ('code', 4), ('short', 3), ('ukandu', 2), ('technical', 1), ('apeh', 1), ('boss', 1)] 

Gracias.

Answer 1

Si los datos ya está ordenada simplemente rebanar los primeros seis tuplas y luego obtener los nombres:

first_six = data[0:6] # or data[:6] 
only_names = [entry[0] for entry in first_six] 

La lista de comprensión se puede desenrollar a:

only_names = [] 
for entry in first_six: 
    only_names.append(entry[0]) 

Si la lista es no ya ordenado puede usar el argumento de palabra clave key del método sort (o el sorted integrado) para ordenar por puntuación:

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

lambda es una función anónima - el equivalente es:

def get_score(entry): 
    return entry[1] 

data.sort(key=get_score, reverse=True) 

Answer 2

data=[('sms', 10), ('bush', 9), ('michaels', 7), ('operations', 6), ('research', 5), ('code', 4), ('short', 3), ('ukandu', 2), ('technical', 1), ('apeh', 1), ('boss', 1)] 
return [x[0] for x in sorted(data, key=lambda x: x[1], reverse=True)[0:6]] 

Lo cual siguientes:

• sorted devuelve datos ordenados usando key función. Como el orden de clasificación estándar es ascendente, reverse=True lo establece haciendo descender;
• lambda x: x[1] es la función anónima que devuelve el segundo elemento del argumento (de una tupla en este caso); itemgetter(1) es la mejor manera de hacerlo, pero requiere importaciones adicionales;
• [0:6] sectores 6 primeros elementos de la lista;
• [x[0] for x in ... ] crea una lista de los primeros elementos de cada tupla pasada;

Answer 3

heapq.nlargest es lo que usted quiere aquí:

import heapq 
from operator import itemgetter 
largest_names = [x[0] for x in heapq.nlargest(6,your_list,key=itemgetter(1))] 

Será más eficiente que la de clasificación, ya que sólo toma los elementos más grandes y descarta el resto. Por supuesto, es menos eficiente que rebanar si la lista está previamente clasificada por otras razones.

Complejidad:

• heapq: O (N)
• clasificar: O (NlogN)
• de corte (sólo si pre-ordenados): O (6)

Explicación :

heapq.nlargest(6,your_list,key=itemgetter(1)) 

Esta línea devuelve una lista de (nombre, valor) tu ples, pero solo los 6 más grandes: la comparación se realiza por el segundo elemento (índice = 1 ->key=itemgetter(1)) en la tupla.

El resto de la línea es una lista de comprensión sobre las 6 tuplas de mayor tamaño, valor que solo toma la porción de nombre de la tupla y la almacena en una lista.

---

que podría ser de interés para usted que se puede almacenar estos datos como un collections.Counter también.

d = collections.Counter(dict(your_list)) 
biggest = [x[0] for x in d.most_common(6)] 

No es probablemente vale la pena convertir sólo para hacer este cálculo (que es lo heapq es porque después de todo ;-), pero puede ser que valga la conversión para que los datos más fáciles de trabajar.