Diccionarios

Usando dir() en un diccionario encontré estos métodos

clear(): Remueve todos los elementos del diccionario

copy(): Copia todos los elementos de un diccionario y los guarda en otra variable

fromkeys(): Crea un diccionario y sus llaves son los items de una secuencia

keys = ['a', 'b', 'c', 'd', 'e']

vowels = dict.fromkeys(keys) 

print(vowels)		# {'o': None, 'i': None, 'u': None, 'a': None, 'e': None}

get(): Devuelve el valor de una llave

items(): Devuelve una tupla con una lista de las llaves y valores del diccionario

sales = { 'apple': 2, 'orange': 3, 'grapes': 4 }

print(sales.items())		# dict_items([('apple', 2), ('orange', 3), ('grapes', 4)])

keys(): Lo mismo que items(), pero con solo las llaves de un diccionario
values(): Lo mismo que items(), pero con solo los valores

pop(key): remueve y retorna un elemento de un diccionario por su llave

popitem(): remueve y retorna un item(key, value) de un diccionario

setdefault(key, default_value): retorna un valor de una llave, si no lo encuentra inserta una llave con un valor en el diccionario

update([]): Recibe una secuencia key/value y actualiza el diccionario actual con el diccionario recibido

https://www.programiz.com/python-programming/methods/dictionary

Comparto un ejercicio espectacular para practicar diccionarios 👇🏼
–> https://www.practicepython.org/exercise/2017/01/24/33-birthday-dictionaries.html

Esto es lo que en JavaScript se conoce como Objetos

Con este tipo de archivo es como se trabaja en bases de datos no relaciones como Mongo DB

Puedo tener un diccionario dentro de un diccionario

comida = {"italiana": "pizza", "mexicana" : {'deliciosas': 'taco'}}

Accedo de esta manera al objeto

comida["mexicana"]["deliciosas"]
>>>'taco'

Jugando un poco con un iterador podemos usar la clase enumerate para saber la posición, la llave, y el valor de cada llave:

for idx, key in enumerate(rae):
    print('{} : {} = {}'.format(idx, key, rae[key])) 

Un diccionario, es un conjunto de datos que están asociados por llaves:valor-de-llave (key: value) estos son muy similares a una lista en el sentido de que se puedes acceder al contenido través de su índices, que son las llave (keys) algunas de sus diferencias son las siguientes:
los índices reciben el nombre de llaves (key).

• En las listas los índices tienen que ser enteros.

• En el diccionario pueden se casi de cualquier tipo.

• Los diccionarios se declaran con {} o con la función dict. Ejemplo:

#video 24. Diccionario
import  os
#Declaraciond de un diccionario
comida_conjunto = {} 
comida_conjunto ['Pasta'] = 'Comida que tiene origen en italia'
comida_conjunto ['Pabellon Criollo'] = 'Comida que tiene origen en Venezuela'
comida_conjunto ['Arepa Criolla'] = 'Comida tradiccional de Venezuela'

cantidades = {1:'uno', 2:'dos', 3:'tres'}

if __name__ == "__main__":
  os.system('clear')
  
  print('las llaves son: ',comida_conjunto.keys()    )
  print('Los valores son: ',comida_conjunto.values() )
  print('los items son: ',comida_conjunto.items()    )
  
 #ciclar a lo largo de las llaves
  print('*'* 50)
  print('las comidas son: ')
  print('*'* 50)
  for comida_keys in comida_conjunto.keys():
      print( comida_keys)
 
  #ciclar  por  los valores
  print('*'* 50)
  print('las definiciones de las comidas son: ')
  print('*'* 50)
  for comida_value in comida_conjunto.values():
      print(comida_value)
      
  #ciclar por llaves y valores de las llaves
  print('*'* 50)
  print('las comidas y definiciones son: ')
  print('*'* 50)
  contador=0
  for comida_keys,comida_value in comida_conjunto.items():
    contador+=1
    print(  '{}.-{}:  {}'.format( contador,comida_keys, comida_value ) )

Un diccionario, es básicamente un diccionario real --> para cada palabra existe una definición .
–> para cada llave existe un valor.

http://dle.rae.es/srv/search?m=30&w=pizza

llave: pizza
valor: Especie de torta de harina amasada, encima de la cual se pone queso, tomate frito y otros ingredientes, y que se cuece en el horno.

Recuerden para borrar elementos del diccionario:
.pop(‘keyName’) -->elimina el keyname
.popitem() --> elimina el ultimo item insertado
del your_Dic_Name[‘KeyName’] --> elimina el 'keyname’
del your_Dic_Name --> elimina por completo el diccionario creado
.clear() --> Vacia el diccionario

Los datos de los diccionarios también se guardan de forma desordenada. Los diccionarios tienen dos elementos por posición la clave : y el valor y esta es separada por dos puntos. Y cada posición esta separada por una coma También se pueden almacenar varios elementos en un diccionario, los diccionarios también aceptan varios tipos de datos, también se pueden añadir duplas, listas y otros diccionarios.
Ejemplo:
Diccionario = {“azul”:”Blue”,”rojo”:red}
Print(diccionario)

Para agregar elementos al diccionario se hace lo siguiente:

Diccionario  [“amarillo”]= “yellow”

Para modificar un elemento dentro del diccionario simplemente directamente en el código se hace la modificación.

Para eliminar un elemento del diccionario se hace lo siguiente.

Del( diccionario[“amarillo”])

Para buscar un elemento dentro de un diccionario se hace lo siguiente.

Print(diccionario[“azul” ] )

Buscar un elementose utiliza el siguiente código.
Print(equipo.get(elemento,”si el elemento no esta le hace saber aquí”))

Para buscar solo las claves dentro del diccionario se hace lo siguiente:

Print(equipo.keys())
for key in diccionario.keys(): se utiliza para buscar las claves dentro del diccionario

Para mostrar los valores dentro del diccionario se hace lo siguiente:

Print(equipo.values( ) )
for valúes in diccionario.values(): se tulipa para buscar los valores dentro del diccionario

Para mostrar las claves y los valores de un diccionario se hace lo siguiente:

Print(equipo.items( ))

Si queremos iterar sobre un diccionario lo podemos hacer por sus keys, values y items

for key in my_dict.keys(): 
	print(key)

for value in my_dict.values():
	print(value)

for key, value in my_dict.items():
	print(key, value)

este tuto de David es otro nivel y se puede complementar con

https://inventwithpython.com/invent4thed/chapter0.html

Otra forma de imprimir los items, no se si sea correcta pero sirve

>>> for item in rae.items():
...     print(item)
...
('pizza', 'La comida mas deliciosa del mundo')
('pasta', 'La comida mas sabrosa de italia')```

un Diccionario seria como un Objeto en Javascript ?

Un diccionario es el equivalente a un objeto en otros lenguajes, ya que se conforma de igual manera: ‘key’ = ‘value’
La ventaja de python sobre otros lenguajes es que maneja métodos para eliminar elementos, limpiar el diccionario, copiar, y varios más. Evitándonos hacer tantas iteraciones y creando capas de diccionarios (ó objetos) con los datos ya filtrados.

excelente explicación

>>> dir(rea)
['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

### Diccionarios

Los diccionarios se conocen con diferentes nombres a lo largo de los lenguajes de programación como HashMaps, Mapas, Objetos, etc. En Python se conocen como **Diccionarios**.

Un diccionario es similar a una lista sabiendo que podemos acceder a través de un indice, pero en el caso de las listas este índice debe ser un número entero. Con los diccionarios puede ser cualquier objeto, normalmente los verán con **strings** para ser más explicitos, pero funcionan con muchos tipos de llaves…

Un diccionario es una asociación entre llaves(**keys**) y valores(**values**) y la referencia en Python es muy precisa. Si abres un diccionario verás muchas palabras y cada palabra tiene su definición.

Para iniciar un diccionario se usa `{}` o con la función `dict`

Estos también tienen varios métodos. Siempre puedes usar la función `dir` para saber todos los métodos que puedes usar con un objeto.

Si queremos ciclar a lo largo de un diccionario tenemos las opciones:

`keys`: nos imprime una lista de las llaves
`values`: nos imprime una lista de los valores
`items`: nos manda una lista de tuplas de los valores

ejemplos:

```pythonn
>>> rea.items()
dict_items([('Pizza', 'la comida mas deliciosa del mundo'), ('Pasta', 'la Comida mas sabrosa de Italia')])
>>> for key in rea.keys():
...     print(key)
...
Pizza
Pasta
>>> for key in rea.values():
...     print(key)
...
la comida mas deliciosa del mundo
la Comida mas sabrosa de Italia
>>> for key, value in rea.items():
...     print(key, value)
...
Pizza la comida mas deliciosa del mundo
Pasta la Comida mas sabrosa de Italia

¿El diccionario es como si fuera el JSON de JavaScript?

En definitivo, Hasta el momento, David es el mejor profesor por mucho en Platzi.

Los diccionarios en Python son una estructura de datos que permite almacenar su contenido en forma de llave y valor. Un diccionario en Python es una colección de elementos, donde cada uno tiene una llave key y un valor value.

print('🍕🍕🍕')

Con diccionarios y su metodo get() se puede implementar un “case statement” (no soportado por python hasta la version 3.10)

Con los diccionarios, podemos ciclar a lo largo de solo las llaves, solo los valores o también los dos.

Lo curioso, es que el nombre del objeto (Diccionario) Viene al mismo sistema que se manejan en los diccionarios. Así que tenemos una abstracción muy precisa. Lo gracioso es que la sola declaración de un diccionario en Python, podemos contener todo un diccionario sin problemas.

Los diccionarios tienen una estructura muy particular, en la que tenemos llaves y tenemos los valores de esas llaves, tanto las llaves cómo los valores, pueden ser casi cualquier objeto.

Diccionario concepto: En los diccionarios los datos se encierran entre { }, Un diccionario es una estructura de datos y un tipo de dato en Python con caracateristicas especiales que nos permiten almacenar cualquier valor ya sea int, float, booleano, string, listas, funciones. Estos se identifican por una clave (Key), ademas son tipos de datos mutables.

Uso del diccionario: Para definir un diccionario, se encierra el listado de valores entre llaves. Las parejas de clave y valor se separan con comas, y la clave y el valor se separan con dos puntos

diccionario = {'nombre' : 'jose', 'edad' : 26, 'cursos': ['Python','Django','JavaScript'] }

–> Podemos acceder al elemento de un Diccionario mediante la clave de este elemento, como veremos a continuación:

print diccionario['nombre'] #jose
print diccionario['edad']#26
print diccionario['cursos'] #['Python','Django','JavaScript']

–> También es posible insertar una lista dentro de un diccionario. Para acceder a cada uno de los valores usamos los índices:

print diccionario['cursos'][0]#Python
print diccionario['cursos'][1]#Django
print diccionario['cursos'][2]#JavaScript

https://data-flair.training/blogs/python-dictionary/

Alguien intento crear un diccionario con keys numericos?
Yo lo intente me salio un error, el diccionario solo funciona con palabras como keys?

productos={1,2,3,4,5}
productos[1]="hola"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support item assignment
productos["1"]="hola"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support item assignment

Alguna info adicional de los diccionarios https://devcode.la/tutoriales/diccionarios-en-python/

Gracias!!

Packaging Python Projects

Packaging Python Projects

https://wilsonmar.github.io/python-install/

la diferencia contra los objetos en otros lenguajes esque es muy practico y facil de aprender

De a cuerdo a la prueba que hice popitem siempre me devuelve la ultima llave con mas su valor registrado en el diccionario, pero según leí en documentación popitem debería agarrar aleatoria mente mostrar la llave y el valor y quitarlo de la lista

Hola compañeros, les dejo unos ejemplos sencillos, espero les ayude.

print('Ejemplos'.center(50,'-'))
###mostrando datos

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print (dict['Name'] ," : ", dict['Name'])
print (dict['Age'] , " : ", dict['Age'])
print('*'.center(50,'-'))
##actualizando y agredando nueva entrada
dict['Age'] = 8 # update existing entry
dict['School'] = "DPS School" # Add new entry

print (dict['Age'], " : ", dict['Age'])
print (dict['School'], " : ", dict['School'])
print('*'.center(50,'-'))
###eliminando
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print(dict)
print('*'.center(50,'-'))
#print(type(dict))
del dict['Name'] # elimina key y value, donde name es la key a eliminar
print(dict)
dict.clear()     # elimina todas las entradas del diccionario, lo deja vacio
print(dict)
dict['a'] = 'a' # aca podemos observar que luedo de vaciar el diccionario podemos agregar valores de nuevo
print(dict)
del dict         # elimina el diccionario por completo, ya no existiria diccionario
print(dict)
dict['a'] = 'a'  # aca observamos que nos lanza un error ya que el dict ya no lo podemos utilizar
print(dict)

#print ("dict['Age']: ", dict['Age'])
#print ("dict['School']: ", dict['School'])

Ejemplo Evitando el error en un diccionario

<rae = {}
rae['pizza'] = 'La comida mas deliciosa del mundo'
rae['pasta'] = 'La comida de Italia'
rae['helado']>

raceback (most recent call last):
File “<stdin>”, line 1, in <module>

< a = rae.get('helado', None)
print(a)>

None

<a = rae.get('pizza', None)
print(a)>

La comida mas deliciosa del mundo

es muy importante tener claro
keys: nos imprime una lista de las llaves
values nos imprime una lista de los valores
items. nos manda una lista de tuplas de los valores

David es un gran maestro

Genial!!

a function as a dictionary key 😃

def say_hello():
    print("Hello!")

o = {'key': "value", 'say_hello': say_hello}

o['key']
o['say_hello']()

Seguramente vamos amar la comodida de update 😄

rae1['ice_cream'] = 'Nieve'
rae.update(rae1)
print(rae)
{'pizza': 'Comida italiana rica', 'pasta': 'Ramen italiano', 'ice_cream': 'Nieve'}

Function (.get)

Diccionarios

metodos de diccionario dir(dict)

import sys

clients = ['pablo', 'ricardo']

def create_client(client_name):
	global clients

	if client_name not in clients :
		clients.append(client_name)
	else:
		print ('Client already is in the client\'s list')

def list_clients():
	for idx, client in enumerate(clients):
		print ('{} : {}'.format(idx, client))


def updated_client(client_name, updated_client_name):
	global clients

	if client_name in clients :
		index = clients.index(client_name)
		clients[index] = updated_name
	else:
		print ('Client is no it client\'s list')


def delete_client(client_name):
	global clients

	if client_name in clients:
		clients.remove(client_name)
	else:
		print('Client is not in client\'s list')

def search_client(client_name):

	for client in clients:
		if client != client_name:
			continue
		else:
			return True


def _print_welcome():
	print ('WELCOME TO PLATZI VENTAS')
	print ('*' * 50)
	print ('What would you like to do today ? ')
	print ('[C]reate client')
	print ('[L]ist client')
	print ('[U]pdated client')
	print ('[D]elete client')
	print ('[S]earch client')


def _get_client_name ():
	client_name = None

	while not client_name:
		client_name = str.lower(input('What is the client name ? '))

		if client_name == 'exit':
			client_name = None
			break

	if not client_name:
			sys.exit()

	return client_name

if __name__ == '__main__':
	_print_welcome()

	command = input()
	command = command.upper()

	if command == 'C':
		client_name = _get_client_name()
		create_client(client_name)
		list_clients()
	elif command == 'L':
		list_clients()
	elif command == 'U':
		client_name = _get_client_name()
		updated_name = str.lower(input ('What is the updated client name ? '))
		updated_client(client_name, updated_name)
		list_clients()
	elif command == 'D':
		client_name = _get_client_name()
		delete_client(client_name)
		list_clients()
	elif command == 'S':
		client_name = _get_client_name()
		found = search_client(client_name)

		if found:
			print('The client is in the client\'s list')
		else:
			print('The client: {} is not in our client\'s list'.format(client_name))

	else:
		print ('Invalid command')

Al igual que con las listas, si “copias” con el operador de asignación ’ = ’ tu diccionario a otra variable, estarás referenciando al mismo espacio de memoria ambos diccionarios.

<>>>
>>> dir(rae)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
>>>>

Aquí mi código

a=x.setdefault(‘w’,5)
retonar el valor de w, sino retorna el diccionario añadiendo w como llave y 5 como valor, es decir,
…‘w’:5}

Un Diccionario es una estructura de datos y un tipo de dato en Python con características especiales que nos permite almacenar cualquier tipo de valor como enteros, cadenas, listas e incluso otras funciones. Estos diccionarios nos permiten además identificar cada elemento por una clave (Key).

This is different with Python 2, good info

Type “help”, “copyright”, “credits” or “license” for more information.

rae = {}
dir(rae)
[‘class’, ‘contains’, ‘delattr’, ‘delitem’, ‘dir’, ‘doc’, ‘eq’, ‘format’, ‘ge’, ‘getattribute’, ‘getitem’, ‘gt’, ‘hash’, ‘init’, ‘init_subclass’, ‘iter’, ‘le’, ‘len’, ‘lt’, ‘ne’, ‘new’, ‘reduce’, ‘reduce_ex’, ‘repr’, ‘setattr’, ‘setitem’, ‘sizeof’, ‘str’, ‘subclasshook’, ‘clear’, ‘copy’, ‘fromkeys’, ‘get’, ‘items’, ‘keys’, ‘pop’, ‘popitem’, ‘setdefault’, ‘update’, ‘values’]

La operación principal en un diccionario es guardar un valor con una llave y extraer el valor dando ésta llave.

dict = {}  #defines an empty dictionary
dict[k] = x #stores x associated to key k
dict[k] #retrieves the item with key k
del dict[k] #removes the item with key k```

.get(): Para evitar que suceda un error.

Interesante el enfasis que hace el profesor David en utilizar la función dir para poder ver los diferentes metodos de las funciones. Pero es importante saber donde obtener la información.

Tenemos la posibilidad de manejar el error a la hora de tener un valor con los dics, con el método get(llave, lo_que_aparece_sino_está), de una forma más elegante.

Para que no se termine tu programa con los errores, hay que saberlos manejar.

nombre_dic[Nombre de la llave] = 'Valor que esta tiene', forma de agregar valores a nuestros dics.

Los diccionarios, son también llamados: Hash-maps, maps, objects.

tuve que partirlo yo mismo para hacer las pruebas de cada funcion… las funciones estan bien hechas pero sin explicacion o demostracion de como lo hace es solo cambiar el codigo pero sin entendimiento…

excelente opción, como un json :v

Para complementar la clase les comparto un excelente video de la Pycon 2017. No tiene desperdicio.
.

Modern Python Dictionaries A confluence of a dozen great ideas

Por: Raymond Hettinger
.

>>> for key in rae.keys():
...     print(key)
... 
pizza
pasta
>>> for value in rae.values():
...     print(value)
... 
La comida mas deliciosa del mundo
La comida mas sabrosa de italia
>>> for item in rae.items():
...     print(item)
... 
('pizza', 'La comida mas deliciosa del mundo')
('pasta', 'La comida mas sabrosa de italia')
>>> for key, value in rae.items():
...     print(key, value)
... 
pizza La comida mas deliciosa del mundo
pasta La comida mas sabrosa de italia

es lo mismo que JSON??