PyQt5 GUI(뷰/입력)와 **프랙탈 그래픽 엔진(계산/렌더링)**을 완전히 분리해서, 엔진은 **Native Python(표준 라이브러리 중심)**으로 구성하는 건 “장기적으로 이득이 큰 선택”이에요. 대신 프랙탈은 계산량이 커서, 분리 설계만으로 해결 안 되는 성능/동시성 함정이 몇 개 있습니다.

아래에 **장점/단점 → 특징 → 주의점(실전 체크리스트)**로 정리할게요.

1) 장점

1) 테스트/검증이 쉬워짐

• 엔진이 Qt에 의존하지 않으면 pytest로 순수 함수/클래스 단위 테스트가 가능
• 예: “같은 파라미터 → 같은 픽셀 결과(결정성)” 검증, 회귀 테스트(렌더 결과 비교) 가능

2) 재사용/이식성이 커짐

• 같은 엔진을
  • PyQt5 GUI
  • CLI 렌더러(이미지 파일 출력)
  • 웹 백엔드(타일 렌더링)
  • 다른 GUI(Tkinter, Delphi, Electron)
    로 쉽게 교체 가능
• “엔진 = 제품”, “GUI = 어댑터”가 됨

3) 설계가 명확해짐(DDD/포트-어댑터에 잘 맞음)

• 엔진 쪽은
  • RenderSpec(입력)
  • RenderResult(출력)
  • Renderer(서비스)
  • Palette, Viewport(값 객체)
    같은 구조가 깔끔하게 자리잡음
• GUI는 “현재 뷰포트/팔레트/프리셋 상태”만 관리

4) 디버깅이 쉬움(재현 가능성 ↑)

• Qt 이벤트 루프/스레드 문제와 분리되면 “렌더링 버그”를 순수 엔진 코드로 재현 가능
• 크래시/멈춤/글리치 원인 분리가 쉬움

5) 의존성/배포가 단순해짐(엔진은 표준 라이브러리만)

• 엔진을 별도 패키지로 떼면:
  • 엔진은 pip 의존 거의 없음
  • GUI만 PyQt5 의존
• 유지보수 비용이 줄어듦

2) 단점

1) 성능 한계가 빨리 드러남(특히 pure Python 루프)

프랙탈은 픽셀마다 반복 연산(복소수/반복)이 많아서:

• “엔진을 Native Python으로만” 만들면
  • 큰 해상도/높은 iteration에서 CPU가 쉽게 한계
• 결국 어느 시점엔
  • multiprocessing(표준)
  • 또는 NumPy/Numba/C 확장(비표준)
    같은 옵션을 고민하게 됨

2) 경계 설계 비용이 생김(데이터 전달/형식)

GUI ↔ 엔진 사이에 주고받는 데이터(픽셀 버퍼, 타일, 팔레트)가 커서:

• 무작정 list[list[int]] 같은 구조로 주고받으면 느리고 메모리 폭발
• “표준+효율” 사이에서 데이터 포맷 설계가 필요

3) 동시성 복잡도(스레드/프로세스/취소/진행률)

GUI는 항상 반응해야 하고, 렌더링은 오래 걸리니:

• 렌더 작업을 백그라운드로 돌리고
• 취소/재시작/진행률 업데이트
  를 구현해야 함
  → 분리하면 더 “정교한 작업 관리”가 필요해짐

4) Qt 이미지 변환 비용(브릿지 비용)

엔진 결과를 Qt에 표시하려면 결국:

• raw bytes → QImage → QPixmap
  변환이 들어가는데, 이 변환이 병목이 될 수도 있음
  (특히 프레임이 자주 갱신될 때)

3) 특징(이 구조에서 “잘 되는” 패턴)

✅ 엔진은 “결정적(deterministic) + 순수”에 가깝게

• 같은 입력(RenderSpec)이면 같은 출력(RenderResult)
• 내부 상태 최소화(캐시/랜덤 최소화)
• I/O 없음(파일/Qt/네트워크 금지)

✅ GUI는 “상태 머신 + 이벤트” 중심

• 줌/팬/팔레트 변경 = 상태 변경 이벤트
• 이벤트가 발생하면 “새 RenderSpec 생성 → 렌더 요청”
• 렌더 완료 신호가 오면 화면 갱신

✅ 경계 데이터는 “작고 명확”하게

• 입력: viewport, size, max_iter, palette_id, formula_id …
• 출력: bytes(RGBA), width/height, stats(시간, iter 히트맵 요약 등)

4) 주의해야 할 점(실전 함정)

1) GUI 스레드에서 렌더링 금지

• Qt 메인 스레드는 이벤트 루프용
• 렌더링을 여기서 하면 UI가 멈춤
• 해결:
  • QThread + 작업 객체
  • 또는 concurrent.futures.ThreadPoolExecutor
  • CPU-bound면 multiprocessing이 더 유리

2) 취소(Cancel) 설계를 처음부터 넣기

프랙탈 탐색은 “사용자가 계속 줌/팬”하므로:

• 이전 렌더는 의미 없어짐 → 즉시 중단해야 함
• 해결 패턴:
  • render 요청마다 job_id 발급
  • 엔진은 루프 중간중간 cancel_token.is_cancelled() 확인
  • GUI는 최신 job_id만 수용(낡은 결과 폐기)

3) 데이터 포맷: list 대신 bytes/bytearray/memoryview

• 픽셀 버퍼는 bytearray(RGBA) 추천
• memoryview로 슬라이스/타일 처리하면 복사 줄어듦
• struct / array('I')도 옵션

4) 프로세스 사용 시 “pickle 비용” 관리

multiprocessing으로 타일을 나누면 좋은데:

• 큰 버퍼를 작업마다 넘기면 직렬화 비용이 큼
• 해결:
  • 타일 단위로 계산해서 작은 결과만 전달
  • 가능하면 shared_memory(표준 lib)로 공유 버퍼 사용

5) 부동소수/확대(zoom) 정밀도 한계

깊게 확대하면 float 정밀도가 깨져서 아티팩트가 생김

• Native Python만 쓰면 decimal로 가는 선택지가 있지만 매우 느림
• 현실적 대안:
  • 일정 줌 이상에서는 품질/속도 타협(샘플링/iteration 조절)
  • 또는 고정소수/임의정밀(비표준 라이브러리) 고려

6) 색상 매핑(팔레트)도 엔진 규칙으로 고정

GUI에서 색을 “그때그때” 바꾸면 재현이 어려움

• 팔레트 정의는 엔진 쪽 “순수 함수”로
• GUI는 팔레트 ID/파라미터만 전달

7) 이벤트 폭주(thrashing) 방지

줌/팬 드래그 중 렌더 요청을 매번 보내면:

• 작업이 계속 쌓이고 CPU만 낭비
• 해결:
  • 디바운스(예: 50~120ms)
  • 드래그 중엔 저해상도 프리뷰, 손 뗄 때 고해상도

5) 한 줄 결론

• 장점: 테스트/재사용/유지보수/이식성이 크게 좋아지고 구조가 깨끗해짐
• 단점: 성능·동시성·데이터 전달(버퍼/변환) 설계를 제대로 안 하면 오히려 복잡해짐

원하면 다음 단계로, 당신이 원하던 스타일(DDD + 이벤트)로:

• RenderSpec / RenderResult / Viewport / Palette
• Renderer 인터페이스 + TMandelbrotRenderer급 구현(파이썬)
• RenderJobManager(취소/디바운스/최신결과만 수용)
• PyQt5 어댑터(QImage 변환 포함)

이렇게 “바로 붙여서 실행” 가능한 스켈레톤을 코드 파일 세트로 정리해줄까요?

“파이썬으로 재사용 가능한 소프트웨어”를 만든다는 건 결국 패키지화 + 경계(레이어) 분리 + 안정적인 API를 만드는 일이라, 아래 템플릿대로 가면 거의 실패가 없습니다.

1) 재사용 가능성을 만드는 7가지 원칙

1. 코어 로직을 프레임워크/입출력에서 분리
   • DB, 웹(Flask), CLI, GUI는 “어댑터”
   • 핵심 규칙/유스케이스는 “순수 파이썬”
2. Public API를 작게 고정
   • __init__.py에서 외부 노출 대상을 최소화
   • 내부 구현은 바꿔도 사용자 코드는 안 깨지게
3. 의존성 주입(Dependency Injection)
   • 함수/클래스 생성자에 repo/logger/clock 등을 주입
   • 전역 싱글턴, 직접 import로 묶지 않기
4. 데이터 구조는 dataclass + 타입 힌트
   • 입출력 DTO(Record), 도메인 객체(Entity/ValueObject) 구분
5. 에러 모델을 “예외 계층”으로 표준화
   • DomainError, ValidationError, NotFound 등
   • 호출자가 예외를 예측하고 처리 가능
6. 테스트 가능한 경계
   • 코어는 unittest/pytest로 순수 단위 테스트 가능해야 함
   • DB/HTTP는 통합 테스트로 따로
7. 문서/예제(Example)가 곧 제품
   • examples/ 폴더 하나만 잘 만들어도 재사용성이 폭발함

2) 추천 프로젝트 구조 (Native Python 스타일)

myproduct/
  pyproject.toml
  README.md
  src/
    myproduct/
      __init__.py          # public API만 export
      version.py
      domain/
        __init__.py
        types.py
        errors.py
        models.py          # dataclasses: Entity/ValueObject
      usecases/
        __init__.py
        services.py        # 유스케이스(순수 파이썬)
      ports/
        __init__.py
        repo.py            # Protocol/ABC (인터페이스)
        clock.py
      adapters/
        __init__.py
        sqlite_repo.py     # sqlite3 구현
        cli.py             # argparse
        web_flask.py       # flask(선택)
  tests/
    test_services.py
    test_domain.py
  examples/
    quickstart.py

핵심은 domain/usecases는 순수 파이썬, adapters만 환경 의존.

3) 최소 예제 코드 (재사용 가능한 “코어 + 포트 + 어댑터”)

(1) ports/repo.py — 인터페이스(Protocol)

from __future__ import annotations
from typing import Protocol, Optional
from dataclasses import dataclass

@dataclass(frozen=True)
class Member:
    id: str
    email: str
    name: str

class MemberRepo(Protocol):
    def save(self, m: Member) -> None: ...
    def find_by_email(self, email: str) -> Optional[Member]: ...

(2) usecases/services.py — 유스케이스(순수 로직)

from __future__ import annotations
from dataclasses import dataclass
from ..ports.repo import MemberRepo, Member

class DomainError(Exception): ...
class DuplicateEmail(DomainError): ...

@dataclass
class RegisterMember:
    repo: MemberRepo

    def execute(self, *, id: str, email: str, name: str) -> Member:
        if self.repo.find_by_email(email):
            raise DuplicateEmail(email)
        m = Member(id=id, email=email, name=name)
        self.repo.save(m)
        return m

(3) adapters/sqlite_repo.py — sqlite3 구현(환경 의존)

import sqlite3
from typing import Optional
from ..ports.repo import MemberRepo, Member

class SqliteMemberRepo(MemberRepo):
    def __init__(self, conn: sqlite3.Connection):
        self.conn = conn
        self.conn.execute("""
        CREATE TABLE IF NOT EXISTS members(
          id TEXT PRIMARY KEY,
          email TEXT UNIQUE NOT NULL,
          name TEXT NOT NULL
        )
        """)

    def save(self, m: Member) -> None:
        self.conn.execute(
            "INSERT OR REPLACE INTO members(id,email,name) VALUES (?,?,?)",
            (m.id, m.email, m.name)
        )
        self.conn.commit()

    def find_by_email(self, email: str) -> Optional[Member]:
        cur = self.conn.execute("SELECT id,email,name FROM members WHERE email=?", (email,))
        row = cur.fetchone()
        return Member(*row) if row else None

(4) examples/quickstart.py — 사용 예

import sqlite3
from myproduct.usecases.services import RegisterMember
from myproduct.adapters.sqlite_repo import SqliteMemberRepo

conn = sqlite3.connect(":memory:")
repo = SqliteMemberRepo(conn)
uc = RegisterMember(repo=repo)

m = uc.execute(id="u1", email="a@b.com", name="Dave")
print(m)

이렇게 만들면:

• CLI/Flask/GUI가 바뀌어도 코어는 그대로 재사용
• DB가 sqlite→postgres로 바뀌어도 어댑터만 교체
• 테스트는 RegisterMember만 단위로 즉시 가능

4) 패키지로 배포 가능하게 만들기 (pyproject.toml 핵심)

[project]
name = "myproduct"
version = "0.1.0"
requires-python = ">=3.10"
dependencies = []

[tool.pytest.ini_options]
testpaths = ["tests"]

[build-system]
requires = ["setuptools>=68"]
build-backend = "setuptools.build_meta"

그리고 설치/개발:

• 개발 설치: pip install -e .
• 배포 빌드: python -m build (build 설치 필요)

5) 체크리스트 (재사용성 점검)

• domain/usecases에서 flask, sqlite3, requests import가 없다
• 외부 공개 API는 myproduct/__init__.py에 정리되어 있다
• 예외 타입이 문서화되어 있고 호출자가 처리 가능하다
• tests는 DB 없이도 코어를 테스트한다
• examples 하나로 사용법이 끝난다

원하는 방향을 하나만 골라줘도, 그에 맞춰 “붙여넣으면 바로 돌아가는 스켈레톤 프로젝트” 형태로 확장해 줄게요:

1. CLI 도구 형태(argparse 서브커맨드)
2. 라이브러리 형태(API 안정성/버전 관리 중심)
3. 웹 백엔드 형태(Flask/FastAPI는 어댑터로)
4. 플러그인/프로세스 매니저 형태(당신이 하던 구조에 맞춤)

지금 만들고 싶은 건 1~4 중에 어느 쪽에 더 가까워요?

**“Native Python Programming”**은 공식 용어라기보다는, 프로그래밍 철학·스타일을 지칭하는 개념적 표현에 가깝습니다.
당신이 진행 중인 프로젝트 맥락에 딱 맞는 개념이기도 하고요.

아래에서 정의 → 핵심 특징 → 다른 스타일과의 비교 → 왜 당신의 프로젝트에 잘 맞는지 순서로 설명할게요.

1️⃣ Native Python Programing이란?

Native Python Programing은 한마디로 말하면:

파이썬을 “파이썬답게”, 외부 의존을 최소화하고
언어 자체가 제공하는 구조·철학·표준 라이브러리를 중심으로
시스템을 설계하고 구현하는 방식

입니다.

여기서 Native의 의미는:

• C 확장이나 다른 언어 바인딩이 아니라
• Django/ORM/대형 프레임워크 의존도 아니라
• Python 언어와 표준 라이브러리 자체를 1급 시민으로 사용하는 것

을 뜻합니다.

2️⃣ 핵심 특징 (Native Python의 기준)

✅ 1. 표준 라이브러리 우선주의

• dataclasses
• typing
• abc
• enum
• sqlite3
• argparse
• logging
• ast
• json / pathlib

👉 “이건 pip 패키지가 필요할까?”를 항상 의심함

✅ 2. 언어 구조를 설계의 중심에 둠

• @dataclass → 도메인 모델
• Value Object → 불변 객체
• Enum / NewType → 타입 안정성
• ABC + Protocol → 인터페이스
• Exception 계층 → 도메인 에러 모델

👉 프레임워크보다 언어 기능 자체가 아키텍처의 뼈대

✅ 3. 프레임워크 비의존 / 약의존

Native Python은 보통:

• ❌ Django-first
• ❌ ORM-first
• ❌ Magic-heavy

대신:

• ✔ Flask/FastAPI는 “어댑터”
• ✔ SQL은 직접 작성
• ✔ ORM 없이 Repository 패턴
• ✔ 테스트는 pytest + 순수 Python 객체

✅ 4. “보여지는 코드”를 중시

• 메타프로그래밍은 절제
• 암묵적 동작보다 명시적 코드
• IDE 없이도 읽히는 구조
• 디버거 없이도 추적 가능한 흐름

👉 코드는 문서다라는 철학에 가까움

3️⃣ 다른 스타일과의 비교

구분Native PythonFramework-DrivenScript Python

4️⃣ 당신의 프로젝트와 왜 잘 맞는가

당신이 지금까지 요청한 내용을 보면:

• DSL 인터프리터
• AST → Native Python Code
• Process / Thread / Signal Manager
• Plugin 시스템
• DDD (Aggregate / Value / Event)
• Flask / PHP / Delphi까지 이식 가능 구조

이 모든 것은 공통적으로:

“프레임워크가 아니라 언어 자체를 기반으로 한 시스템”

을 요구합니다.

👉 이건 Native Python Programming의 정석적인 적용 대상이에요.

특히 당신이 자주 말한:

• “붙여넣으면 바로 실행”
• “코어와 어댑터 분리”
• “프레임워크는 껍데기”
• “DSL → AST → Python”

이건 Native Python 철학 그 자체입니다.

5️⃣ 한 줄 정의 (정리)

Native Python Programming이란
파이썬을 스크립트도, 프레임워크도 아닌
하나의 “완전한 시스템 언어”로 다루는 개발 방식이다.

원하시면 다음도 이어서 정리해줄 수 있어요:

• ✅ Native Python + DDD 공식 템플릿
• ✅ Native Python 프로젝트 표준 디렉토리
• ✅ Native Python DSL/Interpreter 아키텍처
• ✅ Native Python vs Rust/Go 철학 비교
• ✅ “Native Python Manifesto” 문서화

어디까지 같이 정리해볼까요?

json을 기반으로 한 데이터 카드 모델과 enum.Enum을 활용한 데이터 타입 모델을 함께 구성하면 다음과 같이 만들 수 있습니다. 이 구조는 예: 문학관 콘텐츠 시스템(PoemTree)에서 시, 수필, 댓글, 메타정보 등을 저장할 때 사용할 수 있습니다.

✅ 1. Enum 기반 데이터 카드 타입 모델

from enum import Enum

class DataCardType(Enum):
    CONTENT = "content"           # 시, 수필 등 주요 콘텐츠
    META = "meta"                 # 작성자, 날짜, 길이 등 메타정보
    COMMENT = "comment"           # 댓글 정보
    RATING = "rating"             # 평점 정보
    HISTORY = "history"           # 수정 내역
    TAG = "tag"                   # 태그 목록
    CONFIG = "config"             # 설정 정보
    INTERACTION = "interaction"   # 사용자 반응 (좋아요, 즐겨찾기 등)
    STAT = "stat"                 # 통계 정보 (조회수, 댓글 수 등)
    MULTIMEDIA = "multimedia"     # 이미지, 오디오, 영상 등 첨부 자료
    USER = "user"                 # 사용자 정보 카드

✅ 2. JSON 기반 데이터 카드 기본 구조

Python 객체로 JSON 직렬화가 가능한 구조이며, dataclasses와 함께 사용하면 깔끔하게 표현할 수 있습니다.

from dataclasses import dataclass, field, asdict
from datetime import datetime
from typing import List, Dict, Optional, Any
import json
import uuid

@dataclass
class DataCard:
    id: str
    card_type: DataCardType
    data: Dict[str, Any]
    created_at: str = field(default_factory=lambda: datetime.utcnow().isoformat())
    updated_at: Optional[str] = None
    metadata: Dict[str, Any] = field(default_factory=dict)

    def to_json(self) -> str:
        # Enum은 value로 변환해서 JSON 직렬화
        dict_data = asdict(self)
        dict_data["card_type"] = self.card_type.value
        return json.dumps(dict_data, ensure_ascii=False, indent=2)

    @staticmethod
    def from_json(json_str: str) -> 'DataCard':
        obj = json.loads(json_str)
        return DataCard(
            id=obj["id"],
            card_type=DataCardType(obj["card_type"]),
            data=obj["data"],
            created_at=obj.get("created_at", datetime.utcnow().isoformat()),
            updated_at=obj.get("updated_at"),
            metadata=obj.get("metadata", {})
        )

✅ 3. 예제: 콘텐츠 카드 생성 및 JSON 출력

# 시 콘텐츠 카드 예시 생성
poetry_card = DataCard(
    id=str(uuid.uuid4()),
    card_type=DataCardType.CONTENT,
    data={
        "title": "그대 떠난 자리에",
        "author": "이상",
        "content": "바람이 불어오는 자리에 당신의 이름이 있었습니다."
    },
    metadata={
        "language": "ko",
        "length": 34
    }
)

# JSON 출력
print(poetry_card.to_json())

✅ 4. 활용 포인트

• DB 저장 시에는 card_type, data, created_at 필드만 JSON 컬럼 하나로 저장해도 충분합니다.
• 데이터 필터링 시에는 card_type을 기준으로 분류하면 됩니다.
• 확장이 용이하며, 데이터 카드 자체를 API 응답 포맷으로도 바로 사용할 수 있습니다.

필요하다면 이 구조를 기반으로 Flask/FastAPI CRUD 연동, SQLAlchemy JSON 필드 매핑, 검색 인덱싱 전략까지도 설계해드릴 수 있습니다. 요청 주세요!

Flask를 사용해서 위에서 정의한 카드 콜렉션 자료구조의 CRUD 및 검색 기능을 제공하는 간단한 RESTful API 서버 샘플을 만들어볼게요.

🧱 구조 개요

• /cards
  POST: 카드 추가
  GET: 모든 카드 조회
• /cards/<id>
  GET: 특정 카드 조회
  PUT: 카드 업데이트
  DELETE: 카드 삭제
• /search
  GET: 키워드로 검색

🐍 Flask 기반 샘플 코드

from flask import Flask, request, jsonify
from dataclasses import dataclass, field, asdict
from datetime import date
from typing import List, Dict, Optional, Union
import uuid

app = Flask(__name__)

# ----------- 카드 모델 정의 -----------

@dataclass
class BaseCard:
    id: str = field(default_factory=lambda: str(uuid.uuid4()))
    title: str = ""
    last_updated: date = field(default_factory=date.today)

@dataclass
class DataCard(BaseCard):
    description: str = ""
    data_source: str = ""
    variables: List[Dict[str, str]] = field(default_factory=list)
    collection_method: str = ""
    time_coverage: str = ""
    geographic_coverage: str = ""
    quality_notes: Optional[str] = None
    usage_notes: Optional[str] = None

@dataclass
class MetaCard(BaseCard):
    metadata: Dict[str, str] = field(default_factory=dict)

@dataclass
class HistoryCard(BaseCard):
    change_log: List[str] = field(default_factory=list)

@dataclass
class StatsCard(BaseCard):
    metrics: Dict[str, Union[int, float]] = field(default_factory=dict)
    summary: str = ""

CardTypes = {
    'data': DataCard,
    'meta': MetaCard,
    'history': HistoryCard,
    'stats': StatsCard
}

# ----------- 카드 콜렉션 -----------

class CardCollection:
    def __init__(self):
        self.cards: Dict[str, BaseCard] = {}

    def add_card(self, card: BaseCard):
        self.cards[card.id] = card

    def get_card(self, card_id: str):
        return self.cards.get(card_id)

    def update_card(self, card_id: str, data: dict):
        card = self.cards.get(card_id)
        if not card:
            return None
        for key, value in data.items():
            if hasattr(card, key):
                setattr(card, key, value)
        card.last_updated = date.today()
        return card

    def delete_card(self, card_id: str):
        return self.cards.pop(card_id, None)

    def search_cards(self, keyword: str) -> List[BaseCard]:
        return [
            card for card in self.cards.values()
            if keyword.lower() in card.title.lower()
            or (hasattr(card, 'description') and keyword.lower() in getattr(card, 'description', '').lower())
        ]

    def all_cards(self) -> List[BaseCard]:
        return list(self.cards.values())

collection = CardCollection()

# ----------- API 엔드포인트 -----------

@app.route('/cards', methods=['POST'])
def create_card():
    data = request.json
    card_type = data.pop('type', '').lower()
    CardClass = CardTypes.get(card_type)
    if not CardClass:
        return jsonify({'error': 'Invalid card type'}), 400
    card = CardClass(**data)
    collection.add_card(card)
    return jsonify(asdict(card)), 201

@app.route('/cards', methods=['GET'])
def list_cards():
    return jsonify([asdict(card) for card in collection.all_cards()])

@app.route('/cards/<card_id>', methods=['GET'])
def get_card(card_id):
    card = collection.get_card(card_id)
    if not card:
        return jsonify({'error': 'Card not found'}), 404
    return jsonify(asdict(card))

@app.route('/cards/<card_id>', methods=['PUT'])
def update_card(card_id):
    data = request.json
    updated = collection.update_card(card_id, data)
    if not updated:
        return jsonify({'error': 'Card not found'}), 404
    return jsonify(asdict(updated))

@app.route('/cards/<card_id>', methods=['DELETE'])
def delete_card(card_id):
    deleted = collection.delete_card(card_id)
    if not deleted:
        return jsonify({'error': 'Card not found'}), 404
    return jsonify({'message': 'Card deleted'})

@app.route('/search', methods=['GET'])
def search_cards():
    keyword = request.args.get('q', '')
    results = collection.search_cards(keyword)
    return jsonify([asdict(card) for card in results])

# ----------- 실행 -----------

if __name__ == '__main__':
    app.run(debug=True)

💡 실행 방법

1. 위 코드를 app.py로 저장
2. 터미널에서 실행:

pip install flask
python app.py

1. POST, GET, PUT, DELETE 요청은 curl, Postman, 또는 웹 프론트엔드에서 테스트 가능

🔍 예시 JSON 입력 (POST /cards)

{
  "type": "data",
  "title": "2024년 고용 통계",
  "description": "전국 고용 상태 요약",
  "data_source": "고용노동부",
  "variables": [{"name": "job_status", "description": "고용 상태"}],
  "collection_method": "표본 조사",
  "time_coverage": "2024.01 ~ 2024.03",
  "geographic_coverage": "전국"
}

필요하시면 파일 저장, JWT 인증, 웹 UI 연동까지 확장할 수 있어요. 원하시나요?

데이터카드, 메타카드, 히스토리카드, 통계카드 등 다양한 카드 타입을 카드 콜렉션(Card Collection) 형태로 관리할 수 있는 자료구조와 함께, CRUD(Create, Read, Update, Delete) 기능과 검색 기능까지 포함한 파이썬 예제 코드를 만들어볼게요.

🧩 1. 카드 타입 정의

from dataclasses import dataclass, field
from datetime import date
from typing import List, Dict, Optional, Union
import uuid

# 공통 기반 클래스
@dataclass
class BaseCard:
    id: str = field(default_factory=lambda: str(uuid.uuid4()))
    title: str = ""
    last_updated: date = field(default_factory=date.today)

@dataclass
class DataCard(BaseCard):
    description: str = ""
    data_source: str = ""
    variables: List[Dict[str, str]] = field(default_factory=list)
    collection_method: str = ""
    time_coverage: str = ""
    geographic_coverage: str = ""
    quality_notes: Optional[str] = None
    usage_notes: Optional[str] = None

@dataclass
class MetaCard(BaseCard):
    metadata: Dict[str, str] = field(default_factory=dict)

@dataclass
class HistoryCard(BaseCard):
    change_log: List[str] = field(default_factory=list)

@dataclass
class StatsCard(BaseCard):
    metrics: Dict[str, Union[int, float]] = field(default_factory=dict)
    summary: str = ""

📦 2. 카드 콜렉션(CardCollection) 및 CRUD 기능

class CardCollection:
    def __init__(self):
        self.cards: Dict[str, BaseCard] = {}

    # Create
    def add_card(self, card: BaseCard):
        self.cards[card.id] = card
        print(f"✅ 카드 추가됨: {card.title} ({card.__class__.__name__})")

    # Read
    def get_card(self, card_id: str) -> Optional[BaseCard]:
        return self.cards.get(card_id)

    # Update
    def update_card(self, card_id: str, **kwargs):
        card = self.cards.get(card_id)
        if not card:
            print("❌ 카드 없음")
            return
        for key, value in kwargs.items():
            if hasattr(card, key):
                setattr(card, key, value)
        card.last_updated = date.today()
        print(f"🔄 카드 업데이트됨: {card.title}")

    # Delete
    def delete_card(self, card_id: str):
        if card_id in self.cards:
            del self.cards[card_id]
            print(f"🗑️ 카드 삭제됨: {card_id}")
        else:
            print("❌ 삭제할 카드 없음")

    # Search
    def search_cards(self, keyword: str) -> List[BaseCard]:
        result = [
            card for card in self.cards.values()
            if keyword.lower() in card.title.lower()
            or (hasattr(card, 'description') and keyword.lower() in getattr(card, 'description', '').lower())
        ]
        return result

🚀 3. 사용 예제

# 카드 콜렉션 생성
collection = CardCollection()

# 데이터 카드 추가
data_card = DataCard(
    title="2024 인구 센서스",
    description="전국 인구의 분포와 변화 분석",
    data_source="통계청",
    variables=[{"name": "age", "description": "연령"}, {"name": "region", "description": "지역"}],
    collection_method="현장 조사",
    time_coverage="2024.01",
    geographic_coverage="전국"
)
collection.add_card(data_card)

# 메타카드 추가
meta_card = MetaCard(
    title="인구 데이터셋 메타정보",
    metadata={"creator": "KOSTAT", "license": "CC-BY"}
)
collection.add_card(meta_card)

# 통계 카드 추가
stats_card = StatsCard(
    title="인구 증가 통계",
    metrics={"growth_rate": 2.5, "total_population": 52000000},
    summary="2023년 대비 2.5% 증가"
)
collection.add_card(stats_card)

# 카드 검색
results = collection.search_cards("인구")
print("\n🔍 검색 결과:")
for card in results:
    print(f"- {card.title} ({card.__class__.__name__})")

# 카드 업데이트
collection.update_card(data_card.id, description="2024년 전국 인구 분석")

# 카드 삭제
collection.delete_card(meta_card.id)

✅ 요약

• BaseCard를 상속해 다양한 유형의 카드를 정의
• CardCollection으로 여러 카드 통합 관리 (CRUD + 검색)
• 추후 JSON 저장, 파일 입출력, UI 연동 등에 쉽게 확장 가능

필요하다면 카드 직렬화(JSON export/import), 카테고리별 필터링, 또는 웹 API 기반 관리로도 확장 가능해요. 혹시 이걸 웹 앱 형태로 만들고 싶으신가요, 아니면 CLI 형태로만 쓸 예정이신가요?

데이터 카드는 통계 분석, 데이터 공유, 메타데이터 관리 등을 위한 데이터 요약 카드 개념입니다. 특히 통계 목적에서는 데이터의 출처, 변수 설명, 수집 방법, 품질 정보, 사용 제한 등을 메타 수준에서 표현할 수 있어야 합니다.

📌 통계 목적 데이터 카드(Data Card) 자료구조 모델 설명

데이터 카드는 일반적으로 다음과 같은 항목을 포함합니다:

항목 설명

🐍 Python 예제 코드: 데이터 카드 모델 정의 및 생성

from dataclasses import dataclass, field
from datetime import date
from typing import List, Dict, Optional

@dataclass
class VariableInfo:
    name: str
    description: str
    unit: Optional[str] = None
    data_type: Optional[str] = None

@dataclass
class DataCard:
    title: str
    description: str
    data_source: str
    variables: List[VariableInfo]
    collection_method: str
    time_coverage: str
    geographic_coverage: str
    quality_notes: Optional[str] = None
    usage_notes: Optional[str] = None
    last_updated: date = field(default_factory=date.today)

    def summarize(self):
        print(f"📊 데이터 카드: {self.title}")
        print(f"설명: {self.description}")
        print(f"출처: {self.data_source}")
        print(f"수집 방법: {self.collection_method}")
        print(f"시기: {self.time_coverage}, 지역: {self.geographic_coverage}")
        print("\n🔑 변수 정보:")
        for var in self.variables:
            print(f"- {var.name} ({var.data_type or 'N/A'}): {var.description} ({var.unit or '단위 없음'})")
        if self.quality_notes:
            print(f"\n🧪 품질 정보: {self.quality_notes}")
        if self.usage_notes:
            print(f"📌 사용 시 유의사항: {self.usage_notes}")
        print(f"\n⏰ 마지막 수정일: {self.last_updated}")

# 예제 사용
card = DataCard(
    title="2023년 전국 가구 소득 조사",
    description="전국 가구의 연간 소득을 분석한 통계 데이터",
    data_source="통계청",
    variables=[
        VariableInfo(name="household_id", description="가구 고유 식별자", data_type="string"),
        VariableInfo(name="annual_income", description="연간 소득", unit="KRW", data_type="integer"),
        VariableInfo(name="num_members", description="가구 구성원 수", data_type="integer"),
    ],
    collection_method="온라인 설문조사",
    time_coverage="2023.01 ~ 2023.12",
    geographic_coverage="대한민국 전역",
    quality_notes="응답률 87%, 일부 소득 비공개 응답 존재",
    usage_notes="단위는 천 원 기준이며, 지역별 차이 고려 필요"
)

card.summarize()

🧠 요약

• 데이터 카드는 통계적 투명성과 재사용성을 높이기 위한 메타데이터 구조입니다.
• dataclass를 이용하면 구조적이고 명확한 표현이 가능합니다.
• 변수에 대한 정보를 별도의 클래스로 관리하면 확장성이 좋습니다.

필요하면 JSON 형식으로 내보내는 기능도 추가해줄게요. 이 구조를 기반으로 어떤 용도에 적용할 예정인가요?

엑셀 VBA에서 피벗 테이블(Pivot Table) 활용 방법

엑셀 VBA를 사용하여 **피벗 테이블(Pivot Table)**을 생성, 수정, 업데이트하는 방법을 정리합니다.

1. 피벗 테이블 개요

피벗 테이블은 데이터를 요약하고 분석할 수 있는 강력한 기능으로, 특정 필드를 기준으로 그룹화하거나, 합계, 평균 등을 계산하는 데 사용됩니다.
VBA에서는 PivotTable, PivotCache, PivotFields 등의 객체를 사용하여 피벗 테이블을 생성하고 조작할 수 있습니다.

2. 피벗 테이블 생성 방법

(1) 기본 피벗 테이블 생성 (새 워크시트에 추가)

Sub CreatePivotTable()
    Dim wsData As Worksheet
    Dim wsPivot As Worksheet
    Dim ptCache As PivotCache
    Dim pt As PivotTable
    Dim dataRange As Range

    ' 원본 데이터 시트 및 범위 설정
    Set wsData = ThisWorkbook.Sheets("Data") ' 원본 데이터가 있는 시트
    Set dataRange = wsData.Range("A1:D100") ' A1:D100 데이터를 사용

    ' 피벗 테이블을 삽입할 새 워크시트 추가
    Set wsPivot = ThisWorkbook.Sheets.Add
    wsPivot.Name = "PivotTableSheet"

    ' 피벗 캐시 생성 (데이터를 메모리에 로드)
    Set ptCache = ThisWorkbook.PivotCaches.Create(SourceType:=xlDatabase, SourceData:=dataRange)

    ' 피벗 테이블 생성
    Set pt = ptCache.CreatePivotTable(TableDestination:=wsPivot.Range("A3"), TableName:="MyPivotTable")

    ' 필드 추가
    With pt
        .PivotFields("카테고리").Orientation = xlRowField ' 행 필드
        .PivotFields("제품명").Orientation = xlColumnField ' 열 필드
        .PivotFields("매출액").Orientation = xlDataField ' 값 필드
    End With

    MsgBox "피벗 테이블이 생성되었습니다!", vbInformation
End Sub

• 원본 데이터 범위: wsData.Range("A1:D100")에서 가져옴.
• 새로운 시트에 피벗 테이블 생성: TableDestination:=wsPivot.Range("A3")
• 행(Row) 필드: 카테고리
• 열(Column) 필드: 제품명
• 값(Data) 필드: 매출액

(2) 기존 워크시트에서 피벗 테이블 생성

기존에 있는 시트에 피벗 테이블을 추가하려면:

Sub CreatePivotInExistingSheet()
    Dim wsData As Worksheet
    Dim wsPivot As Worksheet
    Dim ptCache As PivotCache
    Dim pt As PivotTable
    Dim dataRange As Range

    ' 원본 데이터와 피벗 테이블을 넣을 시트 지정
    Set wsData = ThisWorkbook.Sheets("Data")
    Set wsPivot = ThisWorkbook.Sheets("PivotSheet")
    Set dataRange = wsData.Range("A1:D100")

    ' 기존 워크시트에서 피벗 캐시 생성
    Set ptCache = ThisWorkbook.PivotCaches.Create(SourceType:=xlDatabase, SourceData:=dataRange)

    ' 기존 시트의 특정 위치에 피벗 테이블 생성
    Set pt = ptCache.CreatePivotTable(TableDestination:=wsPivot.Range("B4"), TableName:="PivotTable2")

    ' 필드 설정
    With pt
        .PivotFields("카테고리").Orientation = xlRowField
        .PivotFields("매출액").Orientation = xlDataField
    End With

    MsgBox "피벗 테이블이 기존 시트에 생성되었습니다!", vbInformation
End Sub

3. 피벗 테이블 필드 수정 및 데이터 조작

(1) 데이터 필드 요약 방식 변경 (합계 → 평균)

Sub ChangeDataFieldSummary()
    Dim wsPivot As Worksheet
    Dim pt As PivotTable

    Set wsPivot = ThisWorkbook.Sheets("PivotTableSheet")
    Set pt = wsPivot.PivotTables("MyPivotTable")

    ' 데이터 필드 요약 방식을 평균으로 변경
    With pt.PivotFields("매출액")
        .Function = xlAverage ' 평균으로 설정
    End With

    MsgBox "피벗 테이블 요약 방식이 '평균'으로 변경되었습니다.", vbInformation
End Sub

• Function = xlAverage → xlSum(합계), xlCount(개수), xlMax(최대값) 등 변경 가능.

(2) 특정 필드 정렬 및 필터링

Sub FilterPivotField()
    Dim wsPivot As Worksheet
    Dim pt As PivotTable

    Set wsPivot = ThisWorkbook.Sheets("PivotTableSheet")
    Set pt = wsPivot.PivotTables("MyPivotTable")

    ' "카테고리" 필드에서 "전자제품"만 필터링
    With pt.PivotFields("카테고리")
        .ClearAllFilters ' 기존 필터 제거
        .CurrentPage = "전자제품"
    End With

    MsgBox "필터가 적용되었습니다!", vbInformation
End Sub

• .ClearAllFilters → 기존 필터를 제거하고 특정 값만 필터링.

4. 피벗 테이블 업데이트 및 삭제

(1) 피벗 테이블 업데이트 (데이터 변경 후 새로고침)

Sub RefreshPivotTable()
    Dim wsPivot As Worksheet
    Dim pt As PivotTable

    Set wsPivot = ThisWorkbook.Sheets("PivotTableSheet")
    Set pt = wsPivot.PivotTables("MyPivotTable")

    ' 데이터 업데이트
    pt.RefreshTable

    MsgBox "피벗 테이블이 업데이트되었습니다!", vbInformation
End Sub

• 원본 데이터가 변경되면 실행하여 반영.

(2) 피벗 테이블 삭제

Sub DeletePivotTable()
    Dim wsPivot As Worksheet
    Dim pt As PivotTable

    Set wsPivot = ThisWorkbook.Sheets("PivotTableSheet")

    ' 특정 피벗 테이블 삭제
    For Each pt In wsPivot.PivotTables
        pt.TableRange2.Clear ' 피벗 테이블 삭제
    Next pt

    MsgBox "피벗 테이블이 삭제되었습니다!", vbInformation
End Sub

• .Clear를 사용하여 테이블을 삭제 가능.

5. 결론

• 피벗 테이블 생성: PivotCaches.Create 및 CreatePivotTable 사용.
• 필드 추가 및 수정: PivotFields("필드명").Orientation = xlRowField 등 사용.
• 데이터 요약 변경: .Function = xlSum, xlAverage, xlCount 등 사용.
• 필터 및 정렬: .ClearAllFilters, .CurrentPage = "필터값" 적용.
• 업데이트 및 삭제: .RefreshTable을 사용하여 새로고침, .Clear로 삭제.

이제 VBA를 활용하여 피벗 테이블을 자동화할 수 있습니다! 🚀

엑셀 VBA에서 워크시트, 표, 차트, 셀 접근 및 객체 변수 생성 방법

엑셀 VBA에서 워크시트(Worksheet), 표(ListObject), 차트(Chart), 셀(Range) 등의 데이터를 조작하기 위해서는 객체(Objects)를 사용해야 합니다.
엑셀의 다양한 요소에 접근하는 방법과 객체 변수를 생성하는 방법을 설명합니다.

1. 워크시트(Worksheet) 접근 및 객체 변수 생성

엑셀에서 워크시트에 접근하는 방법은 여러 가지가 있으며, Worksheets 또는 Sheets 컬렉션을 사용합니다.

(1) 특정 워크시트 접근 방법

1) 워크시트 이름으로 접근

Dim ws As Worksheet
Set ws = ThisWorkbook.Sheets("Sheet1") ' 또는 Worksheets("Sheet1")

• Sheets("Sheet1") 또는 Worksheets("Sheet1") 둘 다 사용 가능.
• ThisWorkbook은 현재 VBA가 포함된 파일을 의미.

2) 워크시트 인덱스로 접근

Set ws = ThisWorkbook.Sheets(1) ' 첫 번째 시트

• 인덱스는 1부터 시작하며, 워크시트 순서에 따라 변경될 수 있음.

3) 활성화된 워크시트 접근

Set ws = ActiveSheet

• 현재 선택된 시트(ActiveSheet)에 접근.

4) 현재 코드가 포함된 워크시트 접근

Set ws = ThisWorkbook.Sheets(ActiveSheet.Name)

(2) 워크시트 추가 및 삭제

1) 새로운 워크시트 추가

Dim newSheet As Worksheet
Set newSheet = ThisWorkbook.Sheets.Add
newSheet.Name = "NewSheet"

2) 워크시트 삭제

Application.DisplayAlerts = False ' 경고 메시지 방지
ThisWorkbook.Sheets("Sheet1").Delete
Application.DisplayAlerts = True

2. 표(ListObject) 접근 및 객체 변수 생성

엑셀의 **테이블(표)**은 ListObject로 관리되며, ListObjects 컬렉션을 통해 접근할 수 있습니다.

(1) 특정 표(ListObject) 접근

Dim tbl As ListObject
Set tbl = ThisWorkbook.Sheets("Sheet1").ListObjects("Table1")

• Table1은 엑셀에서 지정한 테이블 이름 (디자인 탭에서 확인 가능).

(2) 표의 모든 데이터 가져오기

Dim rng As Range
Set rng = tbl.DataBodyRange ' 표의 데이터만 선택
MsgBox "테이블 범위: " & rng.Address

• DataBodyRange는 표의 데이터 영역을 의미하며, 헤더 제외.

(3) 표에 데이터 추가하기

tbl.ListRows.Add
tbl.ListRows(tbl.ListRows.Count).Range.Cells(1, 1).Value = "새 데이터"

• 마지막 행에 새 행 추가 후 첫 번째 열에 값 입력.

(4) 특정 열의 데이터 가져오기

Dim col As Range
Set col = tbl.ListColumns("Column1").DataBodyRange
MsgBox "첫 번째 열의 범위: " & col.Address

3. 차트(Chart) 접근 및 객체 변수 생성

엑셀 차트는 Chart 객체 또는 ChartObject 컬렉션을 사용하여 접근합니다.

(1) 특정 차트 접근

Dim ch As Chart
Set ch = ThisWorkbook.Sheets("Sheet1").ChartObjects(1).Chart

• ChartObjects(1) → 시트 내에서 첫 번째 차트.

(2) 새로운 차트 생성

Dim newChart As ChartObject
Set newChart = ThisWorkbook.Sheets("Sheet1").ChartObjects.Add(Left:=100, Top:=100, Width:=300, Height:=200)
newChart.Chart.ChartType = xlColumnClustered ' 묶은 세로 막대형 차트

(3) 차트 데이터 변경

ch.SetSourceData Source:=ThisWorkbook.Sheets("Sheet1").Range("A1:B10")

• SetSourceData를 사용하여 차트의 데이터 범위 변경.

(4) 차트 제목 변경

ch.ChartTitle.Text = "매출 데이터"

4. 셀(Range) 접근 및 객체 변수 생성

셀에 접근하는 방법은 여러 가지가 있으며, Range 또는 Cells 속성을 사용합니다.

(1) 특정 셀 접근

1) Range를 사용한 접근

Dim rng As Range
Set rng = ThisWorkbook.Sheets("Sheet1").Range("A1")
rng.Value = "Hello"

2) Cells를 사용한 접근

Set rng = ThisWorkbook.Sheets("Sheet1").Cells(1, 1)
rng.Value = "Hello"

• Cells(1, 1)은 Range("A1")과 동일.

(2) 특정 범위 선택

Set rng = ThisWorkbook.Sheets("Sheet1").Range("A1:B10")

(3) 마지막 행/열 찾기

Dim lastRow As Integer
lastRow = ThisWorkbook.Sheets("Sheet1").Cells(Rows.Count, 1).End(xlUp).Row
MsgBox "마지막 데이터 행: " & lastRow

• Rows.Count는 최대 행(1048576)에서 xlUp으로 마지막 데이터 찾기.

(4) 특정 값이 있는 셀 찾기

Set rng = ThisWorkbook.Sheets("Sheet1").Cells.Find(What:="검색할 값")
If Not rng Is Nothing Then
    MsgBox "값이 " & rng.Address & "에 있습니다."
Else
    MsgBox "값을 찾을 수 없습니다."
End If

5. 객체 변수 생성 및 해제

(1) 객체 변수 선언 및 할당

Dim ws As Worksheet
Set ws = ThisWorkbook.Sheets("Sheet1")

• Set 키워드를 사용하여 객체 변수 할당.

(2) 객체 변수 해제 (메모리 관리)

Set ws = Nothing

• 사용이 끝난 객체 변수는 Nothing으로 설정하여 메모리를 해제.

6. 결론

• 워크시트: Sheets("Sheet명") 또는 Sheets(1)을 사용하여 접근.
• 표(ListObject): ListObjects("Table명")을 통해 접근.
• 차트(Chart): ChartObjects(1).Chart를 사용하여 접근.
• 셀(Range): Range("A1"), Cells(1,1), Find 등을 사용하여 접근.
• 객체 변수 생성 시 Set을 사용하고, 필요 없을 때 Nothing으로 해제.

이러한 방법을 사용하면 엑셀 VBA에서 데이터를 효율적으로 조작할 수 있습니다. 🚀

엑셀 VBA 절차적 프로그래밍 – 함수와 루틴 선언 및 호출

엑셀 VBA는 기본적으로 절차적(Procedural) 프로그래밍을 기반으로 동작합니다. 절차적 프로그래밍에서는 프로그램을 순차적으로 실행하며, 특정 기능을 수행하는 **함수(Function) 및 루틴(Sub)**을 사용하여 코드의 재사용성과 가독성을 높일 수 있습니다.

1. 함수(Function)와 루틴(Sub)의 차이점

VBA에서 특정 작업을 수행하기 위해 두 가지 유형의 프로시저(절차)를 사용할 수 있습니다.

유형 선언 방식 반환 값 호출 방식

2. Sub 프로시저(서브 루틴)

**서브 루틴(Sub)**은 특정 작업을 수행하지만 값을 반환하지 않습니다. 버튼 클릭, 이벤트 처리 등에서 주로 사용됩니다.

(1) Sub 프로시저 선언

Sub HelloWorld()
    MsgBox "안녕하세요, VBA입니다!"
End Sub

• MsgBox는 메시지 박스를 띄우는 기본 제공 함수입니다.
• HelloWorld는 호출되면 메시지 창을 띄우지만, 값은 반환하지 않습니다.

(2) Sub 프로시저 호출 방법

1) 직접 호출

HelloWorld

2) Call 키워드 사용

Call HelloWorld

• Call 키워드는 선택 사항이며, 사용해도 되고 안 해도 됩니다.

3) 매개변수가 있는 Sub 호출

Sub GreetUser(name As String)
    MsgBox "안녕하세요, " & name & "님!"
End Sub

호출 예시:

GreetUser "홍길동"

3. Function 프로시저(함수)

Function 프로시저는 값을 반환하는 기능을 하며, Function 키워드를 사용하여 선언합니다.

(1) Function 프로시저 선언

Function AddNumbers(a As Integer, b As Integer) As Integer
    AddNumbers = a + b
End Function

• 두 개의 정수 a와 b를 더한 후 그 값을 반환합니다.
• 함수의 반환 값은 AddNumbers = 값과 같은 형태로 지정합니다.

(2) Function 호출 방법

1) 셀에서 직접 호출

• VBA에서 작성한 함수는 Excel 셀에서 일반 함수처럼 사용 가능함.

=AddNumbers(10, 20)

2) VBA 코드에서 호출

Sub TestFunction()
    Dim result As Integer
    result = AddNumbers(5, 7)
    MsgBox "결과 값: " & result
End Sub

• result = AddNumbers(5, 7) → 함수 호출 후 결과를 변수에 저장.
• MsgBox를 통해 결과 값 표시.

4. ByRef와 ByVal – 매개변수 전달 방식

VBA에서는 매개변수를 ByRef(참조 전달) 또는 ByVal(값 전달) 방식으로 전달할 수 있습니다.

전달 방식 설명

(1) ByVal 예제 (기본값)

Sub ChangeValue(ByVal num As Integer)
    num = num * 2
End Sub

Sub TestByVal()
    Dim x As Integer
    x = 10
    Call ChangeValue(x)
    MsgBox "x 값: " & x ' 여전히 10 (변경되지 않음)
End Sub

(2) ByRef 예제 (원본 변경)

Sub ChangeValueByRef(ByRef num As Integer)
    num = num * 2
End Sub

Sub TestByRef()
    Dim x As Integer
    x = 10
    Call ChangeValueByRef(x)
    MsgBox "x 값: " & x ' 값이 20으로 변경됨
End Sub

• ByRef를 사용하면 x의 값이 함수 실행 후 변경됨.

5. VBA에서 Function과 Sub의 활용 예제

(1) 두 수를 입력받아 합을 구하는 함수와 호출하는 Sub

Function SumNumbers(a As Integer, b As Integer) As Integer
    SumNumbers = a + b
End Function

Sub CalculateSum()
    Dim num1 As Integer, num2 As Integer
    Dim result As Integer

    num1 = 10
    num2 = 20

    result = SumNumbers(num1, num2)
    
    MsgBox "두 수의 합: " & result
End Sub

(2) 특정 범위의 셀 값을 합산하는 함수

Function SumRange(rng As Range) As Double
    Dim cell As Range
    Dim total As Double
    total = 0

    For Each cell In rng
        total = total + cell.Value
    Next cell

    SumRange = total
End Function

엑셀 셀에서 호출 가능:

=SumRange(A1:A10)

6. 결론

• Sub 프로시저는 특정 작업을 실행하지만 값을 반환하지 않음.
• Function 프로시저는 값을 반환하며, 엑셀 셀에서도 직접 호출 가능.
• 매개변수 전달 방식은 기본적으로 ByVal이며, ByRef를 사용하면 원본 변수 값이 변경될 수 있음.
• VBA의 절차적 프로그래밍을 활용하면 반복 작업을 효율적으로 자동화할 수 있음.