<jupyter_start><jupyter_text>![Logo_unad](https://upload.wikimedia.org/wikipedia/commons/5/5f/Logo_unad.png)Escuela de Ciencias Básicas, Tecnología e IngenieríaECBTICurso:Introducción al lenguaje de programación PythonFebrero de 2020 Sesión 06 - Diccionarios  Docente:>  *<NAME>, I.C. Ph.D.*    Diccionarios - Un Diccionario es una estructura de datos y un tipo de dato en `Python`, con características especiales que nos permite almacenar cualquier tipo de valor como: enteros, cadenas, listas e incluso otras funciones. Estos diccionarios nos permiten además identificar cada elemento por una *clave* (`Key`), a diferencia de las tuplas y listas que se hace por un índice.- Para definir un diccionario, se encierra el listado de valores entre llaves, `{...:...}`. Las parejas de *clave* y *valor* se separan con comas, y la *clave* y el *valor* se separan con dos puntos, (`:`).- Los diccionarios (llamados *arrays asociativos* o *tablas de hash* en otros lenguajes), son una estructura de datos muy poderosa, que permite asociar un valor a una clave.- Las claves deben ser de tipo inmutable, los valores pueden ser de cualquier tipo.- Los diccionarios no están ordenados. Si bien se los puede recorrer, el orden en el que se tomarán los elementos no está determinado. - Los diccionarios son una herramienta muy versátil. Se puede utilizar un diccionario, por ejemplo, para contar cuántas apariciones de cada palabra hay en un texto, o cuántas apariciones de cada letra.- Es posible utilizar un diccionario, también, para tener una agenda donde la clave es el nombre de la persona, y el valor es una lista con los datos correspondientes a esa persona.- También podría utilizarse un diccionario para mantener los datos de los alumnos inscritos en una materia. Siendo la clave el ID, y el valor una lista con todas las notas asociadas a ese alumno.- En general, los diccionarios sirven para crear bases de datos muy simples, en las que la clave es el identificador del elemento, y el valor son todos los datos del elemento a considerar.- Otro posible uso de un diccionario sería utilizarlo para realizar traducciones, donde la clave sería la palabra en el idioma original y el valor la palabra en el idioma al que se quiere traducir. Sin embargo esta aplicación es poco destacable, ya que esta forma de traducir es muy mala.<jupyter_code>city_population = {"New York City":8550405, "Los Angeles":3971883, "Toronto":2731571, "Chicago":2720546, "Houston":2296224, "Montreal":1704694, "Calgary":1239220, "Vancouver":631486, "Boston":667137}
city_population["New York City"]
print(type(city_population))
city_population["Toronto"]
city_population["Boston"]<jupyter_output><empty_output><jupyter_text>Qué sucede si intentamos acceder mediante una clave que no está contenida en el diccionario?<jupyter_code>city_population["Marinilla"]<jupyter_output><empty_output><jupyter_text>Tampoco es posible acceder a un elemento dentro de un diccionario mediante un índice, como en *tuplas* y/o *listas*<jupyter_code>city_population[0]<jupyter_output><empty_output><jupyter_text>Es fácil adicionar un elemento al diccionario<jupyter_code>city_population["Halifax"] = 390096
city_population<jupyter_output><empty_output><jupyter_text>Se puede crear un diccionario vacío e irle adicionando elementos *clave:valor*<jupyter_code>city = {}
print(city)
print(type(city))<jupyter_output>{}
<class 'dict'><jupyter_text>Los valores en un diccionario pueden ser iguales, las claves no.<jupyter_code>valores_iguales={"clave0":"valor0","clave1":"valor1","clave2":"valor0","clave3":"valor1"}
print(valores_iguales)<jupyter_output>{'clave0': 'valor0', 'clave1': 'valor1', 'clave2': 'valor0', 'clave3': 'valor1'}<jupyter_text>En el siguiente ejemplo, construyamos un pequeño "diccionario" Inglés - Alemán:<jupyter_code>en_de = {"red" : "rot", "green" : "grün", "blue" : "blau", "yellow":"gelb"}
print(en_de)
print(en_de["red"])<jupyter_output>{'red': 'rot', 'green': 'grün', 'blue': 'blau', 'yellow': 'gelb'}
rot<jupyter_text>Ahora, creamos otro diccionario Alemán-Francés<jupyter_code>de_fr = {"rot" : "rouge", "grün" : "vert", "blau" : "bleu", "gelb":"jaune"}<jupyter_output><empty_output><jupyter_text>Es posible realizar una consulta para traducir del Inglés al Francés, así no contemos con un diccionario Inglés-Francés directo<jupyter_code>print("The French word for red is: " + de_fr[en_de["red"]])<jupyter_output>The French word for red is: rouge<jupyter_text>Podemos usar tipos arbitrarios de valores en un diccionario, pero esto solo para las *clave*. Únicamente tipos de datos inmutables pueden ser usados como *claves*, es decir, no se pueden usar como *claves* listas o diccionarios<jupyter_code>dic = { [1,2,3]:"abc"}
dic = { (1,2,3):"abc"}
print(dic)<jupyter_output>{(1, 2, 3): 'abc'}<jupyter_text>Podemos crear también un diccionario de diccionarios<jupyter_code>dictionaries = {"en_de" : en_de, "de_fr" : de_fr }
print(dictionaries["de_fr"]["blau"])<jupyter_output>bleu<jupyter_text>Decimos "lógicamente" pues la segunda forma es menos eficiente.  Operadores en diccionariosAlgunos operadores en diccionarios son:- `len(d)`**:** Devuelve el número de entradas almacenadas, es decir, el número de los pares `(clave, valor)`- `del d[k]`**:** Borra la clave `k` junto con su valor asociado.- `k in d`**:** Devuelve `True`, si la clave `k` existe en el diccionario `d`- `k not in d`**:** Devuelve `True`, si la clave `k` no existe en el diccionario `d`  Métodos para trabajar los Diccionarios Como se vió en un capítulo anterior, muchas de las estructuras en Python se pueden trabajar con otros métodos, es solo colocar el nombre de la estructura seguida del operador punto, `.`, y se desplegará un menú contextual con los métodos aplicables a dicha variable<jupyter_code>en_de.<jupyter_output><empty_output><jupyter_text>Conexión entre Listas y DiccionariosSi ha trabajado durante un tiempo con `Python`, casi inevitablemente llegará el momento, cuando quiera o tenga que convertir listas en diccionarios o viceversa. No sería demasiado difícil escribir una función haciendo esto. Pero `Python` no sería `Python` si no proporcionara tales funcionalidades.Si tenemos un diccionario`D = {"list": "Liste", "dictionary": "Wörterbuch", "function": "Funktion"}`podríamos convertir esto en una lista con dos tuplas:`L = [("list", "Liste"), ("dictionary", "Wörterbuch"), ("function", "Funktion")]`La lista `L` y el diccionario `D` contienen el mismo contenido, es decir, el contenido de la información. Por supuesto, la información es más difícil de recuperar de la lista `L` que del diccionario `D`. Para encontrar una determinada clave en `L`, tendríamos que examinar las tuplas de la lista y comparar los primeros componentes de las tuplas con la clave estan buscando. Esta búsqueda se implementa implícita y extremadamente eficiente para los diccionarios.  Listas desde DiccionariosEs posible crear listas a partir de diccionarios utilizando los elementos de métodos `items()`, `keys()` y `values()`. Como su nombre lo indica, el método `keys()` crea una lista, que consiste únicamente en las claves del diccionario. `values()` produce una lista que consta de los valores. `items()` se pueden usar para crear una lista que consta de 2 tuplas de pares (clave, valor): - `items()`**:** Devuelve una lista de tuplas, cada tupla se compone de dos elementos: el primero será la *clave* y el segundo, su *valor*.<jupyter_code>dic =   {'a' : 1, 'b': 2, 'c' : 3 , 'd' : 4}
items1 = dic.items()
print(items1)
print(type(items1))<jupyter_output>dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)])
<class 'dict_items'><jupyter_text>- `keys()`**:** Retorna una lista de elementos, los cuales serán las *claves* de nuestro diccionario.<jupyter_code>dic =  {'a' : 1, 'b' : 2, 'c' : 3 , 'd' : 4}
keys= dic.keys()
print(keys)<jupyter_output>dict_keys(['a', 'b', 'c', 'd'])<jupyter_text>- `values()`**:** Retorna una lista de elementos, que serán los *valores* de nuestro diccionario.<jupyter_code>dic =  {'a' : 1, 'b' : 2, 'c' : 3 , 'd' : 4}
values= dic.values()
print(values)<jupyter_output>dict_values([1, 2, 3, 4])<jupyter_text>Convertir Listas a DiccionariosMostraremos como convertir listas a diccionarios, veamos el siguiente ejemplo:<jupyter_code>dishes = ["pizza", "sauerkraut", "paella", "hamburger"]
countries = ["Italy", "Germany", "Spain", "USA"]<jupyter_output><empty_output><jupyter_text>Ahora crearemos un diccionario, que asigna un plato especifico de un país. Para este propósito necesitamos la función `zip()`. El nombre `zip` fue bien elegido, porque las dos listas se combinan como una "cremallera". El resultado es un iterador de lista. Esto significa que tenemos que ajustar una función de conversión `list()` alrededor de la llamada `zip` para obtener una lista para que podamos ver lo que está sucediendo: - `zip()`**:** Recibe como parámetro dos elementos iterables, ya sea una cadena, una lista o una tupla. Ambos parámetros deben tener el mismo número de elementos. Se devolverá un diccionario relacionando el elemento $i$-esimo de cada uno de los iterables.<jupyter_code>country_specialities_iterator = zip(countries, dishes)
print(country_specialities_iterator)
country_specialities = list(country_specialities_iterator)
print(country_specialities)
print(type(country_specialities))<jupyter_output>[('Italy', 'pizza'), ('Germany', 'sauerkraut'), ('Spain', 'paella'), ('USA', 'hamburger')]
<class 'list'><jupyter_text>Ahora nuestros platos específicos de cada país están en forma de lista, es decir, una lista de dos tuplas, donde los primeros componentes se ven como claves y los segundos componentes como valores, que se pueden convertir automáticamente en un diccionario al convertirlo con `dict()` - `dict()`**:** Recibe como parámetro una representación de un diccionario y, si es factible, devuelve un diccionario de datos.<jupyter_code>country_specialities_dict = dict(country_specialities)
print(country_specialities_dict)<jupyter_output>{'Italy': 'pizza', 'Germany': 'sauerkraut', 'Spain': 'paella', 'USA': 'hamburger'}<jupyter_text>Como habrán observado, esto es muy ineficiente, porque creamos una lista de 2 tuplas para convertir esta lista en un diccionario. Esto se puede hacer directamente aplicando `dict` a `zip`:<jupyter_code>dict(zip(countries, dishes))<jupyter_output><empty_output><jupyter_text>Todavía hay una pregunta sobre la función `zip()`. ¿Qué sucede si una de las dos listas de argumentos contiene más elementos que la otra?Es fácil de responder: los elementos que no se pueden emparejar, se ignorarán:<jupyter_code>countries = ["Italy", "Germany", "Spain", "USA"," Switzerland"]
country_specialities = list(zip(countries, dishes))
country_specialities_dict = dict(country_specialities)
print(country_specialities_dict)<jupyter_output>{'Italy': 'pizza', 'Germany': 'sauerkraut', 'Spain': 'paella', 'USA': 'hamburger'}<jupyter_text>Todo en un solo pasoNormalmente, se recomienda no implementar demasiados pasos en una expresión de programación, aunque parece más impresionante y el código es más compacto. El uso de nombres de variables "parlantes" en pasos intermedios puede mejorar la legibilidad. Aunque podría ser atractivo crear nuestro diccionario anterior de una sola vez:<jupyter_code>country_specialities_dict = dict(list(zip(["pizza", "sauerkraut", "paella", "hamburger"], ["Italy", "Germany", "Spain", "USA"," Switzerland"])))
print(country_specialities_dict)<jupyter_output>{'pizza': 'Italy', 'sauerkraut': 'Germany', 'paella': 'Spain', 'hamburger': 'USA'}<jupyter_text>Por otro lado, se ve mejor...<jupyter_code>dishes = ["pizza", "sauerkraut", "paella", "hamburger"]
countries = ["Italy", "Germany", "Spain", "USA"]
country_specialities_zip = zip(dishes,countries)
print(list(country_specialities_zip))
country_specialities_list = list(country_specialities_zip)
country_specialities_dict = dict(country_specialities_list)
print(country_specialities_dict)<jupyter_output>{}<jupyter_text>Otros métodos importantes - `clear()`**:** Elimina todos los ítems del diccionario dejándolo vacío.<jupyter_code>dic1 = {'a' : 1, 'b' : 2, 'c' : 3 , 'd' : 4}
dic1.clear()
print(dic1)<jupyter_output>{}<jupyter_text>- `copy()`**:** Retorna una copia del diccionario original.<jupyter_code>dic = {'a' : 1, 'b' : 2, 'c' : 3 , 'd' : 4}
dic1 = dic.copy()
print(dic1)
dic1["nuevo"] = 5
print(dic1)
print(dic)
dic3 = 1*dic<jupyter_output><empty_output><jupyter_text>- `fromkeys()`**:** Recibe como parámetros un iterable y un valor, devolviendo un diccionario que contiene como claves los elementos del iterable con el mismo valor ingresado. Si el valor no es ingresado, devolverá none para todas las claves.<jupyter_code>dic = dict.fromkeys(['a','b','c','d'],"Hola")
print(dic)<jupyter_output>{'a': 'Hola', 'b': 'Hola', 'c': 'Hola', 'd': 'Hola'}<jupyter_text>- `get()`**:** Recibe como parámetro una clave, devuelve el valor de la clave. Si no lo encuentra, devuelve un objeto none.<jupyter_code>dic = {'a' : 1, 'b' : 2, 'c' : 3 , 'd' : 4}
valor = dic.get('z') 
print(valor)<jupyter_output>None<jupyter_text>- `pop()`**:** Las listas se pueden usar como pilas y el operador `pop()` se usa para tomar un elemento de la pila. Para listas, funcona, pero ¿tiene sentido tener un método `pop()` para diccionarios? Después de todo, un diccionario no es un tipo de datos secuencial, es decir, no hay ordenación ni indexación. Por lo tanto, `pop()` se define de manera diferente con los diccionarios. Las claves y los valores se implementan en un orden arbitrario, que no es aleatorio, sino que depende de la implementación.  Si `D` es un diccionario, entonces `D.pop(k)` elimina la clave `k` con su valor del diccionario `D` y devuelve el valor correspondiente como el valor de retorno, es decir, `D[k]`.  Si no se encuentra la clave, se genera un `KeyError`:<jupyter_code>en_de = {"Austria":"Vienna", "Switzerland":"Bern", "Germany":"Berlin", "Netherlands":"Amsterdam"}
capitals = {"Austria":"Vienna", "Germany":"Berlin", "Netherlands":"Amsterdam"}
capital = capitals.pop("Austria")
print(capital)
print(capitals)
capital = capitals.pop("Switzerland")<jupyter_output>{'Germany': 'Berlin', 'Netherlands': 'Amsterdam'}<jupyter_text>- `setdefault()`**:** Funciona de dos formas. En la primera como get<jupyter_code>dic = {'a' : 1, 'b' : 2, 'c' : 3 , 'd' : 4}
valor = dic.setdefault('b')
print(valor)<jupyter_output>2<jupyter_text>Y en la segunda forma, nos sirve para agregar un nuevo elemento a nuestro diccionario.<jupyter_code>dic = {'a' : 1, 'b' : 2, 'c' : 3 , 'd' : 4}
valor = dic.setdefault('e',5)
print(dic)
print(valor)<jupyter_output>{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
5<jupyter_text>Fusionando diccionarios¿Qué pasa con la concatenación (`merging`) de diccionarios, como hicimos con las listas? Hay algo similar para los diccionarios: - `update()`**:** Recibe como parámetro otro diccionario. Si se tienen claves iguales, actualiza el valor de la clave repetida; si no hay claves iguales, este par clave-valor es agregado al diccionario.<jupyter_code>dic1 = {'a' : 1, 'b' : 2, 'c' : 3 , 'd' : 4}
dic2 = {'c' : 6, 'b' : 5, 'e' : 9 , 'f' : 10}
dic2.update(dic1)
print(dic2)<jupyter_output>{'c': 3, 'b': 2, 'e': 9, 'f': 10, 'a': 1, 'd': 4}<jupyter_text>Iterando sobre diccionariosPara recorrer todo el Diccionario, podemos hacer uso de la estructura for:<jupyter_code>for a in dictionaries:
    print(a, ":", dictionaries[a])<jupyter_output>en_de : {'red': 'rot', 'green': 'grün', 'blue': 'blau', 'yellow': 'gelb'}
de_fr : {'rot': 'rouge', 'grün': 'vert', 'blau': 'bleu', 'gelb': 'jaune'}<jupyter_text>No es necesario un método para iterar sobre las claves en un diccionario:<jupyter_code>for key in de_fr:
    print(key)<jupyter_output>rot
grün
blau
gelb<jupyter_text>Podemos usar el método `keys`, pero el resultado será el mismo<jupyter_code>for key in de_fr.keys():
    print(key)<jupyter_output>rot
grün
blau
gelb<jupyter_text>El métodos `values` es una forma conveniente para iterar directamente sobre los valores:<jupyter_code>for value in de_fr.values():
    print(value)<jupyter_output>rouge
vert
bleu
jaune<jupyter_text>El siguiente ciclo es, lógicamente, equivalente al anterior<jupyter_code>for key in de_fr:
    print(de_fr[key])<jupyter_output>rouge
vert
bleu
jaune<jupyter_text>- ***Ejemplo:*** uso de diccionarios para "encriptar" y "desencriptar" un mensaje:<jupyter_code>import numpy as np

# genera los elementos que serán las claves en el diccionario
letras = "ABCDEFGHIJKLMÑNOPQRSTUVWXYZabcdefghijklmnñopqrstuvwxyz_!¿?ÁÉÍÓÚáéíóú0123456789 "

# genera los elementos que serán los valores en el diccionario
numeros = [x for x in range(len(letras))]

# genera el diccionario con la clave "letras" y el valor "numeros"
diccionario = dict(zip(letras,numeros))

# Mensaje a "encriptar"
mensaje = input("Ingrese el mensaje a encriptar: ") #"Paz y Amor!"

# Se crea una lista con el mensaje encriptado
encriptado = [diccionario.get(i) for i in mensaje]

# se imprime ("envia") el mensaje encriptado
print("mensaje encriptado: ",encriptado)

# se "recibe" y se desencripta el mensaje encriptado enviado:

mensaje = ''
for valor in encriptado:
    k = list(diccionario.keys())[list(diccionario.values()).index(valor)]
    mensaje += k

print("mensaje desencriptado: ",mensaje)<jupyter_output>Ingrese el mensaje a encriptar: mi mamá me mima
mensaje encriptado:  [39, 35, 78, 39, 27, 39, 63, 78, 39, 31, 78, 39, 35, 39, 27]
mensaje desencriptado:  mi mamá me mima<jupyter_text>- **Ejemplo:** uso de listas para convertir números enteros a romanos<jupyter_code>import math
Unidad=["", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"]
Decena=["", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"]
Centena=["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"]
N=int(input("Ingresa numero entero\n"))
u= N % 10
d=int(math.floor(N/10))%10
c=int(math.floor(N/100))
if(N>=100):
    print(Centena[c]+Decena[d]+Unidad[u])
else:
    if(N>=10):
        print(Decena[d]+Unidad[u])
    else:
        print(Unidad[N])<jupyter_output>Ingresa numero entero
37
XXXVII<jupyter_text>Ahora, cómo sería usando diccionarios?<jupyter_code>import math

UnidadR=["", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"]
UnidadA=["",  1,    2,    3,     4,   5,    6,    7,      8,     9 ]
UnidadD=dict(zip(UnidadA,UnidadR))

DecenaR=["", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"]
DecenaA=["",  10,  20,   30,    40,   50,  60,    70,   80,     90 ]
DecenaD=dict(zip(DecenaA,DecenaR))

CentenaR=["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"]
CentenaA=["",  100, 200,  300,   400, 500,  600,  700,   800,    900 ]
CentenaD=dict(zip(CentenaA,CentenaR))

N=int(input("Ingresa numero entero\n"))
u= N % 10
d=(int(math.floor(N/10))%10) * 10
c=int(math.floor(N/100)) * 100

valorC = CentenaD.get(c)
valorD = DecenaD.get(d)
valorU = UnidadD.get(u)

print(valorC + valorD + valorU)
N=int(input("Ingresa numero entero\n"))
u= N % 10
print("u: ", u)
d=(int(math.floor(N/10))%10) * 10
print("d: ", d)
c=int(math.floor(N/100)) * 100
print("c: ", c)<jupyter_output>Ingresa numero entero
345
u:  5
d:  40
c:  300<jupyter_text>Ejemplo: Se desea crear un diccionario con el listado de jugadores de la selección española de fútbol campeona del mundial de Suráfrica 2010 y realizar una serie de consultas sobre él. (*Ejemplo de extraído del blog [Jarroba.com](https://jarroba.com/diccionario-python-ejemplos/)*)<jupyter_code>futbolistas = dict()

futbolistas = {
    1 : "Casillas", 15 : "Ramos",
    3 : "Pique", 5 : "Puyol",
    11 : "Capdevila", 14 : "<NAME>",
    16 : "Busquets", 8 : "<NAME>",
    18 : "Pedrito", 6 : "Iniesta",
    7 : "Villa"
}<jupyter_output><empty_output><jupyter_text>Recorriendo cada uno de los elementos del diccionario e imprimiendo el resultado<jupyter_code>for k,v in futbolistas.items():
    print("el jugador # {0} es {1} ".format(k,v))
    #print("el jugador #", k, "es ", v, "mas", 10.000)<jupyter_output><empty_output><jupyter_text>vamos a determinar la cantidad de elementos del diccionario<jupyter_code>numElem = len(futbolistas)
print("Numero de elementos del diccionario len(futbolistas) = {0}".format(numElem))<jupyter_output><empty_output><jupyter_text>Ahora queremos ver por separado las claves y los valores del diccionario<jupyter_code># Imprimimos una lista con las claves del diccionario
keys = futbolistas.keys();
print("Las claves del diccionario son \n {0}".format(keys))

# Imprimimos en una lista los valores del diccionario
values = futbolistas.values()
print("\nLos valores del diccionario son \n {0}".format(values))<jupyter_output><empty_output><jupyter_text>Si deseamos conocer el valor que tiene una determinada clave empleamos el método `get(key)`<jupyter_code>elem = futbolistas.get(6)
print("el nombre del futbolista que tiene el número '6' es {0}".format(elem))<jupyter_output><empty_output><jupyter_text>A continuación vamos a ver dos formas de insertar elementos en el diccionario. La primera de ellas es la más sencilla (como si de un array asociativo se tratase), pasándole la clave entre corchetes y asignándole un valor:<jupyter_code># Añadimos un nuevo elemento a la lista
futbolistas[22] = 'Navas'
print("\nDiccionario tras añadir un elemento: \n {0}".format(futbolistas))
numElem = len(futbolistas)
print("Numero de elementos del diccionario len(futbolistas) = {0}".format(numElem))<jupyter_output><empty_output><jupyter_text>La segunda forma de insertar un elemento es con el método `setdefault(key,default=valor)` al que se le pasa como parámetros un clave y un valor. Este método tiene la peculiaridad de que solo inserta el elemento en el diccionario sino existe un elemento con esa clave. Si existe un elemento con esa clave no realiza la inserción:<jupyter_code># Insertamos un elemento en el array. Si la clave ya existe no inserta el elemento
elem2 = futbolistas.setdefault(10,'Cesc')
print("\nInsertamos un elemento en el diccionario (Si la clave existe no lo inserta): {0}".format(elem2))
numElem = len(futbolistas)
print("Numero de elementos del diccionario len(futbolistas) = {0}".format(numElem))<jupyter_output><empty_output><jupyter_text>El siguiente método que vamos a ver `pop(key)` nos borrará del diccionario aquel elemento que tenga como clave, la que le pasamos como parámetro. Por ejemplo vamos a borrar el elemento con *clave = 22*:<jupyter_code># Eliminamos un elemento del diccionario dada su clave
futbolistas.pop(22)
print("\nDiccionario tras eliminar un elemento: {0}".format(futbolistas))
numElem = len(futbolistas)
print("Numero de elementos del diccionario len(futbolistas) = {0}".format(numElem))<jupyter_output><empty_output><jupyter_text>Para hacer una copia de un diccionario, se utiliza el método `copy()`:<jupyter_code># Hacemos una copia del diccionario
futbolistasCopy = futbolistas.copy();
print("\nRealizamos una copia del diccionario: \n {0}".format(futbolistasCopy))<jupyter_output><empty_output><jupyter_text>Para eliminar el contenido (o los elementos) de un diccionario utilizamos el método `clear()`:<jupyter_code># Eliminamos los elementos de un diccionario
futbolistasCopy.clear()
print("\nEliminamos los elementos de un diccionario: {0}".format(futbolistasCopy))<jupyter_output><empty_output><jupyter_text>Con el método `fromkeys(listKey,default=value)`, creamos un diccionario cuyas claves son las que le pasamos como parámetro en una lista. Si le pasamos un segundo parámetro, pondrá ese parámetro como clave de cada uno de los elementos. Veamos un ejemplo:<jupyter_code># Creamos un diccionario a partir de una lista con las claves
keys = ['nombre', 'apellidos', 'edad']
dictList = dict.fromkeys(keys, 'nada')
print("Creamos un diccionario a partir de una lista {0}".format(dictList))<jupyter_output><empty_output><jupyter_text>El método que nos permite comprobar si existe o no una clave es el método `has_key(key)`. Veamos un ejemplo:<jupyter_code># Comprobamos si existe o no una clave
exit2 = futbolistas.has_key(2)
exit8 = futbolistas.has_key(8)
print("\nComprobamos si existen los elementos 2 y 8 : {0}, {1}".format(exit2,exit8))<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.12653485952133195, 'fraction_numerical': 0.01639958376690947, 'mean_word_length': 6.204197901049476, 'pattern_counts': {'":': 26, '<': 178, '<?xml version=': 0, '>': 181, 'https://': 2, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '50', 'dir': 'jupyter-structured-clean-dedup', 'id': '247804', 'license': 'MIT', 'n_tokens_mistral': 9223, 'n_tokens_neox': 8787, 'n_words': 2742, 'path': 'Sesion_06_Diccionarios.ipynb', 'repo_name': 'UNADCdD/Python-intro', 'size': '24060'}