Develop Reference

python dictionary getter with default value not behaving as expected [duplicate]

I am trying to provide a function as the default argument for the dictionary's get function, like this
def run():
print "RUNNING"
test = {'store':1}
test.get('store', run())
However, when this is run, it displays the following output:
RUNNING
1
so my question is, as the title says, is there a way to provide a callable as the default value for the get method without it being called if the key exists?

Another option, assuming you don't intend to store falsy values in your dictionary:
test.get('store') or run()
In python, the or operator does not evaluate arguments that are not needed (it short-circuits)
If you do need to support falsy values, then you can use get_or_run(test, 'store', run) where:
def get_or_run(d, k, f):
sentinel = object() # guaranteed not to be in d
v = d.get(k, sentinel)
return f() if v is sentinel else v

See the discussion in the answers and comments of dict.get() method returns a pointer. You have to break it into two steps.
Your options are:
Use a defaultdict with the callable if you always want that value as the default, and want to store it in the dict.
Use a conditional expression:
item = test['store'] if 'store' in test else run()
Use try / except:
try:
item = test['store']
except KeyError:
item = run()
Use get:
item = test.get('store')
if item is None:
item = run()
And variations on those themes.
glglgl shows a way to subclass defaultdict, you can also just subclass dict for some situations:
def run():
print "RUNNING"
return 1
class dict_nokeyerror(dict):
def __missing__(self, key):
return run()
test = dict_nokeyerror()
print test['a']
# RUNNING
# 1
Subclassing only really makes sense if you always want the dict to have some nonstandard behavior; if you generally want it to behave like a normal dict and just want a lazy get in one place, use one of my methods 2-4.

I suppose you want to have the callable applied only if the key does not exist.
There are several approaches to do so.
One would be to use a defaultdict, which calls run() if key is missing.
from collections import defaultdict
def run():
print "RUNNING"
test = {'store':1}
test.get('store', run())
test = defaultdict(run, store=1) # provides a value for store
test['store'] # gets 1
test['runthatstuff'] # gets None
Another, rather ugly one, one would be to only save callables in the dict which return the apropriate value.
test = {'store': lambda:1}
test.get('store', run)() # -> 1
test.get('runrun', run)() # -> None, prints "RUNNING".
If you want to have the return value depend on the missing key, you have to subclass defaultdict:
class mydefaultdict(defaultdict):
def __missing__(self, key):
val = self[key] = self.default_factory(key)
return val
d = mydefaultdict(lambda k: k*k)
d[10] # yields 100
#mydefaultdict # decorators are fine
def d2(key):
return -key
d2[5] # yields -5
And if you want not to add this value to the dict for the next call, you have a
def __missing__(self, key): return self.default_factory(key)
instead which calls the default factory every time a key: value pair was not explicitly added.

If you only know what the callable is likely to be at he get call site you could subclass dict something like this
class MyDict(dict):
def get_callable(self,key,func,*args,**kwargs):
'''Like ordinary get but uses a callable to
generate the default value'''
if key not in self:
val = func(*args,**kwargs)
else:
val = self[key]
return val
This can then be used like so:-
>>> d = MyDict()
>>> d.get_callable(1,complex,2,3)
(2+3j)
>>> d[1] = 2
>>> d.get_callable(1,complex,2,3)
2
>>> def run(): print "run"
>>> repr(d.get_callable(1,run))
'2'
>>> repr(d.get_callable(2,run))
run
'None'
This is probably most useful when the callable is expensive to compute.

I have a util directory in my project with qt.py, general.py, geom.py, etc. In general.py I have a bunch of python tools like the one you need:
# Use whenever you need a lambda default
def dictGet(dict_, key, default):
if key not in dict_:
return default()
return dict_[key]
Add *args, **kwargs if you want to support calling default more than once with differing args:
def dictGet(dict_, key, default, *args, **kwargs):
if key not in dict_:
return default(*args, **kwargs)
return dict_[key]

Here's what I use:
def lazy_get(d, k, f):
return d[k] if k in d else f(k)
The fallback function f takes the key as an argument, e.g.
lazy_get({'a': 13}, 'a', lambda k: k) # --> 13
lazy_get({'a': 13}, 'b', lambda k: k) # --> 'b'
You would obviously use a more meaningful fallback function, but this illustrates the flexibility of lazy_get.
Here's what the function looks like with type annotation:
from typing import Callable, Mapping, TypeVar
K = TypeVar('K')
V = TypeVar('V')
def lazy_get(d: Mapping[K, V], k: K, f: Callable[[K], V]) -> V:
return d[k] if k in d else f(k)

Python dict with default value based on key

I need a dictionary that is automatically filled with a default value for each accessed key that is missing. I've found defaultdict and some other ways to achieve this, but the problem in my case is that I want the default value for each key to be specific to the key itself.
For example, with defaultdict I can achieve something like this:
from collections import defaultdict
d = defaultdict(lambda: 5)
> d[1] = 3
> d[1]
> 3
> d[2]
> 5
But what if I need the default value for each accessed missing key to be for example key + 5? Something like:
from collections import defaultdict
d = defaultdict(lambda key: key + 5) # <-- This does not work as defaultdict expects lambda function to be without any parameters
> d[1] = 3
> d[1]
> 3
> d[2]
> 7 <- Calculated from accessed key + 5 (2+5)
> d[5]
> 10 <- Calculated from accessed key + 5 (5+5)
Is there a clean, builtin way to achieve what I need? I know that I can create a subclass of dict and implement this specific functionality at __getitem__ level, but I want to avoid that if possible.
I couldn't find a solution in other answers, so sorry if it is still a duplicate.

I don't think there is a builtin way of doing this. However, instead of subclassing dict and change getitem, you can subclass defaultdict itself to tell __missing__() to call the default_factory with an argument (the key), rather than without args. It is still a custom class, not a builtin, but it should be quite efficient still.
from collections import defaultdict
class DefaultDict(defaultdict):
def __missing__(self, key):
return self.default_factory(key)
Then:
d = DefaultDict(lambda key: key + 5)
d[2]
# 7

You can also use a function like this
dic = {}
DEFAULT_VALUE = 5
def dict_get(item):
try:
return [dic[item]]
except:
dic[int(item)] = DEFAULT_VALUE + int(item)
return DEFAULT_VALUE + int(item)
print(dict_get(10))

Here is how to do it without creating any class. You can use dict.setdefault:
d = {}
d_default_factory = lambda key: key + 5
d.setdefault(2, d_default_factory(2))
# 7
Optionally, you could save the default factory as an entry in the dictionary, like so:
d = {'default_factory': lambda key: key + 5}
d.setdefault(2, d['default_factory'](2))
# 7

initialize ordereddict in python

I am new in Python.
I am trying to create many ordereddict,but because I am filling it out in messed sequence I had to create a function to pass in the normal dict to get the order I want.
info = dict()
info['age'] = 3
...
keys=['id','name','age','ck_id','image']
def fix_order(my_dict):
new_queue = OrderedDict()
for k in keys:
new_queue[k] = item[k]
return new_queue
What I want to do is to create a simple class which already has the order I want no matter the sequence of filling it.
I checked this questionHow to create an OrderedDict in Python?, but this assumes I have the values first hand.
i.e what I want info = my_dict() #already has the sequence (order) built in

As I understand you want to have a data structure that gives you the same operations as dict, but if iterate over gives items in a precise order.
If this is the case you can override the methods that gives out iterables: the __iter__ method, the key method, the values method and the items method (maybe there are others which I can't remember)
There is a basic class you can start off. (I.e this will only iterate over the elements you specified, but probably you want to extend to iterate over the other elements, too)
from collections import UserDict
class MyDict(UserDict):
def __init__(self, *args, **kwargs):
self.order = kwargs.pop('order')
super().__init__(*args)
def change_order(self, order: list):
self.order = order
def __iter__(self):
for key in self.order:
if key in self:
yield key
def keys(self):
for key in self.order:
if key in self:
yield key
def values(self):
for key in self.order:
if key in self:
yield self[key]
def items(self):
for key in self.order:
if key in self:
yield key, self[key]
There is a test:
d = MyDict({"b" : 2, "c": 3, "a": 1}, order=["a","b","c"])
print(d)
for k in d:
print(k, end=" ")
#a b c
print()
for k in d.keys():
print(k, end=" ")
#a b c
print()
for v in d.values():
print(v, end=" ")
#1 2 3
print()
for k, v in d.items():
print(f"{k}-{v}", end=" ")
#a-1 b-2 c-3
You can override __repr__ and __str__ if you want your dictionary to be converted in string (and printed) in the order you want, too

Generic way to select "other value"

Say I have a dict that contains only two values:
foo = {'bar':someThing, 'foobar':someThingElse}
and I am given in a function foo and a key which can be either bar or foobar:
is there a generic way to select the other element? This function should use the knowledge that $foo$ only contains only two elements.
The hard coded way would be
def funnyStuff(foo, key):
if key == 'bar':
myKey = 'foobar'
if key == 'foobar':
myKey = 'bar'
return foo[myKey]

(python2 only, and breaks when there are not exactly 2 key/value pairs)
foo.values()[not foo.keys().index(key)]

Only two elements? You don't need a dict then.
foo = {'bar':'someThing', 'foobar':'someThingElse'}
def selectOther(data, key):
# structure unpacking is almost like pattern matching!
[(k1, v1), (k2, v2)] = data.items()
if k1 == key:
return v2
elif k2 == key:
return v1
else:
raise KeyError("Your %r is not among data keys!" % key)

You could use list comprehension:
def funnyStuff(foo, key):
return foo[[x for x in foo if x != key][0]]

How about something like this:
foo = {'bar':'someThing', 'foobar':'someThingElse'}
def get_other(foo, key):
return foo.get([k for k in foo.keys() if k != key][0])
print get_other('bar')
Output:
'someThingElse'
Although this works, it is inefficient since we create a list from another list, just to get to the 0th item!

foo = {'bar':'someThing', 'foobar':'someThingElse'}
def funnyStuff(foo, key):
mykey = ""
key_list = foo.keys()
if key == key_list[0]:
mykey = key_list[1]
else:
mykey = key_list[0]
return mykey
print foo[funnyStuff(foo, 'foobar')]

Depending on what you are trying to do this idea could be useful, make a new mapping from your keys to boolean, so that it is easy to negate them:
keys2bool = dict(zip(foo.keys(), [True, False]))
bool2values = dict(zip([True, False], foo.values()))
>>> bool2values[not keys2bool['bar']]
'someThingElse'

pass value by reference into python function

I have allowed = ['someoption','someother'],
,and default = 'default_value'
v comes from user input.
then when I do :
v = v if v.lower() in allowed else default, it works as expected,
v is taking values only if user specified option listed in allowed list, else is set to default_value.
However, I wanted to isolate validation into function by defining it like:
def validate(value, rules, default)
value if value.lower() in rules else default
, but now when I do validate(v, allowed, default), and try to enter value not in allowed list, instead of getting v hold the default_value, I get whatever I entered.
So I expected for v to be passed as reference and being changed, but that did not happened. What should I do, to get the expected result?

Simple solution
First, small correction to your validate function:
def validate(value, rules, default)
return value if value.lower() in rules else default
and then simply assign the value to your result
v = "something"
allowed = ["someoption", "someother"]
default = "default_value"
v = validate(v, allowed, default)
Just keep it simple.
Regarding "pass by reference" - Python does not have this concept. If you pass into a function immutable type of value (like a string), it goes in the way which could be called "by value". If you pass in mutable object (like list), it goes in the way which could be called "by reference". There is no way, you would instruct Python to change how this is done.
ugly_validate with changing result "in place"
If you would really insist on modifying the result being passed in, this (ugly) way could work:
>>> def ugly_validate(value_lst, rules, default):
... if value_lst[0].lower() not in rules:
... value_lst[0] = default
...
>>> v = "something"
>>> allowed = ["someoption", "someother"]
>>> default = "default_value"
>>> v_lst = [v]
>>> ugly_validate(v_lst, allowed, default)
>>> v_lst
['default_value']
>>> v = "someoption"
>>> v_lst = [v]
>>> ugly_validate(v_lst, allowed, default)
>>> v_lst
['someoption']
Alternative solution using "identity dictionary" of allowed values
>>> allowed_dct = {key: key for key in allowed}
>>> allowed_dct
{'someoption': 'someoption', 'someother': 'someother'}
>>> res = allowed_dct.get(v, default)
>>> res
'someoption'
>>> v = "unknown"
>>> res = allowed_dct.get(v, default)
>>> res
'default_value'
Using dedicated class
>>> class AllowedValues():
... def __init__(self, allowed_values, default):
... self.allowed_values = allowed_values
... self.default = default
... def get(self, value):
... if value.lower() in self.allowed_values:
... return value
... else:
... return self.default
...
>>> allowed
['someoption', 'someother']
>>> judge = AllowedValues(allowed, default)
>>> v = "someoption"
>>> v = judge.get(v)
>>> v
'someoption'
>>> v = "unknonw"
>>> v = judge.get(v)
>>> v
'default_value'

In Python everything is passed by asssigment. In your case, the value name is assigned the same object that v is pointing to but as soon as you change value, since what it is pointing to (a string) is immutable, it actually atarts poonting to a new string object and no longer to what v Is pointing to.
The best way to do what you want to do is for the validate function to return the new value (if it's not in rules.
Alternatively (but not recommended), if you make v point to a list containing the user-entered string, then since lists are mutable, the change to the list inside the validate function will also be "visible" outside of that function.