[pyar] Logica repetida en metodos

[david weil]

2010/12/3 Lucas Liendo <mindmaster en gmail.com>:
> Lo que tengo es algo de la siguiente forma :
>
> def metodo_a(self, args) :
>     if condicion_a
>         logica
>         ....
>     ....
>
> def metodo_b(self, args) :
>     if condicion_b
>         logica
>         ....
>     ....
>
> def metodo_c(self, args) :
>     if condicion_c
>         logica
>         ....
>     ....
>
> Es decir luego de condicion_X la logica es la misma para todos los metodos.
> Para aclararte mas el panorama lo que en realidad tengo es un diccionario,
> con la siguiente forma
>
> dict1 = {'key1' : (self.metodo_a, (args)),
> 'key2' : (self.metodo_b, (args)),
> 'key3' : (self.metodo_c, (args))}
>
> luego esta la logica que ejecuta lo apuntado por el diccionario :
>
> ...
> dict1 [key] [0] (*dict [key] [1])
>
> Entonces no tiene sentido que tenga definido 3 metodos diferentes si
> solamente lo que tienen distinto es una comparacion, entonces podria hacer
> algo asi :
>
> dict1 = {'key1' : (self.metodo_a, (cond_lambda_1)),
> 'key2' : (self.metodo_a, (cond_lambda_2)),
> 'key3' : (self.metodo_a, (cond_lambda_3))}
>
> y el codigo de metodo_a compara el resultado de la lambda. El problema con
> esto es que si en lugar de una expr lamba es un metodo, el mismo queda
> evaluado de antemano, por ejemplo :
>
> dict1 = {'key1' : (self.metodo_a, (self.otro_metodo(1,2))),
> 'key2' : (self.metodo_a, (self.otro_metodo(3,4))),
> 'key3' : (self.metodo_a, (self.otro_metodo(4,5))}
>
> self.otro_metodo(1,2) queda por asi decirlo evaluado (o invocado) antes de
> que se ejecute :
>
> dict1 [key] [0] (*dict [key] [1])
>
> Por lo que los valores de la tupla de argumentos siempre es constante y
> justamente eso no es lo que quiero. Me explique bien ?

Mas o menos. Porque no queda muy claro por que tenes todo en un
diccionario, etc.. por ahi con mas contexto hay mejores respuestas,
pero bueno, dado como esta el problema, podes hacer esto:

Fijate que es muy parecido a lo que pones arriba, pero en lugar de
evaluar la funcion, la pasas directamente con los argumentos como
parametros para que quien la vaya a evaluar la evalue cuando quiera
(copie tu diccionario de arriba, supongo que otro_metodo, deberia
cambiar en algun caso para ser diferentes condiciones):

dict1 = {
 'key1' : (self.metodo_a, (self.otro_metodo, (1,2))),
 'key2' : (self.metodo_a, (self.otro_metodo, (3,4))),
 'key3' : (self.metodo_a, (self.otro_metodo, (4,5)))
}

y en metodo_a:

def metodo_a(self, condfunc, args) :
    if condfunc(*args)
        logica


La otra forma, que me gusta menos, para evitar que se evalue el metodo
a la hora de crear el diccionario es meterlo en un lambda:

 dict1 = {'key1' : (self.metodo_a, ( lambda :self.otro_metodo(1,2))), .... }

en este caso, tu metodo_a recibe como parametro una funcion (el
lambda) y recien cuando la llame se va a ejecutar otro_metodo.

salud!

ps: ahi vi que ya estabas haciendo lo del lambda, pero bueno, dejo el
mail como lo habia escrito.
-- 
 There is no dark side of the moon really. Matter of fact it's all dark.