# [ ] = Listas
# ( ) = Tuplas
# { } = Diccionarios
Introducción y primeros pasos con Python
¿Por qué aprender a programar en Python?
Accede a la versión más actualizada de este contenido
Herramientas del curso
Tu primer programa con Python
Herramientas para programar con Python
Playgrounds: Te doy la bienvenida a los ejercicios interactivos
Variables
Playgrounds: Modifica el valor de una variable
Quiz: Introducción y primeros pasos con Python
Tipos de datos en Python
Tipos de datos
Strings
Numbers
Booleans
Transformación de tipos
Playgrounds: Imprime el formato adecuado
Operadores y condicionales
Operadores aritméticos
Operadores de comparación
Comparación de números flotantes
Operadores lógicos: and y or
Operador lógico not
Condicionales
Proyecto: condicionales
Playgrounds: Identifica si un número es par o impar
Listas y diccionarios
String recargado
Indexing y slicing
Listas
Métodos de listas
Playgrounds: Agrega, modifica y elimina elementos de una lista
Tuplas
Proyecto: tuplas
Diccionarios: definición y lectura
Diccionarios: inserción y actualización
Playgrounds: Agrega, modifica y elimina elementos de un diccionario
Ciclos
Loops: While
Loops: For
Playgrounds: Agrega solo los números positivos de una lista
Ciclos anidados
¡Es tu turno: crea un tutorial!
Cierre
Proyecto: aplicando ciclos
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Aportes 93
Preguntas 10
# [ ] = 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)
Algunos métodos de los diccionarios: https://docs.hektorprofe.net/python/metodos-de-las-colecciones/metodos-de-los-diccionarios/
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:
{}
.[]
.len(diccionario)
devuelve el número de elementos en el diccionario.for
.dict()
se utiliza para crear un diccionario vacío.keys()
devuelve una lista de todas las claves del diccionario.values()
devuelve una lista de todos los valores del diccionario.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:
clear()
: Elimina todos los elementos del diccionario.copy()
: Devuelve una copia superficial (shallow copy) del diccionario.get(key, default=None)
: Devuelve el valor de la clave especificada. Si la clave no existe, devuelve el valor predeterminado (por defecto None
).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.popitem()
: Elimina y devuelve el último par clave-valor del diccionario en forma de tupla.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
).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:
len(diccionario)
: Devuelve el número de elementos en el diccionario.dict(iterable)
: Crea un diccionario a partir de una secuencia de pares clave-valor (por ejemplo, una lista de tuplas).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
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)
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
<#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)>
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’}.
Conceptos:
[ ] = Listas
( ) = Tuplas
{ } = Diccionarios
Me gusto esta clase hecha con tuplas. Cada vez mas estoy aprendiendo de este hermoso lenguaje y sus capacidades.
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}]
✅
[ ] Listas
( ) Tuplas
{ } Diccionario
esos diccionarios son muy parecidos a programar en bases de datos no sql como mongoDB
Diccionarios
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(“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()
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)
print(len(mi_diccionario))
#saber la posicion de la variable y da su significado
print(mi_diccionario[“edad”])
print(mi_diccionario[“avion”])
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 objetos en JavaScript y los JSON en JavaScript comparten algunas similitudes en su estructura y propósito, pero hay algunas diferencias importantes entre ellos.
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)
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?