Sort dictionary by multiple values, where amount of values can vary

Question

To come straight to the point:

def sortBy(dict, byWhat):

  # byWhat is a list of 1 - 10 strings, which can include any of allAttributes
  # allAttributes = ['name', 'kingdom', 'diff', 'tier', 'type', 'founder', 'prover', 'server', 'extra', 'link']
  # the lower the index, the higher the sorting priority -> byWhat = ['name', 'diff'] then sort by name first and then if names are the same by diff
  
  # dict has the name as key and then allAttributes above in order as a list for the key's value, so for example:
  # dict[Jump] = [Jump, Mushroom Kingdom, 10/10, Triple Jump, Dude, Dude2, Main Server, Cool jump description, https://twitter.com]
  # All dictionary entries have those 10 attributes, no exceptions
  
  return dict # but sorted

I tried for a while but where my knowledge ends is sorting by a varying size of specifiers with lambda. I can also not just call the function multiple times, because then it won't sort by two attributes, but by the last attribute the function got called with.

"I can also not just call the function multiple times" - Sure you can. — Kelly Bundy, Jan 16 '23 at 21:49

mugiseyebrows · Answer 1 · 2023-01-16T22:03:50.837

0

You can convert dict to list of (key, value) tuples and use list.sort(key) method and utilizing functools.cmp_to_key define key as compare function and then "inject" byWhat parameter into compare function using functools.partial

from functools import cmp_to_key, partial

allAttributes = ["name", "age"]

def sortBy(d, byWhat):
    def cmp(a, b, byWhat):
        for k in byWhat:
            index = allAttributes.index(k)
            if a[1][index] != b[1][index]:
                return -1 if a[1][index] < b[1][index] else 1
        return 0
    items = list(d.items())
    items.sort(key=cmp_to_key(partial(cmp, byWhat=byWhat)))
    return dict(items)

if __name__ == "__main__":
    d = {
        "foo": ["John", 12],
        "bar": ["Adam", 12],
        "baz": ["John", 10],
    }
    print(sortBy(d, ["name", "age"]))

edited Jan 16 '23 at 22:03

answered Jan 16 '23 at 21:56

mugiseyebrows

4,138
1
14
15

Maybe I misunderstood, but I thought `sortBy()` was supposed to be the `key` function to be used in `sort()`. – Barmar Jan 16 '23 at 21:57
What's the advantage of using `cmp`-based sorting here? – Kelly Bundy Jan 16 '23 at 21:58
@KellyBundy comparing to what? – mugiseyebrows Jan 16 '23 at 22:04
@Barmar It's supposed to return the sorted dict, so I think they got this right. – Kelly Bundy Jan 16 '23 at 22:05
@mugiseyebrows Compared to a key function that just returns a list or tuple (similar to Barman's or with itemgetter). – Kelly Bundy Jan 16 '23 at 22:07
(There potentially *is* an advantage, I'd just like to see it pointed out :-) (oh and I'm also curious what *your* reason is) – Kelly Bundy Jan 16 '23 at 22:08
@KellyBundy probably no advantage, I just didn't thought of it, key function returning tuple is a better solution – mugiseyebrows Jan 16 '23 at 22:13
Could be more efficient if `byWhat` is long but items mostly differ at the first value already. The n preconputing all full tuples might be wasteful. Although repeatedly looking up the first value comes at a cost as well, especially this elaborate way. – Kelly Bundy Jan 16 '23 at 22:26
@KellyBundy if you don't mind I will post improved version – mugiseyebrows Jan 16 '23 at 22:44

score 0 · Answer 2 · answered Jan 16 '23 at 22:42

You can convert dict to list of (key, value) tuples, map byWhat into indexes and use list.sort(key) where key is lambda returning list of attributes to sort by.

allAttributes = ["name", "age"]

def sortBy(d, byWhat):
    indexes = [allAttributes.index(k) for k in byWhat]
    items = list(d.items())
    items.sort(key=lambda item: [item[1][index] for index in indexes])
    return dict(items)

if __name__ == "__main__":
    d = {
        "foo": ["John", 12],
        "bar": ["Adam", 12],
        "baz": ["John", 10],
    }
    print(sortBy(d, ["name", "age"]))

Sort dictionary by multiple values, where amount of values can vary

2 Answers2