04-1 리스트

리스트는 03장 기본 자료형에서 배운 자료형들을 줄줄이 사탕으로 담는 데이터입니다. 이미 몇 번 본 적이 있는 대괄호와 쉼표로 감싸 만든 자료형이 바로 리스트입니다. 다음은 숫자형 데이터만 들어 있는 리스트를 만들고 출력하는 코드입니다.

# 숫자로 이루어진 리스트
scores = [85, 92, 78, 96, 88]
print("수학 점수 :", scores)

[실행 결과]

수학 점수: [85, 92, 78, 96, 88]

실행 결과는 입력한 값과 동일합니다. 숫자가 대괄호에 감싸져 있고 쉼표로 구분한 형태입니다. 리스트 안에 쉼표로 구분한 값은 특별히 요소element라고 부릅니다. 앞으로 요소라는 표현을 사용하겠습니다. 그러면 리스트는 요소로 구성된 데이터 묶음으로 생각해도 될 것 같습니다. 그렇다면 리스트를 사용하는 이유는 무엇일까요?

리스트 기초 연습하기

여러분이 어떤 숫자 5개를 계산해서 평균을 계산해야 한다면 어떻게 할 수 있을까요? 점수 평균을 계산해보는 상황을 통해 리스트의 기초를 연습해보겠습니다.

점수 평균 계산해보기

만약 리스트 없이 5개의 숫자형 데이터를 변수에 담아야 한다면 이렇게 코드를 작성해야 했을 겁니다.

score1 = 85
score2 = 92
score3 = 78
score4 = 96
score5 = 88

틀린 코드는 아닙니다. 그렇다면 예를 들어 평균 점수를 구하려면 어떻게 해야 할까요? 이렇게 하면 될 겁니다.

print("평균 점수:", (score1 + score2 + score3 + score4 + score5) / 5)

[실행 결과]

평균 점수: 87.8

하지만 영원히 이렇게 할 수는 없습니다. 예를 들어 점수가 100개라면 어떻게 해야 할까요? 100개의 변수가 필요하고, 100개의 변수를 100으로 나눌 식을 입력해야 합니다. 정말 불편합니다. 리스트의 '한 바구니에 담는 유용함'이 여기서 빛을 발휘합니다. 앞에서 5개의 변수로 나눠 담은 내용을 리스트로 처리하고 숫자형 데이터만 담은 리스트의 합과 길이를 처리해주는 sum( ) 함수, len( ) 함수를 사용하면 이렇게 같은 작업을 할 수 있습니다.

scores = [85, 92, 78, 96, 88]
print("리스트로 관리 :", scores)
print("평균 점수 :", sum(scores) / len(scores))

[실행 결과]

리스트로 관리 : [85, 92, 78, 96, 88]

평균 점수 : 87.8

우선 scores 변수에 리스트를 저장하여 score1, score2, ...와 같이 개별 변수에 값을 담을 필요가 없어 편해졌습니다. 그리고 리스트를 전달 받아 합이나 길이를 처리하는 함수를 사용하여 식이 훨씬 유동적입니다. 만약 점수가 추가된다면 scores에 숫자만 쉼표로 구분하여 더 추가하면 나머지 코드는 건들 필요 없이 바로 평균 점수를 계산할 수 있습니다.

[Note] 개별 변수로 관리했다면 변수 이름을 추가로 만들어야 하고, 평균을 구하는 식에도 추가한 변수를 하나씩 더해야 했을 겁니다.

인덱싱, 슬라이싱하기

문자열에서 인덱싱, 슬라이싱을 배웠습니다. 문자열은 문자가 모인 것이죠? 리스트도 값이 모인 것입니다. 따라서 리스트도 인덱싱, 슬라이싱을 할 수 있습니다. 다음은 리스트의 인덱싱입니다. 특정 요소에 접근해서 요소의 값을 출력하고 있습니다.

[Note] 여기서는 출력문에 f-string을 사용했습니다.

# 리스트의 각 요소에 접근하기
colors = ["빨강", "파랑", "노랑", "초록"]
print(f"첫 번째 색깔 : {colors[0]}")
print(f"두 번째 색깔 : {colors[1]}")
print(f"마지막 색깔 : {colors[-1]}")

[출력 결과]

첫 번째 색깔 : 빨강

두 번째 색깔 : 파랑

마지막 색깔 : 초록

슬라이싱도 이어서 알아봅니다. 슬라이싱도 문자열에서 배운 내용과 크게 다르지 않으므로 따로 설명 없이 코드만 입력해도 이해할 수 있을 겁니다.

[Note] 여기서는 출력문에 쉼표로 구분하여 출력하는 방식을 사용했습니다.

numbers = [10, 20, 30, 40, 50, 60, 70, 80]
# 슬라이싱: [시작:끝] 형태로 사용
print("처음부터 3번 인덱스 전까지:", numbers[0:3])
print("5번 인덱스부터 끝까지:", numbers[5:])

[실행 결과]

처음부터 3번 인덱스 전까지: [10, 20, 30]

5번 인덱스부터 끝까지: [60, 70, 80]

실행 결과를 보면 문자열의 슬라이싱과 다르지 않습니다. 0:3으로 지정하면 인덱스 0부터 2까지 잘라 출력하여 [10, 20, 30]을 출력하고, 5:로 지정하면 인덱스 5부터 끝까지 출력합니다.

리스트로 더하거나 곱하기

리스트는 더하거나 곱할 수 있습니다. 이 두 가지만 알아도 리스트를 훨씬 자유롭게 다룰 수 있게 됩니다. 다음 코드를 입력하여 실행해봅시다.

fruits = ["apple", "banana"]
vegetables = ["carrot", "cucumber"]
cart = fruits + vegetables
print(f"장바구니: {cart}")
repeated_fruits = fruits * 3
print(f"과일 3번 반복: {repeated_fruits}")

[실행 결과]

장바구니: ['apple', 'banana', 'carrot', 'cucumber']

과일 3번 반복: ['apple', 'banana', 'apple', 'banana', 'apple', 'banana']

더하기와 곱하기의 결과를 보면 문자열과 같은 뉘앙스로 동작한다는 걸 알 수 있습니다. 더하기의 결과는 말 그대로 리스트를 더한 순서대로 합친 것이고, 곱하기의 결과는 리스트를 반복한 결과를 합친 것임을 알 수 있습니다. 리스트 연산은 이것이 다입니다. 빼기나 나누기는 할 수 없습니다. 리스트의 연산자는 필요할 때 종종 사용하겠습니다.

for문과 함께 반복하기

리스트를 쓰는 이유는 또 하나가 있습니다. 바로 리스트를 통해 반복 작업을 쉽게 할 수 있다는 것입니다. 예를 들어 리스트 [85, 92, 78, 96, 88]의 숫자의 합은 sum( ) 함수로 계산할 수도 있지만 이렇게 for문과 함께 반복문을 구성하여 계산할 수도 있습니다. 여기서 다루는 for문은 아직 배운적이 없기 때문에 이해하기 어려울 수 있습니다. 하지만 나중에 반복문을 공부하면서 어차피 알게 될 내용이므로 미리 보겠습니다.

scores = [85, 92, 78, 96, 88]
# 반복문으로 합계 구하기
total = 0
for score in scores:

print(f"현재 점수 : {score}, 누적 합계 : {total + score}")

total = total + score

[실행 결과]

현재 점수 : 85, 누적 합계 : 85

현재 점수 : 92, 누적 합계 : 177

현재 점수 : 78, 누적 합계 : 255

현재 점수 : 96, 누적 합계 : 351

현재 점수 : 88, 누적 합계 : 439

실행 결과를 보면 score의 값과 누적 합계 total을 계산하여 출력하고 있습니다. 정확하게 5번 출력하고 있네요. scores에 있는 요소의 개수만큼 출력했습니다. 그리고 파이썬은 묶여 있는 코드 단위를 들여쓰기로 구분합니다. for score in scores:라는 표현식의 콜론 :이 들여쓰기의 시작을 알리는 표시입니다. 콜론으로 끝나는 표현식 다음에 나오는 코드는 들여쓰기로 묶을 수 있습니다. 그래서 for score in scores: ➝ scores는 이렇게 해석해볼 수 있습니다.

scores에 있는(in) 요소를 순서대로 score에 넘기고,
이후 들여쓰기로 작성한 코드를 score와 함께 반복(for) 실행한다.

이후 들여쓰기로 처리한 코드를 보면 score를 맨 앞부터 순서대로 쓰고 있는 것 같습니다. 출력문을 보면 현재 점수를 85, 92, 78, 96, 88 순서로 출력하고 있으니까요. 그러면서 total에는 0을 보관했다가 점차 합을 누적하면서 출력하고 있습니다. 그래서 처음에는 85를 출력하고, 그 다음에는 85 + 92의 결과인 177을 출력합니다. 최종으로는 85 + 92 + 78 + 96 + 88을 더한 439를 출력했습니다.

들여쓰기로 묶은 코드를 코드 블록이라고 합니다

파이썬에서는 관련된 코드들을 묶어서 하나의 단위로 만드는데, 이것을 코드 블록이라고 합니다. 콜론 : 이후 줄바꿈 다음에 나오는 들여쓰기로 맞춘 코드들이 하나의 코드 블록을 이룹니다. 다음 코드는 나중에 배울 if문과 코드 블록의 예입니다.

[Note] if문은 조건식이 맞을 때만 if문 내의 코드 블록을 실행하는 유용한 문법입니다.

score = 85
if score >= 80:
print("우수한 성적입니다")
print("축하합니다!")
print("계속 열심히 하세요")
print("성적 확인이 끝났습니다")

[실행 결과]

우수한 성적입니다

축하합니다!

계속 열심히 하세요

성적 확인이 끝났습니다

if문을 보면 if 바로_점수 >= 80:라고 입력되어 있습니다. 콜론이 보이네요. 콜론 : 뒤에 나오는 세 줄의 print( ) 함수를 보면 모두 똑같은 들여쓰기가 되어 있습니다. 이 세 줄이 하나의 코드 블록을 이루고 if문 내에 속하게 되어 if문의 조건인 score가 80점 이상일 때만 실행됩니다. 코드를 자세히 보면 score에 85를 할당했으므로 조건이 맞습니다. 그래서 우수한 성적이라는 메시지를 보여줍니다.

반면 마지막 print("성적 확인이 끝났습니다")는 들여쓰기가 되어 있지 않습니다. if문 밖에 있는 것이죠. 그래서 if문과 상관없이 항상 실행됩니다.

리스트 응용 연습하기

이제 리스트로 할 수 있는 다른 내용도 알아봅시다. 리스트는 문자열과 다르게 요소를 삭제하거나 수정하는 작업을 할 수 있습니다. 이를테면 문자열의 일부 문자를 변경하려고 다음과 같이 코드를 작성하면 오류가 발생합니다.

hi_sentence = "안녕하세요"
hi_sentence[0] = "냥"

Traceback (most recent call last):

File "<python-input-4>", line 1, in <module>

hi_sentence[0] = "냥"

~~~~~~~~~~~^^^

TypeError: 'str' object does not support item assignment

코드의 의도는 문자열 hi_sentence의 인덱스 0에 해당하는 요소(문자) "안"을 "냥"으로 바꾸려는 겁니다. 하지만 코드를 실행했더니 오류가 발생했네요. 오류 메시지를 커서 채팅창에 전달해보면 다음과 같이 해설해줍니다. 문자열의 요소, 즉, 문자는 변경할 수 없는데 그 이유가 문자열은 불변 객체이기 때문이라고 합니다.

불변 객체란 쉽게 이야기하면 값을 바꿀 수 없는 자료형 정도로 이해하면 됩니다. 문자열은 리스트와 비슷한 성질을 가지고 있지만 요소를 바꿀 수는 없습니다. 그럼 리스트는 어떨까요?

리스트의 요소 수정하기

리스트는 요소를 바꿀 수 있는 자료형입니다. 특정 위치의 요소를 다른 요소로 교체하거나, 여러 요소를 한꺼번에 수정할 수도 있습니다. 리스트의 요소를 수정하려면 인덱스로 위치를 지정하여 새 요소를 할당하면 됩니다. 변수에 값을 넣듯이 리스트[인덱스] = 값 형태로 작성하면 됩니다.

fruits = ["apple", "banana", "cherry"]
print(f"원본 리스트: {fruits}")
# 두 번째 항목 수정 (인덱스 1)
fruits[1] = "blueberry"
print(f"수정 후: {fruits}")

[실행 결과]

원본 리스트: ['apple', 'banana', 'cherry']

수정 후: ['apple', 'blueberry', 'cherry']

실행 결과를 보면 인덱스 1의 값을 "banana"에서 "blueberry"로 바꾼 것을 알 수 있습니다.

슬라이싱으로 리스트 수정하기

당연하지만 슬라이싱을 응용하면 원하는 범위의 값을 수정할 수도 있습니다. 다음은 numbers 리스트에서 인덱스 1:4 범위를 수정하는 예입니다.

numbers = [1, 2, 3, 4, 5]
print(f"원본: {numbers}")
# 중간 세 개를 한꺼번에 수정
numbers[1:4] = [20, 30, 40]
print(f"범위 수정: {numbers}")

[실행 결과]

원본: [1, 2, 3, 4, 5]

범위 수정: [1, 20, 30, 40, 5]

'범위를 꼭 맞춰야 하나?'라는 생각이 들 수 있습니다. 그렇지 않습니다. 리스트의 범위 수정은 원하는 범위에 끼워넣는 개념이므로 더 적은 양으로 교체하거나 더 많은 양으로 교체할 수 있습니다.

# 일부를 더 적은 개수로 교체
colors = ["red", "green", "blue", "yellow", "purple"]
colors[1:4] = ["orange"]
print(f"축소 수정: {colors}")
# 일부를 더 많은 개수로 교체
animals = ["cat", "dog", "bird"]
animals[1:2] = ["rabbit", "hamster", "turtle"]
print(f"확장 수정: {animals}")

[실행 결과]

축소 수정: ['red', 'orange', 'purple']

확장 수정: ['cat', 'rabbit', 'hamster', 'turtle', 'bird']

다만 1개의 값만 교체한다고 해도 범위 수정이므로 리스트 대 리스트로 생각하여 colors[1:4] = ["orange"]와 같이 작성해야 의도한 결과를 볼 수 있습니다. 만약 colors[1:4] = "orange"와 같이 작성하면 리스트 대 문자열로 생각해서 문자열을 리스트처럼 생각하여 o, r, a, n, g, e를 요소로 보고 각각 쪼갠 후 리스트에 추가합니다.

colors = ["red", "green", "blue", "yellow", "purple"]
colors[1:4] = "orange"
print(f"축소 수정: {colors}")

[실행 결과]

축소 수정: ['red', 'o', 'r', 'a', 'n', 'g', 'e', 'purple']

<1:1코칭> 리스트의 특정 인덱스에 2개 이상의 요소를 가진 리스트를 넣으면 어떻게 되나요?

만약 fruits = ["apple", "banana", "cherry"] 리스트에 fruits[0] = ["pineapple", "orange"]를 추가하면 어떻게 될까요? ["apple", "banana", "cherry"]가 ["pineapple", "orange", "banana", "cherry"]로 바뀔까요? 실행해보면 그렇지 않습니다.

fruits = ["apple", "banana", "cherry"]
fruits[0] = ["pineapple", "orange"]
print(fruits)

[['pineapple', 'orange'], 'banana', 'cherry']

결과를 보면 감이 옵니다. fruits[0]은 단위가 리스트가 아니라 요소입니다. 그래서 요소 대 요소로 보고 요소의 값을 수정하려고 합니다. 그래서 ["pineapple", "orange"] 자체를 요소 1개로 보고 수정하는 것입니다. 리스트의 수정은 = 왼쪽에 있는 값을 기준으로 하여 대등하게 처리하는 특징이 있습니다. 만약 의도한 결과를 보려면 다음과 같이 작성해야 합니다.

fruits[0:0] = ["pineapple", "orange"]
print(fruits)

['pineapple', 'orange', 'apple', 'banana', 'cherry']

fruits[0]이 아니라 fruits[0:0]으로 슬라이싱을 하면 슬라이싱의 결과가 리스트이므로 리스트에 값을 대입하려고 하므로 우리가 의도한 2개의 요소를 추가한 효과를 볼 수 있습니다.

</1:1코칭>

리스트의 요소 삭제하기

요소를 삭제하려면 remove( ), pop( ) 함수를 사용하면 됩니다. remove( ) 함수는 삭제하고 싶은 값을 직접 지정해서 지우고, pop( ) 함수는 인덱스를 지정해서 지웁니다. 먼저 remove( ) 함수부터 알아봅시다.

fruits = ["apple", "banana", "orange", "grape", "banana"]
# remove()로 값을 지정해서 삭제
fruits.remove("banana")
print("remove() 후:", fruits)

[실행 결과]

remove() 후: ['apple', 'orange', 'grape', 'banana']

실행 결과를 보면 "banana"를 리스트에서 찾아 삭제했습니다. 다만 리스트에 있던 2개의 "banana" 중 하나만 삭제했습니다. 이처럼 remove( )는 같은 요소가 여러 개 있어도 왼쪽부터 오른쪽으로 탐색하여 맨 처음 찾은 것 하나만 지웁니다.

만약 앞쪽 "banana"가 아니라 뒤쪽의 "banana"를 콕집어 지우려면 어떻게 해야 할까요? 그럴 때는 인덱스로 삭제할 수 있는 pop( ) 함수를 사용하면 됩니다.

[Note] 앞에서 remove( ) 함수로 이미 "banana"를 지웠으므로 리스트에는 4개의 요소가 남아 있을 것이므로 인덱스 3을 지정하여 pop(3)을 사용했습니다.

# pop()으로 인덱스를 지정해서 삭제
removed_fruit = fruits.pop(3)
print("pop() 후:", fruits)
print("삭제된 값:", removed_fruit)

[실행 결과]

pop() 후: ['apple', 'orange', 'grape']

삭제된 값: banana

실행 결과를 보면 pop( ) 함수는 값을 삭제하고, 리스트에서 값을 "팝"하고 튕겨내는 역할도 합니다. 그래서 지운 값을 removed_fruit 변수에 저장할 수도 있었습니다.

<1:1코칭> pop( ) 함수의 비밀, 스택

사실 pop( ) 함수는 자료구조 이론의 스택에서 등장하는 개념입니다. 스택은 여러분이 자주 사용하는 크리넥스를 생각하면 됩니다. 크리넥스에는 휴지가 겹겹이 쌓여있습니다. 휴지를 쌓을 때는 가장 먼저 넣은 휴지가 가장 마지막에 위치하겠죠? 하지만 뽑아 쓸 때는 가장 마지막에 넣은 휴지를 먼저 뽑을 겁니다. 이때 이 '뽑는' 행위가 pop( ) 함수입니다.

<<크리넥스와 함께 보는 pop 그림>>

그림을 보면 가장 마지막에 넣은 데이터를 튕겨냅니다. 그래서 리스트에 인덱스 없이 pop( ) 함수를 사용하면 가장 마지막 요소를 튕겨냅니다.

numbers = [10, 20, 30, 40, 50]
print("원래 리스트:", numbers)
last_value = numbers.pop()
print("pop() 후:", numbers)
print("꺼낸 값:", last_value)

[실행 결과]

원래 리스트: [10, 20, 30, 40, 50]

pop() 후: [10, 20, 30, 40]

꺼낸 값: 50

</1:1코칭>

리스트에 요소 추가하기

앞에서 이미 인덱싱이나 슬라이싱으로 요소를 수정하는 방법을 알았습니다. 만약 요소를 추가하려면 그 방법을 이용하면 됩니다. 하지만 좀 더 간편한 방법으로 요소를 추가하려면 어떻게 해야 할까요? 바로 append( ) 함수나 insert( ) 함수를 이용하면 됩니다. 함수 이름에서 예상할 수 있듯이 append( ) 함수는 리스트 끝 부분에 요소를 추가할 수 있고, insert( ) 함수는 리스트 중간에 요소를 추가할 수 있습니다.

fruits = ["apple", "banana"]
print("원래 리스트:", fruits)
# append()로 맨 끝에 추가
fruits.append("orange")
print("append() 후:", fruits)
fruits.append("grape")
print("한 번 더 append():", fruits)

[실행 결과]

원래 리스트: ['apple', 'banana']

append() 후: ['apple', 'banana', 'orange']

한 번 더 append(): ['apple', 'banana', 'orange', 'grape']

실행 결과를 보면 append("orange")로 리스트 맨 끝에 "orange"를 추가하여 ['apple', 'banana']가 ['apple', 'banana', 'orange']로 바뀌었습니다. 한 번 더 append("grape")를 하여 ['apple', 'banana', 'orange', 'grape']가 되었네요.

만약 중간에 요소를 추가하고 싶다면 다음과 같이 insert( ) 함수를 사용하면 됩니다. 리스트 중간에 끼워 넣어야 하므로 끼워넣을 위치인 인덱스를 함께 전달하여 insert(1, "yellow")와 같이 사용해야 합니다. 이제는 인덱스 개념이 익숙할 겁니다.

colors = ["red", "blue", "green"]
print("원래 리스트:", colors)
# insert(인덱스, 값)으로 특정 위치에 추가
colors.insert(1, "yellow")
print("insert(1, 'yellow') 후:", colors)
colors.insert(0, "purple")
print("insert(0, 'purple') 후:", colors)

[실행 결과]

원래 리스트: ['red', 'blue', 'green']

insert(1, 'yellow') 후: ['red', 'yellow', 'blue', 'green']

insert(0, 'purple') 후: ['purple', 'red', 'yellow', 'blue', 'green']

실행 결과를 보면 colors.insert(1, "yellow")와 같이 작성하여 리스트 colors에 "yellow"를 끼워넣은 것을 알 수 있습니다. 그리고 인덱스의 의미가 '끼워 넣은 다음의 위치'를 의미하는 것도 알 수 있습니다.

리스트에 포함되어 있는 요소 개수 세기

리스트에 몇 개의 요소가 들어있는지 알고 싶을 때는 len( ) 함수를 사용합니다. len( ) 함수는 리스트를 괄호 안에 넣어주기만 하면 그 리스트가 가지고 있는 요소의 개수를 정수로 돌려줍니다. 빈 리스트라면 0을 반환하고, 요소가 있다면 그 개수만큼의 숫자를 알려주죠.

fruits = ["사과", "바나나", "오렌지"]
count = len(fruits)
print(f"과일 리스트에는 {count}개의 요소가 있습니다")

[실행 결과]

과일 리스트에는 3개의 요소가 있습니다

리스트 fruits에는 세 개의 문자열이 요소로 들어 있으므로 len( ) 함수가 3을 반환했습니다. len( ) 함수는 리스트 안에 어떤 종류의 데이터가 들어있든 상관없이 개수만 세어줍니다. 예를 들어 리스트 안에 리스트가 있으면 어떻게 개수를 세어줄까요? len( ) 함수는 리스트 안에 리스트가 있으면 바깥쪽 리스트를 기준으로 요소를 셉니다. 안쪽에 들어있는 리스트가 아무리 길어도, 바깥쪽에서 보면 그냥 하나의 요소로 취급합니다.

nested_list = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
print(f"바깥쪽 리스트의 길이: {len(nested_list)}")
print(f"첫 번째 안쪽 리스트의 길이: {len(nested_list[0])}")
print(f"두 번째 안쪽 리스트의 길이: {len(nested_list[1])}")
print(f"세 번째 안쪽 리스트의 길이: {len(nested_list[2])}")

[실행 결과]

바깥쪽 리스트의 길이: 3

첫 번째 안쪽 리스트의 길이: 3

두 번째 안쪽 리스트의 길이: 2

세 번째 안쪽 리스트의 길이: 4

[1, 2, 3]은 nested_list 입장에서 리스트이긴 하지만 인덱스가 0인 요소에 불과합니다. 그래서 len(nested_list)를 실행하면 3을 반환합니다. 만약 [1, 2, 3]의 길이를 재고 싶다면 len(nested_list[0])과 같이 길이를 재려는 리스트를 콕 집어 알려주면 됩니다. 이 과정을 통해 자연스럽게 중첩 리스트의 개념을 이해하기 바랍니다.

리스트 정렬하기

리스트에 담긴 여러 개의 값들을 순서대로 정렬할 수 있습니다. 파이썬에서는 sort( ) 함수 또는 sorted( ) 함수를 사용해서 리스트를 쉽게 정렬할 수 있습니다. 두 함수는 각각 다음의 차이점이 있습니다.

• sort( ) 함수는 원본 리스트 자체를 정렬합니다. 즉, 원본 리스트를 변경합니다.

• sorted( ) 함수는 원본은 그대로 두고 정렬을 마친 리스트를 새로 만듭니다.

• 두 함수 모두 기본적으로 오름차순(작은 것부터 큰 순서)으로 정렬합니다. 만약 내림차순으로 정렬하고 싶다면 reverse=True 옵션을 사용하면 됩니다.

아직 함수를 배우기 전이라 함수의 사용 방법을 설명한 글이 쉽게 받아들여지지는 않을 겁니다. 하지만 설명 자체만 놓고 보면 이해가 됩니다. sort( ) 함수는 정렬 대상인 리스트를 직접 손을 대는 방식, sorted( ) 함수는 손을 대지 않고 복사해서 정렬하는 방식입니다. 코드를 입력해서 결과를 보면 더 쉽게 이해할 수 있습니다.

# 숫자 리스트 만들기
numbers = [85, 90, 78, 92, 88]
print(f"원본 리스트: {numbers}")
# sort() 메서드로 정렬 (원본 변경)
numbers.sort()
print(f"sort() 후: {numbers}")
# 내림차순 정렬
numbers.sort(reverse=True)
print(f"내림차순 정렬: {numbers}")

[실행 결과]

원본 리스트: [85, 90, 78, 92, 88]

sort() 후: [78, 85, 88, 90, 92]

내림차순 정렬: [92, 90, 88, 85, 78]

리스트가 들어 있는 numbers에 .sort( )를 연이어 작성하여 함수를 리스트에 적용했습니다. 적용 결과는 오름차순이므로 [85, 90, 78, 92, 88]를 [78, 85, 88, 90, 92]로 수정했습니다. reverse 옵션을 적용하는 방식도 봅니다. numbers.sort(reverse=True)라고 sort( )를 빈 상태로 두지 않고 옵션 값을 추가하면 reverse가 True, 즉, 원래 정렬 순서의 반대인 내림차순으로 정렬하여 [92, 90, 88, 85, 78]로 바뀝니다.