276 lines
7.2 KiB
Python
276 lines
7.2 KiB
Python
"""
|
|
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))
|