Dealing with optional python dictionary fields

The pythonic way of going about it would be using the try/except block –

dictionary2 = {"required": {"value1": "one", "value2": "two"}}
try:
    value1 = dictionary2["optional"]["value1"]
except (KeyError, AttributeError) as e:
    value1 = ""

KeyError to capture the missing keys, and AttributeError to capture cases where you have a list/str instead of dict object.

---

If you don’t like tons of try/except in your code, you can consider using a helper function –

def get_val(data, keys):
    try:
        for k in keys:
            data = data[k]
        return data
    except (KeyError, AttributeError) as e:
        return ""

dictionary2 = {"required": {"value1": "one", "value2": "two"}}
print(get_val(dictionary2, ("required", "value2")))
print(get_val(dictionary2, ("optional", "value1")))

outputs –

two

In your code here:

try:
    value1 = dictionary2.get("optional").get("value1")
except AttributeError:
    value1 = " "

You can use brackets and except KeyError:

try:
    value1 = dictionary2["optional"]["value1"]
except KeyError:
    value1 = " "

If this is too verbose for the caller, add a helper:

def get_or_default(d, *keys, default=None):
    try:
        for k in keys:
            d = d[k]
    except (KeyError, IndexError):
        return default
    return d

if __name__ == "__main__":
    d = {"a": {"b": {"c": [41, 42]}}}
    print(get_or_default(d, "a", "b", "c", 1)) # => 42
    print(get_or_default(d, "a", "b", "d", default=43)) # => 43

You could also subclass dict and use tuple bracket indexing, like NumPy and Pandas:

class DeepDict(dict):
    def __init__(self, d, default=None):
        self.d = d
        self.default = default

    def __getitem__(self, keys):
        d = self.d
        try:
            for k in keys:
                d = d[k]
        except (KeyError, IndexError):
            return self.default
        return d

    def __setitem__(self, keys, x):
        d = self.d
        for k in keys[:-1]:
            d = d[k]
        d[keys[-1]] = x

if __name__ == "__main__":
    dd = DeepDict({"a": {"b": {"c": [42, 43]}}}, default="foo")
    print(dd["a", "b", "c", 1]) # => 43
    print(dd["a", "b", "c", 11]) # => "foo"
    dd["a", "b", "c", 1] = "banana"
    print(dd["a", "b", "c", 1]) # => "banana"

But there might be an engineering cost to this if it’s confusing for other developers, and you’d want to flesh out the other expected methods as described in How to "perfectly" override a dict? (consider this a proof-of-concept sketch). It’s best not to be too clever.

You could use toolz.dicttoolz.get_in() for this:

from toolz.dicttoolz import get_in

dictionary1 = {"required": {"value1": "one", "value2": "two"}, "optional": {"value1": "one"}}
dictionary2 = {"required": {"value1": "one", "value2": "two"}}

get_in(("optional", "value1"), dictionary1)
# 'one'

get_in(("optional", "value1"), dictionary2)
# None

If you don’t want to install the whole library, you can just copy the source licensed under BSD:

import operator
from functools import reduce

def get_in(keys, coll, default=None, no_default=False):
    try:
        return reduce(operator.getitem, keys, coll)
    except (KeyError, IndexError, TypeError):
        if no_default:
            raise
        return default

^{Since you like one-liners like dictionary2["optional"]["value1"] if "optional" in dictionary2 else " " and dictionary2.get("optional", {}).get("value1", " "), I thought to also suggest}

getattr(dictionary2.get("optional"), "get", {}.get)("value1", " ")

By using getattr, this also accounts for [and would return " " on] dictionary2['optional'] not being a dictionary [instead of raising an AttributeError or TypeError with the other two methods].

If wrapped as a function, it would be something like

# get_v2 = lambda d, k1, k2, vDef=None: getattr(d.get(k1), 'get', {}.get)(k2,vDef) ## OR
def get_v2(d, k1, k2, vDef=None): 
    return getattr(d.get(k1), 'get', {}.get)(k2,vDef)

a = get_v2(dictionary1, 'optional', 'value1', vDef=' ') ## -->  a='one'
b = get_v2(dictionary2, 'optional', 'value1', vDef=' ') ## -->  b=' '

---

However, if you want to be able to call it for any number of keys you’ll need to used either recursion

def getVal(obj, k1, *keys, vDef=None):
    nxtVal = getattr(obj, 'get', {}.get)(k1, vDef)
    return getVal(nxtVal, *keys, vDef=vDef) if keys else nxtVal

or a loop

def getVal(obj, *keys, vDef=None):
    for k in keys: obj = getattr(obj, 'get', {}.get)(k, vDef)
    return obj

---

Although, I think it’s more efficient to use try..except as already suggested by some.

def getVal(obj, k1, *keys, vDef=None):
    try: return getVal(obj[k1], *keys, vDef=vDef) if keys else obj[k1]
    except: return vDef

or

def getVal(obj, *keys, vDef=None):
    try: 
        for k in keys: obj = obj[k]
    except: obj = vDef
    return obj

---

You can also write a function that returns a function [ a bit like operator.itemgetter ] and can be used like valGetter("optional", "value1")(dictionary2, " ")

def valGetter(k1, *keys):
    if keys:
        def rFunc(obj, vDef=None):
            try: 
                for k in (k1,)+(keys): obj = obj[k]
            except: obj = vDef
            return obj
    else: 
        def rFunc(obj, vDef=None):
            try: return obj[k1]
            except: return vDef 
    return rFunc

but please note that this can turn out to be rather slow compared to the other methods.