Uso de tipos estructurados en el lenguaje de programación Python: tuplas, listas y diccionarios. Con multitud de ejemplos y resultado de salida.
Tuplas en Python
Las tuplas son un tipo de datos estructurado de Python que se utiliza para agrupar variables del mismo tipo o tipos diferentes. Es un tipo de dato inmutable desde su creación (una vez creado, no puede modificarse).
Ejemplo de creación de tuplas de cadenas de texto en Python:
|
1 |
colores = ("Rojo", "Negro", "Verde", "Azul", "Naranja") |
De números:
|
1 |
numeros = (23, 45, 12, -4) |
De cualquier tipo, incluidas otras tuplas en una tupla nueva:
|
1 |
colores_numeros = (colores, numeros, 123, "Violeta", "Marrón", 458) |
Si intentamos modificar algún elemento de una tupla, por ejemplo con:
|
1 |
colores[2] = "Amarillo" |
El compilador nos devolverá este error:
|
1 2 3 4 |
raceback (most recent call last): File "d:Mis documentosProyectoAPythonBuclestuplas.py", line 6, in <module> colores[2] = "Amarillo" TypeError: 'tuple' object does not support item assignment |
Indicando que el objeto colores no admite la asignación, no se pueden modificar sus valores.
Las tuplas en Python admiten métodos genéricos como str(), type() o len(). Por ejemplo, si ejecutamos un len() en la tupla «colores» definida anteriormente:
|
1 2 |
colores = ("Rojo", "Negro", "Verde", "Azul", "Naranja") print(f"El número de elementos de la tupla colores es: {len(colores)}") |
Devolverá: 5, dado que es el número de elementos que contiene la tupla colores.
El acceso a un elemento de la tupla se realizará indicando el índice entre corchetes. Las posiciones de las tuplas empiezan siempre por cero. Por ejemplo, para mostrar el elemento «Verde» de la tupla colores, usaremos el siguiente código Python:
|
1 2 |
colores = ("Rojo", "Negro", "Verde", "Azul", "Naranja") print(colores[2]) |
Devolverá: Verde.
Si queremos obtener el elemento 1 de la tupla colores_numeros, ejecutaremos:
|
1 2 3 4 |
colores = ("Rojo", "Negro", "Verde", "Azul", "Naranja") numeros = (23, 45, 12, -4) colores_numeros = (colores, numeros, 123, "Violeta", "Marrón", 458) print(colores_numeros[1]) |
En este caso, devolverá: (23, 45, 12, -4), que son los valores de la tupla numeros contenida en el elemento 1 de la tupla colores_numeros.
Si queremos saber el número de veces que aparece un mismo elemento en una tupla podemos usar el método count(valor). Por ejemplo, para saber cuántas veces aparece el número 12 en la tupla numeros, ejecutaremos:
|
1 2 |
numeros = (23, 45, 12, -4, 12, 4, 12, 87) print(numeros.count(12)) |
Nos devolverá: 3.
Si no aparece ninguna vez, devolverá 0.
En Python también se puede obtener la posición del elemento de una tupla por su valor, con el método index(valor). Por ejemplo, para obtener la posición del elemento «12» de la tupla numeros, ejecutaremos:
|
1 2 |
numeros = (23, 45, 12, -4, 12, 4, 12, 87) print(numeros.index(12)) |
Si el elemento se repite, como es el caso del ejemplo anterior, devolverá la primera posición donde lo encuentre, en este caso devolverá: 2.
Hay que tener precaución con el método «index», dado que si el elemento no existe, devolverá un error. Por ejemplo, si ejecutamos:
|
1 2 |
numeros = (23, 45, 12, -4, 12, 4, 12, 87) print(numeros.index(88)) |
Devolverá el error:
|
1 2 3 4 |
Traceback (most recent call last): File "d:Mis documentosProyectoAPythonBuclestuplas.py", line 8, in <module> print(numeros.index(88)) ValueError: tuple.index(x): x not in tuple |
En el caso anterior, es recomendable siempre comprobar previamente si existe el elemento antes de usar «index», con «count». Por ejemplo:
|
1 2 3 4 5 6 7 |
numeros = (23, 45, 12, -4, 12, 4, 12, 87) elemento = 88 if numeros.count(elemento) > 0: print(f"Posición del elemento {elemento} en la tupla "numeros": {numeros.index(elemento)}") else: print(f"No se ha encontrado el elemento {elemento} en la tupla "numeros"") |
El ejemplo anterior devolverá: No se ha encontrado el elemento 88 en la tupla «numeros».
En Python se pueden crear tuplas vacías, para asignarles elementos posteriormente. Por ejemplo:
|
1 2 3 4 5 6 |
tVacia = () if tVacia.count("Verde") > 0: tVacia = ("Verde", "Azul") else: tVacia = ("Verde", "Rojo") print(tVacia) |
Devolverá: (‘Verde’, ‘Rojo’).
También se pueden crear tuplas de un solo elemento, con esta nomenclatura: tupla = (valor, ). Por ejemplo:
|
1 2 |
tupla_un_elemento = ("Color", ) print(f"La tupla {tupla_un_elemento} tiene {len(tupla_un_elemento)} elemento") |
Devolverá: La tupla (‘Color’,) tiene 1 elemento.
Se pueden empaquetar varias variables en una tupla de forma directa. Por ejemplo:
|
1 2 3 4 5 6 |
num1 = 43 num2 = -4 color1 = "Verde" color2 = "Marrón" num_color = num1, num2, color1, color2 print(f"La tupla num_color tiene los valores: {num_color}") |
Devolverá: La tupla num_color tiene los valores: (43, -4, ‘Verde’, ‘Marrón’).
Se puede hacer a la inversa, desempaquetando varias variables en una tupla de forma directa:
|
1 2 3 4 5 6 7 |
num1 = 43 num2 = -4 color1 = "Verde" color2 = "Marrón" num_color = num1, num2, color1, color2 v1, v2, v3, v4 = num_color print(f"La tupla num_color se desempaquetó en las variables v1 -> {v1}, v2 -> {v2}, v3 -> {v3} y v4 -> {v4}") |
Devolverá: La tupla num_color se desempaquetó en las variables v1 -> 43, v2 -> -4, v3 -> Verde y v4 -> Marrón.
En el caso del desempaquetado hay que tener precaución, pues hay que añadir el número de variables exacto correspondiente al número de elementos de la tupla, de lo contrario, se producirá un error, o bien por falta de variables:
|
1 2 3 4 |
Traceback (most recent call last): File "d:Mis documentosProyectoAPythonBuclestuplas.py", line 29, in <module> v1, v2, v3 = num_color ValueError: too many values to unpack (expected 3) |
O bien por exceso de variables:
|
1 2 3 4 |
Traceback (most recent call last): File "d:Mis documentosProyectoAPythonBuclestuplas.py", line 29, in <module> v1, v2, v3, v4, v5 = num_color ValueError: not enough values to unpack (expected 5, got 4) |
Listas en Python
Las listas son un tipo de dato estructurado en Python que sirven para agrupar variables del mismo tipo o tipos diferentes. Son similares a las tuplas, con la diferencia de que su contenido se puede modificar. Se definen, en lugar de con paréntesis (como el caso de las tuplas), con corchetes.
El funcionamiento general de las listas es similar al de las tuplas explicado anteriormente, admitiendo los métodos len(), count(valor), str(), type(), index(valor), etc. Por ejemplo:
|
1 2 3 4 |
lstColores = ["Rojo", "Negro", "Verde", "Azul", "Naranja"] print("El elemento "Rojo" aparece en la posición {0} de la lista".format( lstColores.index("Naranja"))) print(f"La lista tiene {len(lstColores)} elementos") |
Devolverá:
El elemento «Rojo» aparece en la posición 4 de la lista
La lista tiene 5 elementos
Las listas son accesibles por subgrupos, teniendo en cuenta que los índices indican:
[Primera posición que se selecciona:primera posición que no se selecciona]
Por ejemplo:
|
1 2 |
lstColores = ["Rojo", "Negro", "Verde", "Azul", "Naranja"] print(lstColores[:2]) |
Devolverá: [‘Rojo’, ‘Negro’], dado que hemos indicado que se seleccione desde la posición 0 a la 2 (desde el «Rojo» al «Verde», pero sin incluir este último.
Otro ejemplo:
|
1 2 |
lstColores = ["Rojo", "Negro", "Verde", "Azul", "Naranja"] print(lstColores[2:4]) |
Devolverá: [‘Verde’, ‘Azul’], dado que hemos indicado que empiece por el elemento 2 (el «Verde») y acabe en el 4 (el «Naranja»), sin incluirlo.
Si no queremos mostrar el último elemento de una lista, usaremos [:-1]
|
1 2 |
lstColores = ["Rojo", "Negro", "Verde", "Azul", "Naranja"] print(lstColores[:-1]) |
Devolverá: [‘Rojo’, ‘Negro’, ‘Verde’, ‘Azul’].
Las listas admiten asignación directa, para modificar sus elementos. Por ejemplo:
|
1 2 3 4 |
lstColores = ["Rojo", "Negro", "Verde", "Azul", "Naranja"] print("El elemento 2 tiene el valor {0}".format(lstColores[2])) lstColores[2] = "Amarillo" print("Ahora, el elemento 2 tiene el valor {0}".format(lstColores[2])) |
Devolverá:
El elemento 2 tiene el valor Verde
Ahora, el elemento 2 tiene el valor Amarillo
Podremos añadir un elemento al final de la lista, con append(valor):
|
1 2 3 4 |
lstColores = ["Rojo", "Negro", "Verde", "Azul", "Naranja"] print(f"La lista tiene {len(lstColores)} elementos") lstColores.append("Blanco") print(f"Ahora, la lista tiene {len(lstColores)} elementos") |
Devolverá:
La lista tiene 5 elementos
Ahora, la lista tiene 6 elementos
Para añadir un elemento en una posición concreta de la lista, usaremos insert(posicion, valor). Por ejemplo:
|
1 2 3 4 5 |
lstColores = ["Rojo", "Negro", "Verde", "Azul", "Naranja"] print(lstColores) # Insertaremos un elemento en la posición 3 lstColores.insert(3, "Violeta") print(lstColores) |
Devolverá:
[‘Rojo’, ‘Negro’, ‘Verde’, ‘Azul’, ‘Naranja’]
[‘Rojo’, ‘Negro’, ‘Verde’, ‘Violeta’, ‘Azul’, ‘Naranja’]
Podremos extender una lista, añadiéndole varios elementos, con extend. Por ejemplo:
|
1 2 3 4 5 |
lstColores = ["Rojo", "Negro", "Verde", "Azul", "Naranja"] print(lstColores) # Extendemos la lista con varios elementos más lstColores.extend(["Violeta", "Rosa", "Púrpura", "Blanco"]) print(lstColores) |
Devolviendo:
[‘Rojo’, ‘Negro’, ‘Verde’, ‘Azul’, ‘Naranja’]
[‘Rojo’, ‘Negro’, ‘Verde’, ‘Azul’, ‘Naranja’, ‘Violeta’, ‘Rosa’, ‘Púrpura’, ‘Blanco’]
Se pueden eliminar elementos por su valor en una lista, usando remove(valor). Por ejemplo:
|
1 2 3 4 5 |
lstColores = ["Rojo", "Negro", "Verde", "Azul", "Naranja"] print(lstColores) # Eliminamos el elemento "Verde" lstColores.remove("Verde") print(lstColores) |
Devolverá:
[‘Rojo’, ‘Negro’, ‘Verde’, ‘Azul’, ‘Naranja’]
[‘Rojo’, ‘Negro’, ‘Azul’, ‘Naranja’]
También se puede eliminar un elemento por su índice, con pop(índice). Por ejemplo:
|
1 2 3 4 5 |
lstColores = ["Rojo", "Negro", "Verde", "Azul", "Naranja"] print(lstColores) # Eliminamos el elemento de la posición 1 lstColores.pop(1) print(lstColores) |
Devolverá:
[‘Rojo’, ‘Negro’, ‘Verde’, ‘Azul’, ‘Naranja’]
[‘Rojo’, ‘Verde’, ‘Azul’, ‘Naranja’]
Podremos evaluar si un elemento está en la lista, usando in. Por ejemplo:
|
1 2 3 4 5 |
lstColores = ["Rojo", "Negro", "Verde", "Azul", "Naranja"] if "Naranja" in lstColores: print("El color 'Naranja' existe en la lista") else: print("El color 'Naranja' no existe en la lista") |
Devolverá: El color ‘Naranja’ existe en la lista.
Para obtener la posición de un elemento en la lista usaremos index(valor). Por ejemplo:
|
1 2 3 4 5 6 |
lstColores = ["Rojo", "Negro", "Verde", "Azul", "Naranja"] if "Naranja" in lstColores: print("El color 'Naranja' existe en la lista, en la posición {0}".format( lstColores.index("Naranja"))) else: print("El color 'Naranja' no existe en la lista") |
Devolverá: El color ‘Naranja’ existe en la lista, en la posición 4.
En el caso del uso de index deberemos tener precaución porque si no existe el elemento se producirá un error:
|
1 2 3 4 |
Traceback (most recent call last): File "d:Mis documentosProyectoAPythonBucleslista.py", line 2, in <module> lstColores.index("Naranjas") ValueError: 'Naranjas' is not in list |
Podremos invertir el orden de una lista, con reverse(). Por ejemplo:
|
1 2 3 4 |
lstColores = ["Rojo", "Negro", "Verde", "Azul", "Naranja"] print(f"La lista antes de invertir el orden: {lstColores}") lstColores.reverse() print(f"La lista antes tras invertir el orden: {lstColores}") |
Devolverá:
La lista antes de invertir el orden: [‘Rojo’, ‘Negro’, ‘Verde’, ‘Azul’, ‘Naranja’]
La lista antes tras invertir el orden: [‘Naranja’, ‘Azul’, ‘Verde’, ‘Negro’, ‘Rojo’]
Podremos ordenar la lista en orden alfabético de menor a mayor con sort(). Por ejemplo:
|
1 2 3 4 |
lstColores = ["Rojo", "Negro", "Verde", "Azul", "Naranja"] print(f"La lista antes de ordenar: {lstColores}") lstColores.sort() print(f"La lista antes tras ordenar: {lstColores}") |
Devolverá:
La lista antes de ordenar: [‘Rojo’, ‘Negro’, ‘Verde’, ‘Azul’, ‘Naranja’]
La lista antes tras ordenar: [‘Azul’, ‘Naranja’, ‘Negro’, ‘Rojo’, ‘Verde’]
Para ordenar alfabéticamente de mayor a menor usaremos sort(reverse = True). Por ejemplo:
|
1 2 3 4 |
lstColores = ["Rojo", "Negro", "Verde", "Azul", "Naranja"] print(f"La lista antes de ordenar: {lstColores}") lstColores.sort(reverse=True) print(f"La lista antes tras ordenar: {lstColores}") |
Devolverá:
La lista antes de ordenar: [‘Rojo’, ‘Negro’, ‘Verde’, ‘Azul’, ‘Naranja’]
La lista antes tras ordenar: [‘Verde’, ‘Rojo’, ‘Negro’, ‘Naranja’, ‘Azul’]
El método sort también ordena listas de números. Por ejemplo:
|
1 2 3 4 |
lstNumeros = [2, -1, 45, 0, -23, 132] print(lstNumeros) lstNumeros.sort() print(lstNumeros) |
Devolverá:
[2, -1, 45, 0, -23, 132]
[-23, -1, 0, 2, 45, 132]
Al igual que reverse, también invertirá el orden de una lista de números:
|
1 2 3 4 |
lstNumeros = [2, -1, 45, 0, -23, 132] print(lstNumeros) lstNumeros.reverse() print(lstNumeros) |
Devolverá:
[2, -1, 45, 0, -23, 132]
[132, -23, 0, 45, -1, 2]
Diccionarios en Python
Los diccionarios son un tipo de datos estructurado que permite agrupar variables. El contenido de los diccionarios son parejas clave:valor. En el caso de los diccionarios no existen índices de posición y los datos no guardan un orden concreto. Los diccionarios en Python se definen usando llaves {}.
A los valores de un diccionario se puede acceder directamente por el nombre de su clave. Por ejemplo:
|
1 2 3 |
animalesES_IN = {"Pájaro": "Bird", "León": "Lion", "Murciélago": "Bat", "Araña": "Spider", "Perro": "Dog", "Gato": "Cat"} print("Pájaro en inglés es {0}".format(animalesES_IN["Pájaro"])) print("Murciélago en inglés es {0}".format(animalesES_IN["Murciélago"])) |
Devolverá:
Pájaro en inglés es Bird
Murciélago en inglés es Bat
Teniendo en cuenta que si la clave no existe devolverá un error (y distingue mayúsculas de minúsculas). Por ejemplo:
|
1 2 3 |
animalesES_IN = {"Pájaro": "Bird", "León": "Lion", "Murciélago": "Bat", "Araña": "Spider", "Perro": "Dog", "Gato": "Cat"} print("Pájaro en inglés es {0}".format(animalesES_IN["Pájaro"])) print("Murciélago en inglés es {0}".format(animalesES_IN["murciélago"])) |
En el caso anterior, la clave «murciélago» no existe y devuelve un error:
|
1 2 3 4 5 |
Pájaro en inglés es Bird Traceback (most recent call last): File "d:Mis documentosProyectoAPythonBuclesdiccionarios.py", line 3, in <module> print("Murciélago en inglés es {0}".format(animalesES_IN["murciélago"])) KeyError: 'murciélago' |
Para evitar este error, podemos usar el método get(), que si la clave no existe, devolverá «None» en lugar de error. Por ejemplo:
|
1 2 3 4 5 6 |
animalesES_IN = {"Pájaro": "Bird", "León": "Lion", "Murciélago": "Bat", "Araña": "Spider", "Perro": "Dog", "Gato": "Cat"} clave = "murciélago" if animalesES_IN.get(clave) == None: print(f"'{clave}' no existe en el diccionario") else: print("{0} en inglés es {1}".format(clave, animalesES_IN[clave])) |
Devolverá:
‘murciélago’ no existe en el diccionario
Otro ejemplo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
animalesES_IN = {"Pájaro": "Bird", "León": "Lion", "Murciélago": "Bat", "Araña": "Spider", "Perro": "Dog", "Gato": "Cat"} clave = "murciélago" mensaje = "" if animalesES_IN.get(clave) == None: # Intentamos convirtiendo la primera letra en mayúscula clave = clave.capitalize() if animalesES_IN.get(clave) == None: mensaje = f"'{clave}' no existe en el diccionario" else: mensaje = "{0} en inglés es {1}".format(clave, animalesES_IN[clave]) else: mensaje = "{0} en inglés es {1}".format(clave, animalesES_IN[clave]) print(mensaje) |
En este caso, devolverá:
Murciélago en inglés es Bat
Podremos recorrer los datos del diccionario mediante un bucle for. Por ejemplo:
|
1 2 3 |
animalesES_IN = {"Pájaro": "Bird", "León": "Lion", "Murciélago": "Bat", "Araña": "Spider", "Perro": "Dog", "Gato": "Cat"} for animal in animalesES_IN: print(f"{animal} en inglés es {animalesES_IN[animal]}") |
Devolverá:
Pájaro en inglés es Bird
León en inglés es Lion
Murciélago en inglés es Bat
Araña en inglés es Spider
Perro en inglés es Dog
Gato en inglés es Cat
Podremos recorrer los elementos y sus valores directamente en un bucle for. Por ejemplo:
|
1 2 3 |
animalesES_IN = {"Pájaro": "Bird", "León": "Lion", "Murciélago": "Bat", "Araña": "Spider", "Perro": "Dog", "Gato": "Cat"} for animalES, animalIng in animalesES_IN.items(): print(f"{animalES} en inglés es {animalIng}") |
Devolverá lo mismo que en el caso anterior.
Podremos acceder a todas las claves con keys(). Por ejemplo:
|
1 2 |
animalesES_IN = {"Pájaro": "Bird", "León": "Lion", "Murciélago": "Bat", "Araña": "Spider", "Perro": "Dog", "Gato": "Cat"} print(animalesES_IN.keys()) |
Devolverá:
dict_keys([‘Pájaro’, ‘León’, ‘Murciélago’, ‘Araña’, ‘Perro’, ‘Gato’])
O también acceder a sus valores con values(). Por ejemplo:
|
1 2 |
animalesES_IN = {"Pájaro": "Bird", "León": "Lion", "Murciélago": "Bat", "Araña": "Spider", "Perro": "Dog", "Gato": "Cat"} print(animalesES_IN.values()) |
dict_values([‘Bird’, ‘Lion’, ‘Bat’, ‘Spider’, ‘Dog’, ‘Cat’])
Y acceso a las claves y valores con items(). Por ejemplo:
|
1 2 |
animalesES_IN = {"Pájaro": "Bird", "León": "Lion", "Murciélago": "Bat", "Araña": "Spider", "Perro": "Dog", "Gato": "Cat"} print(animalesES_IN.items()) |
Devolverá el par clave,valor:
dict_items([(‘Pájaro’, ‘Bird’), (‘León’, ‘Lion’), (‘Murciélago’, ‘Bat’), (‘Araña’, ‘Spider’), (‘Perro’, ‘Dog’), (‘Gato’, ‘Cat’)])
Para insertar un nuevo elemento en un diccionario, podemos usar una asignación directa (al igual que para modificar un elemento existente). Por ejemplo:
|
1 2 3 4 5 |
animalesES_IN = {"Pájaro": "Bird", "León": "Lion", "Murciélago": "Bat", "Araña": "Spider", "Perro": "Dog", "Gato": "Cat"} print(f"Claves del diccionario animales antes de inserción: {animalesES_IN.keys()}") # Insertamos un nuevo elemento en el diccionario animalesES_IN["Gusano"] = "Worm" print(f"Claves del diccionario animales después de inserción: {animalesES_IN.keys()}") |
Devolverá:
Claves del diccionario animales antes de inserción: dict_keys([‘Pájaro’, ‘León’, ‘Murciélago’, ‘Araña’, ‘Perro’, ‘Gato’])
Claves del diccionario animales después de inserción: dict_keys([‘Pájaro’, ‘León’, ‘Murciélago’, ‘Araña’, ‘Perro’, ‘Gato’, ‘Gusano’])
De la misma forma, si la clave ya existe, se modificará su valor. Por ejemplo:
|
1 2 3 4 5 |
animalesES_IN = {"Pájaro": "Bird", "León": "Lion", "Murciélago": "Bat", "Araña": "Spider", "Perro": "Dog", "Gato": "Cat", "Gusano": "Worm"} print(f"Valores del diccionario animales antes de modificación: {animalesES_IN.values()}") # Modificamos un nuevo elemento existente en el diccionario animalesES_IN["Gusano"] = "Caterpillar" print(f"Valores del diccionario animales después de modificación: {animalesES_IN.values()}") |
Devolverá:
Valores del diccionario animales antes de modificación: dict_values([‘Bird’, ‘Lion’, ‘Bat’, ‘Spider’, ‘Dog’, ‘Cat’, ‘Worm’])
Valores del diccionario animales después de modificación: dict_values([‘Bird’, ‘Lion’, ‘Bat’, ‘Spider’, ‘Dog’, ‘Cat’, ‘Caterpillar’])
Podremos eliminar una clave del diccionario usando pop(clave). Por ejemplo:
|
1 2 3 4 5 6 |
animalesES_IN = {"Pájaro": "Bird", "León": "Lion", "Murciélago": "Bat", "Araña": "Spider", "Perro": "Dog", "Gato": "Cat", "Gusano": "Worm"} print(f"Claves del diccionario animales antes de eliminación: {animalesES_IN.keys()}") # Eliminamos dos elementos del diccionario animalesES_IN.pop("Gusano") animalesES_IN.pop("Perro") print(f"Claves del diccionario animales después de eliminación: {animalesES_IN.keys()}") |
Devolverá:
Claves del diccionario animales antes de eliminación: dict_keys([‘Pájaro’, ‘León’, ‘Murciélago’, ‘Araña’, ‘Perro’, ‘Gato’, ‘Gusano’])
Claves del diccionario animales después de eliminación: dict_keys([‘Pájaro’, ‘León’, ‘Murciélago’, ‘Araña’, ‘Gato’])
Hay que tener precaución con el método pop(), dado que si el elemento a eliminar no existe, devolverá un error:
|
1 2 3 4 5 |
Claves del diccionario animales antes de eliminación: dict_keys(['Pájaro', 'León', 'Murciélago', 'Araña', 'Perro', 'Gato', 'Gusano']) Traceback (most recent call last): File "d:Mis documentosProyectoAPythonBuclesdiccionarios.py", line 5, in <module> animalesES_IN.pop("perro") KeyError: 'perro' |
Se puede vaciar el diccionario completo con el método clear(). Por ejemplo:
|
1 2 3 4 5 |
animalesES_IN = {"Pájaro": "Bird", "León": "Lion", "Murciélago": "Bat", "Araña": "Spider", "Perro": "Dog", "Gato": "Cat", "Gusano": "Worm"} print(f"Claves del diccionario animales antes de vaciar contenido: {animalesES_IN.keys()}") # Vaciamos el diccionario animalesES_IN.clear() print(f"Claves del diccionario animales después de vaciar contenido: {animalesES_IN.keys()}") |
Claves del diccionario animales antes de vaciar contenido: dict_keys([‘Pájaro’, ‘León’, ‘Murciélago’, ‘Araña’, ‘Perro’, ‘Gato’, ‘Gusano’])
Claves del diccionario animales después de vaciar contenido: dict_keys([])
En los ejemplos de los diccionarios hemos usado valores de cadena de texto, pero también admiten, de la misma forma, números. Por ejemplo:
|
1 2 |
codigosPostales = {"Murcia": 30, "Albacete": 2, "Burgos": 9, "Granada": 18, "Madrid": 28} print(codigosPostales.items()) |
Devolverá:
dict_items([(‘Murcia’, 30), (‘Albacete’, 2), (‘Burgos’, 9), (‘Granada’, 18), (‘Madrid’, 28)])
O al revés, definiendo las claves como número y los valores como cadena de texto:
|
1 2 |
codigosPostales = {30: "Murcia", 2: "Albacete", 9: "Burgos", 18: "Granada", 28: "Madrid"} print(codigosPostales.items()) |
Devolverá:
dict_items([(30, ‘Murcia’), (2, ‘Albacete’), (9, ‘Burgos’), (18, ‘Granada’), (28, ‘Madrid’)])