python list sorting

Example 1:
>>>L = [2,3,1,4]
>>>L.sort()
>>>L
>>>[ 1,2,3,4]
Example 2:
>>>L = [2,3,1,4]
>>>L.sort(reverse=True)
>> >L
>>>[4,3,2,1]
Example 3: Sorting the second keyword
>>>L = [('b',6),(' a',1),('c',3),('d',4)]
>>>L.sort(lambda x,y:cmp(x[1],y[1]) )
>>>L
>>>[('a', 1), ('c', 3), ('d', 4), ('b', 6)]
Example 4: Sort the second keyword
>>>L = [('b',6),('a',1),('c',3),('d',4 )]
>>>L.sort(key=lambda x:x[1])
>>>L
>>>[('a', 1), ('c ', 3), ('d', 4), ('b', 6)]
Example 5: Sorting the second keyword
>>>L = [('b',2), ('a',1),('c',3),('d',4)]
>>>import operator
>>>L.sort(key=operator.itemgetter( 1))
>>>L
>>>[('a', 1), ('b', 2), ('c', 3), ('d', 4) ]
Example 6: (DSU method: Decorate-Sort-Undercorate)
>>>L = [('b',2),('a',1),('c',3),( 'd',4)]
>>>A = [(x[1],i,x) for i,x in enumerate(L)] #i can confirm the stable sort
>>> ;A.sort()
>>>L = [s[2] for s in A]
>>>L
>>>[('a', 1), ( 'b', 2), ('c', 3), ('d', 4)]
The above gives 6 methods for sorting List, among which Example 3.4.5.6 can play a role in sorting List items. A certain item
is sorted for comparison keywords.
Efficiency comparison:
cmp Through experimental comparison, method 3 is slower than method 6, method 6 is slower than method 4, method 4 and method 5 are basically Quite
multi-keyword comparison sorting:
Example 7:
>>>L = [('d',2),('a',4),('b',3),('c' ,2)]
>>> L.sort(key=lambda x:x[1])
>>> L
>>>[('d', 2), ( 'c', 2), ('b', 3), ('a', 4)]
We see that the sorted L at this time is only sorted according to the second keyword,

If we Do you want to use the second keyword to sort and then use the first keyword to sort? There are two methods
Example 8:
>>> L = [('d',2),(' a',4),('b',3),('c',2)]
>>> L.sort(key=lambda x:(x[1],x[0]))
>>> L
>>>[('c', 2), ('d', 2), ('b', 3), ('a', 4)]
Example 9:
>>> L = [('d',2),('a',4),('b',3),('c',2)]
>>> ; L.sort(key=operator.itemgetter(1,0))
>>> L
>>>[('c', 2), ('d', 2), (' b', 3), ('a', 4)]




For simple list sorting, just call the built-in function directly, but for dict list sorting it is not so straightforward, but there are still A very simple method, such as:

>>> ls1 = [{'a' : 1, 'b' : 12}, {'a' : -1, 'b' : 22},{' a' : 12, 'b' : 32},{'a' : 6, 'b' : 42}]
  >>> ls1.sort(key=lambda obj:obj.get('a') )
                                                                                                                                                                                                                                  : 42}, {'a': 12, 'b': 32}]
& gt; & gt; & gt;

Python DICT and List Sorting
1, List Sorting List is Python's built -in function, which contains SORT itself Method
Such as:
>>> s=[2,1,3,0]
>>> s.sort()
[0, 1, 2, 3]
2. dict sorting
To sort the dictionary, because each item includes a key-value pair, you must choose a comparable key or value to sort

sorted(iterable[, cmp[, key[, reverse]]]
cmp and key generally use lambda
For example:
>>> d={"ok":1,"no":2}
Sort the dictionary by key and return it in the form of a tuple list
>>> ; sorted(d.items, key=lambda d:d[0])
[('no', 2), ('ok', 1)]
Sort the dictionary by value and return it as a tuple list
>>> sorted(d.items, key=lambda d:d[1])
[('ok', 1), ('no', 2)]
3. Tuple list sorting
Such as
>>> li=[(2,'a'),(4,'b'),(1,'d')]
>>> li.sort()
[(1, 'd'), (2, 'a'), (4, 'b')]
If the dictionary is sorted by the first element of the item, it can be converted into a list of tuples
>>> d ={"ok":1,"no":2}
>>> tt=[tuple(item) for item in d.items()]
>>> tt.sort()
[('no', 2), ('ok', 1)]
4 Other people’s implementations, keep a note
The following is an example of a structure


>>> class test:
def __init__ (self,a,b):
                                                                                                                                         
>>> tests = [test1,test2]
>>> sorted (tests,cmp = lambda x,y: cmp(x.a, y.a)) (tests,key = lambda d:d.a)
5、

# (IMHO) the simplest approach:
def sortedDictValues1(adict):
items = adict.items()
items.sort()
return [value for key , value in items]

# an alternative implementation, which
# happens to run a bit faster for large
# dictionaries on my machine:
def sortedDictValues2(adict):
keys = adict.keys()

keys.sort ()

return [dict[key] for key in keys]

# a further slight speed-up on my box
# is to map a bound-method:
def sortedDictValues3(adict):
keys = adict.keys ()
keys.sort()
return map(adict.get, keys)