By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
440,621 Members | 1,077 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 440,621 IT Pros & Developers. It's quick & easy.

How to say $a=$b->{"A"} ||={} in Python?

P: n/a
Hi All.

I'd like to do the following in more succint code:

if k in b:
a=b[k]
else:
a={}
b[k]=a

a['A']=1
In perl it is just one line: $a=$b->{"A"} ||={}.

Thanks,
Geoffrey

Aug 16 '07 #1
Share this Question
Share on Google+
18 Replies


P: n/a
beginner <zy*******@gmail.comwrote:
I'd like to do the following in more succint code:

if k in b:
a=b[k]
else:
a={}
b[k]=a
b.setdefault(k, a)

--
Lawrence, oluyede.org - neropercaso.it
"It is difficult to get a man to understand
something when his salary depends on not
understanding it" - Upton Sinclair
Aug 16 '07 #2

P: n/a
On Aug 16, 5:43 pm, ra...@dot.com (Lawrence Oluyede) wrote:
beginner <zyzhu2...@gmail.comwrote:
I'd like to do the following in more succint code:
if k in b:
a=b[k]
else:
a={}
b[k]=a

b.setdefault(k, a)

--
Lawrence, oluyede.org - neropercaso.it
"It is difficult to get a man to understand
something when his salary depends on not
understanding it" - Upton Sinclair
I am afraid it is not the same. b.setdefault(k, {}) will always create
an empty dict, even if k is in b, as demonstrated in the below code.

b={}
def f(i):
print "I am evaluated %d" % i
return i

b.setdefault('A', f(1))
b.setdefault('A', f(2))
b
Aug 16 '07 #3

P: n/a
On Aug 16, 6:35 pm, beginner <zyzhu2...@gmail.comwrote:
Hi All.

I'd like to do the following in more succint code:

if k in b:
a=b[k]
else:
a={}
b[k]=a

a['A']=1

In perl it is just one line: $a=$b->{"A"} ||={}.

Thanks,
Geoffrey
Define b as a default dict:

b = defaultdict(dict)
b[k]['A'] = l

Carl Banks

Aug 16 '07 #4

P: n/a
On Aug 16, 3:35 pm, beginner <zyzhu2...@gmail.comwrote:
>
In perl it is just one line: $a=$b->{"A"} ||={}.
a = b.setdefault('A', {})

This combines all two actions together:
- Sets b['A'] to {} if it is not already defined
- Assigns b['A'] to a

More info on dict methods here:

http://docs.python.org/lib/typesmapping.html

Aug 17 '07 #5

P: n/a
On Aug 16, 8:28 pm, Jonathan Gardner
<jgardner.jonathangardner....@gmail.comwrote:
On Aug 16, 3:35 pm, beginner <zyzhu2...@gmail.comwrote:
In perl it is just one line: $a=$b->{"A"} ||={}.

a = b.setdefault('A', {})

This combines all two actions together:
- Sets b['A'] to {} if it is not already defined
- Assigns b['A'] to a

More info on dict methods here:

http://docs.python.org/lib/typesmapping.html
No, this has already been proposed and discarded. The OP does NOT
want this, because it always generates an empty {} whether it is
needed or not. Not really a big hardship, but if the default value
were some expensive-to-construct container class, then you would be
creating one every time you wanted to reference a value, on the chance
that the key did not exist.

Carl Banks' post using defaultdict is the correct solution. The
raison d'etre for defaultdict, and the reason that it is the solution
to the OP's question, is that instead of creating a just-in-case
default value every time, the defaultdict itself is constructed with a
factory method of some kind (in practice, it appears that this factory
method is usually the list or dict class constructor). If a reference
to the defaultdict gives a not-yet-existing key, then the factory
method is called to construct the new value, that value is stored in
the dict with the given key, and the value is passed back to the
caller. No instances are created unless they are truly required for
initializing an entry for a never-before-seen key.

-- Paul

Aug 17 '07 #6

P: n/a
On Aug 16, 6:03 pm, Carl Banks <pavlovevide...@gmail.comwrote:
On Aug 16, 6:35 pm, beginner <zyzhu2...@gmail.comwrote:
Hi All.
I'd like to do the following in more succint code:
if k in b:
a=b[k]
else:
a={}
b[k]=a
a['A']=1
In perl it is just one line: $a=$b->{"A"} ||={}.
Thanks,
Geoffrey

Define b as a default dict:

b = defaultdict(dict)
b[k]['A'] = l

Carl Banks- Hide quoted text -

- Show quoted text -
I think the most direct translation of the OP's example to Python
would be:

# setup b as special flavor of dict, that creates a
# new dict for not-yet-created keys
b = defaultdict(dict)

# actual python impl of $a=$b->{k}||={}
a = b[k]

# assign 1 to retrieved/created dict
a['A'] = 1

-- Paul

Aug 17 '07 #7

P: n/a
On Fri, 2007-08-17 at 00:53 +0000, beginner wrote:
$b is supposed to be a hash-table of hash-table. If a key exists in
$b, it points to another hash table. The $a=$b->{"A"} ||={} pattern is
useful when you want to add records to the double hash table.

For example, if you have a series of records in the format of (K1, K2,
V), and you want to add them to the double hash-table, you can do
$a=$b->{K1} || ={}
$a->{K2}=V
What is the best solution in Perl need not be the best solution in
Python. In Python you should just use a tuple as your dict key, i.e.
a[k1,k2] = v, unless you have some other constraints you're not telling
us.

HTH,

--
Carsten Haese
http://informixdb.sourceforge.net
Aug 17 '07 #8

P: n/a
On Aug 16, 9:32 pm, Carsten Haese <cars...@uniqsys.comwrote:
On Fri, 2007-08-17 at 00:53 +0000, beginner wrote:
$b is supposed to be a hash-table of hash-table. If a key exists in
$b, it points to another hash table. The $a=$b->{"A"} ||={} pattern is
useful when you want to add records to the double hash table.
For example, if you have a series of records in the format of (K1, K2,
V), and you want to add them to the double hash-table, you can do
$a=$b->{K1} || ={}
$a->{K2}=V

What is the best solution in Perl need not be the best solution in
Python. In Python you should just use a tuple as your dict key, i.e.
a[k1,k2] = v, unless you have some other constraints you're not telling
us.

HTH,

--
Carsten Haesehttp://informixdb.sourceforge.net
I use tuples this way all the time. It is indeed very neat. But it is
not a replacement for double hash-table. If I want to retrieve
information just by K1, it is not efficient to index on (K1, K2).

Aug 17 '07 #9

P: n/a
On Aug 16, 5:35 pm, beginner <zyzhu2...@gmail.comwrote:
Hi All.

I'd like to do the following in more succint code:

if k in b:
a=b[k]
else:
a={}
b[k]=a

a['A']=1

In perl it is just one line: $a=$b->{"A"} ||={}.

Thanks,
Geoffrey
It looks like defaultdict is the solution for this kind of thing.
Thanks all for your help.

Aug 17 '07 #10

P: n/a
On Fri, 17 Aug 2007 03:15:10 -0000, beginner wrote
On Aug 16, 9:32 pm, Carsten Haese <cars...@uniqsys.comwrote:
What is the best solution in Perl need not be the best solution in
Python. In Python you should just use a tuple as your dict key, i.e.
a[k1,k2] = v, unless you have some other constraints you're not telling
us.

HTH,

--
Carsten Haesehttp://informixdb.sourceforge.net

I use tuples this way all the time. It is indeed very neat. But it
is not a replacement for double hash-table. If I want to retrieve
information just by K1, it is not efficient to index on (K1, K2).
If you have to look up all values associates with k1 and any k2, you're right,
that's not efficient. That would fall under "other constraints you're not
telling us." I'm not a mind reader.

-Carsten

Aug 17 '07 #11

P: n/a
beginner a écrit :
Hi All.

I'd like to do the following in more succint code:

if k in b:
a=b[k]
else:
a={}
b[k]=a

a['A']=1
In perl it is just one line: $a=$b->{"A"} ||={}.

Thanks,
Geoffrey

One solution I often use in such cases:

try:
a = b[k]
except KeyError: #or except IndexError: if b is a list/tuple and not a dict
a = {}
b[k] = a

a['A'] = 1

Indeed, exceptions are handled faster than "if/else" loops. As it was
mentionned earlier, One neat solution in Perl may not be the perfect one
in Python.

Cheers,

Sébastien
Aug 17 '07 #12

P: n/a
On Aug 17, 2:35 am, Sébastien Buchoux <seb.buch...@gmail.comwrote:
beginner a écrit :
Hi All.
I'd like to do the following in more succint code:
if k in b:
a=b[k]
else:
a={}
b[k]=a
a['A']=1
In perl it is just one line: $a=$b->{"A"} ||={}.
Thanks,
Geoffrey

One solution I often use in such cases:

try:
a = b[k]
except KeyError: #or except IndexError: if b is a list/tuple and not a dict
a = {}
b[k] = a

a['A'] = 1

Indeed, exceptions are handled faster than "if/else" loops. As it was
mentionned earlier, One neat solution in Perl may not be the perfect one
in Python.

Cheers,

Sébastien- Hide quoted text -

- Show quoted text -
Wow. This solution is interesting. I'll try this. Thanks.

Aug 17 '07 #13

P: n/a
On Aug 16, 11:02 pm, "Carsten Haese" <cars...@uniqsys.comwrote:
On Fri, 17 Aug 2007 03:15:10 -0000, beginner wrote
On Aug 16, 9:32 pm, Carsten Haese <cars...@uniqsys.comwrote:
What is the best solution in Perl need not be the best solution in
Python. In Python you should just use a tuple as your dict key, i.e.
a[k1,k2] = v, unless you have some other constraints you're not telling
us.
HTH,
--
Carsten Haesehttp://informixdb.sourceforge.net
I use tuples this way all the time. It is indeed very neat. But it
is not a replacement for double hash-table. If I want to retrieve
information just by K1, it is not efficient to index on (K1, K2).

If you have to look up all values associates with k1 and any k2, you're right,
that's not efficient. That would fall under "other constraints you're not
telling us." I'm not a mind reader.

-Carsten
Yeah, I should have mentioned that I actually want to group the data
by K1 and then by K2.

Aug 17 '07 #14

P: n/a
On Aug 16, 10:01 pm, Paul McGuire <pt...@austin.rr.comwrote:
On Aug 16, 8:28 pm, Jonathan Gardner

<jgardner.jonathangardner....@gmail.comwrote:
On Aug 16, 3:35 pm, beginner <zyzhu2...@gmail.comwrote:
In perl it is just one line: $a=$b->{"A"} ||={}.
a = b.setdefault('A', {})
This combines all two actions together:
- Sets b['A'] to {} if it is not already defined
- Assigns b['A'] to a
More info on dict methods here:
http://docs.python.org/lib/typesmapping.html

No, this has already been proposed and discarded. The OP does NOT
want this, because it always generates an empty {} whether it is
needed or not. Not really a big hardship, but if the default value
were some expensive-to-construct container class, then you would be
creating one every time you wanted to reference a value, on the chance
that the key did not exist.

Carl Banks' post using defaultdict is the correct solution. The
raison d'etre for defaultdict, and the reason that it is the solution
to the OP's question, is that instead of creating a just-in-case
default value every time, the defaultdict itself is constructed with a
factory method of some kind (in practice, it appears that this factory
method is usually the list or dict class constructor). If a reference
to the defaultdict gives a not-yet-existing key, then the factory
method is called to construct the new value, that value is stored in
the dict with the given key, and the value is passed back to the
caller. No instances are created unless they are truly required for
initializing an entry for a never-before-seen key.

When I made my response, it occurred to me that Python could be
improved (maybe) if one could overload dict.get() to use a factory,
like so:

b = {}
a = b.get(k,factory=dict)
a['A'] = 1

That's a slight improvement (maybe) over defaultdict since it would
still allow the same dict to have the membership check in other
places. I'm not so sure overloading get to let it modify the dict is
a good idea, though.

Actually, it'd probably be fairly uncontroversial to add a factory
keyword to dict.setdefault(). At least insofar as setdefault is
uncontroversial.
Carl Banks

Aug 18 '07 #15

P: n/a
Carl Banks wrote:
On Aug 16, 10:01 pm, Paul McGuire <pt...@austin.rr.comwrote:
>On Aug 16, 8:28 pm, Jonathan Gardner

<jgardner.jonathangardner....@gmail.comwrote:
>>On Aug 16, 3:35 pm, beginner <zyzhu2...@gmail.comwrote:
In perl it is just one line: $a=$b->{"A"} ||={}.
a = b.setdefault('A', {})
This combines all two actions together:
- Sets b['A'] to {} if it is not already defined
- Assigns b['A'] to a
More info on dict methods here:
http://docs.python.org/lib/typesmapping.html
No, this has already been proposed and discarded. The OP does NOT
want this, because it always generates an empty {} whether it is
needed or not. Not really a big hardship, but if the default value
were some expensive-to-construct container class, then you would be
creating one every time you wanted to reference a value, on the chance
that the key did not exist.

Carl Banks' post using defaultdict is the correct solution. The
raison d'etre for defaultdict, and the reason that it is the solution
to the OP's question, is that instead of creating a just-in-case
default value every time, the defaultdict itself is constructed with a
factory method of some kind (in practice, it appears that this factory
method is usually the list or dict class constructor). If a reference
to the defaultdict gives a not-yet-existing key, then the factory
method is called to construct the new value, that value is stored in
the dict with the given key, and the value is passed back to the
caller. No instances are created unless they are truly required for
initializing an entry for a never-before-seen key.


When I made my response, it occurred to me that Python could be
improved (maybe) if one could overload dict.get() to use a factory,
like so:

b = {}
a = b.get(k,factory=dict)
a['A'] = 1

That's a slight improvement (maybe) over defaultdict since it would
still allow the same dict to have the membership check in other
places. I'm not so sure overloading get to let it modify the dict is
a good idea, though.

Actually, it'd probably be fairly uncontroversial to add a factory
keyword to dict.setdefault(). At least insofar as setdefault is
uncontroversial.
Well it's uncontroversial enough to have made it into the distribution,
which represents a tacit admission by Guido that the .get() method alone
didn't implement his full vision.

The python-dev thread that discussed the feature before implementation
(as so often is the case) exercised many of the possible design paths,
and would be a useful read. [Damn, now I have to
well-known-search-engine it]. Aah, right - I'd forgotten how long it
took to get it right. This would be a suitable starting-point - it's the
beginning of the /third/ round of discussion:

http://mail.python.org/pipermail/pyt...ry/061485.html

Many alternatives were discussed, and my memory at this distance is that
Guido had good reasons for choosing the exact API he did for defaultdict.

regards
Steve
--
Steve Holden +1 571 484 6266 +1 800 494 3119
Holden Web LLC/Ltd http://www.holdenweb.com
Skype: holdenweb http://del.icio.us/steve.holden
--------------- Asciimercial ------------------
Get on the web: Blog, lens and tag the Internet
Many services currently offer free registration
----------- Thank You for Reading -------------

Aug 18 '07 #16

P: n/a
beginner <zy*******@gmail.comwrote:
On Aug 16, 5:43 pm, ra...@dot.com (Lawrence Oluyede) wrote:
beginner <zyzhu2...@gmail.comwrote:
I'd like to do the following in more succint code:
if k in b:
a=b[k]
else:
a={}
b[k]=a
b.setdefault(k, a)

I am afraid it is not the same. b.setdefault(k, {}) will always create
an empty dict, even if k is in b
That is certainly true, but does it matter? You waste a very small
amount of time creating a dict you don't use.

$ python -m timeit '{}'
1000000 loops, best of 3: 0.247 usec per loop

On my machine 250 ns gets you a new dict...

--
Nick Craig-Wood <ni**@craig-wood.com-- http://www.craig-wood.com/nick
Aug 18 '07 #17

P: n/a
Paul McGuire <pt***@austin.rr.comwrote:
Carl Banks' post using defaultdict is the correct solution. The
raison d'etre for defaultdict, and the reason that it is the solution
to the OP's question, is that instead of creating a just-in-case
default value every time, the defaultdict itself is constructed with a
factory method of some kind (in practice, it appears that this factory
method is usually the list or dict class constructor). If a reference
to the defaultdict gives a not-yet-existing key, then the factory
method is called to construct the new value, that value is stored in
the dict with the given key, and the value is passed back to the
caller. No instances are created unless they are truly required for
initializing an entry for a never-before-seen key.
I think that if you truly want to emulate a perl hash then you would
want this which does the above but recursively.

from collections import defaultdict

class hash(defaultdict):
def __init__(self):
defaultdict.__init__(self, hash)

D=hash()

D[1][2][3][4]=5
D[1][4][5]=6

print D

--
Nick Craig-Wood <ni**@craig-wood.com-- http://www.craig-wood.com/nick
Aug 18 '07 #18

P: n/a
On Aug 18, 12:30 pm, Nick Craig-Wood <n...@craig-wood.comwrote:
I think that if you truly want to emulate a perl hash then you would
want this which does the above but recursively.

from collections import defaultdict

class hash(defaultdict):
def __init__(self):
defaultdict.__init__(self, hash)

D=hash()

D[1][2][3][4]=5
D[1][4][5]=6

print D

--
Nick Craig-Wood <n...@craig-wood.com--http://www.craig-wood.com/nick
Nick,
I thought I'd save your hash implementation away in my bag of tricks:
# File: autovivifying_dict.py
from collections import defaultdict
class hash(defaultdict):
""" Used like a dict except sub-dicts automagically created as
needed
Based on: http://groups.google.com/group/comp....34fbdafe4afa37
>>D=hash()
D[1][2][3][4]=5
D[1][4][5]=6
D
hash({1: hash({2: hash({3: hash({4: 5})}), 4: hash({5: 6})})})
>>hash({1: hash({2: hash({3: hash({4: 5})}), 4: hash({7: 8})})})
hash({1: hash({2: hash({3: hash({4: 5})}), 4: hash({7: 8})})})
>>>
"""
def __init__(self, *a, **b):
defaultdict.__init__(self, hash, *a, **b)
def __repr__(self):
return "hash(%s)" % (repr(dict(self)),)

def _test():
import doctest
doctest.testmod()

if __name__ == "__main__":
_test()

- Paddy.
Aug 18 '07 #19

This discussion thread is closed

Replies have been disabled for this discussion.