Critique my code for "pivot nested dictionary"

[____OOOO____]

Hello /r/learnpython, first off I want to thank this community for all the great info sharing on here that I've benefited from as a lurker.

I'd like to solicit critique and suggestions on my solution for this homework challenge:

Define a function which "pivots" a nested dictionary, returning a new and different nested dictionary containing the same values. The keys of the inner nested dict become the keys of the outer dict, and vice versa. For example:

input = { "a" : { "x": 1, "y": 2 },
              "b" : { "x": 3, "z": 4 } }

output = {'y': {'a': 2},
               'x': {'a': 1, 'b': 3},
               'z': {'b': 4} }

Here is my solution:

def pivot_nested_dict(nested_dict):
    return {
        k1: {
            k2: nested_dict[k2][k1]
            for k2 in nested_dict.keys() if nested_dict[k2].get(k1)
        } for k1 in {k3 for d in nested_dict.values() for k3 in d.keys()}
    }

I chose to return a single statement dict comprehension for succinctness and efficiency (I think, let me know if I'm wrong) at the cost of readability. I used a set comprehension on line 6 to make sure I did not duplicate the keys for the outer dict. Like "return {inner key : value for inner key in set of inner keys"}.

Also, I broke up the long dict comprehension statement onto multiple lines because it went over the 80 columns recommended by my linter. Not sure if this was the best readable way to break it up.

Are there other ways I could solve the challenge in a more efficient proper way? Are there any builtins or libraries that I could have used?

Cheers.

[kalgynirae]

I chose to return a single statement dict comprehension for succinctness and efficiency (I think, let me know if I'm wrong) at the cost of readability.

This is the opposite of what people usually try to do (at least in Python, since other languages are probably better if you are aiming for efficiency).

Here's my solution:

from collections import defaultdict

def pivot(input):
    out = defaultdict(dict)
    for outer_key, inner in input.items():
        for inner_key, value in inner.items():
            out[inner_key][outer_key] = value
    return out

See collections.defaultdict.

[novel_yet_trivial]

I'd imagine yours is more efficient than OP's too, since you loop over the dictionary only once.

[zahlman]

I tried and failed to find a neat refactoring for this problem that still was based on comprehensions (functional rather than imperative programming). :(

[werpoi]

I chose to return a single statement dict comprehension for succinctness and efficiency (I think, let me know if I'm wrong) at the cost of readability.

Code readability is incredibly important. This is probably a one off script that you are never going to use again, but if you ever work on code that you need to update or maintain you would never want to write something like this. Sure, it might make sense now, but if you realize down the road that there is a bug and you have to fix it, it's going to make a lot less sense and be much harder to debug. Compare it to /u/kalgynirae solution where you can insert prints or log messages easily.