Is it possible to have optional keys in a dict literal?

Question

Is it possible to have 'optional' keys in a dict literal, rather than add them in in if statements?

Like so:

a = True
b = False
c = True
d = False

obj = {
    "do_a": "args for a" if a,
    "do_b": "args for b" if b,
    "do_c": "args for c" if c,
    "do_d": "args for d" if d,
}

#expect:
obj == {
    "do_a": "args for a",
    "do_c": "args for c",
}

Edit for context: I know how to do the logic :) I just want to avoid if statements because my object is a big block of data that represents declarative logic, so moving stuff around is a bit like "spaghetti coding" something that isn't meant to be procedural at all. I want the value of the object to "look like what it means" as a query.

It's actually an elasticsearch query, so it will look like this:

{
    "query": {
        "bool": {
            "must": [
                 <FILTER A>,
                 <FILTER B>,  # would like to make this filter optional
                 <FILTER C>,
                 {
                     "more nested stuff" : [ ... ]
                 }
             ],
             "other options": [ ... ]
        },
        "other options": [ ... ]
    },
    "other options": [ ... ]
}

and my possibly-dubious goal was to make it look like a query that you could look at and understand the shape of it, without having to trace through ifs. ie, without having "filters": [f for f in filters if f.enabled] because then you have to go and look for the filters, which are all optional-constants anyway here

Answer 1

I think the answer is 'no', as stated by other answers, but here is the closest I've gotten so far...

It's slightly on the 'abhorrent' side of 'wtf' though

a = True
b = False
c = True
d = False

obj = {
    **({"do_a": "args for a"} if a else {}),
    **({"do_b": "args for b"} if b else {}),
    **({"do_c": "args for c"} if c else {}),
    **({"do_d": "args for d"} if d else {}),
}

#expect:
assert(obj == {
        "do_a": "args for a",
        "do_c": "args for c",
    })

or if you want to put the optional-ness in some function:

def maybe(dictionary, condition, default=None):
    return dictionary if condition else default or {}

obj = {
    **maybe({"do_a": "args for a"}, a),
    **maybe({"do_b": "args for b"}, b),
    **maybe({"do_c": "args for c"}, c),
    **maybe({"do_d": "args for d"}, d),
}

The problem with this kind of code is that the conditions get further and further from the results (imagine that we end up passing large dicts to the first param in maybe).

Answer 2

Start by defining your lists of keys, arguments, and boolean variables:

keys = ["do_a", "do_b", ...]
args = ["args for a", "args for b", ...]
mask = [a, b, ...]

Now, construct obj using the mask list to determine what keys are inserted:

obj = {k : a for k, a, m in zip(keys, args, mask) if m}

Alternatively,

obj = {}
for k, a, m in zip(keys, args, mask):
    if m:
        obj[k] = a

Answer 3

No, you can't have "optional values" in a literal. The results of the expressions in the literal are always inserted into the result.

However I would argue that an explicit if statement would probably be better to follow anyway:

a = True
b = False
c = True
d = False

obj = {}
if a: obj["do_a"] = "args for a"
if b: obj["do_b"] = "args for b"
if c: obj["do_c"] = "args for c"
if d: obj["do_d"] = "args for d"

---

Just to mention a few alternatives in case you really don't like the ifs:

• You could also use a different value in case the argument is "false"-ey and then filter the dictionary:

  _to_remove = object()
  
  obj = {
      "do_a": "args for a" if a else _to_remove,
      "do_b": "args for b" if b else _to_remove,
      "do_c": "args for c" if c else _to_remove,
      "do_d": "args for d" if d else _to_remove,
  }
  
  obj = {key: value for key, value in obj.items() if value is not _to_remove}
  

• Or use itertools.compress and the dict builtin:

  key_value_pairs = [
      ("do_a", "args for a"), 
      ("do_b", "args for b"), 
      ("do_c", "args for c"), 
      ("do_d", "args for d")
  ]
  
  from itertools import compress
  
  obj = dict(compress(key_value_pairs, [a, b, c, d]))
  

Answer 4

Here is a different approach. Given your same definitions of:

a = True
b = False
c = True
d = False

You can then construct your literals as three member tuples:

li=[
    ("do_a", "args for a",a),
    ("do_b", "args for b",b),
    ("do_c", "args for c",c),
    ("do_d", "args for d",d)
]

This is equivalent to using zip with three lists of literals but perhaps easier for human eyes to understand the intent with shorter lists.

And then construct your dict conditionally as so:

>>> dict([(k,v) for k,v,f in li if f])
{'do_c': 'args for c', 'do_a': 'args for a'}

---

With the clarification in the post, you can use a function as a dict value and simply call the function as the dict is created (or as you update the dict) :

def filter_a():
    # some expensive function...
    return "<FILTER A>"

def filter_b():
    return "<FILTER B>"  

def filter_c():
    return "<FILTER C>"    

def filter_d():
    return "<FILTER D>" 

li=[
    ("do_a", filter_a, a),
    ("do_b", filter_b, b),
    ("do_c", filter_c, c),
    ("do_d", filter_d, d)
]

Then only the related filter functions are called as constructed:

>>> dict((k,v()) for k,v,f in li if f)
{'do_c': '<FILTER C>', 'do_a': '<FILTER A>'}

Then B and D are never called.

Better still, write the logic so that FILTER X is a form of generator and returns data only as needed.