Python 기억해야 할 팁 정리

파이썬으로 코딩 테스트를 준비하거나 알고리즘 문제를 풀 때 자주 찾게 되는 핵심 문법, 내장 라이브러리, 그리고 필수 알고리즘 템플릿을 한눈에 보기 좋게 정리했습니다.

1. 파이썬 기본 문법 & 코딩 테스트 꿀팁

기본 입출력 최적화

반복문 내에서 대량의 입력을 받을 때 시간 초과를 방지하기 위해 필수적으로 사용합니다.

import sys
input = sys.stdin.readline

f-string 문자열 포맷팅

# 기본 활용 (소수점 지정)
f"이름: {name} | 점수: {score:.1f}"

# 유용한 포맷팅 스타일 모음
f"{num:02d}"       # 2자리 채우기 (남는 자리 0) -> ex) 03, 12
f"{score:.2f}"     # 소수점 둘째 자리까지 표시
f"{num:,}"         # 천 단위 구분 기호 넣기 -> ex) 1,234,567
f"{word:>10}"      # 10칸 확보 후 우측 정렬
f"{word:<10}"      # 10칸 확보 후 좌측 정렬
f"{word!r}"        # repr() 결과 출력 (문자열일 경우 따옴표 포함)

내장 함수 & 자료형 팁

• all(iterable): 인자로 받은 반복 가능한 객체(Iterable)의 모든 요소가 참(True)이면 True를, 하나라도 거짓이 있으면 False를 반환한다.
• enumerate(array, start=1): 반복문에서 인덱스와 원소를 동시에 가져올 때 사용합니다. start 옵션으로 시작 인덱스를 지정할 수 있다.
• find() vs index(): 문자열 위치를 찾을 때 index()는 찾는 값이 없으면 에러를 발생시키지만, find()는 1을 반환하므로 예외 처리 시 더 유용하다.
• [:] (슬라이싱 복사): 1차원 리스트에서 new_list = old_list[:]와 같은 형태로 간편하게 깊은 복사(Deep Copy)를 할 수 있다.

Set(집합) 원소 조작

s = set()
s.add(1)        # 원소 추가
s.remove(1)     # 원소 삭제 (원소가 없으면 KeyError 발생)

---

2. 정렬과 다중 조건 (Lambda 공식)

기본 리스트 정렬

# 1. 원본을 직접 정렬 (반환값 None)
list.sort()
list.sort(reverse=True) # 역순(내림차순) 정렬

# 2. 정렬된 새로운 리스트를 반환 (원본 유지)
new_list = sorted(list)

Lambda식을 활용한 다중 조건 정렬

key=lambda를 이용하면 튜플 형태로 정렬 기준을 여러 개 지정할 수 있다.

# 1. 튜플의 특정 인덱스를 기준으로 정렬
routes.sort(key=lambda x: x[1])

# 2. 다중 조건 정렬 (예: 딕셔너리 등을 {"word": 3} 구조로 저장했을 때)
# 1순위: 빈도수(x[1]) 기준 내림차순 (- 기호)
# 2순위: 단어(x[0]) 기준 오름차순
sorted_data = sorted(data, key = lambda x : (-x[1], x[0]))

---

3. 코딩 테스트 필수 내장 라이브러리

수학 (Math & GCD)

두 수의 곱은 최대공약수(GCD)와 최소공배수(LCM)의 곱과 같다.
($a \times b = GCD(a, b) \times LCM(a, b)$)

import math
# 1. 내장 라이브러리 사용
result = math.gcd(a, b)

# 2. 직접 구현 (유클리드 호제법 공식)
def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

순열과 조합 (Itertools)

from itertools import combinations, permutations

l = [1, 2, 3]

# 조합 (순서 X)
print(list(combinations(l, 2)))
# 결과: [(1, 2), (1, 3), (2, 3)]

# 순열 (순서 O)
print(list(permutations(l, 2)))
# 결과: [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]

개수 세기 (Counter)

from collections import Counter

S = "Hello, World!"
D = Counter(S)
# 결과: {'l': 3, 'o': 2, 'H': 1, 'e': 1, ',': 1, ' ': 1, 'W': 1, 'r': 1, 'd': 1, '!': 1}

우선순위 큐 (Heapq)

파이썬의 heapq는 기본적으로 최소 힙(Min Heap)으로 작동합니다.

from heapq import heappush, heappop

heap = []
heappush(heap, 1)
print(heappop(heap))

# [Tip] 최대 힙(Max Heap) 구현하기
# 값을 넣을 때 (-num, num) 튜플 형태로 우선순위를 반전시켜 저장합니다.
heappush(heap, (-num, num))
max_value = heappop(heap)[1]

---

4. 최단 경로 및 탐색 알고리즘 핵심 템플릿

표준 격자형 BFS(너비 우선 탐색) 템플릿

매 단계마다 상하좌우로 1칸씩 이동하며 최단 거리를 기록하는 가장 범용적인 템플릿입니다.

from collections import deque

def bfs_grid_template(board):
    R = len(board)
    C = len(board[0])

    # 1. 시작점 찾기
    start_x, start_y = 0, 0
    for r in range(R):
        for c in range(C):
            if board[r][c] == "R":
                start_x, start_y = r, c
                break

    # 2. 큐 및 방문 배열 초기화 (-1은 미방문, 0 이상은 시작점으로부터의 거리)
    queue = deque([(start_x, start_y)])
    visited = [[-1] * C for _ in range(R)]
    visited[start_x][start_y] = 0

    # 상, 하, 좌, 우 방향 벡터
    dr = [-1, 1, 0, 0]
    dc = [0, 0, -1, 1]

    # 3. BFS 루프
    while queue:
        r, c = queue.popleft()

        # 목적지 도달 시 거리 반환
        if board[r][c] == "G":
            return visited[r][c]

        for i in range(4):
            nr, nc = r + dr[i], c + dc[i]

            # 격자 범위를 벗어나거나 벽(D)을 만난 경우 패스
            if not (0 <= nr < R and 0 <= nc < C) or board[nr][nc] == "D":
                continue

            # 첫 방문인 경우 거리 갱신 후 큐에 삽입
            if visited[nr][nc] == -1:
                visited[nr][nc] = visited[r][c] + 1
                queue.append((nr, nc))

    return -1 # 도달 불가능한 경우

0-1 BFS 템플릿 (가중치가 0 또는 1인 경우)

간선의 가중치가 0과 1로만 이루어진 그래프에서 일반 Dijkstra($O(E \log V)$)보다 효율적인 $O(V + E)$의 시간 복잡도로 해결할 수 있는 알고리즘입니다. 가중치가 0이면 큐의 앞에(appendleft), 1이면 뒤에(append) 넣는 것이 핵심입니다.

from collections import deque

def zero_one_bfs(graph, start):
    n = len(graph)
    distance = [float('inf')] * n
    distance[start] = 0
    dq = deque([start])

    while dq:
        u = dq.popleft()
        for v, w in graph[u]:
            if distance[u] + w < distance[v]:
                distance[v] = distance[u] + w

                # 가중치가 0이면 큐의 맨 앞에 넣어서 먼저 처리
                if w == 0:
                    dq.appendleft(v)
                # 가중치가 1이면 큐의 맨 뒤에 삽입
                else:
                    dq.append(v)

    return distance

다익스트라(Dijkstra) 최단 경로 템플릿

우선순위 큐(heapq)를 기반으로 작동하며, 음의 가중치가 없는 큰 그래프에서 단일 시작점으로부터 다른 모든 정점까지의 최단 거리를 구할 때 매우 효율적입니다.

import heapq

def dijkstra(graph, start):
    # 최단 거리를 저장할 배열/딕셔너리 초기화
    distances = {node: float('inf') for node in graph}
    distances[start] = 0

    # 우선순위 큐 (가중치, 노드) 초기화
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        # 이미 더 짧은 경로로 처리된 노드라면 무시
        if current_distance > distances[current_node]:
            continue

        # 인접 노드 확인
        for neighbor, weight in graph[current_node]:
            distance = current_distance + weight

            # 더 지름길을 발견하면 거리 갱신 후 큐에 삽입
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances