busqueda en diccionario, pero sin la palabra exacta

[Sebastian Martin Artaza Saade]

Muchisima gracias a todos, voy a tratar de entender de una vez por toda las
funciones lambda creo que hay radica la orientación a lista o lo que en
python se puede hacer con pocas lineas que requieren muchas más en otros
lenguajes,  la solucion de Arnau Sanchez es la que voy a implementar, debido
a lo que estoy haciendo salio este inncomveniente y no  quiero  hacer un
diccionario de busqueda inteligente ni nada por el estilo aunque para algo
más especifico creo que está bueno lo que plantea Luis Peralta, por otro
lado necesito que se guarda en la lista de forma 0,1,2 por eso no lo
convierto en binario, pero cuando consulto si lo hago y necesito que sea en
binario y de la forma que lo muestro una lista de 0 y 1 porque eso son (creo
que es lo que mejor representa a lo que estoy haciendo), habia plantearlo
hacerlo en hexa pero muy poca veces lo necesito por eso le cree una funcion
a la clase que contiene la lista de binario, está funcion convierte de lista
de binario a hexa pero lo que planteo Chema Cortes ya lo habia pensado y
descartado aunque no me lo habia planteado de manera tan simple.
    Por otra parte le comento el proyecto que a pesar de tener unas 200
pocas lineas y de 10 horas de trabajo real entre laburo y facu,  ya está por
terminar la primera etapa, se trata de simular el comportamiento de un
procesador de ciclo único, para esto cree varias clases como por ejemplo
ExtendSign que toma una lista de binario y completa extendiendo con el signo
del primero, tambien hice los multiplexores, sumadores, shift left, alu,
hice la clase de banco de registro y la clases que simulan las memoria de
datos y de instrucciones y los probe a los objetos por separo despues
juntandolos y andan de 10 : ), y ahora estoy haciendo el control para que
uno llene la memoria de instruccion y el procesador ande y simule el
comportamiento de uno real, para eso despues voy a tener que hacer un
compilador para que uno escriba codigo assembler  en un archivo de texto y
lo compile y llene la memoria de instruccion y datos (diccionarios funcionan
como memorias reales) y haga andar la maquina y muestre como queda la
memoria de datos y el banco de registro, la idea es hacer un programa
similar al  spim http://pages.cs.wisc.edu/~larus/spim.html solo que ese usa
todas las intrucciones del mips y yo quiero hacer uno de 8 instrucciones el
que enseña en la facu, y despues poder ponerle nuevas instrucciones por
consola (2º etapa del proyecto) y luego de manera grafica (3º etapa del
proyecto) y que el compilador se amplie solo (4º etapa) y lo estoy haciendo
por hobbi, no es un practico de la facu ni nada por el estilo, queria
comentarle que recien empiezo con python y me parece de no creer lo que se
puede hacer en cuanto rapido y sensillo de programar y no llevo ni un mes es
este lenguaje (y todabia no entiendo las funciones lambda :( bien tenga
tiempo soluciono eso ) y más de 8 años en otros pero me quedo con este sin
duda.
Bueno muchisima gracias a todos y cuando termine voy a subir el proyecto.

El día 29/08/07, Chema Cortes <pych3m4 en gmail.com> escribió:
>
> El 28/08/07, Sebastian Martin Artaza Saade <martin.artaza en gmail.com>
> escribió:
> > Hola que tal, es la mi primera pregunta en está lista y espero que no
> viole
> > ningun tipo de regla.
> > Lo que quiero hacer es lo siguiente:
> > Tengo un diccionario de la siguiente manera:
> > a = { '[0,0,0,2,2,2,2,2,2]' :[0,1,0],  '[0,2,1,2,2,2,2,2,2]' :[1,1,0],
> > '[0,1,2,2,2,2,2,2,2]' :[0,0,1],   '[1,2,2,1,0,0,0,0,0]' :[0,1,0],
> > '[1,2,2,1,0,0,0,1,0]' :[1,1,0],
> > '[1,2,2,1,0,0,1,0,0]' :[0,0,0],   '[1,2,2,1,0,0,1,0,1]' :[0,0,1],
> > '[1,2,2,1,0,1,0,1,0]' :[1,1,1]  }
> > ese diccionario es la tabla de control de un alu del mips simplificado,
> > bueno no viene al caso, lo que necesito es:
> >
> > quiero consultar el diccionario y donde en la clave halla un 2, lo tome
> como
> > indiferente, por ejemplo si consulto cual es el significado de
> > '[1,0,0,1,0,1,0,1,0]' me de [1,1,1], debido que en el diccionario está
> el
> > elemento '[1,2,2,1,0,1,0,1,0]'  (el ultimo) y lo que pregunte es igual
> salvo
> > en los elemento que hay un 2, no se si me explico, otro ejemplo si vemos
> el
> > primer elemento empieza con 0,0,0 y despues es todo 2, si yo pregunto
> por
> > '[0,0,0,(cualquiercosa)]' me de [0,1,0]. Lo que si tiene que ser igual
> es
> > los 1 y los 0 el 2 es el unico indiferente.
>
> La solución de Arnau creo que coincide con lo que pides, tal vez
> usando una función de comparación tal que así:
>
> def mip_cmp(a,b):
>         def _cmp(i,j):
>                 if i==2 or j==2: return True
>                 else: return i==j
>
>         return False not in [_cmp(i,j) for (i,j) in zip(a,b)]
>
>
> De todos modos, lo que quieres hacer se suele implementar (casi
> siempre) con un par de números en binario, donde uno de ellos hace de
> máscara:
>
> [0,0,0,2,2,2,2,2,2]
> -->  (int("000111111",2),int("000111111",2))  ==(n,mask)
> [0,2,1,2,2,2,2,2,2] -->  (int("011111111",2),int("010111111",2))
> [0,1,2,2,2,2,2,2,2] -->  (int("011111111",2),int("001111111",2))
>
> Donde se cumple que n&mask==mask
>
>
> De esta manera tendríamos...:
>
> tabla = (
> (0x03f,  0x03f,  [0,1,0]),
> (0x0ff,   0x0bf,  [1,1,0]),
> (0x0ff,   0x07f,  [0,0,1]),
> (0x1e0, 0x0c0, [0,1,0]),
> (0x1e2, 0x0c0, [1,1,0]),
> (0x1e4, 0x0c0, [0,0,0]),
> (0x1e5, 0x0c0, [0,0,1]),
> (0x1ea, 0x0c0, [1,1,1])
> )
>
> def resultado(item):
>   for n,mask,res in tabla:
>     if (item|mask)==n:
>       return res
>   raise LookupError
> _______________________________________________
> Python-es mailing list
> Python-es en aditel.org
> http://listas.aditel.org/listinfo/python-es
>