Saltar a contenido

Operaciones con diccionarios

Borrar elementos

El método pop() elimina un elemento pasándole la clave

>>> telefonos = {
...     "Ana"      : 2743,
...     "Juan"     : 7145,
...     "Andrés"   : 2812,
...     "Victor"   : 3343,
...     "Luisa"    : 1067,
...     "Cristina" : 7373
...     }

>>> telefonos.pop("Ana")
     2743

>>> telefonos
    {'Juan': 7145, 'Andrés': 2812, 'Victor': 3343, 'Luisa': 1067, 'Cristina': 7373}

Véase que el método pop() devuelve el valor del elemento suprimido del diccionario, que podemos almacenar en otra variable:

suprimido = telefonos.pop("Ana")

Si la clave no existe, obtendremos un error, lo que nos obliga a escribir:

try:
    suprimido = telefonos.pop("Ana")
except:
    suprimido = 0

y examinando la variable, veremos si hay un teléfono suprimido.

El método popitem() elimina el último elemento añadido (en versiones antiguas de Python eliminaba un elemento al azar, ya que no estaban ordenados):

telefonos.popitem()

La palabra del también elimina un elemento:

del telefonos["Ana"]

...o el diccionario completo:

del telefonos

El método clear() suprime todos los elementos y vacía el diccionario:

telefonos.clear()

Unir diccionarios

El método update() permite añadir elementos de otro diccionario. Los añadidos se usan de dos maneras:

  • si el elemento ya existe, se sustituye por el nuevo
  • si no existe, se incorpora el nuevo

Por ejemplo:

>>> telefonos = {
...     "Ana"      : 2743,
...     "Juan"     : 7145,
...     "Andrés"   : 2812
...     }

>>> nuevos_telefonos = {
...     "Ana"      : 4545,
...     "Luisa"    : 1067,
...     "Cristina" : 7373
...     }

>>> telefonos.update(nuevos_telefonos)

>>> telefonos
>>> {'Ana': 4545, 'Juan': 7145, 'Andrés': 2812, 'Luisa': 1067, 'Cristina': 7373}

Obtener una lista de claves

Podemos obtener una colección de claves con el método keys()

>>> persona = {'nombre': 'Teresa', 
...            'edad': 27, 
...            'ciudad': 'Buenos Aires', 
...            'vehículo': 'Ford'}

>>> claves = persona.keys()

La lista así obtenida es un objeto de la clase dict_keys:

>>> type(claves)
<class 'dict_keys'>

¿Que tiene de particular? Almacena una referencia al diccionario, pero no se trata de crear una nueva lista. es decir, si modificamos el diccionario, cambia la lista de claves, sin necesidad de crearla de nuevo:

>>> claves
    dict_keys(['nombre', 'edad', 'ciudad', 'vehículo'])

>>> persona.pop("vehículo")
    'Ford'

>>> claves
    dict_keys(['nombre', 'edad', 'ciudad'])

Obtener una lista de valores

El método values() devuelve una lista de valores:

>>> persona = {'nombre': 'Teresa', 
...            'edad': 27, 
...            'ciudad': 'Buenos Aires', 
...            'vehículo': 'Ford'}

>>> persona.values()
dict_values(['Teresa', 27, 'Buenos Aires', 'Ford'])

Como sucede con las claves, en lugar de obtener una lista ordinaria, se consigue un objeto de la clase dict_values ligado al diccionario original. Un cambio en este modifica la lista así obtenida.

Obtener una lista de parejas

El método items() devuelve una lista de tuplas:

>>> persona.items()
dict_items([('nombre', 'Teresa'), ('edad', 27), ('ciudad', 'Buenos Aires'), ('vehículo', 'Ford')])
>>>

Como sucede con los anteriores, la lista obtenida reflejará los cambios en el diccionario original. Si lo que queremos es obtener una lista independiente, generala con una llamada a la función list():

>>> persona = {'nombre': 'Teresa', 'edad': 27, 'ciudad': 'Buenos Aires', 'vehículo': 'Ford'}
>>> elementos=persona.items()
>>> for x in elementos:
...     print(x)
... 
('nombre', 'Teresa')
('edad', 27)
('ciudad', 'Buenos Aires')
('vehículo', 'Ford')

>>> type(elementos)
<class 'dict_items'>

>>> lista=list(elementos)
>>> type(lista)
<class 'list'>

Pertenencia

Podemos comprobar si una clave está presente, escribimos:

>>> "vehículo" in persona
True
>>> "profesión" in persona
False
>>> "profesión" not in persona
True

Recorrer diccionarios

Podría pensarse que la sentencia for recorre el diccionario y devuelve parejas, pero en realidad lo que devuelve son las claves:

>>> for clave in persona:
...     print(clave)

    nombre
    edad
    ciudad
    vehículo

Si lo que queremos son los valores, escribimos:

>>> for clave in persona:
...     print(persona[clave])
... 

    Teresa
    27
    Buenos Aires
    Ford

También podemos obtener una lista de valores mediante el método values()

>>> for valor in persona.values():
...     print(valor)

O para obtener una lista de claves:

>>> for clave in persona.keys():
...     print(clave)

O una lista de parejas con:

>>> for clave, valor in persona.items():
...     print(clave, valor)

Método fromkeys()

El método dict.fromkeys(iterable, valor) crea un diccionario a partir de una lista de claves, asignando el mismo valor a todas las parejas:

claves = ['clave1', 'clave2', 'clave3']
valor = 0

midiccionario = dict.fromkeys(claves, valor)

Anidar diccionarios

Los valores de un diccionario pueden ser diccionarios a su vez:

familia = {
  "hijo1"    : {
    "nombre" : "Juan",
    "año"    : 1987
  },
  "hijo2"    : {
    "nombre" : "Antonio",
    "año"    : 1990
  },
  "hijo3 "   : {
    "nombre" : "Ana",
    "año"    : 1995
  }
}

Podemos crear los diccionarios por separado y luego ponerlos en el diccionario principal:

hijo1      = {
  "nombre" : "Juan",
  "año"    : 1987
}

hijo2      = {
  "nombre" : "Antonio",
  "año"    : 1990
}

hijo3      = {
  "nombre" : "Ana",
  "año"    : 1995
}

familia = {
  "hijo1" : hijo1,
  "hijo2" : hijo2,
  "hijo3" : hijo3
}

El acceso será mediante doble clave:

print(familia["hijo2"]["nombre"])

Para recorrer un diccionario anidado, lo hacemos usando un bucle for para cada nivel de anidamiento

for hijo, dic in familia.items():
  for clave, valor in dic.items():
     print(hijo, clave, valor)
  print()

Copiar diccionarios

Supongamos que queremos crear un diccionario copiando el contenido de otro

diccionario2 = diccionario1

En realidad, lo que conseguimos son dos diccionarios ligados al mismo paquete de datos. Si modificamos los datos de uno de los diccionarios, se modificará el otro.

Para crear un nuevo paquete de datos tenemos que usar el método copy():

dict2 = dict1.copy()

y ahora los paquetes de datos son independientes el uno del otro.