Python miminum valor en diccionario de listas

Lo siento por la pregunta de reenvío … Debería haber editado esta pregunta en primer lugar. Marcado el nuevo para los mods. Lo siento por la molestia

Tuvo que volver a escribir la pregunta debido a los requisitos cambiados.

Tengo un diccionario como el siguiente:

d = {'a': [4, 2], 'b': [3, 4], 'c': [4, 3], 'd': [4, 3], 'e': [4], 'f': [4], 'g': [4]} 

Quiero obtener las claves que están asociadas con la menor longitud en el diccionario d, así como las que tienen el valor máximo.

En este caso, las claves con la longitud más pequeña (la longitud más pequeña de las listas en este diccionario) deben regresar

     'e, 'f', 'g' 

    Y aquellos con el mayor valor (la sum de los enteros en cada lista) deben devolver

     'b' 'c' 

    Yo he tratado

     min_value = min(dict.itervalues()) min_keys = [k for k in d if dict[k] == min_value] 

    Pero eso no me da el resultado que quiero.

    ¿Algunas ideas?

    ¡Gracias!

    Puede usar min() con un argumento key= , y especificar una función clave que compare la forma que desee.

     d = {'a': ['1'], 'b': ['1', '2'], 'c': ['2'], 'd':['1']} min_value = min(d.values()) min_list = [key for key, value in d.items() if value == min_value] max_len = len(max(d.values(), key=len)) long_list = [key for key, value in d.items() if len(value) == max_len] print(min_list) print(long_list) 

    Notas:

    0) No use dict como nombre de variable; ese es el nombre de la clase para el diccionario, y si lo usa como nombre de variable, lo “sombrea”. Acabo de usar d para el nombre aquí.

    1) min_value fue fácil; no hay necesidad de usar una key= función.

    2) max_len usa una key= función, len() , para encontrar el valor más largo.

    Su problema es que sus listas contienen cadenas ( '2' ) y no enteros ( 2 ). Deja de lado las citas, o usa lo siguiente:

     min_value = min(min(map(int, v) for v in dct.values())) min_keys = [k for k,v in d.items() if min_value in map(int, v)] 

    Del mismo modo, para calcular las claves con la longitud máxima:

     max_length = max(map(len, dct.values())) maxlen_keys = [k for k,v in d.items() if max_length == len(v)] 

    Además, es una mala idea usar dict como un nombre de variable, ya que al hacerlo eclipsa el dictado incorporado.

    ¿Qué hay de usar clasificación y lambdas?

     #!/usr/bin/env python d = {'a': ['1'], 'b': ['1', '2'], 'c': ['8', '1'], 'd':['1'], 'e':['1', '2', '3'], 'f': [4, 1]} sorted_by_sum_d = sorted(d, key=lambda key: sum(list(int(item) for item in d[key]))) sorted_by_length_d = sorted(d, key=lambda key: len(d[key])) print "Sorted by sum of the items in the list : %s" % sorted_by_sum_d print "Sorted by length of the items in the list : %s" % sorted_by_length_d 

    Esto daría como resultado:

     Sorted by sum of the items in the list : ['a', 'd', 'b', 'f', 'e', 'c'] Sorted by length of the items in the list : ['a', 'd', 'c', 'b', 'f', 'e'] 

    Tenga en cuenta que cambié el diccionario inicial (solo para asegurarme de que funcionaba)

    Luego, si desea que el elemento tenga la mayor sum, obtendrá el último elemento de la lista sorted_by_sum_d .

    (No estoy muy seguro de que esto es lo que quieres, sin embargo)

    Editar :

    Si puede asegurarse de que las listas siempre sean listas de enteros (o tipos numéricos, por ejemplo, como long , float …), no es necesario convertir cadenas a enteros. El cálculo de la variable sorted_by_sum_d se puede hacer simplemente usando:

     d = {'a': [1], 'b': [1, 2], 'c': [8, 1], 'd':[1], 'e':[1, 2, 3], 'f': [4, 1]} sorted_by_sum_d = sorted(d, key=lambda key: sum(d[key]))