[OpenPyXL] CSV/JSON 데이터를 서식 있는 엑셀로 변환하기

from openpyxl import Workbook

wb = Workbook()
ws = wb.active
ws.title = "데이터"

# 1. 데이터 추가
json_data = [dict(...), dict(...), dict(...), ...]
headers = list(json_data[0].keys())
ws.append(headers)
for row in json_data:
    ws.append([row.get(col) for col in headers])

# 2. 셀 서식 적용
header_styles = dict(...)
for cell in ws[1]:
    style_cell(cell, **header_styles)

# 3. 열 너비 조정
from openpyxl.utils import get_column_letter

for col_idx, column in enumerate(ws.columns):
    max_width = max([get_cell_width(cell) for cell in column])
    ws.column_dimensions[get_column_letter(col_idx)].width = max_width

# 4. 조건부 서식 적용
from openpyxl.formatting.rule import CellIsRule

rule = CellIsRule(...)
ws.conditional_formatting.add("A1:A10", rule)

# 5. 셀 병합
for merge_range in find_merge_ranges(...):
    ws.merge_cells(merge_range)

wb.save("results.xlsx")

wb = json2excel(
    json_data,
    sheet_name = "데이터",
    header_styles = {"alignment": dict(...), "fill": dict(...), "font": dict(...)},
    column_styles = {1: {"alignment": dict(...)}, 5: dict(number_format="#,##0")},
    column_width = ":fit_values:",
    conditional_formatting = [{"ranges": "A1:A10", "rule": dict(...)}, ...],
    merge_cells = [{"ranges": "A1:B1", "mode": "all"}, ...],
)
wb.save("results.xlsx")

csv_data = [
    # A열     B열    C열
    ["이름", "나이", "직업"],       # 헤더 (1행)
    ["홍길동", 30, "개발자"],       # 데이터 (2행)
    ["김철수", 25, "기획자"],       # 데이터 (3행)
]

header_rows = [1]   # 첫 번째 행이 헤더

json_data = [
    # 헤더 (1행) -> 키 목록 추출
    {"이름": "홍길동", "나이": 30, "직업": "개발자"},   # 데이터 (2행)
    {"이름": "김철수", "나이": 25, "직업": "기획자"},   # 데이터 (3행)
]

headers = list(json_data[0].keys())

json_data = [
    # 헤더 (1행), 헤더 (2행) -> 키 목록 추출
    {("제품 정보", "대분류"): "주변기기", ("제품 정보", "중분류"): "노트북", ("판매 현황", "판매 수량"): 10},   # 데이터 (3행)
    {("제품 정보", "대분류"): "주변기기", ("제품 정보", "중분류"): "마우스", ("판매 현황", "판매 수량"): 30},   # 데이터 (4행)
]

headers = list(zip(*json_data[0].keys()))
# [
#     ("제품 정보", "제품 정보", "판매 현황"),      << 헤더 (1행)
#     ("대분류", "중분류", "판매 수량"),           << 헤더 (2행)
# ]

from openpyxl import Workbook

wb = Workbook() # 엑셀 파일
ws = wb.active  # 활성화된 시트

for row in csv_data:
    ws.append(row)

headers = list(zip(*json_data[0].keys()))
rows = headers + [[row.get(col) for col in headers] for row in json_data]

for row in rows:
    ws.append(row)

def rows2sheet(
        wb: Workbook,
        rows: Sequence[Sequence[Any]],
        sheet_index: int,
        sheet_name: str = "Sheet1",
        **kwargs
    ) -> tuple[Worksheet, State]:
    if sheet_index == 1:
        ws = wb.active
        ws.title = sheet_name
    else:
        ws = wb.create_sheet(sheet_name)

    if not rows:
        return

    for row in rows:
        ws.append(row)

    state = style_sheet(ws, **kwargs)
    return ws, state

def style_sheet( # 매개변수는 명칭 대신에 설명으로 대체합니다.
        "워크시트": Worksheet,
        "헤더 행 번호": Sequence[Row] = [1],
        "헤더 행 서식 옵션": StyleConfig = dict(),
        "열 서식 옵션": dict[Column, StyleConfig] = dict(),
        "행 서식 옵션": dict[Row, StyleConfig] = dict(),
        "열 너비 지정 옵션": float | Multiple | dict[Column,Width] | Literal[...] | None = ":fit:",
        "행 높이 지정 옵션": float | Multiple | dict[Row,Height] | None = None,
        "조건부 서식 옵션 목록": Sequence[ConditionalConfig] = list(),
        "셀 병합 옵션 목록": Sequence[MergeConfig] = list(),
        "범위 서식 옵션 목록": Sequence[tuple[Range, StyleConfig]] = list(),
        "필터 옵션": ColumnFilters = dict(),
        "필터 적용 방식": Literal["hide","list"] | None = None,
        "하이퍼링크 여부": bool = True,
        "오버플로우 자르기": bool = False,
        "줄바꿈 허용": bool = False,
        "틀 고정": Range | None = "A2",
        "줌 배율": int | None = None,
    ) -> State:
    ...

from openpyxl.utils import get_column_letter

Row = TypeVar("Row", bound=int)
header_rows: Sequence[Row] = [1]   # 1행 = 1부터 시작

# --- [0] --- 함수의 첫 번째 부분: 워크시트 범위 파악 및 헤더 추출
min_col, max_col = 'A', get_column_letter(ws.max_column)
min_row, max_row = ((max(header_rows) + 1) if header_rows else 1), ws.max_row
size = dict(min_col=min_col, max_col=max_col, min_row=min_row, max_row=max_row)

if header_rows:
    headers = [
        tuple(ws.cell(row=row_idx, column=col_idx).value for row_idx in header_rows)
            for col_idx in range(1, ws.max_column+1)]
else:
    headers = list()

Column = TypeVar("Column", int, str, tuple[str,...])

def get_column_index(column: Column, headers: list[tuple[str,...]] = list()) -> int | None:
    if isinstance(column, int): # 열 번호
        return column
    elif isinstance(column, (str, tuple)): # 열 명칭
        try:
            name = (column,) if isinstance(column, str) else column
            return headers.index(name) + 1
        except:
            pass
    return None

class StyleConfig(TypedDict, total=False):
    ... # 셀 서식을 적용하는 `style_cell()` 함수 구현 시 설명 예정

def init_column_styles(
        column_styles: dict[Column, StyleConfig],
        headers: list[tuple[str, ...]] = list(),
    ) -> dict[int, StyleConfig]:
    return {col_idx: styles
        for column, styles in column_styles.items()
            if ((col_idx := get_column_index(column, headers)) is not None)}

Width = TypeVar("Width", float, str)
Multiple = TypeVar("Multiple", bound=str)
SINGLE_WIDTH = 8.43

def init_column_width(
        column_width: float | Multiple | dict[Column,Width] | Literal[":fit:",":fit_header:",":fit_values:"],
        headers: list[tuple[str,...]] = list(),
    ) -> dict[int, Union[float, Literal[":fit:",":fit_header:",":fit_values:"]]]:

    def _set_width(value: Width) -> float | Literal[":fit:",":fit_header:",":fit_values:"]:
        if isinstance(value, str):
            if value in (":fit:",":fit_header:",":fit_values:"): # 맞춤 열 너비 상수
                return value
            elif value.endswith('x'): # Multiple 유형의 문자열
                value = SINGLE_WIDTH * float(value[:-1])
        return float(value) if isinstance(value, (float,int)) and value > 0. else None

    if isinstance(column_width, dict):
        # 열 명칭 → 열 번호 변환과 열 너비 옵션값 검증 동시 진행
        return {col_idx: width for column, value in column_width.items()
                if ((col_idx := get_column_index(column, headers)) is not None)
                    and ((width := _set_width(value)) is not None)}
    else:
        # 모든 열에 대해 공통된 열 너비 옵션을 지정하는 경우
        value = _set_width(column_width)
        if value is not None:
            return {col_idx: value for column in headers
                    if (col_idx := get_column_index(column, headers)) is not None}
        else:
            return dict()

column_styles: dict[Column, StyleConfig] = dict()
column_width: float | Multiple | dict[Column,Width] | Literal[...] | None = ":fit:"

# --- [1] --- 함수의 두 번째 부분: 열 서식 및 열 너비 옵션 초기화
column_styles = init_column_styles(column_styles, headers) if column_styles else dict()
column_width = init_column_width(column_width, headers) if column_width is not None else dict()
fit_width = {col_idx: mode for col_idx, mode in column_width.items() if isinstance(mode, str)}

from openpyxl.styles import Alignment, Font

header_styles: StyleConfig = dict()
column_styles: dict[Column, StyleConfig] = init_column_styles(..., headers)
row_styles: dict[Row, StyleConfig] = dict()
column_width: float | Multiple | dict[Column,Width] | Literal[...] | None = init_column_width(..., headers)
hyperlink: bool = True
wrap_text: bool = False

# --- [2] --- 함수의 세 번째 부분: 셀 서식 및 열 너비 적용
for col_idx, column in enumerate(ws.columns, start=1): # 상위 반복문
    fit_mode = fit_width.get(col_idx)
    max_width = SINGLE_WIDTH

    for row_idx, cell in enumerate(column, start=1): # 하위 반복문
        text = str(x) if (x := cell.value) is not None else str()

        # 하이퍼링크 허용 시, 셀 값이 URL 형식이면 자동으로 하이퍼링크 적용
        if hyperlink and text.startswith("https://"):
            cell.hyperlink = text
            cell.font = Font(color="#0000FF", underline="single")

        # 줄바꿈 허용 시, 모든 셀에 줄바꿈 설정
        if wrap_text:
            cell.alignment = Alignment(wrap_text=True)

        # 셀이 포함된 행이 헤더인 경우 헤더 스타일을 지정
        if row_idx in header_rows:
            if header_styles:
                style_cell(cell, **header_styles)
            if fit_mode in (":fit:",":fit_header:"):
                max_width = max(max_width, get_cell_width(text))
        # 셀이 포함된 열이 서식 대상인 경우 열 서식을 적용
        elif col_idx in column_styles:
            style_cell(cell, **column_styles[col_idx])
        # 셀이 포함된 행이 서식 대상인 경우 행 서식을 적용
        elif row_idx in row_styles:
            style_cell(cell, **row_styles[row_idx])

        # 현재 열이 너비 자동 조절 대상인 경우, 맞춤 열 너비 계산
        if (fit_mode in (":fit:",":fit_values:")) and (row_idx not in header_rows):
            max_width = max(max_width, get_cell_width(text))

    # 정해진 열 너비가 있다면, 열 너비 지정
    width = min(max_width + 2., 25.) if fit_mode else column_width.get(col_idx)
    if isinstance(width, float):
        ws.column_dimensions[get_column_letter(col_idx)].width = width
        column_width["width"] = width

class StyleConfig(TypedDict, total=False):
    alignment: dict | None      # 정렬
    border: dict | None         # 테두리
    fill: dict | None           # 채우기
    font: dict | None           # 폰트
    number_format: str | None   # 숫자 서식

Height = TypeVar("Height", float, str)
row_height: float | Multiple | dict[Row,Height] | None = init_row_height(...)

# --- [3] --- 함수의 네 번째 부분: 행 높이 지정
if isinstance(row_height, dict):
    for row_idx, height in row_height.items():
        ws.row_dimensions[row_idx].height = height
elif row_height is not None:
    for row_idx in range(1, max_row+1):
        ws.row_dimensions[row_idx].height = SINGLE_HEIGHT

import re

Range = TypeVar("Range", bound=str)
MinCol = TypeVar("MinCol", bound=int)
MinRow = TypeVar("MinRow", bound=int)
MaxCol = TypeVar("MaxCol", bound=int)
MaxRow = TypeVar("MaxRow", bound=int)

def to_valid_excel_range(ws: Worksheet, value: str) -> Range:
    if ':' not in value:
        return value # 셀 참조로 인식하고 그대로 반환

    # 절대 참조 방식도 고려
    def absolute(x: str) -> Literal['$','']:
        return '$' if x.startswith('$') else ''

    # 범위 문자열에 (최소, 최대) * (행, 열) 이 명시되어 있지 않은 경우 워크시트 데이터 범위를 통해 계산
    min_col, min_row, max_col, max_row = split_range_string(value)
    if not min_col:
        min_col = ((absolute(min_row) or absolute(max_col)) + 'A')
    if not min_row:
        min_row = ((absolute(min_col) or absolute(max_row)) + '1')
    if not max_col:
        max_col = ((absolute(max_row) or absolute(min_col)) + get_column_letter(ws.max_column))
    if not max_row:
        max_row = ((absolute(max_col) or absolute(min_row)) + str(ws.max_row))
    return f"{min_col}{min_row}:{max_col}{max_row}"

# 범위 문자열 `value` 를 정규 표현식을 사용하여 파싱하는 함수
def split_range_string(value: str) -> tuple[MinCol, MinRow, MaxCol, MaxRow]:
    col, row = r"\$?[A-Z]+", r"\$?[1-9][0-9]*"
    cell = r"^({})?({})?$".format(col, row)
    top_left, bottom_right = value.split(':')
    min_col, min_row = match.groups() if (match := re.search(cell, top_left)) else (None, None)
    max_col, max_row = match.groups() if (match := re.search(cell, bottom_right)) else (None, None)
    return (min_col or str()), (min_row or str()), (max_col or str()), (max_row or str())

class ConditionalConfig(TypedDict):
    ranges: Column | Row | Range | list[...]            # 열, 행 또는 범위 문자열
    range_type: Literal["column","row","range","auto"]  # `ranges` 유형
    rule: RuleConfig                                    # 조건부 서식 규칙

class RuleConfig(TypedDict, total=False):
    operator: Literal[...]      # 연산자
    formula: Sequence | None    # 수식 또는 피연산자
    stop_if_true: bool | None   # 우선순위 규칙
    border: dict | None         # 스타일 - 테두리
    fill: dict | None           # 스타일 - 채우기
    font: dict | None           # 스타일 - 폰트

conditional_formatting: Sequence[ConditionalConfig] = list()

# --- [4] --- 함수의 다섯 번째 부분: 조건부 서식 적용
def to_excel_range(range_string: str) -> str:
    return to_valid_excel_range(ws, range_string)

for config in conditional_formatting:
    ranges = get_ranges(config["ranges"], (config.get("range_type") or "auto"), **size, headers=headers)
    if ranges:
        range_string = ' '.join(map(to_excel_range, ranges))
        ws.conditional_formatting.add(range_string, conditional_rule(**config["rule"]))

class MergeConfig(TypedDict):
    ranges: Column | Row | Range | list[...]            # 열, 행 또는 범위 문자열
    range_type: Literal["column","row","range","auto"]  # `ranges` 유형
    mode: Literal["all","blank","same_value"]           # 병합 방식
    styles: StyleConfig | None                          # 병합 후 서식 옵션 (선택사항)

from openpyxl.utils import range_boundaries

merge_cells: Sequence[MergeConfig] = list()

# --- [5] --- 함수의 여섯 번째 부분: (자동) 셀 병합
for config in merge_cells:
    styles = config.get("styles")
    for range_string in get_ranges(config["ranges"], config.get("range_type", "auto"), **size, headers=headers):
        for merge_range in find_merge_ranges(ws, to_excel_range(range_string), (config.get("mode") or "all")):
            ws.merge_cells(merge_range)
            if styles:
                col_start, row_start, _, _ = range_boundaries(to_excel_range(merge_range))
                style_cell(ws.cell(row_start, col_start), **styles)

from openpyxl.utils import range_boundaries

range_styles: Sequence[tuple[Range, StyleConfig]] = list()

# --- [6] --- 함수의 일곱 번째 부분: 범위 서식 적용
for range_string, styles in range_styles:
    col_start, row_start, col_end, row_end = range_boundaries(to_excel_range(range_string))
    for row in ws.iter_rows(row_start, row_end, col_start, col_end):
        for cell in row:
            style_cell(cell, **styles)

class ColumnFilters(TypedDict):
    range: Range | Literal[":all:"]                             # 드롭다운 표시할 필터 범위
    filters: Sequence[tuple[Column, Sequence[FilterConfig]]]    # 필터 설정 리스트
    button: Literal["always","hidden","auto"]                   # 버튼 표시 여부

class FilterConfig(TypedDict, total=False):                     # 필터 유형
    filter_type: Literal["value","top10","custom","dynamic","color","icon","blank","notBlank"]

from openpyxl.worksheet.filters import AutoFilter
from openpyxl.utils import range_boundaries

column_filters: ColumnFilters = dict()
filter_action: Literal["hide","list"] | None = None
filtered_rows: set[Row] = set()

# --- [7] --- 함수의 여덟 번째 부분: 필터 적용 및 필터 대상 행 계산
if column_filters:
    range_string = f"A1:{max_col}{max_row}" if (ref := column_filters["range"]) == ":all:" else to_excel_range(ref)
    _, min_row, _, max_row = range_boundaries(range_string)
    row_range = [row_idx for row_idx in range(min_row, max_row+1) if row_idx not in header_rows]

    filters = list()
    for column, configs in (column_filters.get("filters") or list()):
        if (col_idx := get_column_index(column, headers)) is not None:
            filters.append(filter_column(col_idx, configs, column_filters.get("button", "always")))
            if filter_action:
                values = [(row_idx, ws.cell(row_idx, col_idx).value) for row_idx in row_range if row_idx not in filtered_rows]
                filtered_rows = filtered_rows.union(filter_values(values, configs))
    ws.auto_filter = AutoFilter(ref=range_string, filterColumn=filters)

    if (filter_action == "hide") and filtered_rows:
        for row_idx in filtered_rows:
            ws.row_dimensions[row_idx].hidden = True

def csv2excel(
        obj: Sequence[Sequence[Any]] | dict[str,Sequence[Sequence[Any]]],
        sheet_name: str = "Sheet1",
        header_rows: Sequence[Row] = [1],
        header_styles: StyleConfig | Literal["yellow"] = "yellow",
        column_styles: dict[Column, StyleConfig] = dict(),
        row_styles: dict[Row, StyleConfig] = dict(),
        column_width: float | Multiple | dict[Column,Width] | Literal[":fit:",":fit_header:",":fit_values:"] | None = ":fit:",
        row_height: float | Multiple | dict[Row,Height] | None = None,
        conditional_formatting: Sequence[ConditionalConfig] = list(),
        merge_cells: Sequence[MergeConfig] = list(),
        range_styles: Sequence[tuple[Range, StyleConfig]] = list(),
        column_filters: ColumnFilters = dict(),
        filter_mode: Literal["openpyxl","xml"] | None = None,
        hyperlink: bool = True,
        truncate: bool = False,
        wrap_text: bool = False,
        freeze_panes: str | None = "A2",
        zoom_scale: int | None = None,
    ) -> Workbook:
    from openpyxl import Workbook
    wb = Workbook()
    # 단일 CSV 데이터 형식(1)이라면 `{ 시트명 : CSV_데이터 }` 형식(2)으로 바꿔주기
    obj = {sheet_name: obj} if isinstance(obj, Sequence) else obj
    # `style_sheet()` 함수에서 사용할 매개변수
    kwargs = dict(
        header_rows=header_rows, header_styles=header_styles,
        column_styles=column_styles, row_styles=row_styles, column_width=column_width, row_height=row_height,
        conditional_formatting=conditional_formatting, merge_cells=merge_cells, range_styles=range_styles,
        column_filters=column_filters, filter_action={"openpyxl": "hide", "xml": "list"}.get(filter_mode),
        hyperlink=hyperlink, truncate=truncate, wrap_text=wrap_text, freeze_panes=freeze_panes, zoom_scale=zoom_scale,
    )

    states = list()
    for index, (name, rows) in enumerate(obj.items(), start=1):
        # 각 데이터마다 `rows2sheet()` 함수를 호출하여 시트 생성 및 서식 적용하기
        ws, state = rows2sheet(wb, rows, index, name, **kwargs)
        states.append(state)

    # 필터 적용 방식이 `xml` 이라면 Workbook 수준에서 필터 적용하기 (상태 객체 활용)
    if filter_mode == "xml":
        filtered_rows = {index: state["filtered_rows"] for index, state in enumerate(states, start=1) if state["filtered_rows"]}
        return apply_filters(wb, filtered_rows)
    else:
        return wb

csv2excel(csv_data, **options).save("results.xlsx")

# [0]: JSON 데이터의 모든 레코드(딕셔너리)에서 한 번이라도 사용된 키를 추출하는 함수
def get_all_keys(rows: Sequence[dict]) -> list:
    keys = list()
    for row in rows:
        for key in row.keys():
            if key not in keys:
                keys.append(key)
    return keys

# [1]: 헤더 추출 방식에 따라 JSON 데이터로부터 키(헤더)를 추출하는 함수
def get_json_keys(rows: Sequence[dict], how: Literal["first","all"]) -> list:
    if not rows:
        return list()
    # 첫 번째 행에서만 키(헤더)를 추출하기
    elif how == "first":
        return list(rows[0].keys())
    # 모든 행에서 키(헤더)를 추출하기
    else:
        return get_all_keys(rows)

# [2]: 다중 헤더를 고려하여 키 목록을 2차원 리스트로 변환하는 함수
def keys_to_rows(keys: list) -> list[list]:
    key_depths = {len(key) for key in keys if isinstance(key, tuple)}
    if key_depths:
        def get_value(key: Any, depth: int):
            if isinstance(key, tuple):
                return key[depth] if depth < len(key) else None
            else:
                return key if depth == 0 else None
        return [[get_value(key, depth) for key in keys] for depth in range(max(key_depths))]
    else:
        return [keys]

def json2excel(
        obj: Sequence[dict] | dict[str,Sequence[dict]],
        sheet_name: str = "Sheet1",
        header: Literal["first","all"] | None = "first",
        # 나머지는 `csv2excel()` 함수와 동일
    ) -> Workbook:
    from openpyxl import Workbook
    wb = Workbook()
    obj = {sheet_name: obj} if isinstance(obj, Sequence) else obj
    kwargs = dict(...) # `csv2excel()` 함수와 동일하게 `style_sheet()` 함수의 매개변수 정리

    states = list()
    for index, (name, rows) in enumerate(obj.items(), start=1):
        keys = get_json_keys(rows, how=(header or "first"))
        values = [[row.get(key, None) for key in keys] for row in rows]
        headers = keys_to_rows(keys) if header else list()
        header_rows = list(range(1,len(headers)+1)) if headers else list()
        ws, state = rows2sheet(wb, (headers + values), index, name, **kwargs)
        states.append(state)

    if filter_mode == "xml":
        filtered_rows = {index: state["filtered_rows"] for index, state in enumerate(states, start=1) if state["filtered_rows"]}
        return apply_filters(wb, filtered_rows)
    else:
        return wb

with open("data.csv", 'r', encoding="utf-8") as file:
    rows = [line.split(',') for line in file.read().split('\n')]
csv_data = rows[:2] + [[a, b, int(c), int(d), e] for a, b, c, d, e in rows[2:]]

wb = csv2excel(
    obj = csv_data,
    sheet_name = "데이터",
    # 1행 + 2행을 헤더로 정의
    header_rows = [1, 2],
    # 헤더 서식 - 가운데 정렬 + 모든 테두리 + 노란색 배경 + 볼드체
    header_styles = {
        "alignment": {"horizontal": "center", "vertical": "center"},
        "border": {side: {"style": "thin"} for side in ["left", "right", "top", "bottom"]},
        "fill": {"start_color": "FFFF00", "end_color": "FFFF00", "fill_type": "solid"},
        "font": {"bold": True, "color": "000000"},
    },
    # 열 서식 - 판매 현황에 해당하는 숫자 열에 1,000 단위 구분 서식
    column_styles = {
        ("판매 현황", "판매 수량"): {"number_format": "#,##0"},
        ("판매 현황", "매출액 (원)"): {"number_format": "#,##0"},
    },
    # 모든 열에 셀 값에 맞춘 열 너비 지정
    column_width = ":fit:",
    # C열 값이 3000 이상이면 빨간색 배경, 1000 이하면 파란색 배경의 조건부 서식
    conditional_formatting = [
        {
            "ranges": "C3:C",
            "range_type": "range",
            "rule": {
                "operator": "greaterThanOrEqual",
                "formula": ["3000"],
                "stop_if_true": True,
                "fill": {"start_color": "FE968D", "end_color": "FE968D", "fill_type": "solid"},
            }
        },
        {
            "ranges": "C3:C",
            "range_type": "range",
            "rule": {
                "operator": "lessThanOrEqual",
                "formula": ["1000"],
                "stop_if_true": True,
                "fill": {"start_color": "41B0F6", "end_color": "41B0F6", "fill_type": "solid"},
            }
        },
    ],
    # 헤더 1행에 동일한 값의 셀들을 각각 병합
    merge_cells = [
        {"ranges": "A1:E1", "range_type": "range", "mode": "same_value"},
    ],
    column_filters = {"range": "A2:E"}, # 필터 드롭다운 표시
    freeze_panes = "A3",                # 1행 + 2행 헤더 고정
    zoom_scale = 85,                    # 85% 줌 배율
)
wb.save("results.xlsx")