Python 생태계 2026 완벽 가이드 — Python 3.13 · FastAPI · Django 5 · Litestar · SQLAlchemy 2 · Polars · Pydantic 2 · Ruff · uv · mypy 심층 분석

"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 생태계는 다음 다섯 레이어로 정리됩니다.

핵심 통찰은 "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년 첫 릴리스 이후 20252026년에 Python 패키지 매니저 시장을 폭주적으로 잠식했습니다. Rust로 작성된 단일 바이너리이며 pip / pip-tools / virtualenv / pyenv / pipx / Poetry / PDM의 기능을 한 번에 흡수합니다. 벤치마크상 pip + venv 대비 10100배 빠르고, 캐시 기반 락 파일로 재현 가능한 설치를 제공합니다.

# 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
    name: str = Field(min_length=1, max_length=50)
    age: int = Field(ge=0, le=150)

class UserOut(BaseModel):
    id: int
    email: EmailStr
    name: str

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
import httpx

@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
    name: str

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 위에 구조화/역구조화 레이어를 얹은 도구입니다.

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)
    name: Mapped[str] = mapped_column(String(50))
    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 선택지

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

17. Polars — pandas 후계 후보

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

import polars as pl

# 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 파일을 직접 쿼리할 수 있습니다.

import duckdb, polars as pl

# 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
import pytest
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 — 구조적 동시성
import 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