Compruebe si una clave dada ya existe en un diccionario y auméntela

Dado un diccionario, ¿cómo puedo saber si una clave dada en ese diccionario ya se ha establecido en un valor que no es Ninguno?

Es decir, quiero hacer esto:

my_dict = {} if (my_dict[key] != None): my_dict[key] = 1 else: my_dict[key] += 1 

Es decir, quiero incrementar el valor si ya hay uno, o configurarlo en 1 de lo contrario.

Está buscando collections.defaultdict (disponible para Python 2.5+). Esta

 from collections import defaultdict my_dict = defaultdict(int) my_dict[key] += 1 

Haré lo que quieras.

Para los dict normales de Python, si no hay un valor para una clave dada, no obtendrá None cuando acceda al KeyError se KeyError un KeyError . Entonces, si desea usar un dict regular, en lugar de su código, usaría

 if key in my_dict: my_dict[key] += 1 else: my_dict[key] = 1 

Prefiero hacer esto en una línea de código.

 my_dict = {}

 my_dict [some_key] = my_dict.get (some_key, 0) + 1

Los diccionarios tienen una función, obtener, que toma dos parámetros: la clave que desea y un valor predeterminado si no existe. Prefiero este método por defecto, ya que solo quieres manejar el caso donde la clave no existe en esta línea de código, no en todas partes.

Necesitas la key in dict idioma del key in dict para eso.

 if key in my_dict and not (my_dict[key] is None): # do something else: # do something else 

Sin embargo, probablemente debería considerar el uso de defaultdict (como sugiere dF).

Personalmente me gusta usar setdefault()

 my_dict = {} my_dict.setdefault(some_key, 0) my_dict[some_key] += 1 

Para responder a la pregunta ” ¿cómo puedo saber si un índice dado en ese dictado ya se ha establecido en un valor que no es Ninguno “, preferiría esto:

 try: nonNone = my_dict[key] is not None except KeyError: nonNone = False 

Esto se ajusta al concepto ya invocado de EAFP (más fácil pedir perdón y luego permiso). También evita la búsqueda de claves duplicadas en el diccionario como lo haría en key in my_dict and my_dict[key] is not None lo que es interesante si la búsqueda es costosa.

Para el problema real que ha planteado, es decir, incrementar un int si existe, o establecerlo en un valor predeterminado de lo contrario, también recomiendo

 my_dict[key] = my_dict.get(key, default) + 1 

Como en la respuesta de Andrew Wilkinson.

Hay una tercera solución si está almacenando objetos modificables en su diccionario. Un ejemplo común para esto es un multimapa , donde almacena una lista de elementos para sus claves. En ese caso, puede utilizar:

 my_dict.setdefault(key, []).append(item) 

Si no existe un valor para clave en el diccionario, el método setdefault lo establecerá en el segundo parámetro de setdefault. Se comporta como una my_dict [clave] estándar, devolviendo el valor de la clave (que puede ser el valor recién establecido).

De acuerdo con cgoldberg. Como lo hago es:

 try: dict[key] += 1 except KeyError: dict[key] = 1 

Entonces, o hazlo como se indica arriba, o usa un dictado predeterminado como otros han sugerido. No utilice las declaraciones si. Eso no es Pythonic.

Como se puede ver en las muchas respuestas, hay varias soluciones. Aún no se ha mencionado una instancia de LBYL (mirar antes de saltar), el método has_key ():

 my_dict = {} def add (key): if my_dict.has_key(key): my_dict[key] += 1 else: my_dict[key] = 1 if __name__ == '__main__': add("foo") add("bar") add("foo") print my_dict 

La forma en que intenta hacerlo se llama LBYL (vea antes de saltar), ya que está verificando las condiciones antes de intentar boost su valor.

El otro enfoque se llama EAFP (es más fácil pedir perdón que permiso). En ese caso, solo intentaría la operación (incrementar el valor). Si falla, atrapa la excepción y establece el valor en 1. Esta es una forma un poco más Pythonic de hacerlo (IMO).

http://mail.python.org/pipermail/python-list/2003-May/205182.html

Un poco tarde pero esto debería funcionar.

 my_dict = {} my_dict[key] = my_dict[key] + 1 if key in my_dict else 1 

Esto no responde directamente a la pregunta, pero para mí, parece que es posible que desee la funcionalidad de las colecciones .

 from collections import Counter to_count = ["foo", "foo", "bar", "baz", "foo", "bar"] count = Counter(to_count) print(count) print("acts just like the desired dictionary:") print("bar occurs {} times".format(count["bar"])) print("any item that does not occur in the list is set to 0:") print("dog occurs {} times".format(count["dog"])) print("can iterate over items from most frequent to least:") for item, times in count.most_common(): print("{} occurs {} times".format(item, times)) 

Esto resulta en la salida

 Counter({'foo': 3, 'bar': 2, 'baz': 1}) acts just like the desired dictionary: bar occurs 2 times any item that does not occur in the list is set to 0: dog occurs 0 times can iterate over items from most frequent to least: foo occurs 3 times bar occurs 2 times baz occurs 1 times 

Aquí hay una frase que se me ocurrió recientemente para resolver este problema. Se basa en el método del diccionario setdefault :

 my_dict = {} my_dict[key] = my_dict.setdefault(key, 0) + 1 

Lo estaba buscando, no lo encontré en la web, luego probé mi suerte con Try / Error y lo encontré

 my_dict = {} if my_dict.__contains__(some_key): my_dict[some_key] += 1 else: my_dict[some_key] = 1