"Extracting " a dictionary

[Daniel Klein]

Hello,

I'm quite new to Python, and since a not-so-superficial look into the
docs didn't answer my question (although it still feels quite basic), I
decided to turn to this place:

Is there a way to 'extract' a dictionary into the current namespace?
That is, if you have
{'foo' : 23, 'bar' : 42}
you would get a variable foo with value 23 and a variable bar with value
42? Such a function would of course only work on string keys and would
probably have to check that, but still, it sounds practical enough that
surely someone else thought of it before.

Daniel

[Leif K-Brooks]

Daniel Klein wrote:

Is there a way to 'extract' a dictionary into the current namespace?
That is, if you have
{'foo' : 23, 'bar' : 42}
you would get a variable foo with value 23 and a variable bar with value
42? Such a function would of course only work on string keys and would
probably have to check that, but still, it sounds practical enough that
surely someone else thought of it before.

vars = {'foo': 23, 'bar': 42}
locals().update (vars)
foo 23 bar

42

[Peter Hansen]

Leif K-Brooks wrote:

Daniel Klein wrote:

Is there a way to 'extract' a dictionary into the current namespace?
That is, if you have
{'foo' : 23, 'bar' : 42}
you would get a variable foo with value 23 and a variable bar with
value 42? Such a function would of course only work on string keys and
would probably have to check that, but still, it sounds practical
enough that surely someone else thought of it before.

>>> vars = {'foo': 23, 'bar': 42}
>>> locals().update (vars)
>>> foo 23 >>> bar

42

Except note from this page
http://docs.python.org/lib/built-in-...built-in-funcs that
"""
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.
"""

So Don't Do That.

-Peter

[Heiko Wundram]

Am Montag, 17. Mai 2004 21:34 schrieb Leif K-Brooks:

>>> locals().update (vars)

From the documentation:

"""
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.
"""

Heiko.

[Jeff Epler]

The result of modifying locals() is undefined.

Jeff

[xtian]

Daniel Klein <br****@gmx.a t> wrote in message news:<ma******* *************** **************@ python.org>...

Is there a way to 'extract' a dictionary into the current namespace?
That is, if you have
{'foo' : 23, 'bar' : 42}
you would get a variable foo with value 23 and a variable bar with value
42? Such a function would of course only work on string keys and would
probably have to check that, but still, it sounds practical enough that
surely someone else thought of it before.

Daniel

The most straightforward way I know is

d = {'foo': 23, 'bar': 42}
globals().updat e(d)
print foo, bar 23 42

This only works with globals, though - there's a corresponding
locals(), but unfortunately the docs say updating it's a no-no - the
dict returned could be a copy of the real locals dict (or the real
locals might not be in a dict at all). The interpreter is free to
ignore changes to the dictionary that locals() returns (although it
happens not to in CPython at the moment, that's an implementation
detail).

Even with the globals, it's a bit magical and could end up overwriting
names that match a key in the dictionary (it would be irritating if
one of the keys was "file" or "list").

Maybe a cleaner way to do essentially what you want is to use the
martellibot's Bunch recipe:
http://aspn.activestate.com/ASPN/Coo...n/Recipe/52308

This would allow you to do:
class Bunch: def __init__(self, **kwds):
self.__dict__.u pdate(kwds)

d = {'foo': 23, 'bar': 42}
bunch = Bunch(**d)
print bunch.foo, bunch.bar

23 42

This means you're not clobbering the global or local namespace with
arbitrary bindings, and you could have lots of Bunch instances for
different collections of bindings.

Cheers,
xtian

[Jason Mobarak]

Daniel Klein wrote:

Hello,

I'm quite new to Python, and since a not-so-superficial look into the
docs didn't answer my question (although it still feels quite basic), I
decided to turn to this place:

Is there a way to 'extract' a dictionary into the current namespace?
That is, if you have
{'foo' : 23, 'bar' : 42}
you would get a variable foo with value 23 and a variable bar with value
42? Such a function would of course only work on string keys and would
probably have to check that, but still, it sounds practical enough that
surely someone else thought of it before.

Daniel

Is this illegal?

import __main__
d = {'foo':'oof','b ar':'rab','baz' :'zab'}
for k,v in d.items(): .... setattr(__main_ _, k, v)
.... foo,bar,baz

('oof', 'rab', 'zab')

--
Jason

[Leif K-Brooks]

Jason Mobarak wrote:

Daniel Klein wrote:

Is there a way to 'extract' a dictionary into the current namespace?

Is this illegal?

>>> import __main__
>>> d = {'foo':'oof','b ar':'rab','baz' :'zab'}
>>> for k,v in d.items(): ... setattr(__main_ _, k, v)
... >>> foo,bar,baz

('oof', 'rab', 'zab')

No, but it will need to be changed for the module's name, and won't work
at all in a local namespace (like a function).

[Leif K-Brooks]

Heiko Wundram wrote:

Am Montag, 17. Mai 2004 21:34 schrieb Leif K-Brooks:

>>> locals().update (vars)

From the documentation:

"""
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.
"""

Thanks for pointing that out, I was a bit lazy with TFM. Please ignore
my advice.

[Arnold Filip]

Daniel Klein wrote:

Hello,

I'm quite new to Python, and since a not-so-superficial look into the
docs didn't answer my question (although it still feels quite basic), I
decided to turn to this place:

Is there a way to 'extract' a dictionary into the current namespace?
That is, if you have
{'foo' : 23, 'bar' : 42}
you would get a variable foo with value 23 and a variable bar with value
42? Such a function would of course only work on string keys and would
probably have to check that, but still, it sounds practical enough that
surely someone else thought of it before.

Daniel

How about this:

In [1]: d = {'foo' : 23, 'bar' : 42}

In [2]: for item in d.items():
...: exec "%s = %d" % item
...:

In [3]: foo
Out[3]: 23

In [4]: bar
Out[4]: 42