💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

원문 렌더가 준비되기 전까지 텍스트 가이드로 표시합니다.

> "Python은 2026년에 더 이상 '느린 언어' 가 아니다. Pydantic은 Rust로, Polars도 Rust로, Ruff와 uv 역시 Rust로 — Python의 핫 패스는 모두 시스템 언어로 옮겨갔다." — PyCon US 2026 키노트

Python은 2025~2026년에 가장 큰 도구 체인 교체를 경험했습니다. pip는 uv(Astral, Rust 기반)로, Black + isort + flake8 + pylint는 Ruff 단일 도구로, pandas는 PyArrow 백엔드 또는 Polars로 — 한 번에 네 개의 거대한 도구가 동시에 교체된 사건은 Python 30년 역사에서 처음입니다. 그리고 그 모든 도구의 핵심 엔진은 Rust로 작성되어 있습니다.

언어 자체도 변했습니다. Python 3.13(2024.10)은 실험적 JIT(PEP 744)와 free-threaded 빌드(PEP 703)를 도입했고, 3.14(2025.10)는 이를 안정화시키며 per-interpreter GIL까지 함께 다듬었습니다. 2026년 5월 현재 Python은 "타입이 있고, 비동기를 자연스럽게 다루며, GIL 없이 멀티스레드를 굴릴 수 있는" 언어로 변신 중입니다. 이 글에서는 언어, 웹 프레임워크, ORM/데이터, 검증, 도구 체인, 테스트, 동시성, ML 인접, CLI, 스크래핑, 그리고 한국·일본 도입 사례까지 한 글에 담습니다.

1. 2026년 Python 생태계 한눈에 보기

2026년의 Python 생태계는 다음 다섯 레이어로 정리됩니다.

| 레이어 | 2020년 표준 | 2026년 표준 | 비고 |

|---|---|---|---|

| 패키지 매니저 | pip + virtualenv | uv | 10~100배 빠름 |

| 검증 | pydantic 1 (pure Python) | Pydantic 2 (Rust core) | 5~50배 빠름 |

핵심 통찰은 "**Python은 단일 도구 체인으로 수렴 중이지만, 도구의 내부 구현은 Rust로 분기 중**"이라는 점입니다. 사용자가 작성하는 코드는 여전히 Python이지만, 그 코드를 처리하는 도구는 시스템 언어로 옮겨갔습니다.

2. Python 3.13 — JIT 프리뷰, Free-Threaded, 개선된 에러 메시지

Python 3.13(2024.10)은 백엔드와 데이터 사이언스에 모두 영향을 미치는 세 가지 큰 변화를 도입했습니다.

첫째, **실험적 JIT 컴파일러(PEP 744)** 입니다. copy-and-patch 방식의 JIT가 hot loop를 네이티브 코드로 컴파일합니다. 2026년 기준 5~15% 향상이 표준이며, NumPy 같은 C 확장 호출이 많은 코드에서는 효과가 제한적입니다. 둘째, **Free-threaded 빌드(PEP 703)** 는 `python3.13t` / `python3.14t`로 배포되며 GIL을 완전히 제거합니다. CPU-bound 멀티스레드에서 코어 수만큼 스케일링됩니다. 셋째, **개선된 에러 메시지** — `NameError` 시 비슷한 이름을 제안하고, 들여쓰기 오류를 시각적으로 보여줍니다.

free-threaded Python 3.13 설치 (uv 사용)

uv python install 3.13t

uv venv --python 3.13t

source .venv/bin/activate

GIL 상태 확인

python -c "import sys; print('GIL enabled:', sys._is_gil_enabled())"

free-threaded 빌드에서는 False가 나옴

JIT 활성화 후 확인

PYTHON_JIT=1 python -c "import sys; print('JIT:', sys._jit.is_enabled())"

실무에서는 아직 free-threaded를 프로덕션에 쓰는 곳이 드물고, Granian이나 일부 데이터 처리 워크로드에서 실험적으로 도입되고 있습니다. 라이브러리 호환성 — 특히 C 확장 — 이 가장 큰 장벽입니다.

3. Python 3.14 — JIT 안정화와 Per-Interpreter GIL

Python 3.14(2025.10)는 3.13의 실험적 기능을 다듬는 릴리스입니다. JIT는 여전히 "experimental"이지만 회귀가 줄었고, free-threaded 빌드는 stable PEP 상태로 격상되었습니다. **Per-Interpreter GIL(PEP 684)** 은 같은 프로세스 안에서 여러 서브인터프리터를 띄우면 각각이 독립된 GIL을 갖도록 합니다. WSGI/ASGI 서버에서 fork 비용 없이 멀티 코어를 활용할 수 있는 길이 열린 셈입니다.

새 문법으로는 **PEP 695 (제네릭 문법)** 의 안정화, **PEP 750 (t-string, 템플릿 문자열 리터럴)** 의 도입이 눈에 띕니다. t-string은 SQL 인젝션이나 셸 이스케이프 같은 보안 민감한 영역에서 자동 이스케이프를 강제할 수 있는 새로운 문법입니다. PEP 695 제네릭은 `def first[T](items: list[T]) -> T:` 형태로 클래스/함수에 직접 타입 파라미터를 선언할 수 있게 했고, t-string은 `t"SELECT * FROM users WHERE name = ..."` 구문으로 안전한 템플릿 처리를 강제합니다.

4. uv — pip 그리고 Poetry를 동시에 대체

Astral의 **uv** 는 2024년 첫 릴리스 이후 2025~2026년에 Python 패키지 매니저 시장을 폭주적으로 잠식했습니다. Rust로 작성된 단일 바이너리이며 pip / pip-tools / virtualenv / pyenv / pipx / Poetry / PDM의 기능을 한 번에 흡수합니다. 벤치마크상 pip + venv 대비 10~100배 빠르고, 캐시 기반 락 파일로 재현 가능한 설치를 제공합니다.

pyproject.toml (uv 표준)

[project]

name = "myapi"

version = "0.1.0"

requires-python = ">=3.13"

dependencies = [

"fastapi[standard]>=0.115",

"sqlalchemy[asyncio]>=2.0",

"pydantic>=2.9",

"uvicorn[standard]>=0.30",

"httpx>=0.27",

]

[dependency-groups]

dev = [

"pytest>=8.3",

"pytest-asyncio>=0.24",

"ruff>=0.7",

"mypy>=1.13",

]

[tool.uv]

managed = true

default-groups = ["dev"]

명령어는 직관적입니다. `uv init`, `uv add fastapi`, `uv sync`, `uv run pytest`, `uv pip install -r requirements.txt`. 기존 Poetry 프로젝트는 `uv migrate`로 옮길 수 있고, `pyproject.toml` PEP 621 표준을 그대로 따르므로 마이그레이션 리스크가 낮습니다. 2026년 5월 기준 PyPI 다운로드 상위 100개 패키지 중 70% 이상이 uv 호환 메타데이터를 갖고 있습니다.

5. Ruff — 4개 도구를 하나로

Ruff는 Astral이 만든 Rust 기반 린터·포매터입니다. Black + isort + flake8 + pylint의 700개 이상 규칙을 단일 바이너리로 통합했고, 속도는 평균 10~100배 빠릅니다. 2026년 기준 FastAPI · Pydantic · Polars · Hugging Face · pandas 등 거의 모든 주요 OSS가 Ruff로 이주했습니다.

pyproject.toml에 추가

[tool.ruff]

line-length = 100

target-version = "py313"

[tool.ruff.lint]

select = [

"E", # pycodestyle errors

"W", # pycodestyle warnings

"F", # pyflakes

"I", # isort

"B", # flake8-bugbear

"C4", # flake8-comprehensions

"UP", # pyupgrade

"N", # pep8-naming

"S", # bandit (security)

"RUF", # ruff-specific

]

ignore = ["E501"] # line length는 formatter가 처리

[tool.ruff.format]

quote-style = "double"

indent-style = "space"

`ruff check . --fix && ruff format .` 한 줄로 코드 정리가 끝납니다. 거대 모노레포에서도 1초 이내에 전체 점검이 끝나기 때문에 pre-commit 훅 부담이 사실상 사라졌습니다.

6. mypy 대 pyright — 타입 체커 양강 체제

타입 체커는 **mypy(Python 작성, Dropbox 발)** 와 **pyright(TypeScript 작성, Microsoft)** 의 양강 체제입니다. mypy 1.13(2025)은 PEP 695 제네릭, PEP 696 type defaults, PEP 692 TypedDict for kwargs를 모두 지원하며, pyright는 VS Code Pylance의 핵심 엔진으로 가장 빠른 추론 속도를 자랑합니다.

pyproject.toml — mypy와 pyright 동시 설정

[tool.mypy]

python_version = "3.13"

strict = true

warn_return_any = true

warn_unused_configs = true

disallow_untyped_defs = true

plugins = ["pydantic.mypy", "sqlalchemy.ext.mypy.plugin"]

[[tool.mypy.overrides]]

module = "third_party_without_stubs.*"

ignore_missing_imports = true

[tool.pyright]

include = ["src"]

exclude = ["**/__pycache__"]

pythonVersion = "3.13"

typeCheckingMode = "strict"

reportMissingImports = "error"

reportMissingTypeStubs = "warning"

선택 기준은 명확합니다. **CI/CD 전체 타입 안정성 보장이 목표**이면 mypy(역사가 길고 PEP 권위가 있음), **VS Code 통합과 빠른 인크리멘털 분석**이 목표이면 pyright. 두 도구를 동시에 굴리는 팀도 늘고 있습니다.

7. FastAPI 0.115+ — 자동 OpenAPI · DI · Pydantic 2

FastAPI(2018~, Sebastián Ramírez)는 2026년에도 Python API 프레임워크의 사실상 표준입니다. GitHub 80K+, PyPI 월 다운로드 200M+. 0.115에서는 Starlette 0.41, Pydantic 2.9 의존성으로 올라가면서 검증 속도가 더 빨라졌습니다. 핵심 가치는 자동 OpenAPI 생성, 타입 기반 의존성 주입, Pydantic 2 검증 통합 세 가지입니다.

FastAPI + Pydantic 2 + SQLAlchemy 2 async 표준 패턴

from fastapi import FastAPI, Depends, HTTPException

from pydantic import BaseModel, EmailStr, Field

from sqlalchemy.ext.asyncio import AsyncSession

from typing import Annotated

app = FastAPI(title="User API", version="1.0")

class UserCreate(BaseModel):

email: EmailStr

age: int = Field(ge=0, le=150)

class UserOut(BaseModel):

id: int

email: EmailStr

async def get_db() -> AsyncSession:

async with AsyncSessionLocal() as session:

yield session

DbSession = Annotated[AsyncSession, Depends(get_db)]

@app.post("/users", response_model=UserOut, status_code=201)

async def create_user(payload: UserCreate, db: DbSession) -> UserOut:

user = User(**payload.model_dump())

db.add(user)

await db.commit()

await db.refresh(user)

return UserOut.model_validate(user, from_attributes=True)

`Annotated[Type, Depends(...)]` 패턴이 0.95 이후 권장이며 0.115에서는 sub-dependency 캐시 옵션 등 미세 튜닝이 추가됐습니다.

8. Django 5.1+ — 마침내 성숙한 async 뷰

Django는 2026년 5월 기준 5.2 LTS가 최신 안정 버전이며, **async 뷰가 드디어 실전 수준에 도달**했습니다. Django 5.1에서 async ORM 메서드(`aget`, `acreate`, `afilter`)가 안정화되었고, 5.2에서 async signals · async ORM aggregation · async middleware가 추가되었습니다. WSGI + Gunicorn 시대에서 ASGI + uvicorn/Daphne 시대로 본격 전환이 시작된 것입니다.

Django 5 async 뷰 — 진짜 동시 처리 가능

from django.http import JsonResponse

from django.views.decorators.http import require_GET

from asgiref.sync import sync_to_async

@require_GET

async def aggregate(request):

async with httpx.AsyncClient() as client:

외부 API 두 개를 병렬로

a, b = await asyncio.gather(

client.get("https://api1.example.com/data"),

client.get("https://api2.example.com/data"),

)

async ORM

user = await User.objects.aget(pk=request.user.id)

return JsonResponse({

"user": user.email,

"data1": a.json(),

"data2": b.json(),

})

여전히 Django의 강점은 Admin · Auth · Migrations · ORM이 일체형이라는 점입니다. 대형 SaaS는 비즈니스 로직은 Django, API 게이트웨이는 FastAPI/Litestar를 두는 하이브리드 패턴을 선호합니다.

9. Litestar 2.x — 컨트롤러 기반의 차세대 ASGI

Litestar(구 Starlite, 2021~)는 FastAPI의 함수 기반 API에 만족하지 못한 팀이 주로 채택하는 컨트롤러 기반 ASGI 프레임워크입니다. 2.x에서는 DTO(Data Transfer Object) 시스템, msgspec 통합, OpenTelemetry 1차 지원, 채널(WebSocket pub/sub) 등 엔터프라이즈 기능이 추가되었습니다.

Litestar 2.x — 컨트롤러 기반

from litestar import Controller, Litestar, get, post

from msgspec import Struct

class User(Struct):

id: int

class UserController(Controller):

path = "/users"

@get("/")

async def list_users(self) -> list[User]:

return [User(id=1, name="Alice")]

@post("/")

async def create_user(self, data: User) -> User:

return data

app = Litestar(route_handlers=[UserController])

Litestar는 검증 엔진으로 msgspec을 기본 권장합니다. msgspec은 Pydantic 2 대비 2~5배 더 빠른 직렬화·역직렬화 성능을 보여주며, 메모리 사용량도 적습니다. 다만 IDE 통합과 생태계 크기는 Pydantic 2가 압도적이라 FastAPI를 떠날 정도의 결정적 동기는 아직 부족하다는 의견이 많습니다.

10. Flask 3.x · Sanic · Quart · aiohttp 4 · Robyn — 그 외 진영

Flask 3(2023)은 WSGI 시대의 클래식 마이크로 프레임워크로 살아남았습니다. async 뷰가 제한적으로 지원되지만 본질적으로 동기 기반입니다. **Quart** 는 Flask와 거의 동일한 API에 ASGI를 얹은 포크이며, Flask 팬을 위한 비동기 진영입니다. **Sanic** 은 자체 ASGI 서버까지 포함한 비동기 단일 패키지, **aiohttp 4** 는 클라이언트·서버를 모두 다루는 비동기 HTTP의 클래식입니다.

**Robyn** 은 Rust 코어 위에 Python 인터페이스를 얹은 새로운 시도입니다. 라우터·미들웨어·HTTP 파서 전부가 Rust로 작성돼 있고, Python 핸들러를 호출합니다. 단순 라우팅 벤치마크에서 uvicorn + FastAPI 대비 2~3배 처리량을 보입니다. 다만 생태계가 좁고 Python 디버거 통합이 미흡해 프로덕션 채택은 신중한 편입니다.

|---|---|---|---|

11. Starlette — FastAPI · Litestar의 공통 조상

Starlette은 ASGI 표준 위에 라우팅 · 미들웨어 · 테스트 클라이언트를 얹은 마이크로 프레임워크입니다. FastAPI는 Starlette을 직접 의존성으로 끌어다 쓰고, Litestar는 자체 구현이지만 인터페이스가 매우 유사합니다. 단독 사용 시에는 `from starlette.applications import Starlette` 한 줄로 시작해 라우트·미들웨어를 직접 조립할 수 있고, 그것이 FastAPI/Litestar의 본질적인 차이를 이해하는 가장 좋은 출발점입니다.

12. Granian — uvicorn을 위협하는 Rust ASGI 서버

**Granian** 은 Emmett 프레임워크의 저자가 만든 Rust 기반 ASGI/WSGI/RSGI 서버입니다. uvicorn(uvloop + httptools 기반) 대비 1.5~2배 빠른 처리량을 보여주며, free-threaded Python 3.13t에서 멀티스레드 워커를 자연스럽게 활용합니다.

설치는 `uv add granian` 한 줄, 실행은 `granian --interface asgi main:app` 형태로 uvicorn 호환 드롭인입니다. 워커와 스레드를 동시에 조정하려면 `--workers 4 --threads 2` 같은 옵션을 쓰고, Granian 전용 RSGI 모드는 `--interface rsgi`로 활성화합니다.

2026년 5월 현재 Granian은 "uvicorn 호환 드롭인"으로 자리잡았고, FastAPI/Litestar 모두 공식 가이드에 Granian을 함께 명시합니다. uvicorn은 여전히 표준이지만, 성능이 중요한 곳은 점차 Granian으로 옮겨가고 있습니다.

13. Pydantic 2 — Rust core 검증 엔진

Pydantic 2(2023)는 코어를 Rust로 다시 작성한 검증 엔진입니다. v1 대비 5~50배 빠르고, JSON 직렬화는 orjson 수준에 근접합니다. FastAPI · Django Ninja · Litestar · LangChain · OpenAI SDK 등 거의 모든 API 라이브러리가 Pydantic 2 위에서 동작합니다.

from pydantic import BaseModel, Field, EmailStr, computed_field, model_validator

from datetime import datetime

from typing import Self

class Order(BaseModel):

id: int

email: EmailStr

items: list[str] = Field(min_length=1)

quantity: int = Field(gt=0)

price_per_item: float = Field(gt=0)

created_at: datetime

@computed_field

@property

def total(self) -> float:

return self.quantity * self.price_per_item

@model_validator(mode="after")

def check_premium_quota(self) -> Self:

if self.quantity > 1000 and "@example.com" not in self.email:

raise ValueError("non-premium accounts limited to 1000")

return self

직렬화

order = Order(id=1, email="a@b.com", items=["sku-1"], quantity=10, price_per_item=99.0,

created_at=datetime.now())

print(order.model_dump_json())

Pydantic 2의 핵심 트릭은 모든 검증 로직을 Rust로 옮긴 `pydantic-core`입니다. Python 측은 얇은 래퍼만 남아 있습니다.

14. msgspec · attrs · dataclasses · cattrs — 검증 대안

검증/직렬화에는 Pydantic 2만 있는 게 아닙니다. **msgspec** 은 Pydantic 2 대비 더 빠른 직렬화 라이브러리로 Litestar가 기본 채택했고, **attrs** 는 Python 표준 라이브러리에 영향을 미친 클래스 정의 도구, **dataclasses** 는 stdlib 표준, **cattrs** 는 attrs/dataclasses 위에 구조화/역구조화 레이어를 얹은 도구입니다.

| 도구 | 검증 | 직렬화 속도 | 학습 곡선 | 생태계 |

|---|---|---|---|---|

| Pydantic 2 | 강함 | 빠름 | 보통 | 거대 |

| msgspec | 보통 | 매우 빠름 | 낮음 | 중간 |

| attrs | 약함 | 빠름 | 낮음 | 큼 |

| cattrs | 강함 | 빠름 | 보통 | 중간 |

| marshmallow | 강함 | 보통 | 높음 | 레거시 |

15. SQLAlchemy 2.x — Core + ORM 통합 async

SQLAlchemy 2.0(2023)은 Core와 ORM의 API를 통합한 메이저 릴리스입니다. `select()` 기반 통일 쿼리, `AsyncSession`, 타입 힌트 우선 매핑, PEP 695 제네릭 호환이 핵심입니다. 2026년 5월 기준 2.0.36이 최신이며, asyncio 다이얼렉트는 PostgreSQL(asyncpg), MySQL(aiomysql), SQLite(aiosqlite), MSSQL(aioodbc)이 정식 지원됩니다.

SQLAlchemy 2 — async + typed mapping

from sqlalchemy import select, String

from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, async_sessionmaker

from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column

from datetime import datetime

class Base(DeclarativeBase):

pass

class User(Base):

__tablename__ = "users"

id: Mapped[int] = mapped_column(primary_key=True)

email: Mapped[str] = mapped_column(String(255), unique=True)

created_at: Mapped[datetime] = mapped_column(default=datetime.utcnow)

engine = create_async_engine("postgresql+asyncpg://user:pw@localhost/db", echo=True)

AsyncSessionLocal = async_sessionmaker(engine, expire_on_commit=False)

async def find_recent_users(session: AsyncSession) -> list[User]:

stmt = select(User).where(User.created_at > datetime(2026, 1, 1)).order_by(User.id)

result = await session.scalars(stmt)

return list(result)

`Mapped[...]` 타입 어노테이션이 컬럼 메타데이터의 소스 오브 트루스이며, mypy/pyright와의 통합이 깔끔합니다.

16. SQLModel · Tortoise · Peewee · Piccolo · Edgy — ORM 선택지

| ORM | 기반 | 비동기 | 마이그레이션 | 권장 시나리오 |

|---|---|---|---|---|

| Django ORM | Django | O (5.1+) | 내장 | 풀스택 |

| Peewee | 독자 | 부분 | 외부 | 소형 프로젝트 |

| Piccolo | 독자 | O | 내장 | async-first |

| Edgy | SQLAlchemy 코어 | O | 내장 | 신생 |

SQLModel은 SQLAlchemy 2의 컬럼 매핑 위에 Pydantic 검증을 얹어 "한 모델 = ORM + API DTO" 패턴을 제공합니다. FastAPI 공식 가이드가 SQLModel을 함께 소개하면서 이 패턴이 사실상 표준이 됐습니다.

17. Polars — pandas 후계 후보

**Polars**(Rust + Apache Arrow)는 2024~2025년 동안 pandas를 빠르게 잠식한 데이터프레임 라이브러리입니다. 멀티스레드 쿼리 엔진, lazy 평가, Arrow 메모리 모델을 기본으로 합니다. 대형 데이터(>1GB)에서 pandas 대비 5~30배 빠른 성능을 보여주며, 한국 NAVER · 일본 ZOZO 데이터 팀이 신규 ETL은 모두 Polars로 작성한다고 공개했습니다.

eager API

df = pl.read_csv("orders.csv")

result = (

df.filter(pl.col("country") == "KR")

.group_by("user_id")

.agg([

pl.col("amount").sum().alias("total"),

pl.col("order_id").count().alias("orders"),

])

.sort("total", descending=True)

.head(10)

)

lazy API — 쿼리 플래너 최적화

plan = (

pl.scan_parquet("logs/*.parquet")

.filter(pl.col("status") == 200)

.group_by("path")

.agg(pl.col("latency_ms").mean())

)

print(plan.explain()) # 실행 계획 확인

top_paths = plan.collect()

pandas 사용자가 Polars로 옮길 때 가장 큰 장벽은 인덱스 개념의 부재입니다. Polars는 인덱스 없이 모든 컬럼을 동등하게 다루기 때문에 pandas의 `.set_index()` / `MultiIndex` 패턴을 다시 모델링해야 합니다.

18. pandas 2.x · PyArrow · DuckDB — 데이터 스택 동거

pandas 2.x(2023~)는 PyArrow 백엔드를 1차 지원하면서 메모리 사용량과 string dtype 성능을 개선했습니다. 2.2부터는 `pd.options.future.infer_string = True`가 표준이며, copy-on-write 모드가 기본화되었습니다. Polars로 옮기지 않은 팀도 pandas 2 + PyArrow 백엔드로 큰 성능 이득을 얻을 수 있습니다.

**DuckDB** 는 in-process OLAP 데이터베이스로, pandas/Polars 데이터프레임에 직접 SQL을 실행할 수 있습니다. Jupyter에서 가장 빠른 분석 도구로 자리잡았고, `httpfs` 확장으로 S3/HTTP 파일을 직접 쿼리할 수 있습니다.

Polars 데이터프레임에 SQL 직접 실행

df = pl.read_csv("orders.csv")

result = duckdb.sql("""

SELECT user_id, COUNT(*) AS orders, SUM(amount) AS total

FROM df

WHERE country = 'KR'

GROUP BY user_id

ORDER BY total DESC

LIMIT 10

""").pl() # 결과를 다시 Polars로

S3 Parquet 직접 쿼리

duckdb.sql("INSTALL httpfs; LOAD httpfs;")

top = duckdb.sql("""

SELECT path, AVG(latency_ms) AS avg_lat

FROM read_parquet('s3://bucket/logs/*.parquet')

WHERE status = 200

GROUP BY path

""").df()

19. pytest · pytest-asyncio · hypothesis · polyfactory — 테스트 표준

Python 테스트는 pytest 단일 표준입니다. 2026년 5월 기준 pytest 8.3, pytest-asyncio 0.24가 권장입니다. **hypothesis** 는 property-based testing 도구로, 입력 공간을 자동 탐색해 엣지 케이스를 발견합니다. **polyfactory** 는 Pydantic/dataclass/SQLAlchemy 모델에서 자동으로 가짜 데이터를 생성합니다.

pytest + hypothesis

from hypothesis import given, strategies as st

@given(st.lists(st.integers(min_value=0, max_value=1000), min_size=1))

def test_sum_is_nonneg(xs: list[int]) -> None:

assert sum(xs) >= 0

pytest-asyncio

@pytest.mark.asyncio

async def test_user_create(client):

response = await client.post("/users", json={

"email": "a@b.com", "name": "Alice", "age": 30

})

assert response.status_code == 201

polyfactory

from polyfactory.factories.pydantic_factory import ModelFactory

class UserFactory(ModelFactory[UserCreate]):

__model__ = UserCreate

def test_random_users():

for _ in range(100):

u = UserFactory.build()

assert u.age >= 0

병렬 실행은 pytest-xdist, 커버리지는 coverage + pytest-cov, 뮤테이션 테스트는 mutmut이 표준입니다.

20. asyncio · anyio · trio — 비동기 동시성

Python 동시성은 stdlib의 **asyncio** 가 중심입니다. 다만 cancellation 의미론과 task group이 복잡해서 **anyio** 라는 추상 레이어가 등장했습니다. anyio는 asyncio와 trio를 동시에 지원하며, 구조적 동시성(structured concurrency) 모델을 제공합니다. **trio** 자체는 Nathaniel Smith가 만든 별도의 비동기 라이브러리로, 학술적/디자인적 정합성이 높지만 생태계는 좁습니다.

anyio — 구조적 동시성

async def fetch(url: str) -> int:

async with httpx.AsyncClient() as client:

r = await client.get(url)

return r.status_code

async def main():

async with anyio.create_task_group() as tg:

for url in ["https://a.example", "https://b.example", "https://c.example"]:

tg.start_soon(fetch, url)

task group 종료 시 모든 자식이 정리되었음이 보장됨

anyio.run(main)

FastAPI 0.110+ / Starlette 0.36+은 내부에서 anyio를 채택했고, 2026년 5월 기준 새 async 코드는 anyio 패턴을 따르는 것이 권장됩니다.

21. NumPy 2 · SciPy · scikit-learn · transformers · PyTorch — ML 인접

NumPy 2.0(2024)은 ABI 변경, 새 string dtype, 단순화된 API가 주요 변화입니다. SciPy 1.13+은 NumPy 2 호환, scikit-learn 1.5+는 NumPy 2 + free-threaded 빌드 실험 지원이 추가됐습니다. PyTorch 2.5+는 `torch.compile`이 안정화되었고 free-threaded 빌드의 실험적 지원이 시작됐습니다. transformers 4.45+, JAX 0.4+ 모두 Pydantic 2 검증을 일부 통합했습니다.

ML 워크로드에서는 데이터 파이프라인이 **Polars + DuckDB + PyArrow** 로, 학습이 **PyTorch + Lightning + datasets** 로 정리되었습니다.

22. Typer · Click · argparse · fire — CLI 진영

CLI 도구는 4가지 선택지가 있습니다. **Typer**(FastAPI의 자매 프로젝트, Pydantic/type 기반), **Click**(Flask 진영, 데코레이터 기반), **argparse**(stdlib 표준), **fire**(Google, 객체 자동 노출). Typer는 함수의 타입 힌트가 그대로 CLI 옵션이 됩니다 — `def ingest(path: Path, workers: int = 4, dry_run: bool = False) -> None:` 같은 함수를 `@app.command()` 데코레이터만 붙이면 완성된 CLI가 됩니다.

uv + Typer 조합은 "CLI 스크립트 + 자동 설치"를 가장 깔끔하게 구현합니다. `uv tool install mycli` 한 줄로 시스템 PATH에 등록됩니다.

23. httpx · playwright-python · Scrapy 2.12 — 웹 클라이언트와 스크래핑

**httpx**(Encode)는 requests의 비동기 후계로 자리잡았습니다. requests API 호환에 async, HTTP/2, SOCKS, OAuth 등이 추가됐고, `async with httpx.AsyncClient(http2=True) as client:` 한 줄로 모든 HTTP/2·연결 풀링·타임아웃이 처리됩니다. **playwright-python** 은 브라우저 자동화의 표준으로, Puppeteer/Selenium을 빠르게 대체했습니다. **Scrapy 2.12** 는 본격 크롤링 프레임워크, 가벼운 파싱은 **parsel**(Scrapy에서 분리)을 사용합니다.

24. 한국 도입 사례 — Toss · Naver · Coupang · Kakao

**Toss** 는 ML 플랫폼과 데이터 처리 파이프라인에 Python을 전면 도입했습니다. 모델 서빙은 FastAPI + Pydantic 2 + Granian 조합이고, 피처 엔지니어링은 Polars + DuckDB를 사용합니다. 2025년 3분기 기술 블로그에서 "Polars 도입으로 pandas 대비 8배 빠른 ETL"을 공개했습니다.

**Naver** 는 검색 랭킹 피처 엔지니어링과 Clova 모델 서빙에 Python을 사용하며, 2025년 말 사내 데이터 표준을 Polars 우선으로 변경했다고 공개했습니다. **Coupang** 은 광고/검색 ML 서빙에 FastAPI + Pydantic 2 + SQLAlchemy 2를 사용하고, 사내 모노레포에 Ruff + uv를 표준화했습니다. **Kakao** 는 KoGPT 시리즈 추론 서빙에 FastAPI + PyTorch + ONNX Runtime을 사용합니다.

25. 일본 도입 사례 — Mercari · ZOZO · LINE · SmartNews

**Mercari** 는 ML 플랫폼 ML-2(2024 공개) 전체를 FastAPI + Pydantic 2로 작성했고, 직렬화 핫 패스에 msgspec을 부분 도입했습니다. **ZOZO** 는 패션 추천 시스템 피처 파이프라인을 pandas에서 Polars로 전환하는 작업을 2025년에 완료했고, 사내 표준 린터를 Ruff로 통일했습니다.

**LINE** 은 광고 시스템과 추천 시스템 양쪽 모두에 FastAPI + SQLAlchemy 2 async를 사용하며, 도쿄 PyCon JP 2025에서 Granian 도입 사례를 발표했습니다. **SmartNews** 는 콘텐츠 랭킹 학습 파이프라인을 PyTorch + Polars + DuckDB로 구성했습니다.

26. 도구 체인 마이그레이션 — 2026년 표준 권장 셋업

Python 프로젝트를 2026년 표준으로 셋업한다면 다음 조합이 가장 무난합니다. 이미 운영 중인 프로젝트라면 한 번에 모두 옮기지 말고 단계적으로 진행하세요.

2026 권장 pyproject.toml 셋업

[project]

name = "myproject"

requires-python = ">=3.13"

dependencies = [

"fastapi[standard]>=0.115",

"pydantic>=2.9",

"sqlalchemy[asyncio]>=2.0",

"polars>=1.12",

"httpx>=0.27",

]

[dependency-groups]

dev = [

"pytest>=8.3",

"pytest-asyncio>=0.24",

"hypothesis>=6.115",

"ruff>=0.7",

"mypy>=1.13",

"pyright>=1.1.385",

]

[tool.ruff]

line-length = 100

target-version = "py313"

[tool.ruff.lint]

select = ["E", "W", "F", "I", "B", "C4", "UP", "N", "S", "RUF"]

[tool.mypy]

python_version = "3.13"

strict = true

plugins = ["pydantic.mypy", "sqlalchemy.ext.mypy.plugin"]

[tool.pytest.ini_options]

asyncio_mode = "auto"

addopts = "--strict-markers -ra"

마이그레이션 순서는 **(1) Poetry/pip → uv**, **(2) Black + isort + flake8 → Ruff**, **(3) pandas → Polars (신규 코드만)**, **(4) pydantic 1 → pydantic 2 (BC가 깨지므로 신중히)** 입니다. mypy 와 pyright는 양자택일하지 말고 mypy를 CI, pyright를 IDE에서 동시에 굴리는 패턴이 가장 안정적입니다.

27. 결론 — Python의 핫 패스는 Rust로 옮겨갔다

2026년의 Python을 한 문장으로 요약하면 "**언어는 그대로, 도구는 Rust로**"입니다. 사용자 코드는 여전히 Python으로 작성되지만 그 코드를 처리하는 모든 핵심 도구 — 패키지 매니저(uv), 린터·포매터(Ruff), 검증 엔진(Pydantic 2 / pydantic-core), 데이터프레임(Polars), ASGI 서버(Granian) — 가 Rust로 작성되어 있습니다.

언어 자체도 Python 3.13의 free-threaded 빌드와 JIT, 3.14의 per-interpreter GIL · t-string으로 진화 중입니다. 2030년 즈음에는 GIL 없는 Python이 표준이 될 가능성이 큽니다. 그때까지 우리가 해야 할 일은 **Pydantic 2 + SQLAlchemy 2 + Polars + FastAPI/Django/Litestar + Ruff + uv** 의 표준 조합을 익히고, 새 프로젝트에 적용하며, 기존 프로젝트를 점진적으로 옮기는 것입니다.

References

- Python 공식 문서: https://docs.python.org/3/

- FastAPI: https://fastapi.tiangolo.com/

- Django: https://docs.djangoproject.com/en/5.2/

- Litestar: https://litestar.dev/

- Starlette: https://www.starlette.io/

- SQLAlchemy: https://docs.sqlalchemy.org/en/20/

- Polars: https://pola.rs/

- Pydantic: https://docs.pydantic.dev/latest/

- Ruff: https://docs.astral.sh/ruff/

- uv: https://docs.astral.sh/uv/

- mypy: https://mypy.readthedocs.io/

- pyright: https://github.com/microsoft/pyright

- pytest: https://docs.pytest.org/

- DuckDB: https://github.com/duckdb/duckdb

- msgspec: https://jcristharif.com/msgspec/

- Granian: https://github.com/emmett-framework/granian