**kwds behavior?

[Paradox]

Why does the following attempts to pass in keywords arguments not
work. It would be alot cooler if there was a way to not have to have
the function defined with the variable name. It really seems to me
that the 3rd function should work. Does anyone know how to accomplish
something like this.
def testKeywords1 (**kwds):
print x

def testKeywords2 (**kwds):
locals().update (kwds)
print x

def testKeywords3 (**kwds):
locals().update (kwds)
def testNested():
print x
testNested()

dict = {}
dict['x'] = 5
# doesn't work
testKeywords1(* *dict)
# doesn't work
testKeywords2(* *dict)
# doesn't work
testKeywords3(* *dict)

[John Roth]

The description of the locals() function is:

Update and return a dictionary representing the current local symbol table.
Warning: The contents of this dictionary should not be modified; changes may
not affect the values of local variables used by the interpreter.

Note that this implies that the dictionary is essentially
read only. What you're trying to do shouldn't work.

John Roth

"Paradox" <Jo*****@netzer o.com> wrote in message
news:92******** *************** ***@posting.goo gle.com...

Why does the following attempts to pass in keywords arguments not
work. It would be alot cooler if there was a way to not have to have
the function defined with the variable name. It really seems to me
that the 3rd function should work. Does anyone know how to accomplish
something like this.
def testKeywords1 (**kwds):
print x

def testKeywords2 (**kwds):
locals().update (kwds)
print x

def testKeywords3 (**kwds):
locals().update (kwds)
def testNested():
print x
testNested()

dict = {}
dict['x'] = 5
# doesn't work
testKeywords1(* *dict)
# doesn't work
testKeywords2(* *dict)
# doesn't work
testKeywords3(* *dict)

[Jeff Epler]

Changes to locals() do not necessarily affect anything.
locals()
Update and return a dictionary representing the current local
symbol table. *Warning*: The contents of this dictionary should
not be modified; changes may not affect the values of local
variables used by the interpreter.
-- http://python.org/doc/current/lib/bu...cs.html#l2h-47

You should probably try a different approach to whatever the underlying
task is.

Jeff

[Terry Reedy]

"Paradox" <Jo*****@netzer o.com> wrote in message
news:92******** *************** ***@posting.goo gle.com...

Why does the following attempts to pass in keywords arguments not
work.
What do you mean 'not work'. What was your output and what did you
expect?
It would be alot cooler if there was a way to not have to have
the function defined with the variable name.
I don't understand your meaning here.

It really seems to me that the 3rd function should work. Does anyone know how to accomplish something like this.
Again, what is 'this'?
def testKeywords1 (**kwds):
print x
If you want posted code to be read with indents by everybody, use
space instead of tab to indent. It's your choice to limit readership
or not.

def testKeywords2 (**kwds):
locals().update (kwds)
Above line has same effect as 'pass' for reason John Roth quoted.
print x

def testKeywords3 (**kwds):
locals().update (kwds)
def testNested():
print x
testNested()

dict = {}
dict['x'] = 5
# doesn't work
I usually expect 'doesn't work' to apply to the line above that I just
read -- just as this response applies to the line quoted above. I
suspect you meant 'below doesn't work', whatever 'doesn't work means.
The alternative way to reverse the 'pointer' is to leave a space above
and none below.
testKeywords1(* *dict)
# doesn't work
testKeywords2(* *dict)
# doesn't work
testKeywords3(* *dict)

If you don't get your question answered with above, try again with
different words.

Terry J. Reedy

[Terry Reedy]

"Sean Ross" <sr***@connectm ail.carleton.ca > wrote in message
news:2S******** **********@news 20.bellglobal.c om...

better if attempting to write to an non-writable dict raised an exception, but that is not the current behaviour.
The dict returned by locals(), even within a function, *is* writable

def f(): .... l = locals()
.... l[5] = 6
.... print l
.... f()

{5: 6}

However, it is only a dict copy of the local namespace, (which in
CPython happens to not be a dict of any sort).
So, your call to update has no effect
on the local namespace and, thus, 'x' is not yet defined locally.

So d=locals() can be used for what it is -- a dict initialized from
the local namespace at a particular time, but which is thereafter
independent from the local namespace.

Terry J. Reedy

[Hans Nowak]

Paradox wrote:

Why does the following attempts to pass in keywords arguments not
work. It would be alot cooler if there was a way to not have to have
the function defined with the variable name. It really seems to me
that the 3rd function should work. Does anyone know how to accomplish
something like this.
"this" apparently means, that you want to create local variables (within in the
function) with the same names as the keyword arguments.
def testKeywords1 (**kwds):
print x

def testKeywords2 (**kwds):
locals().update (kwds)
print x

def testKeywords3 (**kwds):
locals().update (kwds)
def testNested():
print x
testNested()

As people already pointed out, modifying locals() like this doesn't work.
There is a solution, but before using it you should stop and ask yourself why
you want this. Is there a reason why leaving the values in the dict isn't
sufficient? (Or putting them in a special class, like one poster suggested.)
Creating variables on-the-fly is usually a bad idea.

Now, on to the yucky solution:

def g(**kwargs): for key, value in kwargs.items():
exec "%s = %s" % (key, repr(value))
# test test...
print x
d = {}
d['x'] = 5
g(**d)

5

HTH,

--
Hans (ha**@zephyrfal con.org)
http://zephyrfalcon.org/

[Terry Reedy]

"Hans Nowak" <ha**@zephyrfal con.org> wrote in message
news:ma******** *************** ***********@pyt hon.org...

Now, on to the yucky solution:

>>> def g(**kwargs):

for key, value in kwargs.items():
exec "%s = %s" % (key, repr(value))
# test test...

This is cute but limited. It only works when values ==
eval(repr(value )), which is to say, numbers, strings, and,
recursively, tuples, lists, and dicts and some user-class instances.
Others will raise syntax error.

Terry J. Reedy

[Jeff Epler]

On Tue, Sep 02, 2003 at 01:10:41PM -0400, Hans Nowak wrote:

Now, on to the yucky solution:

def g(**kwargs): for key, value in kwargs.items():
exec "%s = %s" % (key, repr(value))
# test test...
print x

[...]
Now, you don't need to do that. This one works:
def testKeywords5(* *kwds):
exec ""
locals().update (kwds)
print x

testKeywords5(x =5)

5

even this variant should work (without actually executing any "exec"
statements):
def testKeywords6(* *kwds):
locals().update (kwds)
print x
return
exec ""

.... but I don't think you can/should depend that either variation works.
The key is that when the compiler sees 'bare exec' it disables an
optimization used to turn local name accesses into fast C-array-based
indexing operations...

I stand by my words that you (the OP) should back up a step and choose a
solution that doesn't have this yucky requirement of locals that aren't
known at bytecompile time.

Jeff

[Bengt Richter]

On 2 Sep 2003 07:52:22 -0700, Jo*****@netzero .com (Paradox) wrote:

Why does the following attempts to pass in keywords arguments not
work. It would be alot cooler if there was a way to not have to have
the function defined with the variable name. It really seems to me
that the 3rd function should work. Does anyone know how to accomplish
something like this.
def testKeywords1 (**kwds):
print x

def testKeywords2 (**kwds):
locals().update (kwds)
print x

def testKeywords3 (**kwds):
locals().update (kwds)
def testNested():
print x
testNested()

dict = {}
dict['x'] = 5
# doesn't work
testKeywords1( **dict)
# doesn't work
testKeywords2( **dict)
# doesn't work
testKeywords3( **dict)

A couple of other things that might relate to what you want:

def testkw(**kw): ... exec 'print x' in kw
... testkw(x='did it work?') did it work?

Guess so, but testkw(y='did it work?') Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "<stdin>", line 2, in testkw
File "<string>", line 1, in ?
NameError: name 'x' is not defined

Note that that's a NameError, not a KeyError, as in: def testkw1(**kw): ... print '%(x)s' % kw
... testkw1(x='did it work?') did it work?

Ok, but testkw1(y='did it work?') Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "<stdin>", line 2, in testkw1
KeyError: 'x'

Yet another way ...
def testkw2(**kw): ... ns = type('',(),kw)( )
... print ns.x
... testkw2(x='did it work?') did it work?
testkw2(y='did it work?') Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "<stdin>", line 3, in testkw2
AttributeError: '' object has no attribute 'x'

Or silliness,
def testkw3(**kw): ... exec """
... def foo():
... print x
... """ in kw
... kw['foo']()
... testkw3(x='did it work?') did it work?
testkw3(y='did it work?')

Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "<stdin>", line 6, in testkw3
File "<string>", line 3, in foo
NameError: global name 'x' is not defined

So what are you actually trying to do?

Regards,
Bengt Richter

[Paradox]

Thanks for the replies. basically what I was trying to accomplish was
to be able to load a script text file with python syntax into a class
and have it be able to cleanly reference the properties and methods.

I have currently accomplished it with something like this

code = compile(scriptT ext, '<string>','exe c')
exec code in self.__dict__