Acordeón de los Índices

Índice de los temas

Python Dictionaries
Dictionary
Acess itens
Chenge itens
Add itens
Remove itens
Loop dicionaire
Copy dicionarie
Nested dicionairies
Dicionary methods

Lección: 16 - Python Dictionaries

Python Dictionaries

🗝️ Python Dictionaries: Almacenando Datos en Pares Clave-Valor

Un diccionario en Python es una colección de datos desordenada, mutable e indexada. A diferencia de las listas o tuplas, que están indexadas por un rango de números, los diccionarios están indexados por claves, que pueden ser de cualquier tipo inmutable (como cadenas, números o tuplas).

Los diccionarios se escriben con llaves `{}`, y contienen pares de clave: valor.

Características Principales de los Diccionarios:

Desordenados: Los elementos en un diccionario no tienen un orden específico. El orden en que se almacenan los pares clave-valor puede no ser el mismo en el que se definieron.
Mutables: Puedes cambiar, añadir o eliminar elementos de un diccionario después de su creación.
Indexados por Claves: Accedes a los valores en un diccionario utilizando sus claves, no mediante índices numéricos.
No permiten claves duplicadas: Si defines una clave duplicada, el último valor asignado a esa clave será el que se conserve.
Los valores pueden ser de cualquier tipo: Los valores almacenados en un diccionario pueden ser de cualquier tipo de dato en Python (listas, tuplas, otros diccionarios, etc.).

Creación de Diccionarios:

Para crear un diccionario, coloca pares clave-valor entre llaves, separados por comas. Cada par clave-valor consiste en la clave seguida de dos puntos (`:`) y luego el valor.

      
# Diccionario simple
mi_diccionario = {
    "nombre": "Ana",
    "edad": 30,
    "ciudad": "Madrid"
}
print(mi_diccionario) # Output: {'nombre': 'Ana', 'edad': 30, 'ciudad': 'Madrid'}

# Diccionario con diferentes tipos de valores
info_persona = {
    "nombre": "Carlos",
    "es_estudiante": True,
    "cursos": ["Python", "JavaScript"],
    "direccion": {"calle": "Gran Vía, 1", "codigo_postal": "28001"}
}
print(info_persona)

# Diccionario vacío
diccionario_vacio = {}
print(diccionario_vacio) # Output: {}

# También se puede crear un diccionario usando la función dict()
otro_diccionario = dict(nombre="Elena", edad=25)
print(otro_diccionario) # Output: {'nombre': 'Elena', 'edad': 25}

Los diccionarios son una estructura de datos fundamental en Python para organizar y acceder a información de manera eficiente utilizando claves significativas.

Dictionary

📚 ¿Qué es un Diccionario en Python?

Profundicemos un poco más en la esencia de los diccionarios en Python. Como mencionamos, son colecciones de pares clave-valor. Imagina un diccionario de la vida real: buscas una palabra (la clave) y encuentras su definición (el valor).

En Python, esta analogía se traduce a una estructura de datos muy poderosa para organizar información relacionada. Cada elemento en un diccionario está formado por una clave única y un valor asociado a esa clave.

Componentes Clave de un Diccionario:

Claves (Keys): Las claves son identificadores únicos para cada elemento del diccionario. Deben ser de un tipo de dato inmutable, como cadenas (`"nombre"`, `"edad"`), números (`1`, `3.14`), o tuplas (`(1, 2)`). Las listas no pueden ser claves porque son mutables.
Valores (Values): Los valores son los datos asociados a cada clave. Pueden ser de cualquier tipo de dato en Python, incluyendo números, cadenas, listas, tuplas, ¡e incluso otros diccionarios!
Pares Clave-Valor (Key-Value Pairs): Cada elemento dentro de un diccionario es un par clave-valor. La clave actúa como una etiqueta para acceder a su valor correspondiente.

Ejemplo Ilustrativo:

Considera un diccionario para almacenar información sobre un coche:

      
coche = {
    "marca": "Toyota",
    "modelo": "Corolla",
    "año": 2023,
    "color": "rojo"
}
print(coche)
print(type(coche)) # Output: <class 'dict'>

En este ejemplo:

`"marca"`, `"modelo"`, `"año"`, y `"color"` son las claves.
`"Toyota"`, `"Corolla"`, `2023`, y `"rojo"` son los valores asociados a esas claves respectivamente.
`"marca": "Toyota"` es un par clave-valor.

La capacidad de acceder a los valores mediante claves descriptivas hace que los diccionarios sean muy útiles para representar estructuras de datos complejas y organizar información de manera lógica.

Acess itens

🔑 Acceder a los Elementos de un Diccionario

Para acceder a los valores dentro de un diccionario, utilizas sus claves. A diferencia de las listas o tuplas, donde accedes a los elementos mediante un índice numérico, en los diccionarios empleas la clave asociada al valor que deseas obtener.

Formas Principales de Acceder a Elementos:

Usando corchetes `[]`: Puedes acceder al valor de una clave específica colocando la clave entre corchetes después del nombre del diccionario.
Usando el método `get()`: El método `get()` también se utiliza para acceder al valor de una clave. La principal diferencia con el uso de corchetes es que si la clave no existe, `get()` devuelve `None` (o un valor predeterminado si se especifica), en lugar de generar un error `KeyError`.

Ejemplos de Acceso:

Consideremos el diccionario `coche` que definimos anteriormente:

      
coche = {
    "marca": "Toyota",
    "modelo": "Corolla",
    "año": 2023,
    "color": "rojo"
}

# Accediendo al valor usando corchetes
marca = coche["marca"]
print(f"Marca del coche: {marca}") # Output: Marca del coche: Toyota

año = coche["año"]
print(f"Año del coche: {año}") # Output: Año del coche: 2023

# Intentar acceder a una clave que no existe genera un KeyError
# modelo_inexistente = coche["fabricante"] # Esto causará un error

# Accediendo al valor usando el método get()
modelo = coche.get("modelo")
print(f"Modelo del coche: {modelo}") # Output: Modelo del coche: Corolla

color = coche.get("color")
print(f"Color del coche: {color}") # Output: Color del coche: rojo

# Intentar acceder a una clave inexistente con get() devuelve None
fabricante = coche.get("fabricante")
print(f"Fabricante del coche (usando get()): {fabricante}") # Output: Fabricante del coche (usando get()): None

# Puedes especificar un valor predeterminado si la clave no existe en get()
origen = coche.get("origen", "Desconocido")
print(f"Origen del coche: {origen}") # Output: Origen del coche: Desconocido

¿Cuándo usar cada método?

Utiliza los corchetes `[]` cuando estés seguro de que la clave existe en el diccionario y quieras que se genere un error si no es así.
Utiliza el método `get()` cuando no estés seguro de si la clave existe y prefieras manejar la ausencia del valor (por ejemplo, asignando un valor predeterminado o simplemente continuando sin el valor).

Dominar cómo acceder a los elementos es fundamental para trabajar eficazmente con los diccionarios en Python.

Chenge itens

🔄 Cambiar los Elementos de un Diccionario

Los diccionarios en Python son mutables, lo que significa que puedes modificar sus elementos después de que han sido creados. Puedes cambiar el valor asociado a una clave existente o incluso añadir nuevas claves y valores.

Formas de Cambiar Elementos:

Asignación directa usando corchetes `[]`: Puedes cambiar el valor de una clave específica simplemente asignándole un nuevo valor utilizando la notación de corchetes. Si la clave ya existe, su valor se actualizará. Si la clave no existe, se añadirá un nuevo par clave-valor al diccionario.
Usando el método `update()`: El método `update()` te permite actualizar un diccionario con los elementos de otro diccionario o de un iterable de pares clave-valor. Si las claves ya existen, sus valores se actualizan; si no existen, se añaden nuevos pares.

Ejemplos de Cambio de Elementos:

Volvamos a nuestro diccionario `coche`:

      
coche = {
    "marca": "Toyota",
    "modelo": "Corolla",
    "año": 2023,
    "color": "rojo"
}
print(f"Diccionario original: {coche}") # Output: Diccionario original: {'marca': 'Toyota', 'modelo': 'Corolla', 'año': 2023, 'color': 'rojo'}

# Cambiando el valor de una clave existente usando corchetes
coche["año"] = 2024
print(f"Diccionario después de cambiar el año: {coche}") # Output: Diccionario después de cambiar el año: {'marca': 'Toyota', 'modelo': 'Corolla', 'año': 2024, 'color': 'rojo'}

# Cambiando el valor de otra clave
coche["color"] = "azul"
print(f"Diccionario después de cambiar el color: {coche}") # Output: Diccionario después de cambiar el color: {'marca': 'Toyota', 'modelo': 'Corolla', 'año': 2024, 'color': 'azul'}

# Añadiendo un nuevo par clave-valor usando corchetes
coche["matricula"] = "ABC-123"
print(f"Diccionario después de añadir la matrícula: {coche}") # Output: Diccionario después de añadir la matrícula: {'marca': 'Toyota', 'modelo': 'Corolla', 'año': 2024, 'color': 'azul', 'matricula': 'ABC-123'}

# Usando el método update() para cambiar valores existentes y añadir nuevos
coche.update({"color": "verde", "tiene_aire_acondicionado": True})
print(f"Diccionario después de update(): {coche}") # Output: Diccionario después de update(): {'marca': 'Toyota', 'modelo': 'Corolla', 'año': 2024, 'color': 'verde', 'matricula': 'ABC-123', 'tiene_aire_acondicionado': True}

# También puedes usar update() con pares clave-valor individuales
coche.update(kilometraje=15000)
print(f"Diccionario después de otro update(): {coche}") # Output: Diccionario después de otro update(): {'marca': 'Toyota', 'modelo': 'Corolla', 'año': 2024, 'color': 'verde', 'matricula': 'ABC-123', 'tiene_aire_acondicionado': True, 'kilometraje': 15000}

Ambos métodos (`[]` y `update()`) son herramientas poderosas para modificar el contenido de tus diccionarios en Python.

Add itens

➕ Añadir Elementos a un Diccionario

Como los diccionarios son mutables, puedes añadir nuevos pares clave-valor a un diccionario existente de varias maneras:

Formas de Añadir Elementos:

Asignación directa usando corchetes `[]`: Si asignas un valor a una clave que aún no existe en el diccionario, se creará un nuevo par clave-valor.
Usando el método `update()`: El método `update()` también se puede utilizar para añadir nuevos pares clave-valor a un diccionario. Si la clave no existe, se añade el nuevo par.

Ejemplos de Adición de Elementos:

Sigamos trabajando con nuestro diccionario `coche`:

      
coche = {
    "marca": "Toyota",
    "modelo": "Corolla",
    "año": 2023,
    "color": "rojo"
}
print(f"Diccionario original: {coche}") # Output: Diccionario original: {'marca': 'Toyota', 'modelo': 'Corolla', 'año': 2023, 'color': 'rojo'}

# Añadiendo un nuevo par clave-valor usando corchetes
coche["combustible"] = "gasolina"
print(f"Diccionario después de añadir combustible: {coche}") # Output: Diccionario después de añadir combustible: {'marca': 'Toyota', 'modelo': 'Corolla', 'año': 2023, 'color': 'rojo', 'combustible': 'gasolina'}

# Añadiendo otro par clave-valor
coche["precio"] = 22000
print(f"Diccionario después de añadir precio: {coche}") # Output: Diccionario después de añadir precio: {'marca': 'Toyota', 'modelo': 'Corolla', 'año': 2023, 'color': 'rojo', 'combustible': 'gasolina', 'precio': 22000}

# Usando el método update() para añadir un nuevo par clave-valor
coche.update({"traccion": "delantera"})
print(f"Diccionario después de update() para tracción: {coche}") # Output: Diccionario después de update() para tracción: {'marca': 'Toyota', 'modelo': 'Corolla', 'año': 2023, 'color': 'rojo', 'combustible': 'gasolina', 'precio': 22000, 'traccion': 'delantera'}

# También puedes usar update() con sintaxis de argumentos con nombre
coche.update(puertas=4)
print(f"Diccionario después de otro update(): {coche}") # Output: Diccionario después de otro update(): {'marca': 'Toyota', 'modelo': 'Corolla', 'año': 2023, 'color': 'rojo', 'combustible': 'gasolina', 'precio': 22000, 'traccion': 'delantera', 'puertas': 4}

Ambos métodos son igualmente válidos para expandir tus diccionarios con nueva información.

Remove itens

🗑️ Eliminar Elementos de un Diccionario

Python proporciona varias formas de eliminar elementos de un diccionario cuando ya no los necesitas:

Métodos para Eliminar Elementos:

`pop(key)`: Elimina el elemento con la clave especificada y devuelve el valor asociado. Si la clave no se encuentra, genera un error `KeyError`.
`popitem()`: Elimina y devuelve el último par clave-valor insertado en el diccionario (en versiones anteriores a Python 3.7, elimina un elemento arbitrario).
`del diccionario[key]`: La palabra clave `del` se utiliza para eliminar un elemento con una clave específica. Si la clave no existe, genera un error `KeyError`. También se puede usar para eliminar el diccionario completo.
`clear()`: Elimina todos los elementos del diccionario, dejándolo vacío.

Ejemplos de Eliminación de Elementos:

Continuemos con nuestro diccionario `coche`:

      
coche = {
    "marca": "Toyota",
    "modelo": "Corolla",
    "año": 2023,
    "color": "rojo",
    "combustible": "gasolina",
    "precio": 22000
}
print(f"Diccionario original: {coche}") # Output: Diccionario original: {'marca': 'Toyota', 'modelo': 'Corolla', 'año': 2023, 'color': 'rojo', 'combustible': 'gasolina', 'precio': 22000}

# Eliminando un elemento con pop()
precio = coche.pop("precio")
print(f"Precio eliminado (pop()): {precio}") # Output: Precio eliminado (pop()): 22000
print(f"Diccionario después de pop('precio'): {coche}") # Output: Diccionario después de pop('precio'): {'marca': 'Toyota', 'modelo': 'Corolla', 'año': 2023, 'color': 'rojo', 'combustible': 'gasolina'}

# Eliminando el último elemento con popitem()
ultimo_elemento = coche.popitem()
print(f"Último elemento eliminado (popitem()): {ultimo_elemento}") # Output: Último elemento eliminado (popitem()): ('combustible', 'gasolina')
print(f"Diccionario después de popitem(): {coche}") # Output: Diccionario después de popitem(): {'marca': 'Toyota', 'modelo': 'Corolla', 'año': 2023, 'color': 'rojo'}

# Eliminando un elemento con del
del coche["año"]
print(f"Diccionario después de del ['año']: {coche}") # Output: Diccionario después de del ['año']: {'marca': 'Toyota', 'modelo': 'Corolla', 'color': 'rojo'}

# Intentar eliminar una clave inexistente con del genera KeyError
# del coche["origen"] # Esto causará un error

# Eliminando todos los elementos con clear()
coche.clear()
print(f"Diccionario después de clear(): {coche}") # Output: Diccionario después de clear(): {}

# También puedes eliminar el diccionario completo con del
# del coche
# print(coche) # Esto generaría un NameError porque el diccionario ya no existe

Elige el método de eliminación que mejor se adapte a tus necesidades específicas.

Loop dicionaire

🔄 Iterar a Través de un Diccionario

Puedes recorrer los elementos de un diccionario utilizando un bucle `for`. Sin embargo, dado que los diccionarios tienen claves y valores, la forma en que iteras te permite acceder a diferentes partes del diccionario.

Formas de Iterar:

Iterar sobre las claves: Por defecto, al iterar sobre un diccionario con un bucle `for`, se acceden a las claves del diccionario.
Iterar sobre los valores: Puedes usar el método `values()` para obtener una vista de todos los valores en el diccionario y luego iterar sobre ellos.
Iterar sobre los pares clave-valor: Puedes usar el método `items()` para obtener una vista de todos los pares clave-valor en el diccionario como tuplas, y luego iterar sobre ellos.

Ejemplos de Iteración:

Utilicemos nuestro diccionario `coche` por última vez en esta sección:

      
coche = {
    "marca": "Toyota",
    "modelo": "Corolla",
    "año": 2023,
    "color": "rojo"
}

print("Iterando sobre las claves:")
for clave in coche:
    print(clave) # Output: marca, modelo, año, color (en un orden no garantizado)

print("\nIterando sobre los valores:")
for valor in coche.values():
    print(valor) # Output: Toyota, Corolla, 2023, rojo (en un orden no garantizado)

print("\nIterando sobre los pares clave-valor:")
for clave, valor in coche.items():
    print(f"Clave: {clave}, Valor: {valor}")
    # Output:
    # Clave: marca, Valor: Toyota
    # Clave: modelo, Valor: Corolla
    # Clave: año, Valor: 2023
    # Clave: color, Valor: rojo (en un orden no garantizado)

La elección de cómo iterar depende de si necesitas acceder solo a las claves, solo a los valores, o a ambos simultáneamente.

Copy dicionarie

📄 Copiar un Diccionario

Cuando trabajas con diccionarios, es importante entender cómo copiarlos correctamente para evitar modificaciones inesperadas en el diccionario original. Simplemente asignar un diccionario a una nueva variable no crea una copia independiente; ambas variables harán referencia al mismo diccionario en memoria.

Formas de Copiar un Diccionario:

Usando el método `copy()`: Este método devuelve una copia superficial (shallow copy) del diccionario. Los cambios realizados en la copia no afectarán al diccionario original, y viceversa. Sin embargo, si el diccionario contiene objetos mutables (como listas o diccionarios anidados), la copia seguirá compartiendo estas referencias.
Usando la función `dict()`: También puedes crear una copia de un diccionario pasando el diccionario original a la función `dict()`. Esto también crea una copia superficial.

Ejemplos de Copia:

      
coche_original = {
    "marca": "Toyota",
    "modelo": "Corolla",
    "año": 2023,
    "color": "rojo",
    "accesorios": ["radio", "aire acondicionado"]
}
print(f"Diccionario original: {coche_original}")

# Copiando con el método copy()
coche_copia_copy = coche_original.copy()
coche_copia_copy["color"] = "azul"
coche_copia_copy["accesorios"].append("GPS") # ¡Esto también afectará al original!

print(f"Copia con copy(): {coche_copia_copy}")
print(f"Original después de modificar la copia (copy()): {coche_original}")

# Copiando con la función dict()
coche_copia_dict = dict(coche_original)
coche_copia_dict["año"] = 2024
coche_copia_dict["accesorios"].remove("radio") # ¡Esto también afectará al original!

print(f"Copia con dict(): {coche_copia_dict}")
print(f"Original después de modificar la copia (dict()): {coche_original}")

Copia Superficial vs. Copia Profunda:

Es importante tener en cuenta que tanto `copy()` como `dict()` realizan una copia superficial. Esto significa que solo se crea un nuevo objeto diccionario, pero si los valores dentro del diccionario son objetos mutables, la copia y el original seguirán compartiendo referencias a esos objetos.

Si necesitas una copia completamente independiente, incluyendo los objetos anidados, debes usar la función `deepcopy()` del módulo `copy`.

      
import copy

coche_original_deep = {
    "marca": "Toyota",
    "modelo": "Corolla",
    "año": 2023,
    "color": "rojo",
    "accesorios": ["radio", "aire acondicionado"]
}

coche_copia_deep = copy.deepcopy(coche_original_deep)
coche_copia_deep["accesorios"].append("GPS")

print(f"Copia profunda: {coche_copia_deep}")
print(f"Original después de modificar la copia profunda: {coche_original_deep}")

Entender la diferencia entre copias superficiales y profundas es crucial para evitar errores al manipular diccionarios.

Nested dicionairies

🪆 Diccionarios Anidados

Un diccionario anidado es un diccionario que contiene otros diccionarios como valores. Esto puede ser útil para organizar datos más complejos y representar estructuras jerárquicas.

Creación de Diccionarios Anidados:

Puedes crear diccionarios anidados de la misma manera que creas diccionarios regulares, simplemente incluyendo otro diccionario como valor de una clave.

Ejemplo de Diccionario Anidado:

Imaginemos que queremos almacenar información sobre varios coches:

      
coches = {
    "coche1": {
        "marca": "Toyota",
        "modelo": "Corolla",
        "año": 2023,
        "color": "rojo"
    },
    "coche2": {
        "marca": "Honda",
        "modelo": "Civic",
        "año": 2022,
        "color": "azul"
    },
    "coche3": {
        "marca": "Ford",
        "modelo": "Focus",
        "año": 2024,
        "color": "gris"
    }
}
print(coches)

Acceder a Elementos en Diccionarios Anidados:

Para acceder a los elementos dentro de un diccionario anidado, necesitas usar múltiples claves, encadenando los corchetes `[]` para navegar a través de las diferentes capas del diccionario.

      
# Accediendo a la marca del coche1
marca_coche1 = coches["coche1"]["marca"]
print(f"Marca del coche 1: {marca_coche1}") # Output: Marca del coche 1: Toyota

# Accediendo al año del coche2
año_coche2 = coches["coche2"]["año"]
print(f"Año del coche 2: {año_coche2}") # Output: Año del coche 2: 2022

# Accediendo al color del coche3
color_coche3 = coches["coche3"]["color"]
print(f"Color del coche 3: {color_coche3}") # Output: Color del coche 3: gris

Iterar a Través de Diccionarios Anidados:

Para iterar a través de diccionarios anidados, a menudo necesitas usar bucles `for` anidados o acceder a los elementos internos utilizando sus claves.

      
print("\nInformación de todos los coches:")
for clave_externa, diccionario_interno in coches.items():
    print(f"\n{clave_externa}:")
    for clave_interna, valor_interno in diccionario_interno.items():
        print(f"  {clave_interna}: {valor_interno}")
    # Output:
    # coche1:
    #   marca: Toyota
    #   modelo: Corolla
    #   año: 2023
    #   color: rojo
    #
    # coche2:
    #   marca: Honda
    #   modelo: Civic
    #   año: 2022
    #   color: azul
    #
    # coche3:
    #   marca: Ford
    #   modelo: Focus
    #   año: 2024
    #   color: gris

Los diccionarios anidados son una herramienta poderosa para organizar información compleja de manera estructurada.

Dicionary methods

🛠️ Métodos de Diccionario en Python

Python ofrece una variedad de métodos integrados que facilitan la manipulación y el trabajo con diccionarios. Aquí tienes algunos de los métodos más comunes y útiles:

Métodos Comunes de Diccionario:

`clear()`: Elimina todos los elementos del diccionario.
`copy()`: Devuelve una copia superficial del diccionario.
`get(key, default=None)`: Devuelve el valor de la clave especificada. Si la clave no existe, devuelve `default` (por defecto, `None`).
`items()`: Devuelve una vista de los pares clave-valor del diccionario (como una lista de tuplas).
`keys()`: Devuelve una vista de las claves del diccionario.
`pop(key, default=...)`: Elimina la clave especificada y devuelve su valor. Si la clave no se encuentra, devuelve `default` si se proporciona, de lo contrario, genera un `KeyError`.
`popitem()`: Elimina y devuelve el último par clave-valor insertado (en versiones anteriores a Python 3.7, elimina un elemento arbitrario).
`setdefault(key, default=None)`: Si la clave está en el diccionario, devuelve su valor. Si no está, inserta la clave con un valor de `default` y devuelve `default`.
`update(other)`: Actualiza el diccionario con los pares clave-valor de otro diccionario o iterable de pares clave-valor. Las claves existentes se sobrescriben, y las nuevas claves se añaden.
`values()`: Devuelve una vista de los valores del diccionario.

Ejemplos de Uso de Métodos:

      
mi_diccionario = {
    "nombre": "Juan",
    "edad": 28,
    "ciudad": "Barcelona"
}
print(f"Diccionario inicial: {mi_diccionario}")

# clear()
# copia = mi_diccionario.copy()
# copia.clear()
# print(f"Diccionario después de clear(): {copia}") # Output: {}

# get()
nombre = mi_diccionario.get("nombre")
print(f"Nombre: {nombre}") # Output: Juan
pais = mi_diccionario.get("pais")
print(f"País (con get()): {pais}") # Output: None
idioma = mi_diccionario.get("idioma", "Español")
print(f"Idioma (con get() y default): {idioma}") # Output: Español

# items()
print("\nItems:")
for clave, valor in mi_diccionario.items():
    print(f"{clave}: {valor}")
    # Output:
    # nombre: Juan
    # edad: 28
    # ciudad: Barcelona

# keys()
print("\nClaves:")
for clave in mi_diccionario.keys():
    print(clave) # Output: nombre, edad, ciudad

# values()
print("\nValores:")
for valor in mi_diccionario.values():
    print(valor) # Output: Juan, 28, Barcelona

# pop()
edad = mi_diccionario.pop("edad")
print(f"\nEdad eliminada (pop()): {edad}") # Output: 28
print(f"Diccionario después de pop('edad'): {mi_diccionario}") # Output: {'nombre': 'Juan', 'ciudad': 'Barcelona'}

# setdefault()
mi_diccionario.setdefault("profesion", "Ingeniero")
print(f"Diccionario después de setdefault('profesion'): {mi_diccionario}") # Output: {'nombre': 'Juan', 'ciudad': 'Barcelona', 'profesion': 'Ingeniero'}
ciudad = mi_diccionario.setdefault("ciudad", "Valencia")
print(f"Ciudad después de setdefault('ciudad'): {mi_diccionario}") # Output: {'nombre': 'Juan', 'ciudad': 'Barcelona', 'profesion': 'Ingeniero'}

# update()
otro_diccionario = {"intereses": ["programación", "viajar"], "edad": 30}
mi_diccionario.update(otro_diccionario)
print(f"Diccionario después de update(): {mi_diccionario}")
# Output: {'nombre': 'Juan', 'ciudad': 'Barcelona', 'profesion': 'Ingeniero', 'intereses': ['programación', 'viajar'], 'edad': 30}

Estos métodos proporcionan herramientas poderosas para manipular y obtener información de tus diccionarios de manera eficiente.

Ir al indice

16-dicionarios en python