In SQL, we can specify desc/asc order for each sorting key, i.e. order by key1 desc, key2 asc. How can I acheive the same thing to sort a list of tuples in python?
Suppose I have a list like
[("a", "b", "e"), ("b", "a", "c"), ("b", "a", "d")] I want to use the second key in asc order and the third ky in desc order. So the result is
[("b", "a", "d"), ("b", "a", "c"), ("a", "b", "e")] Note, the elements can be any type that has comparison methods (i.e. __lt__, __gt__ etc)
You need to build a suitable key function for sorting - see Sort tuples based on second parameter and plenty of others
data = [("a", "b", "c"), ("b", "a", "c"), ("b", "a", "d")] s = sorted(data, key = lambda x: (x[1],-ord(x[2]))) # "trick" to sort descending print (s) gives
[('b', 'a', 'd'), ('b', 'a', 'c'), ('a', 'b', 'c')] You use a "customized" tuple as key and need to be a bit creative building it.
The ord funciton gives you the ascii value of the character, by negating it you "sort descending" on it.
If you sort more then letters you need to be even more creative.
Not seriously tested:
data = [("a", "b", "cesa"), ("b", "a", "ceta"), ("b", "a", "derived")] s = sorted(data, key = lambda x: (x[1], tuple((-ord(t) for t in x[2])) ) ) to get
[('b', 'a', 'derived'), ('b', 'a', 'ceta'), ('a', 'b', 'cesa')] 
You can use two sorts (they're stable) in order of decreasing priority:
>>> from operator import itemgetter >>> a = [("a", "b", "e"), ("b", "a", "c"), ("b", "a", "d")] >>> a.sort(key=itemgetter(2), reverse=True) >>> a.sort(key=itemgetter(1)) >>> a [('b', 'a', 'd'), ('b', 'a', 'c'), ('a', 'b', 'e')] Last time I checked, this was btw faster than a single sort with a more complicated key function. And it takes less memory than a key function creating new tuples.
See Python's Sorting HOW TO for more examples of this.
I found a way where I create a sorter class that has custom comparison methods. This is not an efficient way but works fine.
from functools import total_ordering def _apply(v, k): if callable(k): return k(v) else: return v[k] def smart_sort(xs, getters_and_orders): orders = [] getters = [] for x in getters_and_orders: if isinstance(x, tuple): g, o = x else: g = x o = "desc" getters.append(g) orders.append(o) @total_ordering class _Sorter: def __init__(self, v): self._values = [_apply(v, g) for g in getters] def __eq__(self, other): return self._values == other._values def __lt__(self, other): for (a, b, o) in zip(self._values, other._values, orders): if a != b: return a > b if o == "desc" else a < b return False return sorted(xs, key=_Sorter) xs = [("a", "b", "e"), ("b", "a", "c"), ("b", "a", "d")] ret = smart_sort(xs, [(1, "asc"), (2, "desc")]) print(ret) >> [('b', 'a', 'd'), ('b', 'a', 'c'), ('a', 'b', 'e')]
sorted(sorted(l, key=lambda x:x[1]), key=lambda x:x[2], reverse=True). There may be a better solution than this!sortfor two times is redundant. There may be a better and generic solution than this ;-) !!!