On Tue, 25 Oct 2005 16:20:21 GMT, Ron Adam <[EMAIL PROTECTED]> wrote:
>Duncan Booth wrote:
>> Ron Adam wrote:
>>
>>>James Stroud wrote:
>>>
>>>>Here it goes with a little less overhead:
>>>>
>>>>
>>
>> <example snipped>
>>
>>>But it's not a dictionary anymore so you can't use it in the same places
>>>you would use a dictionary.
>>>
>>> foo(**n)
>>>
>>>Would raise an error.
>>>
>>>So I couldn't do:
>>>
>>> def foo(**kwds):
>>> kwds = namespace(kwds)
>>> kwds.bob = 3
>>> kwds.alice = 5
>>> ...
>>> bar(**kwds) #<--- do something with changed items
>>>
>>
>> I agree with Steven D'Aprano's reply, but if you are set on it you could
>> try this:
>>
>>
>>>>>class namespace(dict):
>>
>> def __init__(self, *args, **kw):
>> dict.__init__(self, *args, **kw)
>> self.__dict__ = self
>>
>>
>>
>>>>>n = namespace({'bob':1, 'carol':2, 'ted':3, 'alice':4})
>>>>>n.bob
>>
>> 1
>>
>>>>>n.bob = 3
>>>>>n['bob']
>>
>> 3
>>
>> The big problem of course with this sort of approach is that you cannot
>> then safely use any of the methods of the underlying dict as they could be
>> masked by values.
>>
>> P.S. James, *please* could you avoid top-quoting.
>
>Or worse, the dictionary would become not functional depending on what
>methods were masked.
>
>
>And this approach reverses that, The dict values will be masked by the
>methods, so the values can't effect the dictionary methods. But those
>specific values are only retrievable with the standard dictionary notation.
>
> class namespace(dict):
> __getattr__ = dict.__getitem__
> __setattr__ = dict.__setitem__
> __delattr__ = dict.__delitem__
>
> n = namespace()
> n.__getattr__ = 'yes' # doesn't mask __getattr__ method.
>
> print n['__getattr__'] -> 'yes'
>
>The value is there and __getattr__() still works. But n.__getattr__
>returns the method not the value.
>
>So is there a way to keep the functionality without loosing the methods?
>
>
>BTW, I agree with Steven concerning data structures. This really isn't
>a substitute for a data structure. Many keys will not work with this.
>
> n.my name = 'Ron'
> n.(1,2) = 25
> n.John's = [ ... ]
>
>The use case I'm thinking of is not as a shortcut for data structures,
>but instead, as a way to keep names as names, and maintaining those
>names in a group. Thus the namespace association.
>
> def foo(**kwds):
> kwds = namespace(kwds)
> print kwds.name
> print kwds.value
> ...
>
> name = 'ron'
> value = 25
> foo( name=name, position=position )
>
Just had the thought that if you want to add bindings on the fly modifying the
original object, you could use the __call__ method, e.g.,
>>> class NameSpace(dict):
... __getattr__ = dict.__getitem__
... __setattr__ = dict.__setitem__
... __delattr__ = dict.__delitem__
... def __call__(self, **upd):
... self.update(upd)
... return self
...
>>> def show(x): print '-- showing %r'%x; return x
...
>>> ns = NameSpace(initial=1)
>>> show(ns)
-- showing {'initial': 1}
{'initial': 1}
And updating with a second keyword on the fly:
>>> show(show(ns)(second=2))
-- showing {'initial': 1}
-- showing {'second': 2, 'initial': 1}
{'second': 2, 'initial': 1}
FWIW ;-)
Regards,
Bengt Richter
--
http://mail.python.org/mailman/listinfo/python-list
