파이썬 목록 정렬

예 1:
>>>L = [2,3,1,4]
>>>L.sort()
>>>L
>>>[1,2,3,4]
예 2:
>>>L = [2,3,1,4]
>> ;>L.sort(reverse=True)
>>>L
>>>[4,3,2,1]
예 3: 두 번째 키워드의 경우 정렬
>>>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)]
예시 4: 두 번째 키워드 정렬
>>> ;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)]
예 5: 두 번째 키워드 정렬
>>>L = [('b',2),('a',1 ),('c', 3),('d',4)]
>>>가져오기 연산자
>>>L.sort(key=operator.itemgetter(1) )
>> ;>L
>>>[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
예 6: (DSU 방법: Decorate-Sort-Undercorate)
>>>L = [('b',2),('a',1),('c ',3),(' d',4)]
>>>A = [(x[1],i,x) for i,x in enumerate(L)] #i는 안정적인 정렬을 확인할 수 있습니다
> >>A.sort()
>>>L = [s[2] for s in A]
>>>L
>>>[ ('a', 1), ('b', 2), ('c', 3), ('d', 4)]
위에서는 6쌍의 목록 정렬 방법을 제공합니다. 예 3.4.5.6은
목록 항목의 특정 항목을 정렬하는 데 사용됩니다.
효율성 비교:
cmp < DSU < 키
실험적 비교를 통해 방법 3은 방법 6보다 느립니다. 방법 6은 방법 4보다 느리고 방법 4와 방법 5는 기본적으로 동일합니다.
다중 키워드 비교 정렬:
예 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)]
이때 정렬된 L은 두 번째 키워드에 따라서만 정렬된 것을 볼 수 있습니다.

두 번째 키를 사용하려면 단어를 정렬한 후 첫 번째 키워드로 정렬하는 방법은 두 가지가 있습니다. 메서드
예 8:
>>> L = [('d',2),('a' ,4),('b',3),('c',2) ]
>>> L.sort(key=lambda x:(x[1],x[0]))
>>> [('c', 2), ('d', 2), ('b', 3), ('a', 4 )]
예 9:
>>> [('d',2),('a',4),('b',3),('c',2 )]
>>> itemgetter(1,0))
>>> L
>>>[('c' , 2), ('d', 2), ('b', 3) , ('a', 4)]




간단한 목록 정렬은 직접 내장 함수를 호출하면 되지만 dict 목록 정렬은 그리 간단하지 않습니다. 다음과 같은 매우 간단한 방법도 있습니다.

>>> 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'))
>>> ls1
[{'a': -1, 'b': 22}, {'a': 1, 'b': 12 }, {'a': 6, 'b': 42}, {'a': 12, 'b': 32 }]
>>>

사전 및 목록 정렬 Python
1. 목록 정렬
목록 정렬은 Python에 내장된 기능이며 정렬 메서드가 포함되어 있습니다.
예:
>>> ,3,0]
>>> s.sort()
[0, 1, 2, 3]
2 , dict 정렬
각 항목에 다음이 포함되어 있으므로 사전 정렬 키-값 쌍이므로 정렬을 위해 비교 가능한 키 또는 값을 선택하세요.

sorted(iterable[, cmp[, key[, reverse ]]]
cmp와 키는 일반적으로 다음과 같은 람다
를 사용합니다.
>>> d={"ok":1,"no":2}
사전을 키별로 정렬하고 다음 형식으로 반환합니다. 튜플 목록
>>> sorted(d.items, key=lambda d:d[0])
[('no', 2), ('ok', 1)]
쌍 사전 값으로 정렬, 튜플 목록으로 반환
>>> sorted(d.items, key=lambda d:d[1])
[('ok', 1) , (' no', 2)]
3. 튜플 목록 정렬
예:
>>> ,(1, 'd')]
>>> li.sort()
[(1, 'd'), (2, 'a'), (4, 'b') ]
사전이 항목의 첫 번째 요소로 정렬되면 튜플 목록으로 변환될 수 있습니다
>>> d={"ok":1,"no":2}
>> ;> tt=[d.items()의 항목에 대한 tuple(item)]
>>> tt.sort()
[('no', 2) , ('ok', 1)]
4 다른 사람의 구현, 메모 유지
다음은 구조의 예입니다


>>> > def __init__(self ,a,b):
self.a = a
self.b = b
>>> test1 = test(5,25)
>> ;> test2 = test(10,15)
>>> 테스트 = [test1,test2]
>> sorted(tests,cmp = 람다 x,y: cmp(x.a) , y.a))　🎜>
>>> result = sorted(tests,key =lambda d:d.a)
5、

# (IMHO) 가장 간단한 접근 방식:
def sortedDictValues1(adict ):
items = adict.items()
items.sort()
return [키 값, 항목 값]

# 대체 구현,
# 큰 경우 조금 더 빠르게 실행됩니다.
내 컴퓨터의 # 사전:
def sortedDictValues2(adict):
keys = adict.keys()

keys.sort()

return [dict[key] for key in key]

# 내 상자에서 약간의 속도 향상
#은 경계 메서드를 매핑하는 것입니다:
def sortedDictValues3 (adict):
키 = adict.keys()
키.정렬()
반환 맵(adict.get, 키)