dic.

dict es un tipo integrado que representa una asignación asociativa o un diccionario. Un diccionario admite la indexación con d[k] y las pruebas de membresía de claves con k in d. Ambas operaciones tardan un tiempo constante. Los diccionarios descongelados son mutables y se pueden actualizar asignándolos a d[k] o llamando a ciertos métodos. Los diccionarios son iterables; la iteración genera la secuencia de claves en orden de inserción. El orden de iteración no se ve afectado por la actualización del valor asociado con una clave existente, pero sí por la eliminación y la posterior inserción de una clave.

d = {0: 0, 2: 2, 1: 1}
[k for k in d]  # [0, 2, 1]
d.pop(2)
d[0], d[2] = "a", "b"
0 in d, "a" in d  # (True, False)
[(k, v) for k, v in d.items()]  # [(0, "a"), (1, 1), (2, "b")]

Hay cuatro maneras de construir un diccionario:

1. Una expresión de diccionario {k: v, ...} genera un diccionario nuevo con las entradas de clave/valor especificadas, insertadas en el orden en que aparecen en la expresión. La evaluación falla si dos expresiones clave generan el mismo valor.
2. Una comprensión de diccionario {k: v for vars in seq} genera un diccionario nuevo en el que se inserta cada par clave-valor en el orden de iteración del bucle. Se permiten los duplicados: la primera inserción de una clave determinada determina su posición en la secuencia y la última determina su valor asociado.

   {k: v for k, v in (("a", 0), ("b", 1), ("a", 2))}  # {"a": 2, "b": 1}
   {i: 2*i for i in range(3)}  # {0: 0, 1: 2, 2: 4}
   

3. Una llamada a la función dict incorporada muestra un diccionario que contiene las entradas especificadas, que se insertan en el orden de los argumentos, los argumentos posicionales antes de nombrar. Al igual que con las comprensiones, se permiten claves duplicadas.
4. La expresión de unión x | y genera un diccionario nuevo combinando dos diccionarios existentes. Si los dos diccionarios tienen una clave k en común, gana el valor de la clave del diccionario de la derecha (en otras palabras, y[k]). La variante |= del operador de unión modifica un diccionario en su lugar. Ejemplo:
   

   d = {"foo": "FOO", "bar": "BAR"} | {"foo": "FOO2", "baz": "BAZ"}
   # d == {"foo": "FOO2", "bar": "BAR", "baz": "BAZ"}
   d = {"a": 1, "b": 2}
   d |= {"b": 3, "c": 4}
   # d == {"a": 1, "b": 3, "c": 4}

Miembros

• sencillo
• get
• items
• keys
• pop
• popitem
• setdefault
• actualización
• values

borrar

None dict.clear()

get

unknown dict.get(key, default=None)

Parámetros

elementos

list dict.items()

{2: "a", 4: "b", 1: "c"}.items() == [(2, "a"), (4, "b"), (1, "c")]

claves

list dict.keys()

{2: "a", 4: "b", 1: "c"}.keys() == [2, 4, 1]

pop

unknown dict.pop(key, default=unbound)

Parámetros

popitem

tuple dict.popitem()

setdefault

unknown dict.setdefault(key, default=None)

Parámetros

update

None dict.update(pairs=[], **kwargs)

Parámetros

valores

list dict.values()

{2: "a", 4: "b", 1: "c"}.values() == ["a", "b", "c"]