계층 구조

• 파이썬의 라이브러리 체계는 크게 모듈 > 클래스 > 메서드 순으로 구성

  • 모듈(Module): 관련 있는 코드들을 모아놓은 파일 ( ~.py)

  • 클래스(Class): 객체를 만들기 위한 설계도

  • 메서드(Method): 클래스 내부에서 정의된 함수

표준 라이브러리(Standard Library)

datetime

datetime (모듈/라이브러리)
├── datetime (클래스): 날짜와 시간을 모두 다룸
│   └── now() (메서드): 현재 시간을 가져옴
├── timedelta (클래스): 기간(차이)을 다룸
│   └── total_seconds() (메서드): 전체 초를 계산함
└── date (클래스): 날짜만 다룸

• from datetime import datetime, timedelta
  • datetime : 날짜와 시간을 표현하고 다루는 클래스
    • 연, 월, 일까지만 넣어도 만들 수 있고, 뒤에 시간, 분, 초, 마이크로초는 기본값이 0
  • timedelta : 시간 간격(차이)을 나타내는 클래스 (몇일,몇시간 차이)
    • 주로 datetime끼리의 뺄셈 결과, 혹은 datetime ± timedelta 연산에 사용

# 생성 / 현재 시각
                      from datetime import datetime

# 현재 날짜와 시간 가져오기
                      now = datetime.now()
                      print(now)  # 2025-09-29 17:45:32.123456

# 특정 날짜와 시간 만들기
                      dt = datetime(2025, 9, 29, 15, 30, 0)
                      print(dt)  # 2025-09-29 15:30:00

# 연,월,일만 지정
                      d1 = datetime(2025, 9, 29)
                      print(d1)  # 2025-09-29 00:00:00

# 시,분까지 지정
                      d2 = datetime(2025, 9, 29, 12, 30)
                      print(d2)  # 2025-09-29 12:30:00

# 시,분,초까지 지정
                      d3 = datetime(2025, 9, 29, 12, 30, 45)
                      print(d3)  # 2025-09-29 12:30:45


# 속성 꺼내기
# 2025/09/29 6:12:00 기준 
                            print(now.year)   # 2025
                            print(now.month)  # 09
                            print(now.day)    # 29
                            print(now.hour)   # 6
                            print(now.minute) # 12
                            print(now.second) # 00


# 문자열 ↔ datetime 변환
# datetime → 문자열
                print(now.strftime("%Y-%m-%d %H:%M:%S"))  # 2025-09-29 17:45:32
# 문자열 → datetime
                    s = "2025-10-01 12:00:00"
                    dt = datetime.strptime(s, "%Y-%m-%d %H:%M:%S")
                    print(dt)  # 2025-10-01 12:00:00

# 생성
                            from datetime import timedelta

# 5일
							delta_days = timedelta(days=5)

# 2시간 30분
							delta_time = timedelta(hours=2, minutes=30)

# 활용
							now = datetime.now()

# 5일 뒤
							print(now + timedelta(days=5))

# 3시간 전
							print(now - timedelta(hours=3))

# 두 datetime 차이
                            dt1 = datetime(2025, 9, 29, 12, 0, 0)
                            dt2 = datetime(2025, 10, 1, 15, 0, 0)
                            diff = dt2 - dt1
                            print(diff)            # 2 days, 3:00:00
                            print(diff.days)       # 2
                            print(diff.total_seconds())  # 183600.0

timedelta

• timedelta 는 단순히 며칠, 몇 초 차이만 계산

  • "9월 1일 - 5일" → "8월 27일"처럼 자동으로 월·연도까지 넘어감.
  • 반대로 + 연산하면 자동으로 다음 달/다음 해로 올라감

from datetime import datetime, timedelta

d = datetime(2025, 9, 1)      # 2025-09-01 00:00:00
result = d - timedelta(days=5)
print(result) # 2025-08-27 00:00:00

d1 = datetime(2025, 1, 3)
print(d1 - timedelta(days=5))  # 2024-12-29

• datetime 주요 메서드

# 현재 로컬 시각
print(datetime.now())  

# 현재 UTC 시각
print(datetime.utcnow())

# 오늘 날짜 (시간은 00:00:00)
print(datetime.today())

# 요일을 정수(0~6)으로 돌려줌 # 0 → 월요일 , 6 → 일요일
# 월을 정수(1~12)로 돌려줌 isoweekday() → 1(월) ~ 7(일)
from datetime import datetime

d = datetime(2025, 9, 29)  # 2025년 9월 29일
print(d.weekday())         # 0 (월요일)

d2 = datetime(2025, 10, 5) # 2025년 10월 5일
print(d2.weekday())        # 6 (일요일)

print(d.isoweekday())  # 1 (월요일)
print(d2.isoweekday()) # 7 (일요일)

now = datetime.now()

# 원하는 형식으로 문자열 변환
print(now.strftime("%Y-%m-%d %H:%M:%S"))  # 2025-09-29 18:22:05
print(now.strftime("%A, %B %d"))          # Monday, September 29

s = "2025-10-01 12:30:00"
dt = datetime.strptime(s, "%Y-%m-%d %H:%M:%S")

%Y: 연도(2025)
%m: 월(01~12)
%d: 일(01~31)
%H: 시(00~23)
%M: 분(00~59)
%S: 초(00~59)
%A: 요일 이름(Monday)
%B: 월 이름(September)

date

from datetime import datetime, date

# 1. 현재 날짜만 가져오기
today = date.today()
print(f"오늘 날짜: {today}")  # 출력: 2026-03-22

# 2. datetime 객체에서 날짜만 추출하기
now = datetime.now()
only_date = now.date()
print(f"현재 시간 포함: {now}")
print(f"날짜만 추출: {only_date}")

String

사용 예시

import random, string

# 문자열이 숫자만으로 구성됐는지 검사
s = "12345"
print(all(ch in string.digits for ch in s))  # True

# 문자열에서 공백 제거
s = "hello \t world\n"
cleaned = "".join(ch for ch in s if ch not in string.whitespace)
print(cleaned)  # "helloworld"

# 랜덤 비밀번호 생성
all_chars = string.ascii_letters + string.digits + string.punctuation
password = "".join(random.choice(all_chars) for _ in range(12))
print(password)  # 예: aZ3$9!qW@7Lx

• random.choice(all_chars) : all_chars 문자열에서 무작위로 문자 하나를 선택.
• "".join([...])
  • 리스트나 제너레이터에서 나온 문자들을 빈 문자열("")로 이어붙임

Random

math

enum

• 열거형을 정의하기 위한 라이브러리(재할당 불가)
  • 문자열이나 숫자를 사용하면 오타나 중복 실수가 생길 수 있음
  • Enum을 사용하면 정해진 값만 허용 하도록 강제 가능, 가독성 좋아짐

• Enum → 기본 열거형
• IntEnum → 정수 기반 열거형 (비교 연산 가능)
• StrEnum → 문자열 기반 열거형 (Python 3.11 이상)
• auto() → 값 자동 할당

from enum import Enum, IntEnum, auto, StrEnum

class Number(IntEnum):
    ONE = 1
    TWO = 2

class Fruit(StrEnum):
    APPLE = "apple" # Fruit.APPLE은 "apple"이라는 문자열 값에 고정
    BANANA = "banana"

class AutoEnum(Enum):
    A = auto()
    B = auto()

from enum import Enum

from fastapi import FastAPI


class ModelName(str, Enum):
    alexnet = "alexnet"
    resnet = "resnet"
    lenet = "lenet"


app = FastAPI()


@app.get("/models/{model_name}")
async def get_model(model_name: ModelName):
    if model_name is ModelName.alexnet:
        return {"model_name": model_name, "message": "Deep Learning FTW!"}

    if model_name.value == "lenet":
        return {"model_name": model_name, "message": "LeCNN all the images"}

    return {"model_name": model_name, "message": "Have some residuals"}

typing

타입 힌트(type hint)를 정의하고 활용할 수 있게 해주는 표준 라이브러리
파이썬은 원래 동적 타입 언어라서 변수 타입을 강제하지 않지만, typing을 이용하면 코드의 가독성, 유지보수성, 그리고 IDE/도구(예: mypy, PyCharm)에서의 정적 분석을 강화할 수 있다.

• typing은 변수, 함수 매개변수, 반환값의 타입을 명시할 때 사용.
• 실행 시에는 강제하지 않지만, 정적 타입 체커(mypy 등)가 검증할 수 있음.

class User(TypedDict):
    name: str
    age: int

class C:
    counter: ClassVar[int] = 0

class Node:
    def clone(self) -> Self: ...

T = TypeVar("T")
def first(items: List[T]) -> T: ...

from typing import List, Dict, Optional, Union, Callable

# 리스트와 딕셔너리 타입 힌트
def process_scores(scores: List[int]) -> Dict[str, float]:
    return {"avg": sum(scores) / len(scores)}

# Optional: 값이 없을 수도 있음
def greet(name: Optional[str] = None) -> str:
    if name:
        return f"Hello, {name}!"
    return "Hello!"

# Union: 여러 타입 허용
def stringify(value: Union[int, float]) -> str:
    return str(value)

# Callable: 함수를 인자로 받는 함수
def operate(x: int, y: int, op: Callable[[int, int], int]) -> int:
    return op(x, y)

# 사용 예시
print(process_scores([80, 90, 100]))
print(greet())
print(greet("Kihoon"))
print(stringify(3.14))
print(operate(3, 5, lambda a, b: a + b))

외부 라이브러리(설치 필요)

Pydantic

• 설치 : pip install pydantic

예시

BaseModel

• 클래스를 BaseModel을 상속해서 정의하면
  • 데이터 검증(Validation) + 변환(Parsing) + 직렬화(Serialization) 기능이 자동으로 붙음

BaseSettings(환경 설정용 모델)

• BaseModel과 비슷하게 데이터 검증 + 직렬화 기능을 가지지만,
  • 환경 변수(Environment Variable)나 .env 파일에서 값을 자동으로 읽어와서 클래스 속성에 매핑해줌

FastAPI

tortoise ORM

python-jose

jose.jwt 모듈 — (JWT 인코딩/디코딩 핵심)

• from jose import jwt

jose.exceptions 모듈 — (예외 클래스)

• from jose import JWTError, ExpiredSignatureError, JWTClaimsError

# 보통 이렇게 사용
from jose import jwt, JWTError

try:
    payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
except JWTError:
    raise HTTPException(status_code=401, detail="Invalid token")

jose.constants — (상수 정의)

• from jose.constants import ALGORITHMS

from jose.constants import ALGORITHMS
jwt.encode(payload, key, algorithm=ALGORITHMS.HS256)

jose.utils — (기초 암호화 유틸리티)

• from jose.utils import base64url_encode, base64url_decode

from jose.utils import base64url_encode, base64url_decode

b64 = base64url_encode(b"hello")   # → b'aGVsbG8'
base64url_decode(b64)              # → b'hello'

(선택) JWK / JWS / JWE 관련 — 고급용

• FastAPI 인증 구현에서는 거의 안 쓰지만 참고용

passlib

• 비밀번호 해싱/검증 전용 보안 라이브러리
  • 즉, 비밀번호를 안전하게 저장하고 비교하기 위한 표준 도구

핵심 객체: CryptContext

• 여러 해싱 알고리즘(bcrypt, argon2, pbkdf2 등)을 한곳에서 관리하고, 비밀번호 해싱과 검증을 담당

# 생성
pwd_context = CryptContext(
    schemes=["bcrypt"],       # 사용할 알고리즘 목록
    deprecated="auto",        # 이전 알고리즘 자동 감지
)

• schemes: 사용할 해싱 알고리즘 리스트 (보통 "bcrypt", "argon2", "pbkdf2_sha256")
• deprecated: 이전 해시 버전을 자동으로 감지하여 경고 또는 업데이트 처리
• 보통 bcrypt 단독 사용이 가장 보편적

주요 메서드

예시

from passlib.context import CryptContext

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

# 해싱
hashed_pw = pwd_context.hash("mysecret")
print(hashed_pw)
# → $2b$12$O4mGvSR.0QzRkU/aQZkQ2eb5ScaZ7xHShfQx6Eo.mzUzJjHSMkF6O

# 검증
pwd_context.verify("mysecret", hashed_pw)  # ✅ True
pwd_context.verify("wrongpass", hashed_pw) # ❌ False

## 각 알고리즘의 기본 사용법 (단독 사용 시)
## 실무에서 이런식으로 잘 안씀
from passlib.hash import bcrypt

hashed = bcrypt.hash("1234")
print(bcrypt.verify("1234", hashed))  # True

주요 해싱 알고리즘 객체들 (내부적으로 CryptContext가 사용)

설정 파일 기반 관리 (고급용)

• passlib은 .ini 스타일 설정 파일을 사용 가능

[passlib]
schemes = bcrypt, pbkdf2_sha256
default = bcrypt
deprecated = pbkdf2_sha256

# 불러오기
pwd_context = CryptContext.from_path("passlib.ini")

FastAPI에서의 전형적 사용 구조

from passlib.context import CryptContext

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

def get_password_hash(password: str) -> str:
    return pwd_context.hash(password)

def verify_password(plain: str, hashed: str) -> bool:
    return pwd_context.verify(plain, hashed)

Statistics

• 파이썬 statistics 모듈은 별도의 외부 라이브러리(NumPy, Pandas 등) 설치 없이,
  • 파이썬 기본 리스트(List) 등을 사용하여 기본적인 통계 수치를 계산할 수 있게 해주는 표준 라이브러리
• statistics.mean(data): 산술 평균 (가장 많이 씀)
• statistics.median(data): 중앙값 (이상치에 영향을 덜 받음)
• statistics.mode(data): 최빈값 (가장 자주 나온 값)
• statistics.stdev(data): 표본 표준편차 (가장 많이 씀)
• statistics.variance(data): 표본 분산
• statistics.pstdev(data): 모표준편차 (데이터가 모집단 전체일 때)