Apuntes_Python/01_curso/Modulo_2/2-4b_diccionarios.py

"""
    DICCIONARIOS

    Los diccionarios también pueden ser conocidos como "memorias asociativas"
    o "arreglos asociativos".

    Los diccionarios se indexan con claves, pueden ser cualquiera de tipo inmutable.
    , en vez de un rango numérico como en las secuencias.

    Las tuplas pueden usarse como claves si solamente contienen cadenas, números o
    tuplas; si una tupla contiene cualquier objeto mutable directa o indirectamente,
    no puede usarse como clave. Ni tampoco listas, ya q se modifican con append() y extend().

    Los diccionarios se pueden pensar como un conjunto no ridenado de pares >clave: valor<
    siendo las claves UNICAS.
           gente = {} vacia
           gente = {'pepe': 123, 'joel': 234 }

    Las operaciones principales son:

        - Guardar con una clave:
            gente['raul'] = 345

        - Extraer de un dict. con una clave:
            gente['joel']  # 234

        - Borrar con del clave
            del gente['pepe']

        - Listar claves:
            list(gente.keys())

        - Ordenar:
            sorted(gente.keys())

        - condicional busqueda:
            'joel' in gente #True
            'raul' not in gente #False

        CONSTRUCTOR dict()
"""

# Formas de definir un diccionario
precios = {'manzana': 3.5, 'banana': 4.5, 'kiwi': 6.0, 'pera': 3.75}

precios = dict(manzana=3.5, banana=4.5, kiwi=6.0, pera=3.75)

precios = dict([('manzana', 3.5), ('banana', 4.5), ('kiwi', 6.0), ('pera', 3.75)])


# Acceso a elementos por claves
precios['manzana']  # 3.5
precios['banana']  # 4.5
precios['kiwi']  # 6.0
precios['pera']  # 3.75
#precios['melon']  # KeyError

# Agregar un elemento (clave-valor)
precios['melon'] = 7.5


# Actualizar un elemento (clave-valor)
precios['manzana']  # 3.0


# Borrar un elemento (clave-valor)
del precios['kiwi']


# Pertenencia
'banana' in precios
'sandia' not in precios

#############################################
# 
# Propio, diccionario a partir de 2 listas:
pregs = ['nombre','altura','edad']
resps = ['cilantro', '16', 'a veces']

pyr = {}
for p, r in zip(pregs, resps):
    pyr[p] = r

# En una linea
pyr1 = {p: r for p, r in zip(pregs,resps)}

# Mas efectivo
pyr2 = dict(zip(pregs, resps))

##############################################        

# METODOS en los diccionarios

precios = {'manzana': 3.5, 'banana': 4.5, 'kiwi': 6.0, 'pera': 3.75}

# Cantidad de elementos clave-valor
len(precios)


# Devuelve el valor de clave indicada, se puede definir una por defecto 
# si no existe, si no se indica None.

precios.get('manzana')      # 3.5
precios.get('melon')        # None 
precios.get('melon', 0.00)  # 0.00


# Si existe devuelve el valor, sino, es creado con el valor default o None
# en caso de no indicarlo

precios.setdefault('banana')        #4.5
precios.setdefault('sandia')        #None
precios.setdefault('pepino', 6.6)   #6.6


# Actualizacion de un diccionario

precios.update({'banana': 4.0, 'durazno': 5.5})
precios.update([('durazno', 5.1)])


precios.keys() # Retorna lista con claves del diccionario

precios.values() # Retorna lista con los valores del diccionario

precios.items() # Retorna lista con los items  del diccionario


# Sacar elemento segun clave, se puede definir un default si no lanza KeyError

precios.pop('manzana')
precios.pop('melon', 0.00)
# precios.pop('melon') 


# Sacar elemento segun LIFO (LAST IN FIRST OUT, estilo pila)
precios.popitem()


# Copia "superficial" de diccionarios
precios_cp = precios.copy()

# Borra los elementos del diccionario
precios.clear()


# ITERANDO DICCIONARIOS
#    Vista dinamica de las entradas del diccionario

precios = {'manzana': 3.5, 'banana': 4.5, 'kiwi': 6.0, 'pera': 3.75}

# Vista de Diccionarios

claves = precios.keys()
valores = precios.values()
items = precios.items()

precios['melon'] = 5.5  # Agregamos melon al diccionario

# Iteracion de diccionarios

for fruta, precio in precios.items():
    print("Precio de", fruta, ": $:", precio)

# La consulta a las variables previas asignadas como 
# claves, valores e items. Mantienen sus valores actualizados según
# diccionario (apuntan a la misma direccion de memoria?)

print('\n',claves,'\n'*2, valores,'\n'*2, items)

########################################################################
#
# CONDICIONES QUE DEBEN CUMPLIR LAS CLAVES EN DICCIONARIOS
#
# Los diccionarios están implentados internamente como una tabla hash
# por lo que las claves deben ser objetos **Hasheables**
# 
#   **hashable es un obejto que tiene un valor hash
#     que nunca cambia durante el ciclo de vida del programa
#
#   Debe tener definido el metodo mágico __HASH__
#   Debe poder ser comparado con otros objetos, es decir
#   Debe tener definido el metodo __EQ__
#   Deben ser iguales cuando su hash son iguales
#
#   Todos los objetos inmutables ofrecidos Built-In en Python
#   son hasheables. Ej,:
#       *strings    *numeros    *tuplas
#       *fechas
#
#   Los contenedores mutables como las listas, conjuntos,
#   diccionatios son NO hasheables
#
#   Los objetos que son definidos por instancias de clases
#   definidas por el usuario SON hasheables por defecto
#
#   Los hash al compararse, siempre son distintos a otros obejos,
#   salvo a si mismos.
#
#   Su valor hash se deriba de su ID que es único
#
#########################################################################

# Resumen 2
dict([('pepe', 1234), ('joel', 2345), ('raul', 3456)])

# Creación por comprensión de diccionarios desde expresiones arbitrarias clave/valor
otro = {x: x ** 2 for x in (2, 4, 6)}  # {2: 4, 4: 16, 6: 36}

# Si las claves son cadenas simples, se pueden especificar usando argumentos por claves****
otro = dict(pepe=1234, joel=2345, raul=3456)  # {'pepe': 1234, 'joel': 2345, 'raul': 3456}

# ITERACION  .items()

caayeros = {'xella': 'er-peazo', 'lloga': 'er-siznne'}

for k, v in caayeros.items():
    print(k, v)

# Al iterar una secuencia se puede obtener tanto el índice como el valor correspondiente,
# usando la finción "enumerate()"

for k, v in enumerate(caayeros):
    print(k, v)

# 0 xella
# 1 lloga


# Iterar sobre 2 o mas secuencias, emparejando valores con "zip()"

pregs = ['nombre', 'objetivo', 'color favorito']
resps = ['Yorldan', 'volar', 'diciembre']

for p, r in zip(pregs, resps):
    print('Cual es tu {0}? {1}.'.format(p, r))

# Iterar en orden inverso

for i in reversed(range(1, 10, 2)):
    print(i)

# Iterar secuencia ordenada "sorted()"
# sorted devuelve una nueva lista ordenada
#   recordatorio set() <--- conjunto
canasta = ['manzana', 'naranja', 'manzana', 'pera', 'naranaja', 'banana']
for f in sorted(set(canasta)):
    print(f)

# A veces, es mas simple y seguro crear una nueva lista,
# en vez de cambiar una lista mientras se recorre.
import math

datos = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
datos_filtrados = []
for valor in datos:
    if not math.isnan(valor):
        datos_filtrados.append(valor)

# datos_filtrados ---> [56.2, 51.7, 55.3, 52.5, 47.8]


#   Recopilacion de metodos de mas arriba
# gente['raul'] = 345
# otro = dict(pepe=1234, joel=2345, raul=3456)
# otro = { x: x ** 2 for x in (2, 4, 6) }

#  Usados de base crear Diccionarios con dos listas
pyr = {}
for p, r in zip(pregs, resps):
    pyr[p] = r

pyr1 = {p: r for p, r in zip(pregs, resps)}

pyr2 = dict(zip(pregs, resps))