On 26Mar2015 07:27, Manuel Graune <manuel.gra...@koeln.de> wrote:
Gary Herron <gher...@digipen.edu> writes:
On 03/25/2015 10:29 AM, Manuel Graune wrote:
def test1(a, b, condition="True"):
for i,j in zip(a,b):
c=i+j
if eval(condition):
print("Foo")
test1([0,1,2,3],[1,2,3,4],"i+j >4")
print("Bar")
test1([0,1,2,3],[1,2,3,4],"c >4")
print("Bar")
test1([0,1,2,3],[1,2,3,4],"a[i] >2")
This is nicely done with lambda expressions:
To pass in a condition as a function:
test1([0,1,2,3],[1,2,3,4], lambda i,j: i+j<4)
To check the condition in the function:
if condition(i,j):
This seems to be the right direction and a good solution for simple
cases. Unfortunately this:
To get the full range of conditions, you will need to include all the variables
needed by any condition you can imagine. So the above suggestions may need to
be expanded to:
... lambda i,j,a,b: ... or whatever
and
... condition(i,j,a,b) ... or whatever
is not as concise as I had hoped for. Is there a possibility to do
(maybe with a helper function inside the main function's body) solve
this more elegantly? I'm thinking of some combination of e. g. **kwargs,
dir() and introspection.
Yes.
Consider locals():
https://docs.python.org/3/library/functions.html#locals
which is a built in function returning a copy of the current local variables in
a dict. Example:
condition_test = lambda vars: vars['i'] + vars[j'] > 4
def test1(a, b, condition):
for i, j in zip(a,b):
c = i + j
if condition(locals()):
print("Foo")
test1([0,1,2,3], [1,2,3,4], condition_test)
This passes the local variables inside test1() to "condition" as a single
parameter. Now, I grant that vars['i'] is a miracle of tediousness. So consider
this elaboration:
from collections import namedtuple
condition_test = lambda vars: vars.i + vars.j > 4
def test1(a, b, condition):
for i, j in zip(a,b):
c = i + j
vars = locals()
varnames = list(vars.keys())
varstupletype = namedtuple("locals", varnames)
varstuple = varstupletype(*[ vars[k] for k in varnames ])
if condition(varstuple):
print("Foo")
Here, the condition_test function/lambda uses "vars.i" and "vars.j", which i
think you'll agree is easier to read and write. The price is the construction
of a "namedtuple" to hold the variable name values. See:
https://docs.python.org/3/library/collections.html#collections.namedtuple
So the (untested) code above:
- get the locals() as before
- get the names of the variables; it is important to have this in a array
because we need to access the values in the same order when we make the tuple
- make a new namedtuple class "varstupletype", which is used to make the named
tuple
- make the named tuple itself with the values of the variables in order
If you're writing a lot of test functions like test1 you can push the
namedtuple stuff off into a helper function:
def vartuple(vars):
varnames = list(vars.keys())
varstupletype = namedtuple("locals", varnames)
varstuple = varstupletype(*[ vars[k] for k in varnames ])
return varstuple
and then "test1()" can look like this:
def test1(a, b, condition):
for i, j in zip(a,b):
c = i + j
if condition(vartuple(locals())):
print("Foo")
which makes it much easier to write test2 and so on later.
Does this help?
Cheers,
Cameron Simpson <c...@zip.com.au>
Your reality is lies and balderdash, and I'm glad to say that I have no grasp
of it. - Baron Munchausen
--
https://mail.python.org/mailman/listinfo/python-list
