No tienes acceso a esta clase

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

Diccionarios: definición y lectura

30/38
Recursos

Aportes 93

Preguntas 10

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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

JS - Python
Arreglo - Lista
Objeto - Diccionario

DICICIONARIOS, TUPLAS Y LISTAS
LISTA --> lista = [ ];
TUPLAS --> tupla = ( );
DICCIONARIO —> diccionario = { }

  • El siguiente paso a las listas y tuplas que vimos en anteriores, son los diccionarios. Y un diccionario en Python, es como un diccionario en la vida del día a día.

  • Es decir, cada palabra tiene asociado un significado.

  • Pues exactamente igual tenemos en Python, cada palabra, que llamaremos clave, tiene asociado un significado, que llamaremos valor. Es decir, que un diccionario no es mas que un conjunto de parejas clave – valor. Los diccionarios en Python son un tipo de dato realmente muy potente.

  • Indicar que si bien en el caso de un diccionario al uso, la clave (palabra que buscamos), siempre es una cadena de texto, en Python, la clave puede ser cualquier tipo de dato, un entero, una cadena de texto.

  • Incluso, es posible que el tipo de dato varíe, es decir, que para un elemento sea de un tipo y para otro elemento del diccionario, sea de otro tipo.

#aprederemos sobre la estructura de los diccionarios, encontraremos una palabra y por ende su definición ==> en Python sería una llave (key), y su definición 
#los diccionarios siempre se definen entre llaves 
my_dic = {'persona,niño'}
print(my_dic)
print(type(my_dic))

my_dic = {
  'persona': 'niño',
  'nombre': 'nicolas',
  'genero':'masculino',
  'edad': '12 años'#aca estamos definiendo los datos de diccionario
}
print(my_dic)
print(len(my_dic))#con len podemos saber cuántos elementos tenemos en el dic

#tambien puedo leer ese diccionario con los métodos 
print(my_dic['persona'])
print(my_dic['nombre'])
print(my_dic['genero'])
print(my_dic['edad'])

#tambien hay otra forma de hacer que es con el método get
print(my_dic.get('persona'))
print(my_dic.get('nombre'))
print(my_dic.get('genero'))
print(my_dic.get('edad'))
print(my_dic.get('juan jose'))
#la diferencia con get es que imprímelos datos que no hay nada definido(none)
#es recomendable siempre trabajar con get, porque si no existe el diccionario no dará un error solo pondrá None 

#tambien podemos verificar si una llave no existe ni (IN), que nos arrojara valores bulenos 
print('persona' in my_dic)
print('apellidos' in my_dic)
#en esta clase vimos los primeros acercamientos a los diccionarios

#Los diccionarios se compones de llave, valor.
# muy similares a un archivo .json
my_dict = {
    'avion': 'objeto volador',
    'name': 'Javier',
    'last_name': 'Sepulveda',
    'age': 109
}

print(my_dict)

#el tamanio del diccionario
print(len(my_dict))

#imprimiendo una llave 
print(my_dict['age'])

#La funcion get, si no existe el valor sale un mensaje none(Maneja el error)
# Se cambian los corchetes por parentesis(), ya que get es una funcion de python
print(my_dict.get('test'))

print('name' in my_dict)
print('other' in my_dict)

A los diccionarios en python los conocemos como “objetos” en otros lenguajes de programación, a continuación una lista de sus características más destacables:

  1. Los diccionarios son colecciones de pares clave-valor.
  2. Las claves son únicas e inmutables (generalmente cadenas o números).
  3. Los valores pueden ser de cualquier tipo (enteros, cadenas, listas, tuplas, otros diccionarios, etc.).
  4. Los diccionarios se definen utilizando llaves {}.
  5. Los pares clave-valor se separan por comas.
  6. Puedes acceder a los valores mediante la clave utilizando la notación de corchetes [].
  7. Puedes modificar, agregar o eliminar elementos de un diccionario.
  8. La función len(diccionario) devuelve el número de elementos en el diccionario.
  9. Los diccionarios no tienen un orden específico, es decir, no se puede acceder a sus elementos por índice.
  10. Puedes iterar sobre un diccionario utilizando bucles for.
  11. El método dict() se utiliza para crear un diccionario vacío.
  12. El método keys() devuelve una lista de todas las claves del diccionario.
  13. El método values() devuelve una lista de todos los valores del diccionario.
  14. El método items() devuelve una lista de tuplas (clave, valor) que representan todos los elementos del diccionario.

Los diccionarios tiene métodos y funciones para poder manipular y procesar datos con ellos:

  1. clear(): Elimina todos los elementos del diccionario.
  2. copy(): Devuelve una copia superficial (shallow copy) del diccionario.
  3. get(key, default=None): Devuelve el valor de la clave especificada. Si la clave no existe, devuelve el valor predeterminado (por defecto None).
  4. pop(key, default=None): Elimina y devuelve el valor asociado a la clave. Si la clave no existe, devuelve el valor predeterminado (por defecto None) o lanza una excepción si no se proporciona el valor predeterminado.
  5. popitem(): Elimina y devuelve el último par clave-valor del diccionario en forma de tupla.
  6. setdefault(key, default=None): Devuelve el valor de la clave especificada. Si la clave no existe, agrega la clave con el valor predeterminado (por defecto None).
  7. update(other_dict): Actualiza el diccionario con los pares clave-valor del diccionario other_dict. Si la clave ya existe, su valor será actualizado; de lo contrario, se agregará un nuevo par clave-valor.

Funciones para diccionarios:

  1. len(diccionario): Devuelve el número de elementos en el diccionario.
  2. dict(iterable): Crea un diccionario a partir de una secuencia de pares clave-valor (por ejemplo, una lista de tuplas).
  3. sorted(diccionario): Devuelve una lista de las claves del diccionario ordenadas.

Los diccionarios se los utiliza con corchetes { }

Yo solía llamarle corchetes a las llaves y viceversa . Hoy lo corregí.

JSON ¿eres tú?

Usando if
bus = input("llave que buscas => ")
if bus in mi_dic:
print("busca ",mi_dic[bus])
else:
print(“llave no encontrada”)

Algo importante de todo esto es el .get, por lo menos no te rompe el programa

<my_dict = {
  'avion':'bla bla bla',
  'name':'Nicolas',
  'last_name':'Molina monroy',
  'age':87
}

print(my_dict) 
print(len(my_dict)) # aquí estamos buscando el número de elementos que contiene el diccionario

print(my_dict['age']) # nos imprime el valor que estamos buscando
print(my_dict['last_name'])
print(my_dict.get('age')) # funciona iglual que el anterior, solo que en este caso si ponemos un elementos que no existe en el diccionario nos va a soltar una linea de texto "none", si hicieramos lo mismo con el comando o lo que sea anterior se nos buguearía el código.

print('avion' in my_dict)
print('otroqueno' in my_dict) # el resultado sería false porque  ese elemento no existe dentro del diccionario, esto es otra forma de comprobar si existe un elemento o no en el diccionario.> 

A manera de ilustración:

[ ]: Corchete. En Python se utilizan para crear Listas.
( ): Paréntesis. En Python se utilizan para crear Tuplas.
{ }: Llave. En Python se utilizan para crear Diccionarios.

lista -> [ ] -> Mutable

tupla -> ( ) -> Inmutable

diccionario -> { } -> formato key:value, mutable pero no admite duplicidad de keys

Hola les comparto mi codigo comentado

#Diccionario
#los diccionarios en python funcionan como los diccionarios de la vida real
# [ ] = Listas
# ( ) = Tuplas
# { } = Diccionarios

my_dict = {}
print(type(my_dict))

my_dict = {
  'avion': "748B", #las llaves se definen como string
  'name': "Luis",
  'last_name': 'Bolaños',
  'age': 27
}

print(my_dict)
#se puede haces las siguientes cosas con los diccionarios
print(len(my_dict)) #para leer el diccionario

print(my_dict['name']) #si no encuentra esto, marca un error, y detiene el programa
print(my_dict['last_name'])
print(my_dict.get('peso')) #la diferecia con usar .get o no, es que si no esta definido me regresa un none, y continua con el programa
print('el avion es: ', my_dict['avion'])

#tambien se puede comprobar valores
print( '¿Hay un valor que corresponda a avion?: ' , 'avion' in my_dict)
print( '¿Hay un valor que corresponda a wheather?: ', 'wheather' in my_dict)

Entonces los diccionarios con corchetes “{ }” ?

Los diccionarios en Python son estructuras de datos que almacenan pares de clave-valor. Puedes pensar en ellos como una colección de elementos, donde cada elemento está compuesto por una clave única y su correspondiente valor.

A diferencia de las listas o tuplas que se acceden mediante índices numéricos, los diccionarios permiten acceder a sus valores utilizando las claves asociadas a ellos. Esto hace que los diccionarios sean especialmente útiles cuando quieres buscar, recuperar o modificar valores basados en una clave específica.

Los diccionarios en Python, al igual que las listas y las tuplas, nos permiten almacenar diferentes tipos de datos: Strings, enteros, flotantes, booleanos, tuplas, listas e inclusive otros diccionarios. 😯

Los diccionario son mutables, es decir, es posible modificar su longitud, podemos agregar o quitar elementos de él; de igual forma todos los valores almacenados en el diccionario pueden ser modificados.

A diferencias de las listas y de las tuplas los diccionarios no se rigen por la regla de los índices, no, nada de eso, en este caso todos los valores que se almacenen en el diccionario no corresponderá a un índice, si no a una llave

Diccionarios en Python

from os import system
system('clear')

#declaración
my_dict = {}
my_dict = {
  'name': 'Nicolas',
  'last_name': 'Molina Monroy',
  'age': 87,
  'skils': ['python','javascript']
}

print(' ')
print(type(my_dict))

#Mostrando el diccionario y tamaño del mismo
print('Contenido del diccionario')
print(my_dict)
print('tamaño del diccionario',len(my_dict))
print(' ')

#Accediendo a un valor de u diccionario. Sí leemos con la función my_get() se evita que el programa se detenga, ya que, sí el valor no existe python no dentra el programa
print('name:         ',my_dict['name'])
print('lastname:     ',my_dict['last_name'])
print('skill:        ',my_dict.get('skils'))
print(' ')

#Verificando si un valor existe, en el diccionario
print('avion' in my_dict)
print('otroqueno' in my_dict)

A continuación los ejemplos de la clase

my_dict = {
‘name’: ‘Milton’,
‘last_name’: ‘Valle’,
‘age’ : 42
}

print(my_dict)
print(len(my_dict))

print(my_dict[‘age’])
print(my_dict[‘last_name’])
print(my_dict.get(‘age’))

print(‘avion’ in my_dict)
print(‘name’ in my_dict)

Los diccionarios son una estructura de datos que permite almacenar pares de clave-valor. Aquí están las principales funciones para trabajar con diccionarios: **Creación de un diccionario:** Se puede crear un diccionario vacío o con algunos valores iniciales. \# Crear un diccionario vacío diccionario\_vacio = {} \# Crear un diccionario con valores iniciales diccionario = {"clave1": "valor1", "clave2": "valor2"} **Acceder a los elementos:** Se puede acceder a los elementos de un diccionario utilizando la clave. valor = diccionario\["clave1"] **Agregar o modificar elementos:** Se pueden agregar nuevos elementos o modificar los existentes utilizando la clave. \# Agregar un nuevo elemento diccionario\["clave3"] = "valor3" \# Modificar un elemento existente diccionario\["clave1"] = "nuevo valor1" **Eliminar elementos:** Se pueden eliminar elementos de un diccionario utilizando la instrucción del. del diccionario\["clave1"] **Verificar si una clave existe:** Se puede verificar si una clave existe en el diccionario. if "clave1" in diccionario:     print("La clave1 existe en el diccionario") **Obtener todas las claves:** Se pueden obtener todas las claves de un diccionario utilizando el método keys(). claves = diccionario.keys() **Obtener todos los valores:** Se pueden obtener todos los valores de un diccionario utilizando el método values(). valores = diccionario.values() **Obtener todos los pares clave-valor:** Se pueden obtener todos los pares clave-valor de un diccionario utilizando el método items(). pares = diccionario.items()
Clase 29/30 En esta clase se aprendió sobre cómo crear diccionarios en Python, para ello, se declara la variable, que para el caso de la clase, como es general se nombró como: **my\_dict.** Ahora, para que un dato quede registrado como diccionario es a traves de { } las llaves. Entonces tenemos hasta el momento lo siguiente `() => Tuplas` `[] => Listas ` `{} => Diccionarios` En un diccionario se maneja un valor y una definición. Podemos leer ese diccionario con algunas "funciones" que habíamos visto antes. `print(my_dict["age"])` `print(my_dict["last_name"])` `print(my_dict.get["age"])` `print('avion' in my_dict)` En esos casos se recordó el solicitar un valor dado en un diccionario, se apredió el elemento .get, que no genera un error en la términal en caso dado de que no exista el valor en el diccionario, y únicamente envía 'none' como valor.
![](https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiYoFFD5BrzFxkQ17ValDucs9JyGC7a-VDLUPRJR8ynoxQHdajEXx6cwenGlN9FnqvtD2G3VMTvJ7NIupjPrKaRokey0YjqKiDVnCNuYkvf22l75vTY3Ms74uBKcuoI2vMLUn46G_ZOV6m1FI_oUGQeecKuZwn286Qpp9jCEJTjUslMyZEpRBnUZMGDU4RC/s1024/Dictionary.jpg)
Siendo sincero los diccionarios me parecen una estructura muy confusa, no por el concepto, por el uso que se les puede dar Entiendo que se usa mucho para guardar información de clientes y demás, pero me confunde un poco..... Vamos aprendiendo poco a poco ![](https://static.platzi.com/media/user_upload/Diccionario%201-37a7a74b-d488-45c2-a05f-0ece41020cb7.jpg)
![](https://static.platzi.com/media/user_upload/image-b7549845-a59a-4a9c-8d2d-ad7676dd2919.jpg)

Este me parece que es la estructura un poco mas complicado pero vamos a aprender.
aqui aprendiste el concepto del diccionario y como se crea.
Diccionario = es la estructura que tiene llave y valor en ingles: key y value.
{key:value}

cada vez que cierras una llave estas creando un diccionario.
ahora; una vez creada la llave no puedes cambiar la llave solo el valor asi

diccionario = {"Nombre":"Jose Potes", "Edad": 28, "Nacionalidad":"Singapurense"}

Para actualizarlo solo usa:

actualizacion = diccionario["Nacionalidad"] = "Colombia"

esto es importante, creeme, prestale mucha atencion a esta parte.

Ventajas de usar diccionarios
Mapeo de datos: Los diccionarios son ideales para asociar valores con claves únicas. Permiten almacenar información estructurada donde cada valor se relaciona con una clave específica, facilitando el acceso a los datos de manera rápida y eficiente.

Búsqueda eficiente: Los diccionarios utilizan tablas hash internas para realizar búsquedas directas por clave, lo que resulta en una búsqueda muy rápida y eficiente en comparación con las listas o tuplas, donde la búsqueda requiere iterar a través de elementos.

Acceso a datos por etiquetas: Los diccionarios permiten acceder a los datos utilizando etiquetas o nombres significativos (claves) en lugar de índices numéricos, lo que hace que el código sea más legible y fácil de entender.

_Asociación de propiedades: _Los diccionarios son útiles para asociar propiedades con sus respectivos valores. Puedes usarlos para representar objetos con múltiples atributos y acceder a cada atributo por su nombre (clave).

_Evitar duplicados: _Los diccionarios aseguran que las claves sean únicas, lo que evita duplicados en la estructura de datos. Cada clave tiene asociado un único valor, lo que ayuda a mantener la integridad de los datos.

Actualización y eliminación eficientes: Los diccionarios permiten agregar, modificar o eliminar elementos de forma muy eficiente. Puedes actualizar el valor asociado con una clave existente o eliminar una clave y su valor de manera rápida.

Organización de datos complejos: Los diccionarios pueden contener otras estructuras de datos, como listas o tuplas, lo que te permite organizar datos complejos en una sola estructura. Esto es útil para manejar información con múltiples niveles de jerarquía.

( ) = tuplas
[ ] = lista
{ } = diccionario

Buena explicación de los conceptos y su uso.

Les comparto el código de la clase.

# Diccionarios: definición y lectura

my_dict = {}
print(type(my_dict))

my_dict = {
  "avion": "pajaro metalico",
  "name": "Sara",
  "last_name": "Mejia",
  "age": 30
}

print(my_dict)
print(len(my_dict))

print(my_dict["name"])
print(my_dict["last_name"])

# En caso de no conocer exactamente el nombre de la llave, se usa get
print(my_dict.get("un valor"))

print("avion" in my_dict)
print("pajaro" in my_dict)
print("pajaro" not in my_dict)

visto en clase

He entendido bien lo que son los diccionarios en Python a través de la comparación con un diccionario real. Me parece una estructura de mucha utilidad. Sin embargo, tuve que mirar varias veces la sintaxis del profesor cuando estaba escribiendo mi código.

También se puede usar el metodo dict() para crear un diccionario =)

Tan sencillo pero tan claro y con la analogia explicita de diccionario (por algo se le llamó así) ahora entiendo mejor el tema de diccionarios en Python.

my_dict = {}
print(type(my_dict))

my_dict = {
  'avion':'bla bla bla',
  'name':'Nicolas',
  'last_name':'Molina monroy',
  'age':87
}

print(my_dict)
print(len(my_dict))

print(my_dict['age'])
print(my_dict['last_name'])
print(my_dict.get('age'))

print('avion' in my_dict)
print('otroqueno' in my_dict)

Muy utiles los diccionarios

comparto mi código con notas ☺️ ```js # Diccionarios ''' Los diccionarios se compones de llave, valor. muy similares a un archivo .json ## REFERENCIAS ## [] = Listas () = Tuplas {} = Diccionarios ''' my_dict = {} print(type(my_dict)) my_dict = { 'avion': "bla bla bla", 'name': 'Nicolas', 'last_name': 'Molina Monroy', 'age': 87 } print(my_dict) print(len(my_dict)) print(my_dict['age']) print(my_dict['last_name']) # con get se controla el manejo de errores print(my_dict.get('age')) #verifico existencia de elemento en diccionario print('avion' in my_dict) print('otroqueno' in my_dict) ```*# Diccionarios'''Los diccionarios se compones de llave, valor.muy similares a un archivo .json* *## REFERENCIAS ##\[] = Listas() = Tuplas{} = Diccionarios* *'''*my\_dict = {}print(type(my\_dict)) my\_dict = { 'avion': "bla bla bla", 'name': 'Nicolas', 'last\_name': 'Molina Monroy', 'age': 87} print(my\_dict)print(len(my\_dict)) print(my\_dict\['age'])print(my\_dict\['last\_name'])*# con get se controla el manejo de errores*print(my\_dict.get('age')) *#verifico existencia de elemento en diccionario*print('avion' in my\_dict)print('otroqueno' in my\_dict)
En Python, un diccionario es una estructura de datos que permite almacenar pares de clave-valor. Cada clave dentro de un diccionario es única, y se utiliza para acceder al valor correspondiente. Los diccionarios son muy flexibles y útiles para almacenar y manipular datos en Python. ### Creación de un diccionario: python Copy codemi\_diccionario = {"nombre": "Juan", "edad": 30, "ciudad": "Madrid"} ### Acceso a elementos de un diccionario: python Copy codeprint(mi\_diccionario\["nombre"]) # Salida: "Juan" print(mi\_diccionario\["edad"]) # Salida: 30 ### Modificación de elementos de un diccionario: python Copy codemi\_diccionario\["edad"] = 31 print(mi\_diccionario\["edad"]) # Salida: 31 ### Agregar elementos a un diccionario: python Copy codemi\_diccionario\["profesion"] = "Ingeniero" print(mi\_diccionario) # Salida: {'nombre': 'Juan', 'edad': 31, 'ciudad': 'Madrid', 'profesion': 'Ingeniero'} ### Eliminar elementos de un diccionario: python Copy codedel mi\_diccionario\["ciudad"] print(mi\_diccionario) # Salida: {'nombre': 'Juan', 'edad': 31, 'profesion': 'Ingeniero'} ### Funciones de diccionarios: python Copy code# Obtener todas las claves print(mi\_diccionario.keys()) # Salida: dict\_keys(\['nombre', 'edad', 'profesion']) \# Obtener todos los valores print(mi\_diccionario.values()) # Salida: dict\_values(\['Juan', 31, 'Ingeniero']) \# Comprobar si una clave existe en el diccionario print("nombre" in mi\_diccionario) # Salida: True \# Longitud del diccionario print(len(mi\_diccionario)) # Salida: 3 Los diccionarios son una herramienta poderosa en Python, especialmente para representar datos estructurados y asociativos. Permiten el acceso eficiente a los datos a través de claves únicas y son ampliamente utilizados en aplicaciones Python.
En Python, los diccionarios son estructuras de datos clave-valor que permiten almacenar información de manera organizada. Puedes crear un diccionario utilizando llaves `{}` y asignar pares clave-valor separados por comas. Por ejemplo, `mi_diccionario = {'nombre': 'Juan', 'edad': 25, 'ciudad': 'Ejemplo'}`. Puedes acceder a un valor utilizando su clave, modificar valores existentes y agregar nuevos pares clave-valor. Los diccionarios son útiles para representar datos estructurados, como información de usuarios o configuraciones, y ofrecen una herramienta poderosa para manipular información de manera eficiente en Python.
<#Definicion de diccionarios {}
my_dict = {}
print(type(my_dict))

#Colocar datos en el diccionario {'termino1': "definicion" , 'termino2'...}
my_dict = {
  'avion': "bla bla bla",
  'name': 'Nicolas',
  'last_name': 'Molina Monroy',
  'age': 87
}

#Mostrar todos los datos del diccionario
print(my_dict)
print(len(my_dict))

#Mostrar un dato especifico del diccionario
print(my_dict['age'])
print(my_dict['last_name'])
print(my_dict.get('age')) #cuando un valor no existe este metodo no arroja error, indica "none"

#Validar si un dato existe en el diccionario
print('avion' in my_dict)
print('otroqueno' in my_dict)> 
Ya veo, entonces los diccionarios son como los objetos en programacion orientada a objetos
Hi, I found this regarding the use of the word "brackets" "Brackets" is used interchangeably for various symbols: • angle brackets for <> • round brackets for () • curly brackets for {} • square brackets for \[] • and more, some of which are only used in certain regions or cultures The more specific "braces" and "parentheses" are almost never used for other than {} and (), respectively. So, I prefer "braces" for {}, "parens" (informally or in the context of programming) or "parentheses" for (), and plain "brackets" for \[], though "square brackets" is sometimes required to be explicit about the latter. This gives you a one-word name for any of those common symbols.

Las listas en Python son secuencias ordenadas y mutables de elementos. Se representan utilizando corchetes [] y permiten cambios en sus elementos. Por ejemplo: [1, 2, ‘a’, ‘b’].

Las tuplas también son secuencias ordenadas, pero son inmutables, lo que significa que sus elementos no pueden modificarse después de su creación. Se representan mediante paréntesis () y son ejemplificadas por (1, 2, ‘a’, ‘b’).

Los diccionarios son colecciones no ordenadas de pares clave-valor, lo que significa que contienen elementos que tienen claves y valores asociados. Se representan utilizando llaves {} y permiten la modificación de sus elementos. Por ejemplo: {‘clave’: ‘valor’, ‘nombre’: ‘Juan’}.

Ejercicio en clases ```js my_dict = {} print(type(my_dict)) my_dict = { 'avion':"bla bla bla", 'name': 'Nicolas', 'last_name' : 'molina monrroy', 'age':87 } print(my_dict) print(len(my_dict)) print(my_dict['age']) print(my_dict['last_name']) print(my_dict.get('age')) print(my_dict.get('House')) print('avion' in my_dict) print('otroqueno' in my_dict) ```my\_dict = {}print(type(my\_dict)) my\_dict = {    'avion':"bla bla bla",    'name': 'Nicolas',    'last\_name' : 'molina monrroy',    'age':87}print(my\_dict)print(len(my\_dict)) print(my\_dict\['age'])print(my\_dict\['last\_name'])print(my\_dict.get('age'))print(my\_dict.get('House')) print('avion' in my\_dict)print('otroqueno' in my\_dict)

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

que interesenat esta funcion de dict

Me gusto esta clase hecha con tuplas. Cada vez mas estoy aprendiendo de este hermoso lenguaje y sus capacidades.

No entiendo porqué mira el teclado para escribir....

get = devuelve el valor de la clave especifica, si no existe sale un mensaje none(Maneja el error)
Se cambian los corchetes por parentesis()

Ejemplo : print(my_dict.get(“ciudad”)) ------ None
print(my_dict.get(“age”)) -----------87

Buen dia campeon.

use un caso practico con api de musixmatch…


example …

[{'artist_name': 'Dua Lipa'},{'artist_album': 'Summer yet'}, {'artist_id': 13289411}]

![](https://static.platzi.com/media/user_upload/image-2ef0af5b-57ae-4bf6-822f-afdd25ac7460.jpg)
![](https://static.platzi.com/media/user_upload/image-033302da-a45d-4d34-aee1-a592e2803a48.jpg) Hola a todos!...alguien seria tan amable de ayudarme en encontrar el error? dice que está en la linea 8 pero la verdad no le encuentro la diferencia con el código del ejercicio. Muchas gracias
Por lo que veo los diccionario se entenderían muy bien con los objetos en javascript, esto facilita el intercambio de información entre el frontend y backend

[ ] Listas
( ) Tuplas
{ } Diccionario

esos diccionarios son muy parecidos a programar en bases de datos no sql como mongoDB

Diccionarios

  • estructura de datos que tienen clave, valor
  • permite operaciones CRUD

Colecciones de Python (matrices)

Hay cuatro tipos de datos de recopilación en el lenguaje de programación Python:

  • La lista es una colección ordenada y modificable. Permite miembros duplicados.

  • Tuple es una colección ordenada e inmutable. Permite miembros duplicados.

  • Conjunto es una colección desordenada, inmutable* y no indexada. No hay miembros duplicados.

  • El diccionario es una colección ordenada** y modificable. No hay miembros duplicados.

*Los elementos establecidos no se pueden cambiar, pero puede eliminar elementos y agregar nuevos elementos.

**A partir de la versión 3.7 de Python, los diccionarios se ordenan . En Python 3.6 y versiones anteriores, los diccionarios están desordenados .

Al elegir un tipo de colección, es útil comprender las propiedades de ese tipo. Elegir el tipo correcto para un conjunto de datos en particular podría significar la retención del significado y podría significar un aumento en la eficiencia o la seguridad.

my_dict = {}
print(type(my_dict))

my_dict = {
  'avion': "bla bla bla",
  'name': 'Nicolas',
  'last_name': 'Molina Monroy',
  'age': 87
}

# Print the dict
print(my_dict)

# Len of the dict
print(len(my_dict))

# Print value of a key
print(my_dict['age'])
print(my_dict['last_name'])

# Print value of a key with get() method (Return Null if there is not value)
print(my_dict.get('age'))


# Buscar el valor de una llave por el nombre de la llave
print('avion' in my_dict)
print('otroqueno' in my_dict)```

diferencia en declaraion de estructuras de datos # [ ] = Listas # ( ) = Tuplas # { } = Diccionarios

Diccionario . secuencia de valores con indices de cualquier tipo.
tipo : asociacion de indices que se le llamara claves y conjunto de valores. Esta asociacion de clave-valor es llamada part clave-valor o elemento.

Diccionarios: son estructura de datos muy util en python que permite almacenar informacion en forma de clave-valor.

Esta es la forma eficiente de manejar grandes cantidades de datos.

Parece POO

{ } --> Llaves

Un diccionario es una estructura de datos mutable y sin orden que permite almacenar pares clave-valor. Cada elemento en un diccionario consiste en una clave única y su correspondiente valor asociado. La clave actúa como un identificador único para acceder al valor correspondiente de manera eficiente.

A diferencia de las listas o las tuplas, que se acceden mediante índices numéricos, los diccionarios se acceden mediante las claves. Esto proporciona una forma rápida de buscar y recuperar valores asociados con una clave determinada.

Los diccionarios en Python son una herramienta poderosa y versátil para organizar y manipular datos de manera eficiente. Se utilizan ampliamente en diversos escenarios, como el procesamiento de datos, la configuración de aplicaciones, el almacenamiento de información estructurada y mucho más.

.len = para preguntar cuantos elementos tiene un diccionario .get = sirve para preguntar al diccionario, si existe un valor y en caso de no existir lo indicara mediante la palabra none .in = nos sirve para preguntar dentro de un diccionario si existe un valor y no indica mediante True o False.

my_dict = {
“avion”: “Un objeto volador”,
“name”: “Angelo”,
“age”: “15”
}

print(type(my_dict), my_dict)
print(len(my_dict))

print(my_dict[“avion”])
print(my_dict[“age”])
print(my_dict[“name”])

print(my_dict.get(“aaa”)) #none

print(my_dict[“aaa”]) #error

print(“avion” in my_dict) #true
print(“aaa” in my_dict)

import os
import time
import random
os.system("clear")

tijera = {
  'papel': 'gana tijera',
  'piedra': ' gana piedra',
  'tijera': 'empate'
}
piedra = {
  'papel': 'gana papel',
  'tijera': 'gana piedra',
  'piedra': 'empate'
}
papel={
  'papel': 'empate',
  'piedra': 'gana papel',
  'tijera': 'gana tijera'
}

def play():
  options = ("piedra", "papel", "tijera")
  user_selection = input("piedra, papel o tijera? =>")
  if not user_selection in options:
    print("Intenta seleccionar una opcion valida")
  print("*" * 50)
  print(f"Has seleccionado {user_selection}")
  time.sleep(3)
  comp_selection = random.choice(options)
  print(f"La computadora a elegido {comp_selection}")
  print("*" * 50)
  time.sleep(3)
  if user_selection == "tijera":
    print(tijera[comp_selection])
  elif user_selection == "piedra":
    print(piedra[comp_selection])
  elif user_selection == "papel":
    print(papel[comp_selection].capitalize())

play()

Mucho que practicar, tremenda clase.

Aparte de que la función get() no rompe el programa, te permite agregar un valor por default si la clave no existe

default_value = 50
print( my_dict.get( 'noexiste', default_value ))

# En consola => 50

Muy buena clase

mi_diccionario = {}
print(type(mi_diccionario))

mi_diccionario = {
“avion”: “vuela”,
“nombre”: “camilo”,
“apellido”: “salazar”,
“edad”: 22
}

print(mi_diccionario)

cantidad de palabras del diccionario

print(len(mi_diccionario))

#saber la posicion de la variable y da su significado
print(mi_diccionario[“edad”])
print(mi_diccionario[“avion”])

preguntar con el .get si esta en el diccionario

print(mi_diccionario.get(“valor”))

print(“avion” in mi_diccionario)
print(“valor” in mi_diccionario)

my_dict = {} # Se definen con corchetes
print(type(my_dict)) # Tienen claves y valor
# Normalmente vienen como strings
my_dict = {
  'avion': 'el avion melo',
  'name': 'Andres',
  'last_name': 'Sanchez Ballesteros',
  'age': 22
 }

print(my_dict)
print(len(my_dict))

print(my_dict['age'])
print(my_dict['last_name'])
print(my_dict.get('age')) # .get(valor) tambien obtiene el valor, se previenen errores

print('avion' in my_dict)
print('otro' in my_dict)

Tambien podemos agregar llaves-valors a nuestro diccionario

my_dict [‘ciudad’] = ‘Barcelona’

my_dict = {}
print(type(my_dict))
my_dict ={
‘auto hibrido’: ‘bla bla bla’,
‘name’ : ‘Johnny’,
‘last_name’ : ‘Delgado Rodriguez’,
‘age’: ‘45’
}

print(my_dict)
print (len(my_dict))
print (my_dict[‘age’])
print (my_dict[‘last_name’])
’’‘
print (my_dict.get(‘age’))
’’'
print (my_dict.get(‘un valor’))
print(‘auto hibrido’ in my_dict)
print(‘mototaxi’ in my_dict)

Estructura:

‘’‘
dictionary{
“clave”: “valor”
}
’’’

Un ejemplo práctico del uso de diccionarios (o también llamado objetos en otros lenguajes), con usuarios:

user1 = {
  'height':1.65,
  'last_name':"Dishman",
  'age': 35 
}

user2 = {
  'height':1.74,
  'last_name':"Larrat",
  'age': 23 
}

#Diccionario se crea mediante { }

#Su sintaxis es la siguiente ‘Dato Inicial’:“Traducción”
#para buscar el valor se llama la variable y en [“el campo a consultar”]

#por medio del get arroja un valor si está si no arroja NULL, se utilizar para evitar errores y paros de procesos en python

#Validar campos en diccionario mediante la funcion IN ejemplo: print (“Valor” in Variable)

Los diccionarios en Python…

Los objetos en JavaScript y los JSON en JavaScript comparten algunas similitudes en su estructura y propósito, pero hay algunas diferencias importantes entre ellos.

  • Un diccionario en Python es una estructura de datos que permite almacenar y acceder a valores mediante claves únicas. Los valores pueden ser de cualquier tipo de datos, incluidos otros diccionarios, y se acceden a ellos mediante sus claves. Los diccionarios en Python se definen utilizando llaves {} y separando cada par clave-valor con una coma. Por ejemplo:
mi_diccionario = {'nombre': 'Juan', 'edad': 25, 'telefono': '123456789'}

En cambio, en JavaScript, un objeto es una estructura de datos similar a un diccionario en Python. Los objetos también permiten almacenar y acceder a valores mediante claves únicas, pero a diferencia de los diccionarios en Python, los objetos en JavaScript pueden contener métodos (funciones) y no tienen una sintaxis específica para su creación. Por ejemplo:

let mi_objeto = {nombre: 'Juan', edad: 25, telefono: '123456789'};

Por otro lado, JSON (JavaScript Object Notation) es un formato de intercambio de datos que se utiliza para enviar datos entre aplicaciones. Es un formato de texto simple que es fácil de leer y escribir para humanos, y fácil de analizar y generar para las aplicaciones. JSON utiliza una sintaxis similar a la de los objetos en JavaScript y los diccionarios en Python, pero tiene algunas limitaciones en cuanto a los tipos de datos que se pueden representar. Por ejemplo:

{
    "nombre": "Juan",
    "edad": 25,
    "telefono": "123456789"
}

En resumen, las principales diferencias entre un diccionario en Python, un objeto en JavaScript y JSON en JavaScript son la sintaxis de creación, la capacidad de incluir métodos y la utilización de JSON como formato de intercambio de datos entre aplicaciones. Sin embargo, todas estas estructuras permiten almacenar y acceder a valores mediante claves únicas y son ampliamente utilizadas en sus respectivos lenguajes de programación.

Otra vez: El profe parece que se diera clase a él mismo: La sintaxis? casi no dice nada de lo que usa. Por ej. aqui no dice que cada par de datos debe ir con los 2 puntos, y al final UNA COMA… uno tiene que cometer el error al probar y aprender!!!

En clases anteriores lo mismo: No se refiere explicitamente a la sintaxis!.. aprendizaje por PRUEBA y ERROR

Considero que si bien los profesores son muy buenos es importante que manejen un buen speaking y no tengan english gaps en la pronunciacion

Los diccionarios en Python nos permiten almacenar una serie de mapeos entre dos conjuntos de elementos, llamados keys and values (Claves y Valores) Ej: ‘clave’:‘valor’, ‘name’:‘Nico’, ‘animal’: ‘gaviota’, etc. Todos los elementos en el diccionario se encuentran encerrados en un par de llaves ó corchetes { }.

my_dict = {}
print(type(my_dict))

#propiedad : definicion
my_dict = {
  'avion': "bla bla bla",
  'name': 'Nicolas',
  'last_name': 'Molina Monroy',
  'age': 87
}

print(my_dict)
# Para saber cuantos elementos hay dentro del diccionario
print(len(my_dict))

#para saber en que posicion esta ese objeto
print(my_dict['age'])
print(my_dict['last_name'])
#.get se utiliza para saber si en verdad hay un dato
print(my_dict.get('age'))

# in se utiliza para validar si un elemento esta dentro del diccionario
print('avion' in my_dict)
print('otroqueno' in my_dict)

Podemos usar los diccionarios para mejorar la legibilidad en nuestro juego a la hora de tener que ver si el usuario ganó o perdió

if user_option == pc_option:
  print('Empate')
else:
  battle_options = {
    'piedra': {
      'tijera': True,
      'papel': False
    },
    'papel': {
      'tijera': False,
      'piedra': True,
    },
    'tijera': {
      'papel': True,
      'piedra': False
    }
  }

  user_win = battle_options[user_option][pc_option];
  if user_win:
    print('Ganaste :D')
  else:
    print('Perdiste :(')

De esta manera es más fácil entender a simple vista qué sucede en cada caso

in my dick.

Cuando aprendi un poquito de python hace tiempo no me dí cuenta que la estructura de los diccionarios es muy similar a la del formato Json.

my_dict = {}
print(type(my_dict))

my_dict={
    "avion":"bla bla bla",
    "name":"Nicolas",
    "last_name":"Moreno Alca",
    "age":21
}
print(my_dict)
print(len(my_dict))

print(my_dict["name"])
print(my_dict["age"]) #Si no existe, colapsa el programa
print(my_dict.get("age")) #Si no existe lo maneja

#Comprabando si un elemento existe
print("avion" in my_dict) 




"""
Diccionarios{}
-Estructuras de datos que permite almacenar valores de diferente tipo.
-Son junto a las listas las colecciones más utilizadas y se basan en una estructura mapeada
donde cada elemento de la colección se encuentra identificado con una clave única, por lo que no
puede haber dos claves iguales. En otros lenguajes se conocen como arreglos asociativos.
-Su acceso a datos es por medio de una clave.
-Presentan claves unicas
"""
#Sintaxis 
numeroForma1={
    "num1":25,
    "num2":12
}
print(numeroForma1)
my_dict = {}
print(type(my_dict))

my_dict = {
  'avion': "bla bla bla",
  'name': 'Ivan',
  'last_name': 'Negrete Avilez',
  'age': 23
}

print(my_dict) 

#¿Cuantos elementos hay dentro del diccionario
print(len(my_dict))
#Como ir al valor que me interesa (leer)
print(my_dict['age'])
print(my_dict['last_name'])
#Otra forma de ir al valor que me interesa (leer) UTILIZAR ESTE MEJOR
print(my_dict.get('age'))
print(my_dict.get('Otro valor'))

#Validar si un dato esta dentro del diccionario
print('avion' in my_dict)
print('otro que no' in my_dict)
""" Dictionary """
my_dicto = {
  "name":"Elisabeth",
  "age": 23,
  "live": True,
  False: "window",
  True: 73,
  1000: "counter",
  -123: False,
  58: 934
}
print("my_dicto =", my_dicto)
print(type(my_dicto))

# basic operators with dictonary
print("-" * 35)
person = {
  "name": "Black",
  "last_name": "Star",
  "age": 19,
  "live": True,
  "resonance": True
}
print("person =", person)
print("person['name'] =>", person['name'])
print('person["live"] =>', person["live"])
print('person.get("resonance") =>', person.get("resonance"))
print('person.get(1234) =>', person.get(1234))
print('len(person) =>', len(person))
print('"last_name" in person =>', "last_name" in person) # solo para verificar las keys
print('"Star" in person =>', "Star" in person)

Algo para grabar sobre mármol, **
cuando Python encuentra un error se detiene el programa. **

I LOVE PYTHON

my_dic = {
	'love' : 'Python and only Python
}

my_dict = {}
print(type(my_dict))

my_dict = {
‘avion’: “bla bla bla”,
‘name’: ‘Nicolas’,
‘last_name’: ‘Molina Monroy’,
‘age’: 87
}

print(my_dict)
print(len(my_dict))

print(my_dict[‘age’])
print(my_dict[‘last_name’])
print(my_dict.get(‘age’))

print(‘avion’ in my_dict)
print(‘otroqueno’ in my_dict)