Python list vs tuple vs set 완벽 비교 | 자료구조 선택 가이드

Python list vs tuple vs set 완벽 비교 | 자료구조 선택 가이드

· 23분 읽기 · 수정 초급
Python list vs tuple vs set 완벽 비교 | 자료구조 선택 가이드

이 글의 핵심

Python list, tuple, set의 차이점을 가변성, 성능, 메모리 관점에서 비교. 실전에서 어떤 자료구조를 써야 하는지 선택 기준과 예제를 설명합니다.

들어가며

“리스트만 쓰면 되는 것 아닌가요?” Python을 처음 배울 때 자주 나오는 질문입니다. 이 글에서는 list, tuple, set의 차이를 명확히 이해하며, 상황에 맞는 자료구조를 선택하는 방법을 다룹니다. 비유로 말씀드리면, list는 순서가 있는 줄 서기, tuple은 한 번 찍은 스티커 사진(바꿀 수 없음), set은 중복 없이 모아 두는 주머니에 가깝습니다. “빠른 포함 검사”가 중요하면 set을 떠올리시면 됩니다.

언제 list를, 언제 tuple·set을 쓰나요?

관점listtupleset
성능끝쪽 삽입은 편함, 멤버십은 O(n)불변·해시 가능(요소가 해시 가능할 때)멤버십 평균 O(1)
사용성가변, 순서 있음키로 쓰기 좋은 불변중복 제거·집합 연산
적용 시나리오시퀀스 처리좌표·레코드유일 값, 교집합 등

이 글을 읽으면

  • list, tuple, set의 특성 차이를 이해하실 수 있습니다
  • 각 자료구조의 시간 복잡도를 익히실 수 있습니다
  • 메모리 사용량 차이를 파악하실 수 있습니다
  • 실전에서 어떤 것을 써야 하는지 판단하실 수 있습니다

1. 빠른 비교표

특성listtupleset
가변성가변불변가변
순서유지유지유지 안 됨 (3.7+는 삽입 순서)
중복허용허용불허
인덱싱✅ O(1)✅ O(1)❌ 불가능
검색O(n)O(n)O(1) 평균
추가append O(1)❌ 불가능add O(1)
삭제remove O(n)❌ 불가능remove O(1)
메모리보통적음많음
용도일반 목록불변 데이터, 딕셔너리 키중복 제거, 집합 연산

2. 가변성 차이

list: 가변

lst = [1, 2, 3]
lst.append(4)      # ✅ [1, 2, 3, 4]
lst[0] = 10        # ✅ [10, 2, 3, 4]
lst.remove(2)      # ✅ [10, 3, 4]
  • append: 끝에 O(1) 평균으로 붙입니다(재할당이 나면 순간적으로 더 드는 경우가 있습니다).
  • 인덱스 대입: 임의 위치의 요소를 바꿉니다.
  • remove(x): 값이 x인 첫 번째 항목 하나를 제거합니다(없으면 예외).

tuple: 불변

tup = (1, 2, 3)
tup.append(4)      # ❌ AttributeError: 'tuple' object has no attribute 'append'
tup[0] = 10        # ❌ TypeError: 'tuple' object does not support item assignment
  • 한 번 만들면 요소 추가·치환이 되지 않아, 딕셔너리 키나 집합 원소로 쓰기에 안전한 경우가 많습니다(요소가 모두 해시 가능할 때).

set: 가변 (하지만 순서 없음)

s = {1, 2, 3}
s.add(4)           # ✅ {1, 2, 3, 4}
s.remove(2)        # ✅ {1, 3, 4}
s[0]               # ❌ TypeError: 'set' object is not subscriptable
  • add/remove는 집합 연산에 맞춰져 있으며, 인덱스 접근은 지원하지 않습니다(순서가 보장되지 않기 때문입니다).

3. 성능 비교

검색 성능

import time
# 데이터 준비
n = 100000
lst = list(range(n))
tup = tuple(range(n))
s = set(range(n))
# list 검색: O(n)
start = time.time()
for _ in range(1000):
    99999 in lst
print(f"list: {time.time() - start:.3f}s")  # 약 1.2s
# tuple 검색: O(n)
start = time.time()
for _ in range(1000):
    99999 in tup
print(f"tuple: {time.time() - start:.3f}s") # 약 1.1s (list보다 약간 빠름)
# set 검색: O(1)
start = time.time()
for _ in range(1000):
    99999 in s
print(f"set: {time.time() - start:.3f}s")   # 약 0.0001s (10,000배 빠름!)

추가/삭제 성능

# list.append: O(1) 평균, O(n) 최악 (재할당)
lst = []
for i in range(100000):
    lst.append(i)  # 빠름
# list.insert(0, x): O(n) (모든 요소 이동)
lst.insert(0, -1)  # 느림
# set.add: O(1) 평균
s = set()
for i in range(100000):
    s.add(i)  # 빠름

4. 메모리 사용량

메모리 비교

import sys
data = range(10000)
lst = list(data)
tup = tuple(data)
s = set(data)
print(f"list: {sys.getsizeof(lst):,} bytes")   # 약 85,176 bytes
print(f"tuple: {sys.getsizeof(tup):,} bytes")  # 약 80,064 bytes (5% 적음)
print(f"set: {sys.getsizeof(s):,} bytes")      # 약 524,520 bytes (6배 많음)

왜 차이가 나나?

  • tuple: 불변이므로 메타데이터 적음
  • list: 동적 확장을 위한 여유 공간
  • set: 해시 테이블 오버헤드 (빠른 검색 대가)

5. 실전 선택 가이드

선택 플로우차트

아래 다이어그램은 결정 → 분기 → 결과 순으로 읽으시면 됩니다. 순서가 필요하면 list/tuple 쪽으로, 순서 없이 유일 값만 필요하면 set으로 가는 흐름입니다.

graph TD
    A[자료구조 선택] --> B{순서가 중요한가?}
    B -->|Yes| C{수정이 필요한가?}
    B -->|No| D[set]
    C -->|Yes| E[list]
    C -->|No| F{딕셔너리 키로 쓰나?}
    F -->|Yes| G[tuple]
    F -->|No| H{성능이 중요한가?}
    H -->|Yes| G
    H -->|No| E

상황별 선택

# 1. 일반 목록 → list
users = ['Alice', 'Bob', 'Charlie']
users.append('David')
# 2. 불변 데이터 → tuple
point = (10, 20)  # 좌표
rgb = (255, 0, 0)  # 색상
# 3. 중복 제거 → set
unique_ids = set([1, 2, 2, 3, 3, 3])  # {1, 2, 3}
# 4. 빠른 검색 → set
allowed_users = {'alice', 'bob', 'charlie'}
if username in allowed_users:  # O(1)
    grant_access()
# 5. 딕셔너리 키 → tuple (불변만 가능)
cache = {
    (10, 20): 'result1',  # ✅ tuple
    [10, 20]: 'result2',  # ❌ TypeError: unhashable type: 'list'
}
# 6. 함수 반환값 (여러 값) → tuple
def get_user():
    return ('Alice', 25, 'alice@example.com')  # tuple
name, age, email = get_user()  # 언패킹

6. 흔한 실수

실수 1: set에 인덱싱

s = {1, 2, 3}
print(s[0])  # ❌ TypeError: 'set' object is not subscriptable
# 해결: list로 변환
print(list(s)[0])  # ✅ 하지만 순서는 보장 안 됨

실수 2: tuple 수정 시도

tup = (1, 2, 3)
tup[0] = 10  # ❌ TypeError
# 해결: 새 tuple 생성
tup = (10,) + tup[1:]  # ✅ (10, 2, 3)

실수 3: list를 딕셔너리 키로

cache = {}
key = [1, 2, 3]
cache[key] = 'value'  # ❌ TypeError: unhashable type: 'list'
# 해결: tuple 사용
key = (1, 2, 3)
cache[key] = 'value'  # ✅

7. 고급 활용

list comprehension

# 짝수만 필터링
even = [x for x in range(10) if x % 2 == 0]
# 중첩 리스트
matrix = [[i*j for j in range(5)] for i in range(5)]

set 연산

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a | b)  # 합집합: {1, 2, 3, 4, 5, 6}
print(a & b)  # 교집합: {3, 4}
print(a - b)  # 차집합: {1, 2}
print(a ^ b)  # 대칭 차집합: {1, 2, 5, 6}

Named tuple

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(p.x)  # 10 (인덱스 대신 이름으로 접근)
print(p[0]) # 10 (인덱스도 가능)

마무리

Python 자료구조 선택의 핵심:

  1. 순서 + 수정 → list
  2. 순서 + 불변 → tuple
  3. 중복 제거 + 빠른 검색 → set
  4. 성능 측정 → 상황에 맞게 선택 핵심: 각 자료구조의 특성을 이해하며, 문제에 맞는 것을 선택하시면 성능이 크게 개선됩니다. 데이터가 컨베이어 위에서 순서대로 처리되어야 한다면 list/tuple, 중복 제거·합집합 같은 공정이 중요하면 set을 먼저 떠올려 보시면 됩니다.

관련 글

키워드

Python, list, tuple, set, 자료구조, 성능, 시간 복잡도, 메모리, 비교, 선택 가이드

자주 묻는 질문 (FAQ)

Q. 이 내용을 실무에서 언제 쓰나요?

A. Python list, tuple, set의 차이점을 가변성, 성능, 메모리 관점에서 비교. 실전에서 어떤 자료구조를 써야 하는지 선택 기준과 예제를 설명합니다. Python·list·tuple 중심으로 설명합니다.… 실무에서는 위 본문의 예제와 선택 가이드를 참고해 적용하면 됩니다.

Q. 선행으로 읽으면 좋은 글은?

A. 각 글 하단의 이전 글 또는 관련 글 링크를 따라가면 순서대로 배울 수 있습니다. C++ 시리즈 목차에서 전체 흐름을 확인할 수 있습니다.

Q. 더 깊이 공부하려면?

A. cppreference와 해당 라이브러리 공식 문서를 참고하세요. 글 말미의 참고 자료 링크도 활용하면 좋습니다.

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

이 글에서 다루는 키워드 (관련 검색어)

Python, list, tuple, set, 자료구조, 성능, 비교 등으로 검색하시면 이 글이 도움이 됩니다.