converting a string to a function parameter

[koranthala]

Hi,
Is it possible to convert a string to a function parameter?
Ex:
str = 'True, type=rect, sizes=[3, 4]'
and I should be able to use it as:
test(convert(str)) and the behaviour should be same as calling test
with those values :
i.e. test(True, type=rect, sizes=[3, 4])

I tried eval, but it did not work. And any other mechanism I think
turns out to be creating a full fledged python parser.

Is there any mechanism with which we can do this straight away?

[Chris Rebert]

Firstly, don't use `str` as a variable name since it conflicts with
the name of the builtin type.

Now here's how to use eval() properly:

[insert standard 'eval() is EVIL!' warning/lecture here]

eval("test("+the_str+")")

or

eval(test.__name__+"("+the_str+")")

Cheers,
Chris

--
I have a blog:
http://blog.rebertia.com

[koranthala]

On Mar 13, 1:01 pm, Chris Rebert <c...@rebertia.com> wrote:

Thank you very much Chris.
I also thought about the first method a second after I posted this.
But I never thought about the second method.
I will heed the warning about the str part.

Thank you very much again, Chris.

[odeits]

If the string has all of the names you could parse it into a
dictionary and pass it as the keyword arguments

[Scott David Daniels]

koranthala wrote:
> Hi,
> Is it possible to convert a string to a function parameter?
> Ex:
> str = 'True, type=rect, sizes=[3, 4]'
> and I should be able to use it as:
> test(convert(str)) and the behaviour should be same as calling test
> with those values :
> i.e. test(True, type=rect, sizes=[3, 4])
>
> I tried eval, but it did not work. And any other mechanism I think
> turns out to be creating a full fledged python parser.

This might work [again be avoid eval if possible].
You _might want to do something like:

def _args(*_nargs, **_kwargs):
'''Collect call parameters from a call'''
return _nargs, _kwargs
...
nargs, kwargs = eval('_args(%s)' % arglist
...
test(*nargs, **kwargs)

--Scott David Daniels
Scott....@Acm.Org

[Aaron Brady]

I heard 'pyparsing' was good. ...Not that I've even been to its
webpage.

[Paul McGuire]

Did someone say 'pyparsing'? :) Here is a first cut (partially lifted
from a previous post):

from pyparsing import *

LPAR,RPAR,LBRACK,RBRACK,EQ,COMMA = map(Suppress,"()[]=,")

noneLiteral = Literal("None")
boolLiteral = oneOf("True False")
integer = Combine(Optional(oneOf("+ -")) + Word(nums)).setName
("integer")
real = Combine(Optional(oneOf("+ -")) + Word(nums) + "." +
Optional(Word(nums))).setName("real")

ident = Word(alphas+"_",alphanums+"_")

listStr = Forward().setName("list")
tupleStr = Forward().setName("tuple")
listItem = real | integer | noneLiteral | boolLiteral | \
quotedString.setParseAction(removeQuotes) | Group(listStr) |
tupleStr | ident
listStr << ( LBRACK + Optional(delimitedList(listItem)) + Optional
(COMMA) + RBRACK )
tupleStr << (LPAR + Optional(delimitedList(listItem)) + Optional
(COMMA) + RPAR)

# parse actions perform parse-time conversions
noneLiteral.setParseAction(lambda: None)
boolLiteral.setParseAction(lambda toks: toks[0]=="True")
integer .setParseAction(lambda toks: int(toks[0]))
real .setParseAction(lambda toks: float(toks[0]))
listStr .setParseAction(lambda toks: toks.asList())
tupleStr .setParseAction(lambda toks: tuple(toks.asList()))

arg = Group(ident("varname") + EQ + listItem("varvalue")) | listItem

argstring = 'True, type=rect, sizes=[3, 4,], coords = ([1,2],[3,4])'

parsedArgs = delimitedList(arg).parseString(argstring)
args = []
kwargs = {}
for a in parsedArgs:
if isinstance(a,ParseResults):
if isinstance(a.varvalue,ParseResults):
val = a.varvalue.asList()
else:
val = a.varvalue
kwargs[a.varname] = val
else:
args.append(a)

print "Args:", args
print "Kwargs:", kwargs

Prints:

Args: [True]
Kwargs: {'coords': ([1, 2], [3, 4]), 'type': 'rect', 'sizes': [3, 4]}

[Aaron Brady]

On Mar 13, 3:21 pm, Paul McGuire <pt...@austin.rr.com> wrote:
> On Mar 13, 11:46 am, Aaron Brady <castiro...@gmail.com> wrote:
>
>
>
> > On Mar 13, 2:52 am, koranthala <koranth...@gmail.com> wrote:
>
> > > Hi,
> > >     Is it possible to convert a string to a function parameter?
> > > Ex:
> > > str = 'True, type=rect, sizes=[3, 4]'
> > > and I should be able to use it as:
> > > test(convert(str)) and the behaviour should be same as calling test
> > > with those values :
> > > i.e. test(True, type=rect, sizes=[3, 4])
>
> > > I tried eval, but it did not work. And any other mechanism I think
> > > turns out to be creating a full fledged python parser.
>
> > > Is there any mechanism with which we can do this straight away?
>
> > I heard 'pyparsing' was good.  ...Not that I've even been to its
> > webpage.
>
> Did someone say 'pyparsing'? :)  Here is a first cut (partially lifted
> from a previous post):

snip 40 lines

> Prints:
>
> Args: [True]
> Kwargs: {'coords': ([1, 2], [3, 4]), 'type': 'rect', 'sizes': [3, 4]}

Ha, ok, out of my league. It's a bit heavyweight I accede. The OP
didn't say what s/he knew about his/er data prior, what fault
tolerance s/he needed, what complexity and nesting of data in the
string, etc.

Hmmm..., just thinking. Could the strings come from a python file:
test1= fargs(True, type=rect, sizes=[3, 4])
test2= fargs(...)
?

[andrew cooke]

I'm a bit late to the party, but LEPL 2.2, just released, can now handle
this too. I suspect email may mangle this, so you can also read it at
http://www.acooke.org/lepl/examples.html#parsing-a-python-argument-list

from lepl import *

comma = Drop(',')
none = Literal('None') >> (lambda x: None)
bool = (Literal('True') | Literal('False')) >> (lambda x: x == 'True')
ident = Word(Letter() | '_',
Letter() | '_' | Digit())
float_ = Float() >> float
int_ = Integer() >> int
str_ = String() | String("'")
item = str_ | int_ | float_ | none | bool | ident

with Separator(~Regexp(r'\s*')):
value = Delayed()
list_ = Drop('[') & value[:, comma] & Drop(']') > list
tuple_ = Drop('(') & value[:, comma] & Drop(')') > tuple
value += list_ | tuple_ | item
arg = value >> 'arg'
karg = (ident & Drop('=') & value > tuple) >> 'karg'
expr = (karg | arg)[:, comma] & Drop(Eos()) > Node

parser = expr.string_parser()

ast = parser('True, type=rect, sizes=[3, 4], coords = ([1,2],[3,4])')
print(ast[0])

which gives:

Node
+- arg True
+- karg (u'type', u'rect')
+- karg (u'sizes', [3, 4])
`- karg (u'coords', ([1, 2], [3, 4]))

you can then access those values:
>>> ast[0].arg
[True]
>>> ast[0].karg
[('type', 'rect'), ('sizes', [3, 4]), ('coords', ([1, 2], [3, 4]))]

alternatively, you could avoid using a Node altogether and just put them
in a list or whatever....

andrew

> --
> http://mail.python.org/mailman/listinfo/python-list
>
>

[pietr...@gmail.com]

I need the exact opposite, what is the inverse function?
example: i pass to a function an argument

m=[654,54,65]
def function(m):
return takethenameof(m)

and it have to return to me 'm' not [654,54,65] or '[654,54,65]'

anybody can help?
i think that when one is talking about a function he have to talk also of the inverse function (also because google have problems searching about this...)

[Ned Batchelder]

On 1/5/14 2:39 PM, pietr...@gmail.com wrote:

The difficulty in writing such a function is that values don't have
unique names, if they have names at all. What should be returned in
these cases?

m = [654, 54, 65]
def function(m):
m2 = m
m3 = m[:]
takethenameof(m)
takethenameof(m2)
takethenameof(m3)
takethenameof(m[:])
takethenameof(2)
takethenameof(2+2)

There are samples online that try to do a "reasonable" job of this, but
my googling isn't turning them up...

--
Ned Batchelder, http://nedbatchelder.com

[Gary Herron]

Absolutely not. Objects (like [654,54,65]) do not have names, never did
and never will! Objects do have a type and a value (and an identity),
but not a name.

Various namespaces will have dictionary-like associations between a name
(like "m") and an object, and it *is* possible to get your hands on a
(dictionary representing a) namespace and search it, but this is
troublesome.

For instance, consider this small variation of your code:

def function(m):
return takethenameof(m)

a=[654,54,65]
b = a
function(a)

While function is running, there will be three names associated with the list object.
The outer namespace will have "a" and "b" associated with the list object,
and the namespace local to function will have "m" associated with the same object.
That's one object associated with three names in two different namespaces.

Gary Herron