Busqueda Parcial con Tuplas como Clave de Diccionario

[Alejandro Novo]

Lo primero gracias por las respuestas, he aprendido mucho con ellas, sobre
todo con las list comprenhension de python, que son realmente útiles y
elegantes :)

Después de probar las soluciones que me planteabais he optado por esta
solución:

for x in d:
   e, lx = x
   try:
      dAux[lx].append(d[x])
   except KeyError:
      dAux[lx] = [d[x]]


Como recordareis el principal problema que tenía era el tamaño del
diccionario. Con las solución que yo había planteado, lo que hacía era
recorrer n veces (siendo n el tamaño de la lista de claves) el diccionario
entero, lo que hacía incrementar el tiempo del proceso.

Ahora lo que hago es recorrer únicamente 1 vez el diccionario, agilizando en
gran medida el tiempo y rebajando el coste de la operación.

Me han venido genial vuestros aportes para "jugar" con las posibilidades que
me da python, y espero poder aplicarlas en adelante.

De nuevo gracias.

Un saludo

>  Alejandro,
>
> Primero, tu bucle quedaría mucho más compacto usando una list
> comprehension:
>
> dAux = {}
> for lx in l:
>        dAux[lx] = [d[x] for x in d if lx in x]
>
> En cuanto a velocidad, seguramente así vaya un poco más rápido, pero la
> diferencia no será sustancial. Si quieres que realmente vaya mucho más
> rápido,
> tendrías que generar estructuras auxiliares antes de la búsqueda. Por
> ejemplo,
> podrías generar este diccionario:
>
> de {('a', 'b'): ['1', '2', '3']} ...
>
> podrías sacar {'a': ['1', '2', '3']  'b': ['1', '2', '3'] ... }
>
> y luego, al recorrer este diccionario la búsqueda sería seguro mucho más
> ágil.
>
> La forma de encarar el problema depende de muchas cosas, de la naturaleza
> de los
> datos, cuándo los obtienes, si estos se van modificando o son estáticos,
> etc.
> Pero al final, la idea es básicamente la misma, trata tus datos antes de
> entrar
> en el algoritmo de búsqueda.
>
> nos cuentas
>
> arnau
>
> ------------------------------------------------------------------------------------------------------------
>
> Dependiendo de los datos que tengas esto podria ser mas rapido:
>
> l = dict.fromkeys(l)
> for elem in d:
>    for elem2 in elem:
>        if elem2 in l:
>            dAux.setdefault(elem2, []).append(d[elem])
>
>
> obtienes dos beneficios:
>
> * evitas iterar sobre *toda* la lista l en cada iteracion del bucle
> externo
>
> * al convertir l en un diccionario la comprobacion 'elem2 in l' se
> calcula en tiempo constante.
>
>
> si la longitud media de las claves es menor que la longitud de l este
> algoritmo sera mas rapido.
>
>
> Otra cosa, es posible que una clave contenga dos elementos de l, por
> ejemplo ('b', 'd')? Si la respuesta es 'no' podrias forzar la
> finalizacion del bucle interno con un break una vez verificado que elem2
> esta en l.
>
>
>
>
> Saludos
> --
> ^X^C
>
> Alexis Roda
> Universitat Rovira i Virgili
> Reus, Tarragona (Spain)
>