파이썬 자료구조 가이드: List, Set, Dict, Tuple

한눈에 비교

1. List (리스트)

순서 있고, 수정 가능한 가장 기본 자료구조

python    lst = [3, 1, 4, 1, 5]

    lst.append(9)        # 끝에 추가 → [3,1,4,1,5,9]
    lst.insert(2, 99)    # index 2에 삽입
    lst.extend([7, 8])   # 여러 값 추가
    lst.pop()            # 마지막 요소 제거 및 반환
    lst.pop(0)           # index 0 제거
    lst.remove(1)        # 첫 번째 1 제거
    lst.index(4)         # 4의 인덱스 반환
    lst.count(1)         # 1의 개수 반환
    lst.sort()           # 오름차순 정렬 (원본 변경)
    lst.sort(reverse=True) # 내림차순
    lst.reverse()        # 순서 뒤집기
    lst.copy()           # 얕은 복사
    lst.clear()          # 전체 삭제
    len(lst)             # 길이
    sorted(lst)          # 정렬된 새 리스트 반환 (원본 유지)

2. Tuple (튜플)

불변(immutable), 리스트보다 빠름

python    tpl = (3, 1, 4, 1, 5)

    tpl.count(1)    # 1이 몇 개인지 → 2
    tpl.index(4)    # 4의 인덱스 → 2
    len(tpl)        # 길이
    tpl[1:3]        # 슬라이싱 → (1, 4)

    # 언패킹
    a, b, c = (1, 2, 3)
    first, *rest = (1, 2, 3, 4)  # first=1, rest=[2,3,4]

3. Set (집합)

중복 제거, 순서 없음

python    s = {1, 2, 3, 4}

    s.add(5)           # 요소 추가
    s.remove(3)        # 없으면 KeyError 발생
    s.discard(3)       # 없어도 에러 없음
    s.pop()            # 임의 요소 제거
    s.clear()          # 전체 삭제
    s.copy()           # 복사

    # 집합 연산
    a = {1, 2, 3}
    b = {3, 4, 5}
    a | b              # 합집합 → {1,2,3,4,5}
    a & b              # 교집합 → {3}
    a - b              # 차집합 → {1,2}
    a ^ b              # 대칭차집합 → {1,2,4,5}
    a.issubset(b)      # 부분집합 여부
    a.issuperset(b)    # 상위집합 여부

4. Dictionary (딕셔너리)

키-값 쌍, 빠른 검색

python    d = {"name": "홍길동", "age": 25}

    d["city"] = "광주"       # 추가/수정
    d.get("name")            # 값 반환 (없으면 None)
    d.get("x", "없음")       # 기본값 지정
    d.keys()                 # 키 목록
    d.values()               # 값 목록
    d.items()                # (키, 값) 튜플 목록
    d.pop("age")             # 키 제거 후 반환
    d.update({"age": 30})    # 여러 값 업데이트
    d.setdefault("job", "개발자")  # 키 없으면 기본값 설정
    d.copy()                 # 복사
    d.clear()                # 전체 삭제
    "name" in d              # 키 존재 여부

    # 순회
    for k, v in d.items():
        print(k, v)

5. Stack (스택)

LIFO(후입선출) — List로 구현 가능

python    stack = []

    stack.append(1)   # push
    stack.append(2)
    stack.append(3)
    stack.pop()       # pop → 3 (가장 최근 값)
    stack[-1]         # peek (맨 위 확인만)
    len(stack)        # 크기

6. Queue (큐)

FIFO(선입선출) — collections.deque 사용 권장

pythonfrom collections import deque

    queue = deque()

    queue.append(1)     # enqueue (오른쪽 추가)
    queue.append(2)
    queue.append(3)
    queue.popleft()     # dequeue → 1 (왼쪽에서 제거)
    queue[0]            # 맨 앞 확인만
    len(queue)          # 크기

💡 List로도 큐 구현 가능하지만 pop(0)은 O(N)이라 느림. deque.popleft()는 O(1)

7. Deque (덱)

양방향 큐 — 앞뒤 모두 O(1) 삽입/삭제

pythonfrom collections import deque

    dq = deque([1, 2, 3])

    dq.append(4)        # 오른쪽 추가
    dq.appendleft(0)    # 왼쪽 추가
    dq.pop()            # 오른쪽 제거
    dq.popleft()        # 왼쪽 제거
    dq.rotate(1)        # 오른쪽으로 1칸 회전
    dq.rotate(-1)       # 왼쪽으로 1칸 회전
    dq.extend([5, 6])   # 오른쪽에 여러 값 추가
    dq.extendleft()  # 왼쪽에 추가 (역순 삽입)
    dq.maxlen           # 최대 크기 (설정 시)

    # 최대 크기 설정 (슬라이딩 윈도우에 유용)
    dq = deque(maxlen=3)
    dq.append(1); dq.append(2); dq.append(3); dq.append(4)
    # → deque([2, 3, 4]) 자동으로 앞 제거

8. Heap (힙)

최솟값을 O(log N)으로 관리 — 우선순위 큐 구현에 사용

pythonimport heapq

    heap = []

    heapq.heappush(heap, 5)    # 삽입
    heapq.heappush(heap, 1)
    heapq.heappush(heap, 3)
    heapq.heappop(heap)         # 최솟값 제거 및 반환 → 1
    heap[0]                     # 최솟값 확인만 (제거 X)
    heapq.heapify([3,1,4,1,5]) # 리스트를 힙으로 변환

    # 최댓값 힙 (부호 반전 트릭)
    heapq.heappush(heap, -9)
    -heapq.heappop(heap)        # → 9

    # 가장 큰/작은 n개 추출
    heapq.nlargest(3, [5,1,8,2,9])   # → [9, 8, 5]
    heapq.nsmallest(3, [5,1,8,2,9])  # → [1, 2, 5]

9. collections 모듈 특수 자료구조

collections 모듈은 기본 자료구조를 확장한 강력한 클래스들을 제공합니다

pythonfrom collections import Counter, defaultdict, OrderedDict, namedtuple

    # ① Counter — 요소 개수 자동 카운팅
    c = Counter("mississippi")
    # → Counter({'i':4,'s':4,'p':2,'m':1})
    c.most_common(2)    # 가장 많은 2개 → [('i',4),('s',4)]
    c["i"]              # → 4
    c + Counter("aaa")  # 카운터 합산

    # ② defaultdict — 없는 키에 기본값 자동 설정
    dd = defaultdict(int)    # 기본값 0
    dd["a"] += 1             # KeyError 없이 바로 사용
    dd2 = defaultdict(list)
    dd2["fruits"].append("apple")  # 기본값 []

    # ③ OrderedDict — 삽입 순서 보장 (Python 3.7+ dict도 순서 보장)
    od = OrderedDict()
    od["a"] = 1
    od["b"] = 2
    od.move_to_end("a")      # "a"를 끝으로 이동

    # ④ namedtuple — 이름 있는 튜플 (가독성 향상)
    Point = namedtuple("Point", ["x", "y"])
    p = Point(3, 4)
    p.x          # → 3
    p.y          # → 4
    p._asdict()  # → {'x':3, 'y':4}

자료구조 선택 가이드