Category Reference

Python

문법, 자료형, 함수, 객체지향, 테스트, 패키징, 현대 Python 패턴까지 Python의 핵심 흐름을 카드형 레퍼런스로 정리합니다.

Search cards

46 cards

Search titles, summaries, tags, and subcategories.

시작과 자료형

2 cards

시작과 자료형

변수와 기본 타입

Python 변수는 타입 칸이 아니라 이름 바인딩이라는 점, `int`/`float`/`str`/`bool`이 각각 어떤 역할을 맡는지, truthy/falsy를 어떻게 읽는지 정리합니다.

name = "Mina"       # str
age = 26            # int
ratio = 3.14        # float
is_ready = True     # bool
result = None       # None

value = 10
value = "ten"       # 같은 이름을 다른 값에 다시 바인딩

시작과 자료형

문자열 기본

문자열을 값 하나가 아니라 텍스트 시퀀스로 읽는 감각, immutable 성질, 잘라 읽기와 조합하기, `join`과 `f-string`의 역할을 정리합니다.

text = "hello world"

first = text[0]
head = text[:5]
upper = text.upper()
joined = ", ".join(["a", "b", "c"])

컬렉션과 문자열

9 cards

컬렉션과 문자열

리스트 기본

여러 값을 담을 때 왜 list가 기본 선택이 되는지, 언제 tuple/set/deque보다 list가 맞는지, 끝 작업과 중간 수정의 감각을 정리합니다.

items = ["apple", "banana"]
items.append("orange")

first = items[0]
items[1] = "kiwi"

for item in items:
    print(item)

컬렉션과 문자열

리스트 메서드

리스트를 바꿀 때 하나를 붙일지, 여러 개를 이어 붙일지, 값으로 지울지, 위치에서 꺼낼지처럼 작업 목적별 메서드 선택 기준을 정리합니다.

items = ["a", "b"]
items.append("c")
items.extend(["d", "e"])

items.remove("b")
last = items.pop()
items.sort()

컬렉션과 문자열

슬라이싱과 인덱싱

값 하나를 읽을지, 구간을 잘라낼지, 뒤에서부터 접근할지, 얕은 복사를 만들지처럼 시퀀스 읽기 규칙을 정리합니다.

items = [10, 20, 30, 40, 50]

first = items[0]
last = items[-1]
head = items[:2]
tail = items[2:]
reversed_items = items[::-1]

컬렉션과 문자열

리스트 컴프리헨션

새 리스트 결과를 만들 때 `for` 루프 대신 리스트 컴프리헨션을 언제 쓰는지, 변환/필터/조건식을 어떻게 읽는지, generator expression과 어디서 갈리는지 정리합니다.

numbers = [1, 2, 3, 4, 5]

# 값 변환
squares = [n * n for n in numbers]

# 일부만 남김
passed = [n for n in numbers if n >= 3]

# 값 가공 + 빈 값 제거
labels = [name.strip().title() for name in raw_names if name.strip()]

# 결과 값을 둘 중 하나로 나눔
status = ["pass" if score >= 80 else "retry" for score in scores]

# 리스트 대신 지연 평가
square_iter = (n * n for n in numbers)

컬렉션과 문자열

딕셔너리 기본

값을 순서대로 찾는 게 아니라 키로 바로 찾고 싶을 때, `[]`와 `get()` 중 무엇을 쓸지, 집계와 그룹화에 dict를 어떻게 쓰는지 정리합니다.

scores = {"mina": 1200, "jin": 980}

score = scores.get("mina", 0)
scores.setdefault("sora", 0)
scores["sora"] += 50

for name, value in scores.items():
    print(name, value)

컬렉션과 문자열

tuple 과 set 기본

순서 있는 고정 값 묶음이 필요할 때는 tuple, 중복 없는 원소 집합이나 빠른 membership 테스트가 필요할 때는 set을 고르는 기준을 정리합니다.

point = (10, 20)
seen_ids = {101, 102, 103}

if 102 in seen_ids:
    print("already seen")

x, y = point

컬렉션과 문자열

정렬과 key 함수

원본을 바로 정렬할지 새 결과를 만들지, 정렬 기준을 `key`로 어떻게 뽑을지, 여러 기준을 tuple key로 읽는 법을 정리합니다.

names = ["mina", "Jin", "sora"]
ordered = sorted(names, key=str.lower)

users = [
    {"name": "Mina", "age": 26},
    {"name": "Jin", "age": 21},
]
users.sort(key=lambda user: user["age"])

컬렉션과 문자열

f-string과 문자열 포매팅

값을 문자열에 직접 끼워 넣을지, 자리수와 정렬을 맞출지, 레거시 `str.format()`과 `%` 포매팅을 언제 읽어야 하는지 정리합니다.

name = "Mina"
score = 93.456

message = f"{name} scored {score:.1f}"
percent = f"{0.378:.2%}"
aligned = f"|{name:>10}|"

컬렉션과 문자열

언패킹과 starred 표현식

시퀀스를 변수로 풀어 받을지, 나머지를 `*rest`로 모을지, 함수 호출에서 `*args`와 `**kwargs`로 펼칠지처럼 starred 문법의 공통 흐름을 정리합니다.

point = (10, 20)
x, y = point

first, *middle, last = [1, 2, 3, 4, 5]

values = [1, 2, 3]
print(*values)

제어 흐름

3 cards

제어 흐름

if / elif / else 조건문

값이 비었는지, None인지, 여러 후보 중 하나인지, 한 줄 선택이 필요한지처럼 조건문에서 자주 찾는 케이스를 빠르게 구분하는 카드입니다.

# 기본 분기
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
else:
    grade = "C"

# 비어 있는 값 검사
if not items:
    print("비어 있음")

# None 구분
if result is None:
    print("결과 없음")

# 여러 후보 중 하나인지 검사
if command in {"start", "run", "go"}:
    print("실행")

# 값 하나를 짧게 고름
badge = "adult" if age >= 20 else "minor"

제어 흐름

반복문 기본

값을 순회할지, 횟수만큼 돌릴지, 조건이 풀릴 때까지 반복할지, `break`와 `else`를 어디에 붙일지처럼 반복에서 먼저 고를 선택지를 정리합니다.

# 값만 순회
for name in names:
    print(name)

# 숫자 범위를 반복
for retry in range(3):
    print("retry", retry)

# 조건이 바뀔 때까지 반복
while queue:
    item = queue.pop(0)
    process(item)

제어 흐름

zip과 enumerate

반복에서 번호를 붙일지, 두 iterable을 맞춰 돌릴지, 길이 차이를 오류로 볼지처럼 `enumerate`와 `zip`을 고르는 기준을 정리합니다.

# 값에 번호를 붙일 때
for index, name in enumerate(names, start=1):
    print(index, name)

# 두 흐름을 나란히 읽을 때
for name, score in zip(names, scores):
    print(name, score)

# 길이 차이를 오류로 보고 싶을 때
for name, score in zip(names, scores, strict=True):
    print(name, score)

함수와 모듈

6 cards

함수와 모듈

함수 기본

반복되는 동작에 언제 함수를 뽑을지, `return`으로 값을 돌려줄지, 부작용을 어디까지 맡길지처럼 함수의 기본 역할을 정리합니다.

def ping() -> None:
    print("pong")


def greet(name: str) -> str:
    return f"Hello, {name}"


def is_even(value: int) -> bool:
    return value % 2 == 0

message = greet("Mina")

함수와 모듈

args, kwargs와 함수 인자 모델

인수를 순서로 받을지, 이름으로 강제할지, `*args`와 `**kwargs`로 열어 둘지처럼 Python 함수 시그니처를 설계하는 기준을 정리합니다.

def report(name, score, *, passed=True, extra):
    status = "PASS" if passed else "FAIL"
    return {"name": name, "score": score, "status": status, extra}


def add_all(*numbers):
    return sum(numbers)

함수와 모듈

기본 인자와 None 패턴

기본값이 언제 평가되는지, 어떤 기본값은 그대로 둬도 되는지, 리스트나 dict에서는 왜 `None` 또는 별도 sentinel이 필요한지 정리합니다.

def add_tag(name: str, tags: list[str] | None = None) -> list[str]:
    if tags is None:
        tags = []
    tags.append(name)
    return tags

함수와 모듈

lambda 기본

`lambda`가 이름 없는 짧은 함수인 이유, `sorted`/`key` 같은 짧은 콜백에 맞는 이유, 일반 `def`로 돌아가야 하는 경계를 정리합니다.

users = [
    {"name": "Mina", "age": 26},
    {"name": "Jin", "age": 21},
]

ordered = sorted(users, key=lambda user: user["age"])
formatter = lambda name: name.strip().title()

함수와 모듈

모듈과 import 기본

모듈이 이름 공간을 나누는 이유, `import`와 `from ... import ...`의 차이, 실행 시점 부작용을 줄이는 기준을 정리합니다.

import math
from pathlib import Path

root = Path("data")
area = math.pi * 3 ** 2

함수와 모듈

main guard와 entry point

`if __name__ == "__main__"`가 import 부작용을 막는 이유, 스크립트 실행과 모듈 재사용을 함께 만족시키는 구조를 정리합니다.

def main() -> None:
    print("run app")


if __name__ == "__main__":
    main()

파일과 예외

5 cards

파일과 예외

pathlib 파일 처리 기본

경로를 문자열로 다루지 않고 `Path` 객체로 읽는 이유, 경로 조합과 존재 확인, 텍스트 파일 읽기/쓰기의 기본 흐름을 정리합니다.

from pathlib import Path

base_dir = Path("data")
file_path = base_dir / "users" / "list.txt"

file_path.parent.mkdir(parents=True, exist_ok=True)
file_path.write_text("mina\njin\n", encoding="utf-8")
content = file_path.read_text(encoding="utf-8")

파일과 예외

JSON과 CSV 파일 처리 기본

데이터 모양이 중첩 구조인지 표 형태인지에 따라 JSON과 CSV를 어떻게 고르는지, `json`과 `csv` 표준 라이브러리의 기본 읽기/쓰기 흐름을 정리합니다.

import csv
import json
from pathlib import Path

config = {"name": "Mina", "active": True}
Path("config.json").write_text(
    json.dumps(config, ensure_ascii=False, indent=2),
    encoding="utf-8",
)

with Path("users.csv").open("w", newline="", encoding="utf-8") as file:
    writer = csv.DictWriter(file, fieldnames=["name", "age"])
    writer.writeheader()
    writer.writerow({"name": "Mina", "age": 26})

파일과 예외

예외 처리 기본

언제 예외를 잡고 언제 그대로 올려보낼지, `try/except/else/finally`의 역할, 넓게 잡지 않는 패턴과 `raise ... from e`를 정리합니다.

try:
    value = int(text)
except ValueError:
    value = 0
else:
    print("parse success")
finally:
    print("done")

파일과 예외

with문과 Context Manager

파일, 락, 연결처럼 끝나면 정리해야 하는 자원을 `with`로 어떻게 다루는지, `__enter__`/`__exit__`와 `contextlib` 패턴을 정리합니다.

from pathlib import Path

with Path("notes.txt").open("r", encoding="utf-8") as file:
    content = file.read()

파일과 예외

logging 기본

`print` 대신 로그 레벨이 있는 이벤트를 남겨야 할 때, `basicConfig`로 어디까지 시작할 수 있는지, logger/handler/level 역할을 어떻게 읽는지 정리합니다.

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

logger.info("start processing")
logger.warning("retrying request")
logger.error("request failed")

객체와 타입

8 cards

객체와 타입

클래스 기본

함수와 dict만으로는 어색해질 때 왜 클래스로 묶는지, `self`와 인스턴스 상태를 어떻게 읽는지, dataclass와 어디서 갈리는지 정리합니다.

class User:
    def __init__(self, name: str) -> None:
        self.name = name
        self.login_count = 0

    def greet(self) -> str:
        return f"Hello, {self.name}"

    def mark_login(self) -> None:
        self.login_count += 1

객체와 타입

dataclass 기본

필드 저장이 중심인 클래스에서 왜 `@dataclass`가 편한지, 일반 class와 어디서 갈리는지, `default_factory`가 왜 중요한지 정리합니다.

from dataclasses import dataclass, field

@dataclass
class User:
    name: str
    age: int
    tags: list[str] = field(default_factory=list)

객체와 타입

상속 기본

같은 종류의 객체를 공통 인터페이스로 다루고 싶을 때 상속을 언제 쓰는지, `super()`와 오버라이드, 합성과 어디서 갈리는지 정리합니다.

class Animal:
    def speak(self) -> str:
        return "..."

class Dog(Animal):
    def speak(self) -> str:
        return "woof"

객체와 타입

classmethod와 staticmethod

메서드가 인스턴스 상태를 쓰는지, 클래스 자체를 다루는지, 단순 유틸인지에 따라 일반 메서드와 `@classmethod`, `@staticmethod`를 어떻게 고르는지 정리합니다.

class User:
    def __init__(self, name: str) -> None:
        self.name = name

    @classmethod
    def from_csv(cls, row: str) -> "User":
        return cls(row.strip())

    @staticmethod
    def normalize(name: str) -> str:
        return name.strip().title()

객체와 타입

property 기본

단순 필드를 속성 문법 그대로 유지하면서 검증이나 계산 로직을 넣고 싶을 때 `@property`를 언제 쓰는지, setter와 read-only 속성의 경계를 정리합니다.

class User:
    def __init__(self, age: int) -> None:
        self.age = age

    @property
    def age(self) -> int:
        return self._age

    @age.setter
    def age(self, value: int) -> None:
        if value < 0:
            raise ValueError("age must be >= 0")
        self._age = value

객체와 타입

가변 객체와 복사

대입이 복사가 아니라 바인딩이라는 점, 얕은 복사와 깊은 복사의 차이, 언제 복사보다 공유가 더 맞는지 정리합니다.

import copy

original = [[1, 2], [3, 4]]
shallow = original[:]              # 또는 copy.copy(original)
deep = copy.deepcopy(original)

객체와 타입

타입 힌트 기본

타입 힌트가 런타임 강제가 아니라 함수 계약을 보여 주는 도구라는 점, 기본 제네릭 표기와 `T | None`, 그리고 `Callable`/`TypeVar`/`Protocol`이 언제 필요한지 정리합니다.

from pathlib import Path

def read_names(path: Path) -> list[str]:
    return path.read_text(encoding="utf-8").splitlines()

def find_user(user_id: int) -> dict[str, str] | None:
    ...

객체와 타입

추상 기반 클래스 (ABC)

구현을 런타임에 강제해야 할 때는 ABC, 상속 없이 인터페이스 계약을 표현하고 싶을 때는 Protocol을 쓰는 기준과 `runtime_checkable`의 한계를 정리합니다.

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self) -> float: ...

class Circle(Shape):
    def __init__(self, radius: float):
        self.radius = radius

    def area(self) -> float:
        return 3.14159 * self.radius ** 2

개발 환경과 테스트

3 cards

개발 환경과 테스트

가상환경과 pip 기본

프로젝트마다 왜 가상환경을 따로 두는지, `venv` 생성과 인터프리터 연결, `python -m pip`로 설치하는 기본 습관을 정리합니다.

python -m venv .venv
# Windows
.venv\Scripts\activate

# macOS / Linux
source .venv/bin/activate
python -m pip install requests pytest
python -m pip list

개발 환경과 테스트

pyproject.toml과 패키징 기본

`pyproject.toml`이 왜 프로젝트 설정의 중심 파일이 됐는지, `[build-system]`과 `[project]`를 어떻게 읽는지, 의존성 선언을 어디에 두는지 정리합니다.

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

[project]
name = "sample-app"
version = "0.1.0"
dependencies = ["requests>=2.32"]

개발 환경과 테스트

pytest 기본과 테스트 구조

pytest를 왜 `assert` 중심 테스트 도구로 읽는지, fixture와 parametrize를 언제 꺼내는지, 파일/환경 의존성을 테스트 안에서 어떻게 제어하는지 정리합니다.

# test_math.py

def add(a, b):
    return a + b


def test_add():
    assert add(1, 2) == 3

고급 주제

10 cards

고급 주제

dict와 set comprehension

dict/set comprehension으로 변환과 필터를 짧게 표현하는 패턴, 리스트 컴프리헨션과 다른 점, 중복 키와 중복 제거 기준을 정리합니다.

scores = {"mina": 91, "jin": 77, "sora": 88}

passed = {name: score for name, score in scores.items() if score >= 80}
normalized = {name.lower() for name in ["Mina", "Jin", "Mina"]}

고급 주제

collections.Counter 기본

빈도수 집계가 목적일 때 `Counter`를 언제 바로 써야 하는지, `dict` 누적과 어디서 갈리는지, `most_common()`과 `update()`를 어떻게 읽는지 정리합니다.

from collections import Counter

counts = Counter(words)
counts.update(["python", "python"])
top_three = counts.most_common(3)

고급 주제

any, all, generator expression

`any()`와 `all()`로 조건 순회를 질문처럼 읽는 법, generator expression과 붙였을 때의 장점, `for` 루프와 어디서 갈리는지 정리합니다.

has_error = any(line.startswith("ERROR") for line in lines)
all_ready = all(task.done for task in tasks)
first_admin = next((user for user in users if user["role"] == "admin"), None)

고급 주제

iterable과 iterator 기본

iterable과 iterator의 차이, `iter()`와 `next()`가 실제로 무엇을 하는지, 한 번 소비되는 흐름을 어떻게 다뤄야 하는지 정리합니다.

items = [10, 20, 30]
it = iter(items)

print(next(it))  # 10
print(next(it))  # 20

고급 주제

generator와 yield

`yield`가 함수를 한 번에 끝나는 계산에서 이어서 값을 내놓는 흐름으로 바꾸는 방식, 리스트와 generator의 선택 기준, 한 번 소비되는 특성을 정리합니다.

def countdown(n):
    while n > 0:
        yield n
        n -= 1

for value in countdown(3):
    print(value)

고급 주제

itertools 기본

`itertools`를 반복 흐름 조합 도구로 읽는 법, `chain`, `islice`, `product`, `groupby`의 역할 차이, 리스트 대신 iterator 파이프라인을 유지해야 하는 시점을 정리합니다.

from itertools import chain, islice, product

flat = list(chain([1, 2], [3, 4]))
first_three = list(islice(range(10), 3))
pairs = list(product(["x", "y"], [1, 2]))

고급 주제

deque와 heapq 기본

양쪽 끝 조작이 많은 흐름에는 `deque`, 우선순위가 핵심인 작업에는 `heapq`를 쓰는 기준과 list와의 경계를 정리합니다.

from collections import deque
import heapq

queue = deque(["a", "b"])
queue.appendleft("start")
next_item = queue.popleft()

heap = []
heapq.heappush(heap, (2, "medium"))
heapq.heappush(heap, (1, "high"))
priority, task = heapq.heappop(heap)

고급 주제

decorator 기본

데코레이터를 함수 감싸기 패턴으로 읽는 법, 공통 부가 기능을 어디까지 데코레이터로 빼는지, `functools.wraps`가 왜 필요한지 정리합니다.

from functools import wraps


def log_calls(func):
    @wraps(func)
    def wrapper(*args, kwargs):
        print(f"calling {func.__name__}")
        return func(*args, kwargs)
    return wrapper


@log_calls
def greet(name: str) -> str:
    return f"Hello, {name}"

고급 주제

match-case 기본

`match-case`를 단순 switch가 아니라 구조 분해 분기로 읽는 법, tuple/dict/class 패턴과 guard, OR 패턴의 역할 차이를 정리합니다.

def describe(command):
    match command:
        case ("move", x, y):
            return f"move to {x}, {y}"
        case {"type": "quit"}:
            return "stop"
        case _:
            return "unknown"

고급 주제

async/await 기본 패턴

coroutine과 이벤트 루프를 어떻게 읽어야 하는지, `await`, `gather()`, `create_task()`를 언제 고르는지, async가 맞는 문제와 아닌 문제를 정리합니다.

import asyncio

async def fetch_data(name: str) -> str:
    await asyncio.sleep(0.5)
    return f"data:{name}"

async def main() -> None:
    results = await asyncio.gather(fetch_data("a"), fetch_data("b"))
    print(results)

asyncio.run(main())

Loading category cards

Preparing references and filters for this topic. 이 주제의 레퍼런스와 필터를 준비하고 있습니다.

name = "Mina" # str age = 26 # int ratio = 3.14 # float is_ready = True # bool result = None # None value = 10 value = "ten" # 같은 이름을 다른 값에 다시 바인딩

numbers = [1, 2, 3, 4, 5] # 값 변환 squares = [n * n for n in numbers] # 일부만 남김 passed = [n for n in numbers if n >= 3] # 값 가공 + 빈 값 제거 labels = [name.strip().title() for name in raw_names if name.strip()] # 결과 값을 둘 중 하나로 나눔 status = ["pass" if score >= 80 else "retry" for score in scores] # 리스트 대신 지연 평가 square_iter = (n * n for n in numbers)

# 기본 분기 if score >= 90: grade = "A" elif score >= 80: grade = "B" else: grade = "C" # 비어 있는 값 검사 if not items: print("비어 있음") # None 구분 if result is None: print("결과 없음") # 여러 후보 중 하나인지 검사 if command in {"start", "run", "go"}: print("실행") # 값 하나를 짧게 고름 badge = "adult" if age >= 20 else "minor"

# 값만 순회 for name in names: print(name) # 숫자 범위를 반복 for retry in range(3): print("retry", retry) # 조건이 바뀔 때까지 반복 while queue: item = queue.pop(0) process(item)

# 값에 번호를 붙일 때 for index, name in enumerate(names, start=1): print(index, name) # 두 흐름을 나란히 읽을 때 for name, score in zip(names, scores): print(name, score) # 길이 차이를 오류로 보고 싶을 때 for name, score in zip(names, scores, strict=True): print(name, score)

def report(name, score, *, passed=True, extra): status = "PASS" if passed else "FAIL" return {"name": name, "score": score, "status": status, extra} def add_all(*numbers): return sum(numbers)

from pathlib import Path base_dir = Path("data") file_path = base_dir / "users" / "list.txt" file_path.parent.mkdir(parents=True, exist_ok=True) file_path.write_text("mina\njin\n", encoding="utf-8") content = file_path.read_text(encoding="utf-8")

import csv import json from pathlib import Path config = {"name": "Mina", "active": True} Path("config.json").write_text( json.dumps(config, ensure_ascii=False, indent=2), encoding="utf-8", ) with Path("users.csv").open("w", newline="", encoding="utf-8") as file: writer = csv.DictWriter(file, fieldnames=["name", "age"]) writer.writeheader() writer.writerow({"name": "Mina", "age": 26})

class User: def __init__(self, name: str) -> None: self.name = name self.login_count = 0 def greet(self) -> str: return f"Hello, {self.name}" def mark_login(self) -> None: self.login_count += 1

class User: def __init__(self, name: str) -> None: self.name = name @classmethod def from_csv(cls, row: str) -> "User": return cls(row.strip()) @staticmethod def normalize(name: str) -> str: return name.strip().title()

class User: def __init__(self, age: int) -> None: self.age = age @property def age(self) -> int: return self._age @age.setter def age(self, value: int) -> None: if value < 0: raise ValueError("age must be >= 0") self._age = value

from abc import ABC, abstractmethod class Shape(ABC): @abstractmethod def area(self) -> float: ... class Circle(Shape): def __init__(self, radius: float): self.radius = radius def area(self) -> float: return 3.14159 * self.radius ** 2

from collections import deque import heapq queue = deque(["a", "b"]) queue.appendleft("start") next_item = queue.popleft() heap = [] heapq.heappush(heap, (2, "medium")) heapq.heappush(heap, (1, "high")) priority, task = heapq.heappop(heap)

from functools import wraps def log_calls(func): @wraps(func) def wrapper(*args, kwargs): print(f"calling {func.__name__}") return func(*args, kwargs) return wrapper @log_calls def greet(name: str) -> str: return f"Hello, {name}"

def describe(command): match command: case ("move", x, y): return f"move to {x}, {y}" case {"type": "quit"}: return "stop" case _: return "unknown"

import asyncio async def fetch_data(name: str) -> str: await asyncio.sleep(0.5) return f"data:{name}" async def main() -> None: results = await asyncio.gather(fetch_data("a"), fetch_data("b")) print(results) asyncio.run(main())