Python 컬렉션 완전 정리

Python code

# 딕셔너리 생성
d1 = {"name": "Alice", "age": 30}
d2 = dict(name="Bob", age=25)
d3 = dict.fromkeys(["a", "b", "c"], 0)  # {'a':0,'b':0,'c':0}

# 접근 & 안전한 읽기
print(d1["name"])              # Alice
print(d1.get("email", "N/A")) # N/A (KeyError 없음)

# 수정
d1["email"] = "alice@test.com"
d1.update({"age": 31, "city": "Seoul"})

# setdefault — 없으면 설정하고 반환
d1.setdefault("score", 100)

# 순회
for key in d1:          print(key)
for val in d1.values(): print(val)
for k, v in d1.items(): print(f"{k}: {v}")

# 딕셔너리 병합 (Python 3.9+)
merged = d1 | d2      # 새 딕셔너리
d1 |= {"extra": True} # 인플레이스 병합

# 딕셔너리 컴프리헨션
squares = {x: x**2 for x in range(1, 6)}
inverted = {v: k for k, v in squares.items()}

# 중첩 딕셔너리 안전 접근
from collections import defaultdict
word_count = defaultdict(int)
for word in "python is great and python is easy".split():
    word_count[word] += 1
print(dict(sorted(word_count.items(), key=lambda x: -x[1])))

Python code

from collections import Counter, deque, namedtuple, OrderedDict

# Counter — 빈도 계산
text = "python programming is fun and python is easy"
word_count = Counter(text.split())
print(word_count.most_common(3))
# [('python', 2), ('is', 2), ('programming', 1)]

c1 = Counter("apple")
c2 = Counter("pear")
print(c1 + c2)   # Counter({'p':2,'a':2,'e':1,'l':1,'r':1})
print(c1 & c2)   # 교집합

# deque — 양방향 큐 (O(1) 추가/삭제)
dq = deque([1, 2, 3], maxlen=5)
dq.appendleft(0)    # [0, 1, 2, 3]
dq.append(4)        # [0, 1, 2, 3, 4]
dq.rotate(1)        # [4, 0, 1, 2, 3]

# namedtuple — 이름 있는 튜플
Point = namedtuple("Point", ["x", "y"])
p = Point(3, 4)
print(p.x, p.y)     # 3 4
print(p._asdict())  # {'x': 3, 'y': 4}

# typing.NamedTuple — 타입 힌트 버전 (권장)
from typing import NamedTuple

class Employee(NamedTuple):
    name: str
    dept: str
    salary: float = 50000.0

emp = Employee("Alice", "Engineering")
print(emp)   # Employee(name='Alice', dept='Engineering', salary=50000.0)

Python code

<span class="cm">// httpx 비동기 HTTP 클라이언트 예제
// data/prompts.js의 생성 프롬프트로 상세 코드 생성 가능</span>
fun main() { println("httpx 비동기 HTTP 클라이언트") }

Python code

from itertools import chain, product, permutations, combinations

# chain: 여러 이터러블 연결
a = [1, 2, 3]
b = [4, 5, 6]
print(list(chain(a, b)))  # [1, 2, 3, 4, 5, 6]

# product: 데카르트 곱
colors = ["빨강", "파랑"]
sizes = ["S", "M", "L"]
for color, size in product(colors, sizes):
    print(f"  {color}-{size}", end="")
print()

# permutations: 순열
print(list(permutations([1, 2, 3], 2)))
# [(1,2), (1,3), (2,1), (2,3), (3,1), (3,2)]

# combinations: 조합
print(list(combinations([1, 2, 3, 4], 2)))
# [(1,2), (1,3), (1,4), (2,3), (2,4), (3,4)]

# accumulate: 누적 연산
from itertools import accumulate
import operator
data = [1, 2, 3, 4, 5]
print(list(accumulate(data)))                  # 누적 합
print(list(accumulate(data, operator.mul)))    # 누적 곱

Python code

from collections.abc import (
    Iterable, Iterator, Sequence, MutableSequence, Mapping
)

# 타입 체크
print(isinstance([1, 2], Sequence))      # True
print(isinstance({1: 2}, Mapping))       # True
print(isinstance(range(10), Sequence))   # True

# 커스텀 Sequence 구현
class FibSequence(Sequence):
    def __init__(self, n: int):
        self._data = []
        a, b = 0, 1
        for _ in range(n):
            self._data.append(a)
            a, b = b, a + b

    def __getitem__(self, index):
        return self._data[index]

    def __len__(self):
        return len(self._data)

fib = FibSequence(10)
print(list(fib))         # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
print(5 in fib)          # True (자동 구현됨)
print(fib.index(8))      # 6 (자동 구현됨)
print(fib.count(1))      # 2 (자동 구현됨)
print(fib[2:5])          # [1, 2, 3]

Python code

class LimitedStack:
    """크기 제한이 있는 스택"""
    def __init__(self, maxsize: int = 10):
        self._items: list = []
        self._maxsize = maxsize

    def push(self, item):
        if len(self) >= self._maxsize:
            raise OverflowError(f"스택 최대 크기({self._maxsize}) 초과")
        self._items.append(item)

    def pop(self):
        if not self:
            raise IndexError("빈 스택")
        return self._items.pop()

    def __len__(self):
        return len(self._items)

    def __bool__(self):
        return len(self._items) > 0

    def __contains__(self, item):
        return item in self._items

    def __iter__(self):
        return reversed(self._items)

    def __repr__(self):
        return f"LimitedStack({self._items})"

stack = LimitedStack(5)
for i in range(5):
    stack.push(i)

print(stack)           # LimitedStack([0, 1, 2, 3, 4])
print(3 in stack)      # True
print(len(stack))      # 5
print(list(stack))     # [4, 3, 2, 1, 0]
print(stack.pop())     # 4

Python code

# 중첩 루프
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [x for row in matrix for x in row]
print(flat)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 행렬 전치
transposed = [[row[i] for row in matrix] for i in range(3)]
print(transposed)  # [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

# 조건부 표현식 (if-else)
nums = range(-5, 6)
labels = ["양수" if n > 0 else "0" if n == 0 else "음수"
          for n in nums]
print(labels)

# walrus 연산자로 중복 계산 방지
import math
data = [2, 7, 15, 3, 25, 8]
results = [(x, y) for x in data
           if (y := math.sqrt(x)) > 2.5]
print(results)  # [(7, 2.6457...), (15, 3.8729...), (25, 5.0), (8, 2.8284...)]

# 중첩 vs 제너레이터 (메모리 효율)
big_flat = [x for row in range(1000)
            for x in range(1000)]  # 메모리 사용 큼
# 제너레이터가 더 효율적
big_gen = (x for row in range(1000)
           for x in range(1000))

Python code

# 기본 딕셔너리 컴프리헨션
squares = {x: x**2 for x in range(1, 6)}
print(squares)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 키-값 뒤집기
inv = {v: k for k, v in squares.items()}
print(inv)  # {1: 1, 4: 2, 9: 3, 16: 4, 25: 5}

# 조건부 필터링
scores = {"Alice": 85, "Bob": 62, "Carol": 91, "Dave": 45}
passed = {k: v for k, v in scores.items() if v >= 70}
print(passed)  # {'Alice': 85, 'Carol': 91}

# 중첩 딕셔너리 변환
students = {
    "Alice": {"math": 90, "eng": 85},
    "Bob": {"math": 70, "eng": 92},
}
averages = {name: sum(s.values()) / len(s)
            for name, s in students.items()}
print(averages)  # {'Alice': 87.5, 'Bob': 81.0}

# zip으로 두 리스트를 딕셔너리로
keys = ["name", "age", "city"]
values = ["Alice", 30, "서울"]
info = {k: v for k, v in zip(keys, values)}
print(info)  # {'name': 'Alice', 'age': 30, 'city': '서울'}

Python code

# 제너레이터 표현식 vs 리스트 컴프리헨션
import sys

list_comp = [x**2 for x in range(10000)]
gen_expr = (x**2 for x in range(10000))

print(f"리스트: {sys.getsizeof(list_comp):,} bytes")
print(f"제너레이터: {sys.getsizeof(gen_expr)} bytes")

# 함수 인자로 직접 전달 (괄호 생략 가능)
total = sum(x**2 for x in range(100))
print(f"제곱의 합: {total}")

exists = any(x > 50 for x in [10, 20, 60, 30])
print(f"50 초과 존재: {exists}")  # True

# 체이닝
lines = ["  hello  ", "", "  world  ", "  ", "python"]
cleaned = list(
    filter(None, (line.strip() for line in lines))
)
print(cleaned)  # ['hello', 'world', 'python']

# 대용량 파일 처리 패턴
# total_size = sum(
#     os.path.getsize(f)
#     for f in glob.glob("**/*.py", recursive=True)
# )

Python code

import heapq

# 기본 힙 연산
data = [5, 3, 8, 1, 9, 2]
heapq.heapify(data)  # 리스트를 힙으로 변환 O(n)
print(data)  # [1, 3, 2, 5, 9, 8]

# 삽입과 추출
heapq.heappush(data, 0)
print(heapq.heappop(data))   # 0 (최솟값)
print(heapq.heappop(data))   # 1

# nlargest / nsmallest
scores = [85, 92, 78, 95, 88, 76, 91]
print(heapq.nlargest(3, scores))   # [95, 92, 91]
print(heapq.nsmallest(3, scores))  # [76, 78, 85]

# 우선순위 큐 구현
class PriorityQueue:
    def __init__(self):
        self._heap = []
        self._counter = 0

    def push(self, priority: int, item):
        heapq.heappush(self._heap, (priority, self._counter, item))
        self._counter += 1

    def pop(self):
        return heapq.heappop(self._heap)[2]

pq = PriorityQueue()
pq.push(2, "낮은 우선순위")
pq.push(0, "높은 우선순위")
pq.push(1, "중간 우선순위")
print(pq.pop())  # 높은 우선순위

Python code

import bisect

# 정렬된 리스트에 삽입 위치 찾기
data = [10, 20, 30, 40, 50]
pos = bisect.bisect(data, 25)
print(f"25의 삽입 위치: {pos}")  # 2

# insort: 삽입 위치에 바로 추가
bisect.insort(data, 25)
print(data)  # [10, 20, 25, 30, 40, 50]

# 성적 등급 매기기
def grade(score):
    breakpoints = [60, 70, 80, 90]
    grades = "FDCBA"
    return grades[bisect.bisect(breakpoints, score)]

scores = [33, 60, 77, 85, 92, 100]
for s in scores:
    print(f"  {s}점 → {grade(s)}등급")

# bisect_left vs bisect_right
arr = [1, 3, 3, 3, 5, 7]
print(bisect.bisect_left(arr, 3))   # 1 (왼쪽)
print(bisect.bisect_right(arr, 3))  # 4 (오른쪽)

# 정렬된 리스트에서 값 검색
def binary_search(arr, target):
    i = bisect.bisect_left(arr, target)
    if i < len(arr) and arr[i] == target:
        return i
    return -1

print(binary_search(arr, 3))   # 1
print(binary_search(arr, 4))   # -1

Python code

from collections import deque

# 기본 사용
dq = deque([1, 2, 3, 4, 5])
dq.appendleft(0)      # 왼쪽 추가
dq.append(6)           # 오른쪽 추가
print(dq)  # deque([0, 1, 2, 3, 4, 5, 6])

dq.popleft()           # 왼쪽 제거 O(1)
dq.pop()               # 오른쪽 제거 O(1)

# 회전
dq.rotate(2)           # 오른쪽으로 2칸
print(dq)
dq.rotate(-2)          # 왼쪽으로 2칸

# maxlen: 고정 크기 버퍼 (슬라이딩 윈도우)
buffer = deque(maxlen=3)
for i in range(5):
    buffer.append(i)
    print(f"  추가 {i}: {list(buffer)}")
# 마지막: [2, 3, 4]

# 이동 평균 계산
def moving_avg(data, window=3):
    buf = deque(maxlen=window)
    results = []
    for val in data:
        buf.append(val)
        results.append(sum(buf) / len(buf))
    return results

prices = [100, 102, 104, 103, 105, 107]
print(moving_avg(prices, 3))

Python code

from collections import ChainMap

# 계층적 설정
defaults = {"color": "red", "size": 10, "font": "Arial"}
user_prefs = {"color": "blue", "font": "Helvetica"}
cli_args = {"color": "green"}

config = ChainMap(cli_args, user_prefs, defaults)
print(config["color"])  # green (가장 앞쪽 우선)
print(config["size"])   # 10 (defaults에서 가져옴)
print(config["font"])   # Helvetica

# 모든 키 조회
print(list(config.keys()))

# 새 레이어 추가
session = config.new_child({"size": 20})
print(session["size"])    # 20
print(session["color"])   # green
print(session.parents["size"])  # 10

# maps로 모든 레이어 접근
for i, m in enumerate(config.maps):
    print(f"  레이어 {i}: {m}")

# 변경은 첫 번째 맵에만 적용
config["new_key"] = "value"
print(cli_args)  # {'color': 'green', 'new_key': 'value'}

Python code

from types import MappingProxyType
from dataclasses import dataclass, field

# MappingProxyType: 읽기 전용 딕셔너리 뷰
original = {"a": 1, "b": 2, "c": 3}
readonly = MappingProxyType(original)
print(readonly["a"])      # 1
# readonly["a"] = 10      # TypeError!

# 원본 변경은 뷰에 반영됨
original["d"] = 4
print(readonly["d"])      # 4

# 불변 데이터클래스
@dataclass(frozen=True)
class Config:
    host: str
    port: int
    tags: tuple[str, ...] = ()  # 불변 시퀀스

    def with_port(self, new_port: int) -> "Config":
        """변경된 복사본 반환"""
        return Config(self.host, new_port, self.tags)

cfg = Config("localhost", 8080, ("web", "api"))
# cfg.port = 9090  # FrozenInstanceError

cfg2 = cfg.with_port(9090)
print(f"{cfg.port} → {cfg2.port}")  # 8080 → 9090

# 해시 가능 (딕셔너리 키로 사용 가능)
cache = {cfg: "기본 설정", cfg2: "새 설정"}
print(cache[cfg])  # 기본 설정

Python code

from operator import attrgetter, itemgetter

# 다중 키 정렬
students = [
    {"name": "Alice", "grade": 3, "score": 85},
    {"name": "Bob", "grade": 2, "score": 92},
    {"name": "Carol", "grade": 3, "score": 92},
    {"name": "Dave", "grade": 2, "score": 85},
]

# 학년 오름차순 → 점수 내림차순
result = sorted(students, key=lambda s: (s["grade"], -s["score"]))
for s in result:
    print(f"  {s['grade']}학년 {s['name']}: {s['score']}점")

# operator 모듈 (더 빠름)
by_score = sorted(students, key=itemgetter("score"), reverse=True)

# 안정 정렬 활용 (Timsort)
# 여러 키로 정렬 시 덜 중요한 키부터 정렬
data = [(1, "b"), (2, "a"), (1, "a"), (2, "b")]
data.sort(key=lambda x: x[1])  # 먼저 문자 정렬
data.sort(key=lambda x: x[0])  # 그 다음 숫자 정렬
print(data)  # [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]

# functools.cmp_to_key (복잡한 비교)
from functools import cmp_to_key
words = ["banana", "Apple", "cherry"]
result = sorted(words, key=cmp_to_key(
    lambda a, b: (a.lower() > b.lower()) - (a.lower() < b.lower())
))
print(result)  # ['Apple', 'banana', 'cherry']

Python code

import bisect
from typing import Optional

def binary_search(arr: list, target) -> Optional[int]:
    """이진 검색: O(log n)"""
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return None

# 하한/상한 검색
def lower_bound(arr, target):
    """target 이상인 첫 번째 위치"""
    return bisect.bisect_left(arr, target)

def upper_bound(arr, target):
    """target 초과인 첫 번째 위치"""
    return bisect.bisect_right(arr, target)

data = [1, 3, 3, 3, 5, 7, 9]
print(f"검색 3: 인덱스={binary_search(data, 3)}")
print(f"하한 3: {lower_bound(data, 3)}")  # 1
print(f"상한 3: {upper_bound(data, 3)}")  # 4
print(f"3의 개수: {upper_bound(data, 3) - lower_bound(data, 3)}")  # 3

# 조건 기반 이진 검색
def find_min_satisfying(lo, hi, predicate):
    while lo < hi:
        mid = (lo + hi) // 2
        if predicate(mid):
            hi = mid
        else:
            lo = mid + 1
    return lo

# x^2 >= 100인 최소 x
result = find_min_satisfying(0, 100, lambda x: x * x >= 100)
print(f"x²≥100인 최소 x: {result}")  # 10

Python code

from collections import defaultdict, deque

# 이진 트리
class TreeNode:
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

# 트리 순회
def inorder(node):
    if node:
        yield from inorder(node.left)
        yield node.val
        yield from inorder(node.right)

root = TreeNode(4,
    TreeNode(2, TreeNode(1), TreeNode(3)),
    TreeNode(6, TreeNode(5), TreeNode(7)))

print("중위:", list(inorder(root)))  # [1, 2, 3, 4, 5, 6, 7]

# 그래프 (인접 리스트)
graph = defaultdict(list)
edges = [("A","B"), ("A","C"), ("B","D"), ("C","D"), ("D","E")]
for u, v in edges:
    graph[u].append(v)
    graph[v].append(u)

# BFS
def bfs(graph, start):
    visited = {start}
    queue = deque([start])
    order = []
    while queue:
        node = queue.popleft()
        order.append(node)
        for neighbor in graph[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)
    return order

print("BFS:", bfs(graph, "A"))  # ['A', 'B', 'C', 'D', 'E']

Python code

class HashTable:
    def __init__(self, size=16):
        self._size = size
        self._buckets: list[list] = [[] for _ in range(size)]
        self._count = 0

    def _hash(self, key) -> int:
        return hash(key) % self._size

    def __setitem__(self, key, value):
        bucket = self._buckets[self._hash(key)]
        for i, (k, v) in enumerate(bucket):
            if k == key:
                bucket[i] = (key, value)
                return
        bucket.append((key, value))
        self._count += 1

    def __getitem__(self, key):
        bucket = self._buckets[self._hash(key)]
        for k, v in bucket:
            if k == key:
                return v
        raise KeyError(key)

    def __contains__(self, key):
        try:
            self[key]
            return True
        except KeyError:
            return False

    def __len__(self):
        return self._count

ht = HashTable()
ht["name"] = "Alice"
ht["age"] = 30
ht["city"] = "서울"
print(ht["name"])       # Alice
print("age" in ht)      # True
print(len(ht))          # 3