P2-8.2 리스트(list): 순서가 있는 값 묶음¶

Section ID: P2-8.2 Version: v2026.07.23

P2-8.1에서는 값(value), 변수(variable), 타입(type)을 봤습니다. 이제 여러 값을 한 번에 다루기 위한 첫 번째 구조로 리스트(list)를 봅니다.

리스트는 같은 목적이나 맥락의 값들을 순서대로 모아 두는 자료구조(data structure)입니다. 점수 목록, 문장 목록, 파일 이름 목록, 모델 출력 목록처럼 “여러 개를 순서대로 보고 싶다”는 상황에서 자주 만납니다.

여기서는 리스트(list)와 인덱스(index)의 기본 구분을 설명합니다. 값(value), 변수(variable), 타입(type)의 대표 설명은 P2-8.1과 개념사전에 두고, 여기서는 값이 여러 개가 되었을 때 왜 순서 있는 묶음이 먼저 필요한지에 집중합니다.

앞 절이 하나의 값이 어떤 이름과 타입으로 존재하는가를 다뤘다면, 여기서는 그런 값들이 여러 개가 되었을 때 왜 순서 있는 묶음이 먼저 필요한지를 봅니다. 이 기준이 잡히면, 바로 다음 절의 딕셔너리도 또 다른 문법이 아니라 순서 대신 이름으로 찾는 구조로 읽기 쉬워집니다.

핵심 기준: 리스트(list): 순서가 있는 값 묶음¶

• 리스트(list)를 순서가 있는 값 묶음으로 설명할 수 있습니다.
• 인덱스(index)가 0부터 시작한다는 점을 설명할 수 있습니다.
• 값을 알고 시작하는 리스트, 빈 리스트, 같은 값으로 채운 리스트를 구분할 수 있습니다.
• 리스트가 바뀔 수 있는 값(mutable value)임을 설명할 수 있습니다.
• AI 실습에서 점수, 문장, 모델 출력, 파일 이름 목록을 리스트로 읽을 수 있습니다.

먼저 붙잡을 기준¶

이 절에서 가장 먼저 붙잡아야 할 기준은 리스트는 순서가 있는 값 묶음이라는 점입니다.

즉 리스트는 순서대로 담고, 위치로 꺼내고, 필요하면 바꾸는 구조라는 감각이 먼저 잡혀야 합니다.

세 가지 기준¶

여기서는 Python 문법보다 여러 값을 어떻게 한꺼번에 다룰 것인가를 먼저 봅니다. 아래 세 가지 기준이 이후 딕셔너리, 반복, 배열 설명의 바탕이 됩니다.

리스트는 순서가 있는 값 묶음이다¶

일반적으로 순서가 있는 묶음은 여러 값을 일정한 순서로 놓고, 위치(index)로 다시 꺼내는 구조입니다. 점수 목록, 문장 목록, 파일 목록처럼 “몇 번째 값인가”가 의미를 가질 때 이런 구조가 필요합니다.

Python에서는 이런 구조를 리스트(list)로 자주 표현합니다.

문제 상황: 여러 점수를 하나의 순서 있는 묶음으로 표현하는 가장 기본 모양을 먼저 보고 싶습니다. 입력(input): 점수 네 개 82, 75, 91, 68. 기대 출력(output): 점수 목록과 그 타입이 출력됩니다. 확인할 개념: 리스트는 여러 값을 순서대로 담는 기본 구조입니다.

1
2
3
4
5

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
scores = [82, 75, 91, 68]

print(scores)
print(type(scores))

Python 리스트 안의 각 값은 항목(item) 또는 원소(element)라고 부를 수 있습니다.

Python 리스트는 순서가 있으므로 위치(index)로 값을 꺼낼 수 있습니다.

문제 상황: 리스트에서 첫 번째 값과 두 번째 값을 위치로 꺼내는 방식을 확인하고 싶습니다. 입력(input): 점수 리스트 scores. 기대 출력(output): scores[0]과 scores[1] 값이 출력됩니다. 확인할 개념: 리스트의 값은 인덱스로 접근하며 Python에서는 보통 0부터 셉니다.

1
2
3
4
5

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
scores = [82, 75, 91, 68]

print(scores[0])
print(scores[1])

Python의 인덱스(index)는 보통 0부터 시작합니다. 그래서 scores[0]은 첫 번째 값입니다. 중요한 것은 “값이 어떤 순서에 놓여 있고, 그 위치로 다시 꺼낼 수 있다”는 점입니다.

이 0부터 시작하는 규칙은 낯설 수 있습니다. 하지만 Python 문자열, 리스트, 이후에 만날 NumPy 인덱싱에서도 0부터 세는 방식이 자주 나타납니다. 여기서 중요한 것은 리스트를 배열로 부르는 것이 아니라, “순서가 있는 구조에서는 위치 번호가 필요할 수 있다”는 감각입니다.

리스트는 배열을 대신하는 말이 아니다¶

다른 언어를 먼저 배운 사람은 리스트(list)를 배열(array)로 바로 이해할 수 있습니다. 둘 다 순서가 있고 위치(index)로 값을 꺼낼 수 있기 때문입니다.

하지만 이 절에서는 리스트와 배열을 같은 말로 쓰지 않습니다. Python 리스트는 여러 값을 담고 순서대로 다루는 일반 목적 컨테이너(container)에 가깝습니다. 반면 AI 수치 계산에서 말하는 배열(array)은 보통 같은 종류의 숫자를 일정한 구조로 놓고 빠르게 계산하기 위한 자료구조를 가리킵니다.

Python 공식 문서도 이 구분을 뒷받침합니다. list는 변경 가능한 시퀀스(mutable sequence)로 설명되고, 표준 라이브러리의 array 모듈은 숫자값을 효율적으로 담는 배열을 따로 제공합니다. array는 리스트처럼 동작하는 부분이 있지만, 담을 수 있는 값의 타입이 생성 시점의 type code로 제한됩니다.

혼동은 다차원 배열을 볼 때 더 커질 수 있습니다. Python에서도 리스트 안에 리스트를 넣으면 표처럼 보이는 구조를 만들 수 있습니다.

문제 상황: 리스트 안에 리스트를 넣으면 표처럼 보이는 구조가 만들어진다는 점을 먼저 보고 싶습니다. 입력(input): 두 개의 행 리스트 [1, 2, 3], [4, 5, 6]. 기대 출력(output): 중첩 리스트 rows. 확인할 개념: 중첩 리스트는 2차원처럼 보이지만 여전히 리스트 안에 리스트가 든 구조입니다.

1
2
3
4
5

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
rows = [
    [1, 2, 3],
    [4, 5, 6],
]

이 모양은 행렬(matrix)이나 2차원 배열(two-dimensional array)처럼 보입니다. 하지만 이것은 여전히 “리스트 안에 리스트가 들어 있는 구조”입니다. NumPy의 다차원 배열(ndarray)은 shape, axis, dtype 같은 정보를 가진 계산 구조이며, NumPy 문서도 ndarray를 N차원 배열로 설명합니다. 따라서 “중첩 리스트가 행렬처럼 보인다”와 “중첩 리스트가 수치 계산용 다차원 배열이다”는 구분해야 합니다.

그래서 이 절에서는 리스트를 “순서가 있는 값 묶음”으로만 읽습니다. 수치 계산을 빠르게 하기 위한 배열(array), 벡터(vector), 행렬(matrix)은 Part 2 Chapter 3과 Part 2 Chapter 11에서 별도로 다룹니다.

이 구분은 중요합니다. Python 리스트는 여러 샘플을 모아 두는 데 편리하지만, 모델 계산에서 대량의 숫자를 빠르게 계산할 때는 보통 NumPy 배열(array) 같은 별도 구조를 사용합니다. 따라서 “리스트로 숫자를 담을 수 있다”와 “리스트가 수치 계산용 배열이다”는 같은 말이 아닙니다.

리스트는 다른 자료구조와 역할이 다르다¶

Python 리스트의 설계는 “순서가 있는 값을 담고, 필요하면 끝에 추가하거나 꺼내며, 반복해서 처리하기 쉬운 변경 가능한 시퀀스(mutable sequence)”로 이해할 수 있습니다. Python 공식 튜토리얼도 리스트 메서드, 스택(stack)처럼 쓰는 방식, 큐(queue)로 쓸 때의 한계, 딕셔너리(dictionary), 집합(set), 튜플(tuple)을 분리해서 설명합니다.

즉 리스트는 모든 묶음을 대신하는 구조가 아닙니다. 무엇을 기준으로 값을 다룰지에 따라 다른 구조를 선택합니다.

따라서 리스트를 볼 때는 “배열인가?”보다 먼저 “순서가 있는 일반 목적 묶음인가?”를 묻는 편이 좋습니다. 리스트는 Python 코드에서 가장 자주 만나는 기본 구조이지만, 계산 목적이 분명해지면 딕셔너리, 집합, 덱, NumPy 배열 같은 다른 구조로 생각을 옮겨야 합니다.

이 차이를 짧게 다시 정리하면:

리스트는 값을 추가하고 바꿀 수 있다¶

리스트는 바뀔 수 있는 값(mutable value)입니다. 이 점을 먼저 이해하면 빈 리스트에 값을 모으는 패턴과 같은 값으로 길이를 맞추는 패턴을 더 조심해서 읽을 수 있습니다.

문제 상황: 리스트는 만든 뒤에도 값을 추가하고 바꿀 수 있다는 점을 직접 확인하고 싶습니다. 입력(input): 초기 점수 리스트와 append, 인덱스 대입. 기대 출력(output): 값이 추가되고 일부 항목이 바뀐 리스트. 확인할 개념: 리스트는 변경 가능한 값이며, 끝 추가와 위치 변경이 모두 가능합니다.

1
2
3
4
5
6
7

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
scores = [82, 75, 91]

scores.append(68)
scores[1] = 77

print(scores)

append()는 리스트 끝에 값을 추가합니다. scores[1] = 77은 두 번째 항목을 바꿉니다.

P2-8.1에서 “변수는 값에 붙인 이름”이라고 했습니다. 리스트에서는 이 관점이 더 중요해집니다.

문제 상황: 같은 리스트를 두 이름이 함께 가리킬 때 한쪽 수정이 다른 쪽에도 보이는지 확인하고 싶습니다. 입력(input): 같은 리스트를 가리키는 scores, other_scores. 기대 출력(output): 두 이름에서 모두 같은 변경 결과가 출력됩니다. 확인할 개념: 리스트를 다른 변수에 대입해도 자동으로 복사본이 생기지 않을 수 있습니다.

1
2
3
4
5
6
7
8

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
scores = [82, 75, 91]
other_scores = scores

other_scores.append(68)

print(scores)
print(other_scores)

scores와 other_scores는 서로 다른 리스트를 복사한 것이 아니라 같은 리스트를 가리킵니다. 그래서 한쪽 이름으로 값을 추가하면 다른 이름으로 봐도 같은 변경이 보입니다.

이 절에서는 다음 기준만 남깁니다.

• 숫자나 문자열 하나를 바꾸는 감각과 리스트를 바꾸는 감각은 다를 수 있습니다.
• 리스트를 다른 이름에 대입했다고 해서 자동으로 새 복사본이 생기는 것은 아닙니다.
• 데이터 전처리에서 원본을 보존해야 하면 복사 여부를 조심해야 합니다.

복사 여부와 원본과 복사본이 언제 함께 바뀌는가라는 질문은 바로 뒤의 P2-8.7 보충학습에서 다시 정리합니다.

리스트는 축약 문법으로 붙이고 자르고 바꿀 수 있다¶

Python 리스트를 읽다 보면 함수 이름보다 기호와 대괄호 문법이 먼저 보일 때가 많습니다. 다른 언어에서 concat, join, slice, splice 같은 이름으로 만났던 동작이 Python에서는 연산자(operator), 슬라이스(slice), 대입문(assignment), del 문으로 표현되기도 합니다.

여기서 중요한 것은 “Python 리스트에 그런 이름의 함수가 모두 있다”가 아닙니다. Python은 시퀀스(sequence)를 다루는 공통 문법을 제공하고, 리스트는 그 문법을 자주 사용합니다.

리스트를 붙인다: 연결(concatenation)¶

두 리스트를 붙여 새 리스트를 만들 때는 +를 사용할 수 있습니다. 이미 있는 리스트 끝에 다른 값을 이어 붙이고 싶다면 extend()를 사용할 수 있습니다.

문제 상황: +와 extend()가 모두 리스트를 붙이지만 원본을 바꾸는 방식이 다른지 비교하고 싶습니다. 입력(input): front, back, scores. 기대 출력(output): 새로 만든 combined, 그대로 남은 front, 수정된 scores. 확인할 개념: +는 붙인 새 리스트를 만들고, extend()는 기존 리스트 자체를 수정합니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
front = [1, 2]
back = [3, 4]

combined = front + back
print("combined:", combined)
print("front after +:", front)

scores = [82, 75]

scores.extend([91, 68])
print("scores after extend:", scores)

+는 붙인 결과를 새로 만들고, extend()는 기존 리스트를 바꿉니다. 이 차이는 뒤에서 참조와 변경을 구분할 때 중요합니다.

리스트를 자른다: 슬라이스(slice)¶

리스트의 일부 구간만 꺼낼 때는 슬라이스(slice)를 사용합니다.

문제 상황: 리스트의 앞, 중간, 뒤 일부를 잘라 읽는 방식을 한 번에 보고 싶습니다. 입력(input): 다섯 개 점수가 들어 있는 scores. 기대 출력(output): 중간 구간, 앞 두 개, 뒤쪽 구간이 각각 출력됩니다. 확인할 개념: 슬라이스는 시작과 끝 범위를 지정해 일부 구간을 읽는 문법입니다.

1
2
3
4
5
6

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
scores = [82, 75, 91, 68, 88]

print(scores[1:4])
print(scores[:2])
print(scores[3:])

scores[1:4]는 인덱스 1부터 4 바로 앞까지 꺼냅니다. 그래서 결과는 [75, 91, 68]입니다. “끝 번호는 포함하지 않는다”는 규칙은 낯설 수 있지만, Python의 문자열과 리스트에서 반복해서 만나는 방식입니다.

슬라이스는 원본 리스트에서 일부를 읽어 오는 문법입니다.

리스트의 일부를 지우거나 바꾼다: 삭제와 슬라이스 대입¶

다른 언어의 splice처럼 리스트의 중간 구간을 지우거나 바꾸는 동작은 Python에서 별도 splice() 메서드로 제공되지 않습니다. 비슷한 목적은 del, insert(), 슬라이스 대입(slice assignment)으로 표현합니다.

문제 상황: 리스트 중간 구간을 지우면 어떤 결과가 남는지 확인하고 싶습니다. 입력(input): items = ["A", "B", "C", "D"], 삭제 범위 1:3. 기대 출력(output): 가운데 두 항목이 제거된 리스트. 확인할 개념: del과 슬라이스를 함께 쓰면 특정 구간을 삭제할 수 있습니다.

1
2
3
4
5
6

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
items = ["A", "B", "C", "D"]

del items[1:3]

print(items)

del items[1:3]은 인덱스 1부터 3 바로 앞까지 지웁니다. 결과는 ["A", "D"]입니다.

구간을 다른 값으로 바꿀 수도 있습니다.

문제 상황: 리스트 일부 구간을 다른 길이의 값 목록으로 바꿀 수 있는지 확인하고 싶습니다. 입력(input): items[1:3] 구간과 새 값 ["X", "Y", "Z"]. 기대 출력(output): 바뀐 구간이 반영된 리스트. 확인할 개념: 슬라이스 대입은 같은 길이가 아니어도 구간 교체가 가능합니다.

1
2
3
4
5
6

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
items = ["A", "B", "C", "D"]

items[1:3] = ["X", "Y", "Z"]

print(items)

결과는 ["A", "X", "Y", "Z", "D"]입니다. 구간을 같은 길이로만 바꿔야 하는 것은 아닙니다.

join은 리스트가 아니라 문자열의 동작이다¶

join은 Python에서 자주 보이지만, 리스트 메서드가 아닙니다. 문자열(str)이 문자열 목록을 하나의 문자열로 연결할 때 사용하는 메서드입니다.

문제 상황: 문자열 목록을 하나의 문장으로 합칠 때 join이 어떻게 쓰이는지 보고 싶습니다. 입력(input): 문자열 리스트 words와 구분자 " ". 기대 출력(output): 공백으로 연결된 문장 sentence. 확인할 개념: join()은 리스트가 아니라 문자열 쪽 메서드입니다.

1
2
3
4
5
6

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
words = ["AI", "needs", "data"]

sentence = " ".join(words)

print(sentence)

결과는 "AI needs data"입니다. 여기서 동작의 주체는 리스트가 아니라 " "라는 문자열입니다. 이 문자열이 words 안의 문자열들을 사이에 공백을 넣어 이어 붙입니다.

따라서 Python에서 리스트를 읽을 때는 다음처럼 구분하는 편이 안전합니다.

이 절에서는 이 문법을 모두 외울 필요는 없습니다. “Python 리스트는 이름 있는 함수만으로 다루는 것이 아니라, 시퀀스 문법으로 붙이고 자르고 바꾸는 경우가 많다”는 정도를 기억하면 됩니다.

리스트를 처음 만드는 기본 패턴¶

일반적으로 자료구조를 초기화(initialize)한다는 말은 그 구조를 처음 만든다는 뜻입니다. Python에서는 값이 이미 있는지, 나중에 채울지, 일단 같은 값으로 자리를 만들지에 따라 여러 방식으로 리스트를 시작합니다. 이때 리스트가 바뀔 수 있는 값이라는 점을 함께 기억해야 합니다.

일반화하면 리스트를 시작하는 방식은 세 가지 질문으로 나뉩니다. 값을 이미 알고 있는가, 나중에 채울 것인가, 우선 같은 값으로 자리를 만들어 둘 것인가입니다.

이미 값을 알고 있을 때¶

처음부터 들어갈 값을 알고 있다면 대괄호([]) 안에 값을 적습니다.

문제 상황: 값을 이미 알고 있을 때 서로 다른 종류의 리스트를 한 번에 만드는 예를 보고 싶습니다. 입력(input): 점수 목록, 라벨 목록, 불리언 목록. 기대 출력(output): 세 리스트가 각각 출력됩니다. 확인할 개념: 리스트는 숫자, 문자열, 불리언처럼 다양한 값 목록을 직접 초기화할 수 있습니다.

1
2
3
4
5
6
7
8

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
scores = [82, 75, 91, 68]
labels = ["positive", "negative", "neutral"]
flags = [True, False, True]

print(scores)
print(labels)
print(flags)

이 방식은 학습용 예시나 작은 설정 목록을 만들 때 값의 구성을 가장 직접적으로 드러냅니다.

빈 리스트로 시작할 때¶

값이 없지만 나중에 값을 담을 예정이라면 빈 리스트로 시작할 수 있습니다.

문제 상황: 비어 있는 리스트에 나중에 값을 하나씩 모으는 기본 패턴을 확인하고 싶습니다. 입력(input): 빈 리스트 passed_scores와 두 번의 append. 기대 출력(output): 추가된 값이 들어 있는 리스트. 확인할 개념: 빈 리스트는 결과를 나중에 쌓아 가는 시작점으로 자주 쓰입니다.

1
2
3
4
5
6
7

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
passed_scores = []

passed_scores.append(82)
passed_scores.append(75)

print(passed_scores)

이 예시는 리스트가 만든 뒤에도 값을 추가할 수 있음을 보여 줍니다. 실제 데이터 처리에서는 반복(loop)을 사용해 조건에 맞는 값을 빈 리스트에 모으는 일이 많습니다. 그 패턴은 P2-8.4에서 다시 봅니다.

같은 값으로 길이를 맞춰 시작할 때¶

필요한 길이를 알고 있고, 일단 같은 값으로 채워 두고 싶을 때도 있습니다.

문제 상황: 같은 기본값으로 길이가 맞는 리스트를 빠르게 만드는 예를 보고 싶습니다. 입력(input): 기본값 0, 반복 횟수 5. 기대 출력(output): 다섯 개의 0이 들어 있는 리스트. 확인할 개념: [값] * 개수는 단순한 초기값 목록을 빠르게 만들 때 쓸 수 있습니다.

1
2
3
4

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
predictions = [0] * 5

print(predictions)

이 코드는 [0, 0, 0, 0, 0]을 만듭니다. 다만 이 방식은 숫자나 문자열처럼 단순한 값에는 이해하기 쉽지만, 리스트 안에 리스트를 넣는 경우에는 조심해야 합니다.

문제 상황: 같은 안쪽 리스트를 여러 번 복제한 듯 보이는 코드가 왜 위험한지 확인하고 싶습니다. 입력(input): rows = [[]] * 3와 첫 번째 안쪽 리스트에 "A" 추가. 기대 출력(output): 모든 안쪽 리스트가 함께 바뀐 것처럼 보이는 결과. 확인할 개념: 중첩 리스트에서는 같은 객체를 여러 번 가리키는 초기화가 예상 밖 공유를 만들 수 있습니다.

1
2
3
4
5
6

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
rows = [[]] * 3

rows[0].append("A")

print(rows)

이 코드는 기대와 다르게 보일 수 있습니다. 안쪽 리스트가 각각 새로 만들어진 것이 아니라 같은 리스트를 여러 번 가리키기 때문입니다. 이 절에서는 중첩 리스트(nested list)를 이런 방식으로 만들지 않는 기준을 둡니다.

반복 규칙으로 새 리스트를 만들 때¶

기존 값들을 하나씩 처리해 새 리스트를 만드는 일도 많습니다. 다만 이것은 리스트 자체보다 반복 구조의 주제입니다. 이 절에서는 “새 결과를 담을 리스트가 필요하다”는 정도만 남기고, 실제 반복 패턴은 P2-8.4에서 다룹니다.

이 절에서는 다음 기준으로 리스트의 시작 모양을 고릅니다.

리스트를 쓰는 상황들¶

리스트는 같은 목적이나 맥락의 값들이 순서대로 모여 있고, 위치나 순서가 의미를 가질 때 사용합니다.

점수 여러 개¶

문제 상황: 점수 목록 하나로 여러 요약값을 계산하는 기본 사용 예를 보고 싶습니다. 입력(input): 점수 리스트 scores. 기대 출력(output): 최댓값, 최솟값, 평균 계산 결과. 확인할 개념: 리스트는 여러 숫자 값을 한 번에 모아 요약 계산의 입력으로 쓸 수 있습니다.

1
2
3
4
5
6

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
scores = [82, 75, 91, 68]

print(max(scores))
print(min(scores))
print(sum(scores) / len(scores))

점수 목록은 순서가 있을 수도 있고, 전체를 모아 평균을 낼 수도 있습니다.

문장 여러 개¶

문제 상황: 여러 문장을 같은 방식으로 하나씩 처리하는 예를 보고 싶습니다. 입력(input): 세 문장이 들어 있는 리스트 texts. 기대 출력(output): 각 문장이 반복문에서 차례대로 출력됩니다. 확인할 개념: 리스트는 텍스트처럼 같은 종류의 여러 항목을 순서대로 순회하기 좋습니다.

1
2
3
4
5
6
7
8
9

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
texts = [
    "AI is useful.",
    "Data quality matters.",
    "Models can fail.",
]

for text in texts:
    print(text)

LLM이나 텍스트 분류 실습에서는 문장 목록을 자주 만납니다.

모델 출력 여러 개¶

문제 상황: 여러 확률 점수를 기준값으로 하나씩 판단하는 예를 보고 싶습니다. 입력(input): 확률 리스트 probabilities와 임계 기준 0.8. 기대 출력(output): 각 점수마다 high confidence 또는 check가 출력됩니다. 확인할 개념: 리스트는 모델의 여러 출력값을 순서대로 평가하는 데 쓰일 수 있습니다.

1
2
3
4
5
6
7
8

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
probabilities = [0.92, 0.31, 0.77, 0.12]

for probability in probabilities:
    if probability >= 0.8:
        print("high confidence")
    else:
        print("check")

모델이 여러 입력에 대해 확률 점수(probability score)를 냈다면, 그 결과도 리스트로 볼 수 있습니다.

파일 이름 여러 개¶

문제 상황: 여러 파일 이름을 같은 절차로 처리하는 가장 단순한 예를 보고 싶습니다. 입력(input): train.csv, valid.csv, test.csv가 들어 있는 리스트. 기대 출력(output): 각 파일 이름이 차례대로 출력됩니다. 확인할 개념: 리스트는 같은 종류의 작업 대상을 순서대로 나열하는 데 적합합니다.

1
2
3
4
5
6
7
8
9

# 이 예제는 리스트가 여러 값을 순서대로 묶고 처리하는 방식을 확인합니다.
file_names = [
    "train.csv",
    "valid.csv",
    "test.csv",
]

for file_name in file_names:
    print(file_name)

프로젝트 실습에서는 여러 파일을 같은 방식으로 처리해야 하는 경우가 많습니다.

사례 및 예시¶

사례 1. 여러 예측 점수를 한 번에 다루려면 무엇이 필요한가¶

한 모델이 다섯 개 샘플에 대해 확률 점수 다섯 개를 냈다고 하겠습니다. 사람은 처음에 0.92, 0.31, 0.77 같은 값을 하나씩 볼 수는 있지만, 곧 전체를 순서대로 처리하고 싶다, 세 번째 결과만 다시 보고 싶다는 요구가 생깁니다.

이때 값들을 낱개 변수로 score1, score2, score3처럼 두면 관리가 급격히 불편해집니다. 순서가 있는 여러 값을 같은 기준으로 다루기 어렵고, 반복이나 부분 선택도 번거로워집니다.

리스트는 바로 이런 장면에 맞는 구조입니다. 점수, 문장, 파일 이름처럼 같은 목적의 값이 여러 개 있고 순서가 의미를 가질 때, 리스트로 묶어 두면 위치(index)로 꺼내고, 필요하면 끝에 추가하고, 새 목록을 만들기 쉬워집니다.

확인 가능한 결과는 인덱스로 곧바로 드러납니다. probabilities[2]처럼 세 번째 값을 바로 확인할 수 있고, append()로 새 결과를 뒤에 붙일 수 있다면, 개별 변수 나열보다 리스트가 더 적합한 상황입니다.

체크리스트¶

• 리스트를 순서가 있는 값 묶음으로 설명할 수 있는가?
• scores[0]과 scores[-1]를 읽을 수 있는가?
• 리스트와 NumPy 배열을 같은 말로 쓰면 왜 위험한지 설명할 수 있는가?
• 같은 리스트를 두 이름이 함께 가리킬 수 있다는 점을 말할 수 있는가?
• 리스트(list)를 순서가 있는 값 묶음으로 설명할 수 있다.
• scores[0], scores[-1]의 의미를 설명할 수 있다.
• 이미 값을 알고 시작하는 리스트, 빈 리스트, 같은 값으로 채운 리스트를 구분할 수 있다.
• append()로 값을 추가하는 흐름을 읽을 수 있다.
• +, extend(), 슬라이스(slice), del, 슬라이스 대입의 차이를 대략적으로 구분할 수 있다.
• join()은 리스트 메서드가 아니라 문자열(str) 메서드임을 설명할 수 있다.
• Python 리스트에는 JavaScript식 splice() 메서드가 없으며, 비슷한 작업은 del, insert(), 슬라이스 대입으로 표현함을 설명할 수 있다.
• 같은 리스트를 여러 이름이 가리킬 수 있음을 설명할 수 있다.
• 중첩 리스트를 같은 값 반복으로 만들 때 주의가 필요함을 설명할 수 있다.

출처와 참고 자료¶

• Python Software Foundation, Data Structures, Python 3.14.6 documentation, 확인 날짜: 2026-07-20. 리스트 메서드, 리스트를 스택처럼 쓰는 예, 리스트 컴프리헨션과 중첩 리스트 예시 확인에 사용했다.
• Python Software Foundation, Built-in Types, Python 3.14.6 documentation, 확인 날짜: 2026-07-20. 시퀀스 타입과 mutable sequence 연산, 인덱싱·슬라이싱 동작 확인에 사용했다.
• Python Software Foundation, array — Efficient arrays of numeric values, Python 3.14.6 documentation, 확인 날짜: 2026-07-20. Python 표준 라이브러리의 array가 같은 기본 타입의 값을 효율적으로 저장하는 구조라는 설명 확인에 사용했다.
• NumPy Developers, NumPy: the absolute basics for beginners, NumPy v2.5 Manual, 확인 날짜: 2026-07-20. NumPy 배열이 Python 리스트와 다르게 빠르고 많은 숫자 데이터를 다루는 핵심 구조라는 설명 확인에 사용했다.