No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso Básico de Python

Curso Básico de Python

Facundo García Martoni

Facundo García Martoni

¿Qué son los diccionarios?

30/32
Recursos

Los diccionarios en Python son una estructura de datos mutable las cuales almacenan diferentes tipos de valores sin darle importancia a su orden. Identifican a cada elemento por una clave (Key). Se escriben entre {}.

Operaciones en diccionarios

  • .keys():Retorna la clave de nuestro elemento.

  • .values(): Retorna una lista de elementos (valores del diccionario).

  • .items(): Devuelve lista de tuplas (primero la clave y luego el valor).

  • .clear(): Elimina todos los items del diccionario.

  • .pop(“n”): Elimina el elemento ingresado.

Cómo trabajar con diccionarios

  • Definir función principal
def run():
    # Defino el diccionario, agrego los valores.
    mi_diccionario = {
      'llave1' : 1,
      'llave2' : 2,
      'llave3' : 3,
    }
  • Imprimir las llaves del diccionario utilizando un bucle for. Con ‘.keys()’ estamos llamando a imprimir las llaves, no los valores.
    for llave in mi_diccionario.keys():
        print(llave)
  • Imprimir los valores del diccionario empleando un bucle for. Con ‘.values()’ estoy llamando a imprimir los valores.
    for valores in mi_diccionario.values():
        print(valores)
  • Imprimir las llaves y los valores usando ‘.items()’. Para esto, coloco las variables llave e items.
for llave, items in mi_diccionario.items():
        print("La llave: '" + llave + "' contiene el item: " + str(items))

if __name__ == '__main__':
    run()

Aporte creado por: Rusbel Bermúdez, Ignacio Escudero.

Aportes 240

Preguntas 66

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Sí quieren hacer más legibles los números grandes como el de las poblaciones pueden hacerlo con _

población_paises = {
	'Argentina': 44_938_712,
	'Brasil': 210_147_125,
	'Colombia': 50_372_424
}

Diccionarios: Son una estructura de datos mutable las cuales almacenan diferentes tipos de valores sin darle importancia a su orden. Identifican a cada elemento por una clave (Key). Se escriben entre {}.

Operaciones:

  • .keys() —> Retorna la clave de nuestro elemento

  • .values()—> Retorna una lista de elementos (valores del diccionario)

  • .items() —> Devuelve lista de tuplas (primero la clave y luego el valor)

  • .clear() —> Elimina todos los items del diccionario

  • .pop(“n”) —> Elimina el elemento ingresado

Para recordar la infancia

def run():
    caballeros_dorados = {
        'aries': 'mu',
        'tauro': 'aldebaran',
        'cancer': 'deadmask',
        'geminis': 'saga',
        'leo': 'aioria',
        'virgo': 'shaka',
        'libra': 'dohko',
        'sagitario': 'aioros',
        'escorpion': 'milo',
        'capricornio': 'shura',
        'acuario': 'camus',
        'piscis': 'afrodita',
    }
    # for signo_zodiacal in caballeros_dorados.keys():
    #     print(signo_zodiacal)
    # for nombre_caballero in caballeros_dorados.values():
    #     print(nombre_caballero)
    # for signo_zodiacal, nombre_caballero in caballeros_dorados.items():
    #     print(str(signo_zodiacal).capitalize() + ': ' + str(nombre_caballero).capitalize())
    seguir = 's'
    while seguir.lower() == 's':
        llave = input('Escribe tu signo zodical: ').lower()
        print (f'El caballero que representa tu signo es: {str(caballeros_dorados[llave]).capitalize()}')
        seguir = input('Desea continuar S/N:')
if __name__ == "__main__":
    run()

Me encontré esto
Tipos de datos en Python
.
Inmutables:
Strings (Texto)
Int (Número entero)
Float (Número de coma flotante)
Decimal (Número decimal)
Complex (Complejo)
Bool (Booleano)
Tuple (Tupla)
Frozenset (Conjunto congelado)
Bytes (8 bits)
Range (Rango)
None (Nulo)
.
Mutables:
List (Listado)
Dict (Diccionario)
Set (Conjunto)
Bytearray (array de bits)
MemoryView (Vista de la memoria)
.
https://jarroba.com/mutables-e-inmutables/
(ノ◕ヮ◕)ノ*:・゚✧

Acabo de descubrir por casualidad en Visual Studio que:

  • Alt+flecha arriba o abajo: mueve la linea de codigo donde esta el cursor

  • Shift+Alt+flecha arriba o abajo copia la linea completa de codigo

Hola compañ[email protected]!
Encontré esta ficha que muestra las diferencias y principales características de una tupla, una lista, un conjunto y un diccionario.
Espero les sirva 😄

No se que tan buena práctica sea convertir las variables a string para poder imprimirlas. Me parece que una mejor manera de hacer sería con print(f’’)

En vez de colocar:

print(pais + ' tiene ' + str(poblacion) + ' habitantes')

Se puede colocar:

print(f'{pais}  tiene {poblacion} habitantes')

En donde las variables que queremos imprimir va en los corchetes {} sin necesidad de convertir a string. Me parece una forma más “limpia” de escribir el código.

Saludos

Metodos diccionario

variable.keys('devuelve_el_nombre_llave')
variable.values('devuelve_el_valor_de_la_llave)
variables.items('devuelve_tanto_el_nombre_como_el_valor')

Puedes crear listas dentro de diccionarios, o diccionarios dentro de listas
Este es mi ejercicio:
- Primero cree una lista y dentro cree 3 diccionarios.
- Después recorriendo la lista, valide condiciones para agregar salarios (nuevos key:value) y puestos de trabajo.
- Finalmente imprimi información de cada empleado incluyendo la data que se agregó después a cada diccionario.

__

__

Y este es el resultado final:

__

tupla = (,,,)
lista = [,,,]
diccionario = {,,,} 

(●’◡’●)

Gracias profe le entendí perfectamente woow me inscribí a la escuela de ciencia de datos y me recomendaron tomar este curso y antes de seguir avanzando y valió la pena, ojalá tenga más cursos en platzi, gracias

Realmente los comentarios de Facundo y su método de enseñanza me hacen sentir que realmente se preocupa por todos y cada uno de nosotros, en serio GRACIAS y espero llegar a ser un crack en un futuro, con semejante curso de base tan bueno ♥ gracias mil!

👾 Agregando mi país al diccionario.

def void():
    poblacion_paises = {
        "Argentina": 44938712,
        "Bolivia": 11510225,
        "Brasil": 210147125,
        "Colombia": 50372424,
    }

    for pais, poblacion in poblacion_paises.items():
        print(pais + ' tiene ' + str(poblacion) + ' habitantes')


if __name__ == "__main__":
    void()

[ ] = Listas
( ) = Tuplas
{ } = Diccionarios

.Keys Metodo del diccionario que devuelve las llaves.
.Values Metodo del diccionario que devuelve el valor de las llaves.
.Items Metodo del diccionario que devuelve los dos valores tanto las llaves (nombre de la variable) como el valor (lo que contiene)

¿Qué son las tuplas y diccionarios?
Tuplas: son una estructura de datos inmutables. Son parecidas a las listas ya que una tupla puede contener diferentes valores y con diferentes formatos, pero a diferencia de las listas estas son inmutables, esto significa que no puedes ser alteradas. Sirve principalmente para lograr hacer iteraciones más rápidas ya que este ocupa de manera más eficiente la memoria de datos. Para poder usar una tupla se hace de la siguiente manera:
• <Variable = (valor1, valor2, valor3, valorN)>
Diccionarios: Son una estructura de datos mutable las cuales almacenan diferentes tipos de valores sin darle importancia a su orden. Identifican a cada elemento por una clave (Key). Se escriben entre {}.
Operaciones:
• .keys() —> Retorna la clave de nuestro elemento
• .values()—> Retorna una lista de elementos (valores del diccionario)
• .items() —> Devuelve lista de tuplas (primero la clave y luego el valor)
• .clear() —> Elimina todos los items del diccionario
• .pop(“n”) —> Elimina el elemento ingresado

Los diccionarios tienen varios metodos unos de ellos son:

población_paises = {
	'Argentina': 44_938_712,
	'Brasil': 210_147_125,
	'Colombia': 50_372_424
}

.keys()
Devuelve el nombre de la llave

for pais in diccionario.keys()
	print(pais)

.values()
Devuelve el valor de la llave

for pais in diccionario.values()
	print(pais)

.items()
Devuelve el nombre de la llave y el valor de la llave

for pais, poblacion in diccionario.items()
	print(pais + ' tiene ' + str(poblacion) + ' habitantes')

Ay - yo me emociono cuando dicen Bolivia… Aunque salte error… #LoveBolivia
Ame este tema, Gracias Facundo!

Buenas tardes,

Para leer mejor los datos se pueden usar caracteres de escape como por ejemplo ’ \n ’ que produce un enter entonces tenemos una línea vacía entre cada ítem del diccionario.
Saludos! 🖖

¿Qué son los diccionarios?


Un diccionario es una estructura de datos de llaves y valores. Esto quiere decir que para poder acceder un elemento lo vamos a hacer a través de su índice.

def run():
    """
    docstring
    """
    mi_diccionario = {
        'usuario': 'richard',
        'clave': 123456789
    }

    print('Mi usuario es ' + str(mi_diccionario['usuario']) + ' y mi clave es ' + str(mi_diccionario['clave']))

if __name__ == "__main__":
    run()

Además podemos recorrer los diccionarios con el ciclo for como si fuera una tupla.

    poblacion_paises = {
        'Panama': 23998488,
        'Venezuela': 29847555,
        'Urugay': 5389337
    }

    for pais in poblacion_paises.keys():
        print(pais)

    for pais in poblacion_paises.values():
        print(pais)

    for pais, poblacion in poblacion_paises.items():
        print(pais + ' tiene ' + str(poblacion) + ' habitantes')

keys() —> Retorna las llaves del diccionario.

<salario_dicc = {
    'gerente': 5000000,
    'director': 450000,
    'coordinador': 370000,
    'programador': 3500000,
    'auxiliar': 1700000,
    'operador': 1500000,
}

for cargo in salario_dicc.keys():
    print(cargo, end=' ')
>>>
gerente director coordinador programador auxiliar operador> 

values() —> Retorna los valores o elementos del diccionario

<salario_dicc = {
    'gerente': 5000000,
    'director': 450000,
    'coordinador': 370000,
    'programador': 3500000,
    'auxiliar': 1700000,
    'operador': 1500000,
}

for cargo in salario_dicc.values():
    print(cargo, end=' ')
>>>
5000000 450000 370000 3500000 1700000 1500000> 

items() —> Devuelve (primero la clave o llave y luego el valor)

<salario_dicc = {
    'gerente': 5000000,
    'director': 450000,
    'coordinador': 370000,
    'programador': 3500000,
    'auxiliar': 1700000,
    'operador': 1500000,
}

for cargo in salario_dicc.items():
    print(cargo, end=' ')
>>>
('gerente', 5000000) ('director', 450000) ('coordinador', 370000) ('programador', 3500000) ('auxiliar', 1700000) ('operador', 1500000)> 

clear() —> Elimina todos los ítems del diccionario

<salario_dicc = {
    'gerente': 5000000,
    'director': 450000,
    'coordinador': 370000,
    'programador': 3500000,
    'auxiliar': 1700000,
    'operador': 1500000,
}

salario_dicc.clear()
print(salario_dicc)
>>>
{}> 

pop(“n”) —> remueve específicamente una clave de diccionario y devuelve valor correspondiente. Lanza una excepción KeyError si la clave no es encontrada.

<salario_dicc = {
    'gerente': 5000000,
    'director': 450000,
    'coordinador': 370000,
    'programador': 3500000,
    'auxiliar': 1700000,
    'operador': 1500000,
}

print(salario_dicc)
salario_dicc.pop('director')
print(salario_dicc)

>>>
{'gerente': 5000000, 'director': 450000, 'coordinador': 370000, 'programador': 3500000, 'auxiliar': 1700000, 'operador': 1500000}
{'gerente': 5000000, 'coordinador': 370000, 'programador': 3500000, 'auxiliar': 1700000, 'operador': 1500000}> 

get() —> Recibe como parámetro una clave, devuelve el valor de la clave. Si no lo encuentra, devuelve un objeto none

<salario_dicc = {
    'gerente': 5000000,
    'director': 450000,
    'coordinador': 370000,
    'programador': 3500000,
    'auxiliar': 1700000,
    'operador': 1500000,
}

print(salario_dicc.get('director'))
print(salario_dicc.get('vigilante'))

>>>
450000
None> 

Diccionarios en Python:
Operaciones que no modifican un diccionario
Operaciones que modifican un diccionario
Copia de diccionarios
Acceso a datos
https://notnumber.com/diccionarios-en-python/

Por si aún no lo sabías, puede presionar tab para obtener cuatro espacios, es decir para no estar presionando 4 veces la tecla de espacio.

Los diccionarios son otra estructura de datos que nos permite almacenar múltiples datos a través de llaves, pudiendo identificar cada elemento con una llave. Para escribir un diccionario, lo hacemos de la siguiente manera:

poblacion_paises = {
        'Argentina': 44938712,
        'Brasil': 210147125,
        'Colombia': 50372424
    }

Aquí, hemos creado la variable población_países, el igual para asignar valores, abrimos y cerramos llaves. Las llaves delimitan el contenido del diccionario. Bueno, ahora tenemos tres llaves, qué se crean con las comillas, qué en este caso son tres países: Argentina, Brasil y Colombia. Cada uno es una llave, y poseen un valor, el cuál es la población que poseen. Si por ejemplo, queremos imprimir alguna de estas llaves, aparecerán así:
λ py diccionarios.py {'Juan': 23, 'Ricardo': 28, 'Carlos': 12, 'Alfonso': 65, 'Fernando': 40}

En el caso de que queramos solo imprimir una de las llaves, escribimos: print(edad_chicos[“Juan”]) #Esto se puede realizar con cualquier llave que hayamos creado.

También, podemos recorrer el ciclo for en los diccionarios utilizando métodos, así:
Diccionario de métodos para el diccionario:

  • keys: nos permite mostrar únicamente el nombre de la llave.
  • values: nos muestra únicamente el valor de la llave, sin su nombre.
  • items: muestra el nombre de la llave y su valor.
    Ejemplo usando los tres métodos:
for persona in edad_chicos.keys():
        print(persona)
    for edad in edad_chicos.values():
        print(persona)
    for persona, edad in edad_chicos.items():
        print(persona + " = " + edad)

Para obtener valores de los diccionarios y protegerte de los errores, es mejor no usar los corchetes ([ ]) sino el método get(), tipo:

diccionario.get("Colombia",0)

El método get te retorna un None en caso de que no haya un valor asociado a la key o el valor que le definas como segundo parámetro como default

Recibe como parámetro una representación de un diccionario y si es factible, devuelve un diccionario de datos.
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.
items()

Devuelve una lista de tuplas, cada tupla se compone de dos elementos: el primero será la clave y el segundo, su valor.
keys()

Retorna una lista de elementos, los cuales serán las claves de nuestro diccionario.
values()

Retorna una lista de elementos, que serán los valores de nuestro diccionario
clear()

Elimina todos los ítems del diccionario dejándolo vacío.
copy()

Retorna una copia del diccionario original.
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.
get()

Recibe como parámetro una clave, devuelve el valor de la clave. Si no lo encuentra, devuelve un objeto none.
pop()

Recibe como parámetro una clave, elimina esta y devuelve su valor. Si no lo encuentra, devuelve error.

La verdad no me queda claro la importancia o el uso de los diccionarios respecto a las listas y tuplas, quizá en temas futuros me quede más claro.

¿en que curso se enseña a subir bases de datos completas de excel a python? o de excel a R? o de Mysql a Python o R?

Un diccionario es una colección de pares formados por una clave y un valor asociado a la clave.

Se construyen poniendo los pares entre llaves { } separados por comas, y separando la clave del valor con dos puntos :.

Se caracterizan por:

No tienen orden.
Pueden contener elementos de distintos tipos.
Son mutables, es decir, pueden alterarse durante la ejecución de un programa.
Las claves son únicas, es decir, no pueden repetirse en un mismo diccionario, y pueden ser de cualquier tipo de datos inmutable.

<h1>Diccionario vacío</h1>

type({})
<class ‘dict’>

<h1>Diccionario con elementos de distintos tipos</h1>

{‘nombre’:‘Alfredo’, ‘despacho’: 218, ‘email’:‘[email protected]’}

<h1>Diccionarios anidados</h1>

{‘nombre_completo’:{‘nombre’: ‘Alfredo’, ‘Apellidos’: ‘Sánchez Alberca’}}

Probe de esta manera el ciclo for

for pais in poblacion_paises.items():
        print(pais)

me di cuenta de que un diccionario es una coleccion de tuplas, asi que para tener el mismo resultado podria hacer asi

for pais in poblacion_paises.items():
        print(pais[0] + ' tiene ' + str(pais[1]) + ' habitantes.')

Pero de la manera que lo hizo el profesor es mas facil de leer

Hola a todos.
Hice un ejemplo de lo aprendido para una fondita. Te aparece un listado de opciones, en donde el diccionario es el menú de comida por día. Puedes elegir entre ver los días que hay menú, el menú de todos los días y el menú de un día en específico, usando diccionarios y tuplas para la asignación de los menús del día


def run():

    menu = {
        'Lunes': ('Sopa de papa', 'Arroz colorado', 'Filete de pescado con ensalada', 'Flan napolitano'),
        'Martes': ('Sopa de verduras', 'Arroz con cúrcuma', 'Sopecitos con bistec', 'Plátanos fritos'),
        'Miercoles': ('Crema de champiñones', 'Moros y cristianos', 'Enchiladas potosinas', 'Jericallas'),
        'Jueves': ('Sopa de lentejas', 'Ensalada de nopales', 'Mole de olla', 'Fresas con crema'),
        'Viernes': ('Consomé de pollo', 'Arroz poblano', 'Chamorros', 'Gelatina de frambuesa')
    }
    
    eleccion = input("""
Fonda La Chiquita

Elije la opción de tu preferencia:
(1) Muestra los días que hay menú disponible
(2) Muestra el menú de todos los días
(3) Muestra el menú de un día en específico

""")

    if int(eleccion) == 1:
        for dia in menu.keys():
            print('')
            print(dia)
    elif int(eleccion) ==2:
        for dia, comida in menu.items():
            print('')
            print('La comida del día ' + dia +' es: ' + str(comida))
    elif int(eleccion) ==3:
        print('')
        consulta = input ('Escribe el día del que quieres conocer el menú:  ')
        print('')
        print ('El menú del día '+ consulta.lower().capitalize().replace(" ","") + ' es: ')
        print (menu[consulta.lower().capitalize().replace(" ","")])
        print('')
    else:
        print ('El valor ingresado no forma parte de las opciones :(')


if __name__ == '__main__':
    run()

¿Qué son los diccionarios?


  • Los lenguajes de programación como python suelen tener muchas estructuras de datos diferentes

  • Utilizar la estructura adecuada para la situación correcta es una ventaja competitiva ante otros programadores ya que nos permiten programar de forma más eficiente

  • Diccionarios: Para declararlas se utilizan las llaves {}

    • En otros lenguajes, las llaves se utilizan para delimitar los bloques de código, en Python solo se usan los dos puntos (😃 y el espaciado
  • Un diccionario es una estructura que utiliza llaves y valores

    • Llaves: pueden entenderse como índices a los cuáles se les puede poner un nombre propio
    • Valores: son los valores que componen el diccionario y están asignados a una única llave
    def main():
        mi_diccionario = {
            'llave1': 1,
            'llave2': 2,
            'llave3': 3
        }
        
        print(mi_diccionario)
    
    if __name__ == "__main__":
        main()
    
    • Para acceder a cada elemento de un diccionario se utilizan sus llaves de forma similar a un índice en una lista o tupla
    def main():
        mi_diccionario = {
            'llave1': 1,
            'llave2': 2,
            'llave3': 3
        }
    
        print(mi_diccionario['llave1'])
        print(mi_diccionario['llave2'])
        print(mi_diccionario['llave3'])
    
    if __name__ == "__main__":
        main()
    
    • Si se intenta a acceder a un valor de una llave que no existe en el diccionario, se genera el error KeyError
    def main():
        poblacion_paises = {
            'Argentina': 44938712,
            'Brasil': 210147125,
            'Colombia': 50372424
        }
    
    		print(poblacion_paises['Argentina'])
        print(poblacion_paises['Bolivia'])
    
    if __name__ == "__main__":
        main()
    
    • Al igual que las listas y las tuplas, los diccionarios también son estructuras iterables, es decir, pueden ser recorridas utilizando el ciclo for
    def main():
        poblacion_paises = {
            'Argentina': 44938712,
            'Brasil': 210147125,
            'Colombia': 50372424
        }
    
        # Imprimir las llaves de un diccionario
        for pais in poblacion_paises.keys():
            print(pais)
    
        # Imprimir los valores del diccionario
        for pais in poblacion_paises.values():
            print(pais)
    
        # Imprimir las llaves con sus valores de un diccionario
        for pais, poblacion in poblacion_paises.items():
            print(f'{pais} tiene {poblacion} habitantes')
    
    if __name__ == "__main__":
        main()
    

Copiar línea: Shift + Alt + down_arrow

Esta vez comparto mi humilde apunte porque me ayudo a identificar cada elemento en el ejemplo:

Los iré mejorando.

Espero le sirva a alguien

Podemos usar la función String.format sin que tengamos que concatenar cadenas de caracteres y además podemos allí mismo darle formato a los números para que sean más legibles.

def run():
    poblacion_paises = {
        'Argentina': 44938712,
        'Brasil': 210147125,
        'Colombia': 50372424
    }

    if poblacion_paises.get('Bolivia') == None:
        print('No tenemos información acerca de Bolivia')

    for pais in poblacion_paises.keys():
        print('- {}, población: {:,} habitantes.'.format(pais, poblacion_paises.get(pais)))


if __name__ == '__main__':
    run()

El resultado en consola sería algo como:

No tenemos información acerca de Bolivia

  • Argentina, población: 44,938,712 habitantes.
  • Brasil, población: 210,147,125 habitantes.
  • Colombia, población: 50,372,424 habitantes.

hice un programa donde puedes rentar películas, almacena las películas disponibles en un diccionario y los valores del arrendatario en una clase con atributos.

def run():

    class Arrendatario:
        pelicula = ''
        nombre = ''
        edad = ''

    peliculas = {1: 'Space Jam: el juego del siglo', 
    2:'Truman Show: historia de una vida',
    3: 'Stuart Little'}

    menu = 'Hola estas en PELICULAS DE LOS 90s Tenemos estas peliculas disponibles \n' '\n1: ' + peliculas.get(1) + '\n2: ' + peliculas.get(2) + '\n3: ' + peliculas.get(3) + '\n\nEligue una pelicula: '

    opcion = int(input(menu))
    if opcion <= 3:
        print('\nPara rentar una pelicula debes facilitar los sieguientes datos\n')
        persona = Arrendatario()
        persona.pelicula = peliculas.get(opcion)
        persona.nombre = input('Cual es tu nombre?: ').capitalize()
        persona.edad = int(input('Cual es tu edad?: '))
        # print('Elegiste: ' + persona.pelicula)
        if persona.edad <= 13:
            print('debes ser mayor de 12 años para rentar')
    else:
        print('Eligue entre las peliculas disponibles')
        
if __name__ == '__main__':
    run()

Hola a todos! Estuve investigando un poco más sobre los diccionarios y encontré algunas cosas que considero pueden ser útiles:

  • Puedes definir un diccionario sin ‘llaves-valores’ iniciales de la siguiente manera:
>>> poblacion_paises = {}
  • Supongamos que tu diccionario ya tiene pre-definidas una serie de ‘llaves-valores’. Puedes añadir una nueva ‘llave-valor’ de la siguiente manera:
>>> poblacion_paises
{'Argentina': 44938712, 'Brasil': 210147125, 'Colombia': 50372424}
>>> poblacion_paises['Venezuela']= 28515829
>>> poblacion_paises
{'Argentina': 44938712, 'Brasil': 210147125, 'Colombia': 50372424, 'Venezuela': 28515829}
  • Si quieres eliminar una ‘llave-valor’ del diccionario puedes hacerlo de la siguiente manera:
>>> del poblacion_paises['Brasil']
>>> poblacion_paises
{'Argentina': 44938712, 'Colombia': 50372424, 'Venezuela': 28515829}

**Algunas funciones : **
str(dicccionario) Convierte el diccionario en cadena.
dicc.copy() Copia el diccionario en otra variable.
dicc.update(dicc2) Añade los pares clave-valor de dicc2 en dicc1
dicc.items() Regresa una lista de pares clave-valor
dicc.fromkeys(lista, valor) Crea un nuevo diccionario (Las claves son de la lista con valor)

Este es mi aporte a la clase, un catálogo con la posibilidad de averiguar el precio según la petición del usuario, se agradecen correcciones

def run():
    catalogo = {
        'lampara':40_000,
        'sofa':250_000,
        'camara': 750_000
    }

    s = ', '
    s= s.join(catalogo.keys()) #join ingresa las llaves de catalogo y las separa por el valor de s
    usuario=input('¿Qué elemento deseas averiguar? \n     ¿' + s + '? : ')
    print( 'Este árticulo tiene un valor de $' + str(catalogo[usuario.lower()]) + ' pesos colombianos')

if __name__=='__main__':
    run()

seguir aprendiendo sobre estructura de datos

DICCIONARIOS

from typing import KeysView

def run():
mi_diccionario = {
" LLAVE":1,
“LLAVE2”:2,
“LLAVE3”:3,
}
print (mi_diccionario[“LLAVE2”])
# las llaves definen diccionarios
# diccionario es una estructura de llaves () y valores ()
# llave es como palabra en el diccionario y variable es como la definicion
poblacion_paises ={
“Argentina”: 44938,
“Brasil”: 2101472,
“Colombia”:5037500
}
print (poblacion_paises [“Colombia”])
# que me devuelva cada uno de los elementos del diccionario
# .keys en un metodo
for pais in poblacion_paises.keys ():
print (pais)
# .values metodo para valores del diccionario
# .items me da llave y valor
if name ==“main”:
run()
#.clear() elimina los elementos del diccionario
#.pop(“n”) elimina el ultimo elemento ingresado

Información resumida de esta clase
#EstudiantesDePlatzi

  • Existen muchas estructuras de datos dentro de los lenguajes de programación

  • Con los diccionarios ponemos nuestros datos entre llaves { }

  • El diccionario es una estructura de datos de llaves y valores

  • Utilizando .keys en un diccionario puedo seleccionar solo las llaves

  • Utilizando .values en un diccionario puedo seleccionar solo los valores

  • Utilizando .items en un diccionario puedo seleccionar llaves t valores

Comparto mis apuntes de la clase:

Notas 📒

✏️ Diccionarios

Son una estructura de datos mutable las cuales almacenan diferentes tipos de valores y se escriben entre {}.

Se conforman por Llaves y valores. Con ayuda de las llaves es como se puede obtener el contenido y estas llaves pueden ser de cualquier tipo de dato y no seguir un orden como en las listas y los indices (0,1,2,3…)

Ejemplo de diccionario:

dias_x_meses = {
    'Enero': 31,
    'Febrero': 28,
    'Marzo': 31,
    'Abril': 30,
    'Mayo': 31,
    'Junio': 30,
    'Julio': 31,
    'Agosto': 31,
    'Septiembre': 30,
    'Octubre': 31,
    'Noviembre': 30,

Obtener un valor con la llave

dias_x_meses['Septiembre'] -> 30

Iterar llaves del diccionario

for mes in dias_x_meses.keys():
        print(mes)

o con

for mes in dias_x_meses:
        print(mes)

Iterar contenido del diccionario

for dias in dias_x_meses.values():
        print(dias)

Iterar llave y contenido del diccionario

for mes,dias in dias_x_meses.items():
        print(f"El mes {mes} tiene {dias} días")

Realmente agradecido de poder participar en un curso con tan talentoso profesor; la manera de enseñar, la claridad y la energía a lo largo del curso, son para aplaudirte Facundo.
.
Gracias. 👏🏻👏🏻👏🏻

Aquí les dejo un conversor de moneda que utiliza un diccionario para almacenar los factores de conversión de cada moneda. Es básicamente un diccionario anidado donde el primer nivel del diccionario indica la moneda de y el segundo nivel la moneda de destino:

import sys

help_text = """
uso:
    convertir <cantidad> <moneda de origen> <moneda de destino>

ej:
    convertir 40 MXN USD

Monedas compatibles:
    MXN: Peso mexicano
    ARS: Peso argentino
    USD: Dólar estadounidense
    CLP: Peso Chileno
    COP: Peso colombiano
"""

if sys.argv[1] == "--help":
    print(help_text)
    exit()

cantidad = float(sys.argv[1])
moneda_origen = sys.argv[2].upper()
moneda_destino = sys.argv[3].upper()
factor_conversion = 1

monedas = {
    "MXN": {
        "ARS": 4.79,
        "USD": 0.05,
        "CLP": 36.32,
        "COP": 183.90,
    },
    "ARS": {
        "MXN": 0.21,
        "USD": 0.011,
        "CLP": 7.59,
        "COP": 38.41,
    },
    "USD": {
        "MXN": 19.87,
        "ARS": 95.13,
        "CLP": 721.80,
        "COP": 3654.50,
    },
    "CLP": {
        "MXN": 0.28,
        "ARS": 0.13,
        "USD": 0.0014,
        "COP": 5.06,
    },
    "COP": {
        "MXN": 0.0055,
        "ARS": 0.026,
        "USD": 0.00028,
        "CLP": 0.20,
    }
}

factor_conversion = monedas[moneda_origen][moneda_destino]

total_conversion = cantidad * factor_conversion

if total_conversion > 0.01:
    total_conversion = round(total_conversion, 2)

total_conversion= str(total_conversion)

print("Tienes $" + total_conversion + " " + moneda_destino)


Aquí hay una pagina en la que explican los diccionarios, junto a otros métodos, es muy buena 👇
https://devcode.la/tutoriales/diccionarios-en-python/

Las estructuras de datos son poderas, es la mejor clase que llevaras si decides entrar a la Universidad.

Diccionarios

  • Funcionan por llaves y valores
  • No necesariamente van del 1 al x elemento
  • Tiene los métodos .keys() .values() y .items()
  • Se puede acceder a los objetos con índices apuntando a la llave: mi_diccionario[‘mi_llave’]
def main():
    paises = {
        "alemania": 4,
        "brasil": 5,
        "argentina": 2,
        "francia": 2
    }

    for i, x in paises.items():
        print(i +"tiene " + str(x) +" copas del mundo")


if __name__ == "__main__":
    main()

Una novedad desde python 3.6 es el uso del formato de strings, que no solo son más legibles, más concisas y menos propensas a errores que otras formas de formateo, ¡sino que también son más rápidas!

Aquí un ejemplo de su uso para el mismo bucle FOR usado por Facundo:

for pais, poblacion in poblacion_paises.items():
print(f’{pais} tiene {poblacion} habitantes’)

nombre_de_diccionario.keys() -> retorna nombre de llaves nombre_de_diccionario.values() -> retorna valor de las llaves nombre_de_diccionario.items() -> retorna ambos, nombre y valor de cada llave

Estuve en tantos cursos de python y al fin pude encontrar a alguien que explique de una forma tan sencilla y clara lo que muchos se complican.

def run():
    mi_diccionario = {
        'llave1': 1,
        'llave2': 2,
        'llave3': 3,
    }

    # print(mi_diccionario['llave1'])
    # print(mi_diccionario['llave2'])
    # print(mi_diccionario['llave3'])

    poblacion_paises = {
        'Argentina': 44938712,
        'Brasil': 210147125,
        'Colombia': 50372424
    }

    # print(poblacion_paises['Bolivia'])

    # for pais in poblacion_paises.keys():
    #     print(pais)

    # for pais in poblacion_paises.values():
    #     print(pais)

    for pais, poblacion in poblacion_paises.items():
        print(pais + ' tiene ' + str(poblacion) + ' habitantes')


if __name__ == '__main__':
    run()

En la función for se mencionan dos variables: país y población, pero estos toman su valor de acuerdo al orden que se mencionan en la función

Que tuanis y eso que antes no sabía qué eran estructuras de datos, por acá deben haber. No estoy seguro hacia donde tendría que moverme después de este curso a nivel de python.

def run():
# mi_diccionario = {
# ‘llave1’: 1,
# ‘llave2’: 2,
# ‘llave3’: 3,

# }

# print(mi_diccionario)

poblacion_paises = {
    'Argentina': 45678900009,
    'Brasil' : 67044000,
    'México': 120000000,
}

#print(poblacion_paises['Argentina'])

# for pais in poblacion_paises.keys():
#     print(pais)

# for pais in poblacion_paises.values():
#     print(pais)

for pais, poblacion in poblacion_paises.items():
    print(pais + ' tiene ' + str(poblacion) + ' habitantes')

if name == ‘main’:
run()

Cree un programa para practicar las capitales de los departamentos de Colombia, espero que les guste 💚

<import random

def ciudades():
    departamentos = { 
    "Amazonas": "leticia",
    "Antioquia":"medellin", 
    "Arauca":"arauca",
    "Atlántico":"barranquilla",
    "Bolívar":"cartagena",
    "Boyacá":"tunja", 
    "Caldas":"manizales",
    "Caquetá":"florencia",
    "Casanare":"yopal", 
    "Cauca":"popayan", 
    "Cesar":"valledupar", 
    "Chocó":"quibdo", 
    "Córdoba":"monteria", 
    "Cundinamarca":"bogota", 
    "Guainía":"inirida", 
    "Guaviare":"sanjosedelguaviare", 
    "Huila":"neiva", 
    "Guajira":"riohacha", 
    "Magdalena":"santamarta", 
    "Meta":"villavicencio", 
    "Nariño":"pasto", 
    "Norte de Santander":"cucuta", 
    "Putumayo":"mocoa", 
    "Quindío":"armenia", 
    "Risaralda":"pereira", 
    "San Andrés y Providencia": "sanandres"}
    capitales = list(departamentos.keys())
    random.shuffle(capitales)
    for ciudad in capitales:
        for i in range (5):
            intento = input("La capital de {} es : " .format(ciudad)).lower().replace(" ", "")
            if intento == departamentos[ciudad]:
                print("Espectacular, te ha quedado bien 👍")
                break
            else:
                print("Te ha quedado mal ❌, este es tu intento numero " + str(i) + " de 5")
        i += 1
        if i == 5:
            print("Haz perdido tu ultima vida 😥😥😥")
            break
      
      
      
def run():
    print("""
    ----------------------------------Bienvenido---------------------------------
                                        👋😃
    En este programa practicaras tus conocimientos acercade las capitales de los
    departamentos Colombianos 💛💙💓
    """)
    welcome = input("¿Estas listo?: ").upper()
    if welcome == "SI":
        ciudades()
    else:
        print("Gracias por venir")


if __name__ == "__main__":
    run()> 

DICCIONARIOS💚
Es una estructura de datos de llaves y valores.
Utiliza los { }
Las llaves son los nombres que se le pone a los “índices”.

Yo, que vengo de PHP, creo que los diccionarios -y no las listas- son el equivalente a los arrays en PHP.

La diferencia sería que en PHP puedes no definir llaves y el lenguaje les asignará un valor número como índice, igual que con las listas en Python.

¿Será?

Muy buena esta clase.
Apliqué lo aprendido en esta clase tomando la data de inmunización contra Covid-19 en diversos departamentos de mi país (Perú):

Si te ha fascinado las estructuras y tipos de datos te dejo esta imagen genial que nos muestra todos los tipos de datos que existen en python
si quieres verlo más a fondo te dejo la página

La estructura de datos tipo diccionario utiliza una clave para acceder a un valor. El subíndice puede ser un entero, un float, un string, una tupla etc.

a que pagina me recomiendan ir para practicar lo que he aprendido, ejercicios,proyectos etc gratis

Excelente, siento que he aprendido mucho en este curso… c:
Siento mucha emoción de casi terminar c:

el profe anima mucho a estudiar

Entendi esa referencia cuando pusiste bolivia

Por si tenían duda si, Los diccionario son los Hash Tables de otros lenguajes.

https://platzi.com/clases/2156-estructuras-datos/33727-hash-tables/

😊😊😊😊😊😊😊😊😊😊😊😊😊😊

<def run():
    miDiccionario = {
        # son estructuras de datos de llaves y valor.
        'llave1':1,
        'llave2' :2,
        'llave3' :3,
    }
    # print(miDiccionario['llave1'])
    # print(miDiccionario['llave2'])
    # print(miDiccionario['llave3'])
    poblacionPaises = {
        'Argentina' : 12098765,
        'Brasil' : 40567432,
        'Chile' : 98674832
    }
    # print(poblacionPaises['Argentina'])

    # metodo keys muestra los nombres del diccionario
    for pais in poblacionPaises.keys():
        print(pais)

    for pais in poblacionPaises.values():
        print(pais)

    for pais, poblacion in poblacionPaises.items():
        print(pais, " tiene ", str(poblacion), ' habitantes.')

if __name__ == '__main__':
    run()> 

Una forma de agregar más elementos al diccionario!

    poblacion = {
        'Argentina' : 44938712,
        'Brasil' : 210147125,
        'colombia' : 50372424,
    }
    
    a = input("Ingrese pais: ")
    poblacion[a] = int(input("Ingrese poblacion: "))
mi_diccionario = {
        'key1': 1,
        'key2': 2,
        'key3': 3
    }

    for i in mi_diccionario:
        print('Key:',i, ' value:', mi_diccionario[i])

Los diccionarios son como los JSON en JavaScript

Manejo de diccionarios

def run():
mi_diccionario = {
‘BC238’: ‘Transistor de uso general’,
‘1N4007’: ‘Diodo rectificador genérico’,
‘HEF4001’: ‘IC de 4 puerta Y salida negada (NAND) de 2 entradas’
}

# print(mi_diccionario['1N4007'])
# print(mi_diccionario['BC238'])
# print(mi_diccionario['HEF4001'])

for codigo in mi_diccionario.keys():
    print(codigo)
print('¨'*20)

for descripcion in mi_diccionario.keys():
    print(descripcion)
print('¨'*20)

print('Código\t| Descripción\n' + '-' * 60)
for codigo, descripcion in mi_diccionario.items():
    print(codigo + '\t| ' + descripcion)
print('¨'*20)

if name == ‘main’:
run()

Excelente explicación!!!

Antes de ver cómo se mostraba la llave junto con el valor pausé el video he hice esto:

for pais in poblacion_paises.keys():
    print(pais + " tiene: " + str(poblacion_paises[pais]) + " habitantes")

Así es mas fácil imprimir el mensaje

En JavaScript(JS) se mantiene muchas cosas de Python, por ejemplo: llaves y valores, en JS se llaman de la misma manera.
En Python son ‘Diccionarios’ en JS son ‘Objetos’.
Una forma de comunicacion es enviar JSON (JavaScript Object Notation) que es lo mismo que enviar un diccionario.
Algo mas, en JS los Objetos tienen muchisimas opciones y posibilidades de manipulacion, otra diferencia es que las llaves en JS no se colocan como Strings, se pasan como variables, ejemplo: ‘llave_de_python’ llaveEnJS

el profe enseña bien.

Cuando Hablan de estructuras de datos no evito recordar este chiste (Aplica a cualquier Lenguaje de Programación)

Un diccionario es una estructura de llaves y valores, a los elementos se puede acceder a través de las llaves, así mismo, el nombre que lleva el indice se llaman llaves

def run():
    mi_diccionario={
        'llave1':1,
        'llave2':2,
        'llave3':3,
    }

    """ print(mi_diccionario['llave1'])
    print(mi_diccionario['llave2'])
    print(mi_diccionario['llave3']) """

    poblacion_paises={
        'Argentina':44_938_712,
        'Brasil':210_147_125,
        'Colombia':50_372_424,
    }
    """ print(poblacion_paises['Argentina']) """
    """ for pais in poblacion_paises.keys():
        print(pais) """

    """ for pais in poblacion_paises.values():
            print(pais) """
    for pais,habitantes in poblacion_paises.items():
        print(pais+ ' tiene '  +str(habitantes)+ ' habitantes ')



if __name__ =='__main__':
    run()

que explicación tan sencilla y clara

Los diccionarios son dinámicos porque crecen y decrecen, se pueden quitar y agregar elementos o ver los valores y las llaves al mismo tiempo.

Como curiosidad :
Los diccionarios son otro tipo de colección donde los elementos se guardan sin orden.
Estos tiene dos elementos por posicion, la CLAVE : y el VALOR. Y en estos no puede haber claves duplicadas. En los diccionarios puedes ingresar, listas, tuplas, conjuntos, hasta otros diccionarios.
:
A diferencia de las listas, no vamos a acceder a un elemento a traves de su indice, sino que vamos a acceder atraves de sus llaves.
:
Las llaves a diferencia de los índices accedemos a ellas poniéndoles nombres

Jjaja curiosamente intente hacerlo antes de ver el video y parece ser este método también funciona

def run():
    población_paises = {
	'Argentina': 44_938_712,
	'Brasil': 210_147_125,
	'Colombia': 50_372_424
    }

for pais in población_paises.keys():
        #print(f"La poblacion de {pais} es de: {población_paises[pais]} ")

if __name__ == "__main__":
    run()

def run():

    mi_dict = {
        "name": "Victor Adrian",
        "Edad": 18,
        "Deporte": "Basquet"
    }

    print(mi_dict["name"])
    print(mi_dict["Edad"])
    print(mi_dict["Deporte"])

    población_paises = {
        'Argentina': 44_938_712,
        'Brasil': 210_147_125,
        'Colombia': 50_372_424
    }

    for x in población_paises.keys(): # Me devuelve el valor de las llaver
        print(x)

    for poblacion in población_paises.values(): # De mevuelve el valor de las llaves
        print(poblacion)

    for pais, poblacion in población_paises.items():
        print(f'El pais {pais} tiene {poblacion} habitantes')

run()

Como siempre, Bolivia no existe ni en el código de prueba :’(, que Freddy ni se entere porque le reafirmara la idea de que Bolivia no existe xD

mi resultado

def run():
    mi_diccionario = {
        'llave1': 1,
        'llave2': 2,
        'llave3': 3,
    }

    # print(mi_diccionario['llave1'])
    # print(mi_diccionario['llave2'])
    # print(mi_diccionario['llave3'])

    poblacion_paises = {
        'Argentina': 44938712,
        'Brasil': 210147125,
        'Colombia': 50372424
    }

    # print(poblacion_paises['Bolivia'])

    # for pais in poblacion_paises.keys():
    #     print(pais)

    # for pais in poblacion_paises.values():
    #     print(pais)

    for pais, poblacion in poblacion_paises.items():
        print(pais + ' tiene ' + str(poblacion) + ' habitantes')


if __name__ == '__main__':
    run()

Los diccionarios son estructuras de datos de llaves y valores, a diferencias de las listas que acceden a sus elementos por medio de índices. No es necesario identar, pero se hace por buenas prácticas al contenido que se encuentra dentro de las llaves

A los elementos (valores) de un diccionario se accede por sus llaves, no por índice.

Los corchetes o llaves se utilizan para delimitar codigo en otros lenguajes, pero en python se usan para crear diccionarios.

Las estructuras de datos en Python se pueden entender como un tipo de dato compuesto, debido a que en una misma variable podemos almacenar una estructura completa con información. Dichas estructuras, pueden tener diferentes características y funcionalidades. De hecho, existen múltiples tipos de estructuras de datos en Python

Las estructuras de datos más comunes en Python son las listas, las tablas y los diccionarios. Aunque tienen otro nombre, en otros lenguajes, son los arreglos o vectores, las matrices y los arreglos indexados, respectivamente. Son en esencia lo mismo, aunque como es habitual en Python, con varias facilidades y funcionalidades ya incluidas.

En esta serie de contenidos vamos entonces a explorar cada una de esas estructuras de datos en Python (listas, tablas y diccionarios), en ese mismo orden.

Las estructuras de datos han sido creadas para solucionar una gran variedad de problemáticas que no podrían ser resueltas con lo que conocemos hasta ahora, pues permiten agrupar fácilmente un conjunto de datos (normalmente relacionados) para operar fácilmente con ellos. Cosas como ordenar, agregar, eliminar, mostrar, recorrer, entre otras operaciones, son posibles y fáciles en Python.

Sin la existencia de las estructuras de datos sería imposible o bastante complicado, por ejemplo, conocer y manejar todos los números de identificación, nombres y direcciones de todos los usuarios de un sistema (que normalmente serían muchísimos) pero ahora con las estructuras de datos es muy simple definir una serie de posiciones para cada valor que deseamos guardar y accediendo a ellos por medio de una única variable. No tendría sentido, tener que crear 500 variables para almacenar los nombres de 500 usuarios (por ejemplo).

Los diccionarios en Python son un tipo de estructuras de datos que permite guardar un conjunto no ordenado de pares clave-valor, siendo las claves únicas dentro de un mismo diccionario (es decir que no pueden existir dos elementos con una misma clave). Los diccionarios son estructuras de datos muy extendidos en otros lenguajes de programación, aunque en otros lenguajes como java se les denominan con distintos nombres como “Map” (ver entrada “Map en Java, con ejemplos”).

Veamos a continuación un ejemplo de como declarariamos un diccionario en Python en cuyos elementos tenemos los jugadores de la selección Española, siendo la clave su dorsal (clave única) y el valor su nombre.

Defino la varible ‘futbolistas’ como un diccionario. No es necesario declarar que tipo de dato es

futbolistas = dict()

futbolistas = {
1 : “Casillas”, 15 : “Ramos”,
3 : “Pique”, 5 : “Puyol”,
11 : “Capdevila”, 14 : “Xabi Alonso”,
16 : “Busquets”, 8 : “Xavi Hernandez”,
18 : “Pedrito”, 6 : “Iniesta”,
7 : “Villa”
}

Como vemos el diccionario de declara entre los caracteres ‘{}’ y cada uno de los elementos los separamos por comas (’,’). Cada elemento lo definimos con su par clave:valor, pudiendo der la clave y el valor de cualquier tipo de dato (‘int’, ‘float’, ‘chr’, ‘str’, ‘bool’, ‘object’).

Vamos a continuación a recorrer el diccionario (con un foreach) y a imprimir sus pares clave:valor (más adelante veremos todos los métodos de los diccionarios) :

Recorrer un diccionario, imprimiendo su clave-valor

for k,v in futbolistas.items():
print “%s -> %s” %(k,v)

Como resultado de este código tenemos lo siguiente:

1 -> Casillas
3 -> Pique
5 -> Puyol
6 -> Iniesta
7 -> Villa
8 -> Xavi Hernandez
11 -> Capdevila
14 -> Xabi Alonso
15 -> Ramos
16 -> Busquets
18 -> Pedrito

Vamos a pasar ahora a mostrar los métodos (o funciones) para trabajar con los diccionarios en Python, y posteriormente a poner ejemplos del funcionamiento de estos métodos:

Declaración de un diccionario

diccionario = dict()

Devuelve el numero de elementos que tiene el diccionario

len(dict)

Compara el número de elementos distintos que tienen los dos

cmp (dict1,dict2)

Devuelve una lista con las claves del diccionario

dict.keys()

Devuelve una lista con los valores del diccionario

dict.values()

Devuelve el valor del elemento con clave key. Sino devuelve default

dict.get(key, default=None)

Inserta un elemento en el diccionario clave:valor. Si la clave existe no lo inserta

dict.setdefault(key, default=None)

Insertamos un elemento en el diccionario con su clave:valor

dict[‘key’] = ‘value’

Eliminamos el elemento del diccionario con clave key

dict.pop(‘key’,None)

Devuleve la copia de un diccionario dict2 = dict.copy()

dict.copy()

Elimina todos los elementos de un diccionario

dict.clear()

Crea un nuevo diccionario poniendo como claves las que hay en la lista y los valores por defecto si se les pasa

dict.fromkeys(list, defaultValue)

Devuelve true si existe la clave. Sino devuelve false

dict.has_key(key)

devuelve un lista de tuplas formadas por los pares clave:valor

dict.items()

Añade los elementos de un diccionario a otro

dict.update(dict2)

Una vez vistos los métodos (o funciones) que nos permiten trabajar con los diccionarios, vamos a mostrar como trabajar con estos métodos. Para ello nos vamos a utilizar el diccionario ‘futbolistas’ que hemos declarado al principio, en el que hemos guardado elementos futbolista te tienen como clave su dorsal (es decir un ‘int’) y como valor su nombre (un ‘string’).

En primer lugar vamos a mostrar como contar los elementos de un diccionario, que lo hacemos de la siguiente forma

Vemos cuantos elementos tiene nuestro diccionario

numElem = len(futbolistas)
print “\nNumero de elementos del diccionario len(futbolistas) = %i” %numElem

Teniendo como salida de ese fragmento de código:

Numero de elementos del diccionario len(futbolistas) = 11

Con el método “keys()” obtenemos una lista con las claves de los diccionarios y de la misma forma con el método “values()” obtenemos una lista con los valores del diccionario. En el siguiente fragmento de código vemos como obtener estas listas:

Imprimimos una lista con las claves del diccionario

keys = futbolistas.keys();
print “\nClaves del diccionario futbolistas.keys(): \n%s” %keys

Imprimimos en una lista los valores del diccionario

values = futbolistas.values()
print “\nValores del diccionario futbolistas.values(): \n%s” %values

Como salida de este fragmento de código tenemos lo siguiente:

Claves del diccionario futbolistas.keys():
[1, 3, 5, 6, 7, 8, 11, 14, 15, 16, 18]

Valores del diccionario futbolistas.values():
[‘Casillas’, ‘Pique’, ‘Puyol’, ‘Iniesta’, ‘Villa’, ‘Xavi Hernandez’, ‘Capdevila’, ‘Xabi Alonso’, ‘Ramos’, ‘Busquets’, ‘Pedrito’]

Con el método “get(key)”, pasándole como parámetro una clave, obtenemos el valor del elemento que tiene esa clave:

Obtenemos el valor de un elemento dada su clave

elem = futbolistas.get(6)
print “\nObtenemos el valor cuya clave es ‘6’ futbolistas.get(6): %s” %elem

Como resultado, obtenemos el nombre del futbolista con clave = 6:

Obtenemos el valor cuya clave es ‘6’ futbolistas.get(6): Iniesta

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:

Añadimos un nuevo elemento a la lista

futbolistas[22] = 'Navas’
print “\nDiccionario tras añadir un elemento: futbolistas[22] = ‘Navas’ \n%s” %futbolistas

Como resultado, tenemos en el diccionario un elemento más:

Diccionario tras añadir un elemento: futbolistas[22] = ‘Navas’
{1: ‘Casillas’, 3: ‘Pique’, 5: ‘Puyol’, 6: ‘Iniesta’, 7: ‘Villa’, 8: ‘Xavi Hernandez’, 10: ‘Cesc’, 11: ‘Capdevila’, 14: ‘Xabi Alonso’, 15: ‘Ramos’, 16: ‘Busquets’, 18: ‘Pedrito’, 22: ‘Navas’}

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:

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”
“\nfutbolistas.setdefault(10,‘Cesc’): %s” %elem2

Como resultado al fragmento de código anterior tenemos lo siguiente:

Insertamos un elemento en el diccionario. Si la clave existe no lo inserta
futbolistas.setdefault(10,‘Cesc’): Cesc

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:

Eliminamos un elemento del diccionario dada su clave

futbolistas.pop(22)
print “\nDiccionario tras eliminar un elemento: futbolistas.pop(22) \n%s” %futbolistas

Como resultado de este fragmento de código, podemos observar que efectivamente ha realizado el borrado del elemento con clave = 22:

Diccionario tras eliminar un elemento: futbolistas.pop(22)
{1: ‘Casillas’, 3: ‘Pique’, 5: ‘Puyol’, 6: ‘Iniesta’, 7: ‘Villa’, 8: ‘Xavi Hernandez’, 10: ‘Cesc’, 11: ‘Capdevila’, 14: ‘Xabi Alonso’, 15: ‘Ramos’, 16: ‘Busquets’, 18: ‘Pedrito’}

Para hacer una copia de un diccionario, se utiliza el método “copy()”:

Hacemos una copia del diccionario

futbolistasCopy = futbolistas.copy();
print “\nRealizamos una copia del diccionario futbolistasCopy=futbolistas.copy(): \n%s” %futbolistas

Vamos a ver que como resultado, tenemos un nuevo diccionario llamado ‘futbolistasCopy’ que contiene los mismos elementos que el diccionario ‘futbolistas’:

Realizamos una copia del diccionario futbolistasCopy=futbolistas.copy():
{1: ‘Casillas’, 3: ‘Pique’, 5: ‘Puyol’, 6: ‘Iniesta’, 7: ‘Villa’, 8: ‘Xavi Hernandez’, 10: ‘Cesc’, 11: ‘Capdevila’, 14: ‘Xabi Alonso’, 15: ‘Ramos’, 16: ‘Busquets’, 18: ‘Pedrito’}

Para eliminar el contenido (o los elementos) de un diccionario utilizamos el método “clear()”:

Eliminamos los elementos de un diccionario

futbolistasCopy.clear()
print “\nEliminamos los elementos de un diccionario futbolistasCopy.clear(): %s” %futbolistasCopy

Vemos como con el fragmento de código anterior nos elimina el contenido del diccionario, pero no elimina el diccionario:

Eliminamos los elementos de un diccionario futbolistasCopy.clear(): {}

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:

Creamos un diccionario a partir de una lista con las claves

keys = [‘nombre’, ‘apellidos’, ‘edad’]
dictList = dict.fromkeys(keys, ‘nada’)
print “\nCreamos un diccionario a partir de una lista dictList = dict.fromkeys(keys, ‘nada’): \n%s” %dictList

Como resultado, nos crea un diccionario llamado ‘dictList’, con las claves que le pasamos en la lista y con el valor ‘nada’ que le pasamos como parámetro:

Creamos un diccionario a partir de una lista dictList = dict.fromkeys(keys, ‘nada’):
{‘apellidos’: ‘nada’, ‘nombre’: ‘nada’, ‘edad’: ‘nada’}

El método que nos permite comprobar si existe o no una clave es el método “has_key(key)”. Veamos un ejemplo:

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 \n\tfutbolistas.has_key(2) = %s "
“\n\tfutbolistas.has_key(8) = %s” %(exit2,exit8)

Como resultado de la comprobación de claves anterior tenemos lo siguiente:

Comprobamos si existen los elementos 2 y 8
futbolistas.has_key(2) = False
futbolistas.has_key(8) = True

Otro método muy util; sobre todo para hacer un foreach del diccionario y obtener sus pares clave:valor, es el método “items()” que devuelve los elementos de los diccionarios en tuplas, en la que en cada una de ellas esta en la primera posición la clave y en la segunda el valor. Veamos un ejemplo:

Devolvemos los elementos del diccionario en tuplas

tuplas = futbolistas.items()
print “\nPasamos el diccionario a tuplas con clave-valor: tuplas = futbolistas.items() \n%s” %tuplas

Como resultado vemos que efectivamente nos devuelve una lista de tuplas con los pares clave:valor:

Pasamos el diccionario a tuplas con clave-valor: tuplas = futbolistas.items()
[(1, ‘Casillas’), (3, ‘Pique’), (5, ‘Puyol’), (6, ‘Iniesta’), (7, ‘Villa’), (8, ‘Xavi Hernandez’), (10, ‘Cesc’), (11, ‘Capdevila’), (14, ‘Xabi Alonso’), (15, ‘Ramos’), (16, ‘Busquets’), (18, ‘Pedrito’)]

Por último vamos a ver el método “update(dict)” que nos va a permitir unir los elementos de dos diccionarios. Este método inserta en el diccionario aquellos elementos del diccionario que se le pasa como parámetro, cuyas claves no estén en el diccionario. Veamos el siguiente ejemplo:

Mergeamos dos diccionarios

suplentes = {
4:‘Marchena’, 9:‘Torres’, 12:‘Valdes’,
13:‘Mata’ , 17:‘Arbeloa’, 19:‘Llorente’,
20:‘Javi Martinez’, 21:‘Silva’, 23:‘Reina’
}

futbolistas.update(suplentes)
print “\nAñadimos los elementos de un diccionario a otro futbolistas.update(suplentes): \n%s” %futbolistas

Como vemos en este ejemplo nos hemos creado un nuevo diccionario con los futbolistas ‘suplentes’ y lo hemos unido al diccionario futbolistas. De esta forma el diccionario ‘futbolistas’ ya tiene todos los futbolistas (titulares+suplentes) de la selección Española campeona del mundo en el año 2010. Como resultado tenemos lo siguiente:

Añadimos los elementos de un diccionario a otro futbolistas.update(suplentes):
{1: ‘Casillas’, 3: ‘Pique’, 4: ‘Marchena’, 5: ‘Puyol’, 6: ‘Iniesta’, 7: ‘Villa’, 8: ‘Xavi Hernandez’, 9: ‘Torres’, 10: ‘Cesc’, 11: ‘Capdevila’, 12: ‘Valdes’, 13: ‘Mata’, 14: ‘Xabi Alonso’, 15: ‘Ramos’, 16: ‘Busquets’, 17: ‘Arbeloa’, 18: ‘Pedrito’, 19: ‘Llorente’, 20: ‘Javi Martinez’, 21: ‘Silva’, 23: ‘Reina’}

Estos han sido los métodos más importantes para el manejo de diccionarios en python. A continuación mostramos todo el fragmento del código que hemos ido desgranando en este tutorial:

-- coding: utf-8 --

author = ‘Richard’

Defino la varible ‘futbolistas’ como un diccionario. No es necesario declarar que tipo de dato es

futbolistas = dict()

futbolistas = {
1 : “Casillas”, 15 : “Ramos”,
3 : “Pique”, 5 : “Puyol”,
11 : “Capdevila”, 14 : “Xabi Alonso”,
16 : “Busquets”, 8 : “Xavi Hernandez”,
18 : “Pedrito”, 6 : “Iniesta”,
7 : “Villa”
}

Recorrer un diccionario, imprimiendo su clave-valor

for k,v in futbolistas.items():
print “%s -> %s” %(k,v)

Vemos cuantos elementos tiene nuestro diccionario

numElem = len(futbolistas)
print “\nNumero de elementos del diccionario len(futbolistas) = %i” %numElem

Imprimimos una lista con las claves del diccionario

keys = futbolistas.keys();
print “\nClaves del diccionario futbolistas.keys(): \n%s” %keys

Imprimimos en una lista los valores del diccionario

values = futbolistas.values()
print “\nValores del diccionario futbolistas.values(): \n%s” %values

Obtenemos el valor de un elemento dada su clave

elem = futbolistas.get(6)
print “\nObtenemos el valor cuya clave es ‘6’ futbolistas.get(6): %s” %elem

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”
“\nfutbolistas.setdefault(10,‘Cesc’): %s” %elem2

Añadimos un nuevo elemento a la lista

futbolistas[22] = 'Navas’
print “\nDiccionario tras añadir un elemento: futbolistas[22] = ‘Navas’ \n%s” %futbolistas

Eliminamos un elemento del diccionario dada su clave

futbolistas.pop(22)
print “\nDiccionario tras eliminar un elemento: futbolistas.pop(22) \n%s” %futbolistas

Hacemos una copia del diccionario

futbolistasCopy = futbolistas.copy();
print “\nRealizamos una copia del diccionario futbolistasCopy=futbolistas.copy(): \n%s” %futbolistas

Eliminamos los elementos de un diccionario

futbolistasCopy.clear()
print “\nEliminamos los elementos de un diccionario futbolistasCopy.clear(): %s” %futbolistasCopy

Creamos un diccionario a partir de una lista con las claves

keys = [‘nombre’, ‘apellidos’, ‘edad’]
dictList = dict.fromkeys(keys, ‘nada’)
print “\nCreamos un diccionario a partir de una lista dictList = dict.fromkeys(keys, ‘nada’): \n%s” %dictList

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 \n\tfutbolistas.has_key(2) = %s "
“\n\tfutbolistas.has_key(8) = %s” %(exit2,exit8)

Devolvemos los elementos del diccionario en tuplas

tuplas = futbolistas.items()
print “\nPasamos el diccionario a tuplas con clave-valor: tuplas = futbolistas.items() \n%s” %tuplas

Mergeamos dos diccionarios

suplentes = {
4:‘Marchena’, 9:‘Torres’, 12:‘Valdes’,
13:‘Mata’ , 17:‘Arbeloa’, 19:‘Llorente’,
20:‘Javi Martinez’, 21:‘Silva’, 23:‘Reina’
}

futbolistas.update(suplentes)
print “\nAñadimos los elementos de un diccionario a otro futbolistas.update(suplentes): \n%s” %futbolistas