[Python(파이썬)] 2차원 리스트 정렬_인덱스, 길이 등에 따른 정렬

1차원 리스트 정렬

 

[Python(파이썬)] sort와 sorted 차이

 

1) 1차원 리스트 길이에 따른 정렬

>>> test = ['abd', 'a', 'b', 'eg', 'adbde', 'aedb']

>>> test.sort(key = len)

>>> test
['a', 'b', 'eg', 'abd', 'aedb', 'adbde']

 

2) 여러가지 정렬

test.sort(key = lambda x : (len(x), 함수,  x)) 

정렬을 길이, 함수의 결과 값, 사전 순 등 다양하게 할 수 있다.

 

<여러가지 정렬 경우 예시 문제>

[백준(Baekjoon)] 1431 시리얼 번호

 

 

 

 

2차원 리스트 정렬

 

1. sort()

- 첫번째 인덱스의 값으로 정렬한다. 그리고 첫번째 인덱스의 값이 같다면 두번째 인덱스의 값을 비교한다. 

>>> test = [[15, 'e'], [12, 'c'], [21, 'a'], [9, 'z']]
>>> test.sort()

>>> test
[[9, 'z'], [12, 'c'], [15, 'e'], [21, 'a']]


# 첫번째 인덱스에 같은 값이 있을 때 
>>> test = [[15, 'e'], [12, 'c'], [12, 'a'], [9, 'z']]
>>> test.sort()

>>> test
[[9, 'z'], [12, 'a'], [12, 'c'], [15, 'e']]

 

역순으로 정렬 (reverse = True)

- 첫번째 인덱스를 역순으로 정렬하고 같은 값이 있으면 두번째 인덱스를 역순으로 정렬

>>> test = [[15, 'e'], [12, 'c'], [21, 'a'], [9, 'z']]
>>> test.sort(reverse = True)
>>> test
[[21, 'a'], [15, 'e'], [12, 'c'], [9, 'z']]

# 첫번째 인덱스의 값이 같은 경우
>>> test = [[15, 'e'], [12, 'a'], [12, 'c'], [9, 'z']]
>>> test.sort(reverse = True)
>>> test
[[15, 'e'], [12, 'c'], [12, 'a'], [9, 'z']]

 

2. sorted()

>>> test = [[15, 'e'], [12, 'c'], [12, 'a'], [9, 'z']]

>>> sorted(test)
[[9, 'z'], [12, 'a'], [12, 'c'], [15, 'e']]

>>> sorted(test, key=lambda x:x[0])
[[9, 'z'], [12, 'c'], [12, 'a'], [15, 'e']]

>>> sorted(test, key=lambda x: (x[1], x[0]))
[[12, 'a'], [12, 'c'], [15, 'e'], [9, 'z']]

- sorted(test) : 0번 인덱스에 대해 정렬 후 1번 인덱스에 대해 정렬 (0번부터 순서대로)

- sorted(test, key=lambda x:x[0]) : 0번 인덱스에 대해서만 정렬

- sorted(test, key=lambda x: (x[1], x[0])) :  1번 인덱스에 대해 정렬 후 0번 인덱스에 대해 정렬

 

 

역순으로 정렬 (-x[])

>>> test = [[15, 'e'], [12, 'c'], [19, 'c'], [9, 'c'], [38, 'a']]

>>> sorted(test, key=lambda x: (x[1], -x[0]))
[[38, 'a'], [19, 'c'], [12, 'c'], [9, 'c'], [15, 'e']]

>>> sorted(test, key=lambda x: (-x[1], x[0]))
Traceback (most recent call last):
  File "<pyshell#33>", line 1, in <module>
    sorted(test, key=lambda x: (-x[1], x[0]))
  File "<pyshell#33>", line 1, in <lambda>
    sorted(test, key=lambda x: (-x[1], x[0]))
TypeError: bad operand type for unary -: 'str'

- sorted(test, key=lambda x: (x[1], -x[0])) : 1번 인덱스에 대해서 정렬 후 0번 인덱스에 대해 역순으로 정렬

- sorted(test, key=lambda x: (-x[1], x[0])) :  문자열을 위와 같은 방법으로 정렬하려고 하면 error 발생

 

 

---

ex)

 

>>> test = [[0.333, 1, 50, 1], [0.333, 0, 82, 2], [0.666, 2, 75, 3], [0.666, 0, 120, 4]]

>>> sorted(test, key=lambda x: (-x[0], -x[1], -x[2], x[3]))
[[0.666, 2, 75, 3], [0.666, 0, 120, 4], [0.333, 1, 50, 1], [0.333, 0, 82, 2]]

 

• sorted(test, key=lambda x: (-x[0], -x[1], -x[2], x[3]))

0번 인덱스에 대해 역순으로 먼저 정렬 후 1번 인덱스에 대해 역순으로 정렬 하고 그 다음 2번 인덱스에 대해 역순으로 정렬 후 3번 인덱스에 대해 정렬

 

# 정렬 전
[[0.333, 1, 50, 1], 
 [0.333, 0, 82, 2], 
 [0.666, 2, 75, 3], 
 [0.666, 0, 120, 4]]

# 정렬 후 
[[0.666, 2, 75, 3], 
 [0.666, 0, 120, 4], 
 [0.333, 1, 50, 1],
 [0.333, 0, 82, 2]]

 

 

 

 

3. sorted를 sort 방식으로 바꾸기 

• test = sorted(test, key=lambda x: (-x[0], -x[1], -x[2], x[3])) 
• test.sort(key=lambda x: (-x[0], -x[1], -x[2], x[3])) 

위의 두 방식은 원본의 내용을 바꾸지 않고 정렬된 내용을 새로운 리스트로 반환하는 sorted 방식과 원본의  내용을 정렬한 형태로 바꿔주는  sort 방식의 차이일뿐 정렬은 똑같이 key=lambda x: (-x[0], -x[1], -x[2], x[3]) 를 사용하여 할 수 있다.