Python Web Framework

동적 웹사이트, 웹 서비스 및 웹 애플리케이션의 개발을 지원하기 위해 만들어진 소프트웨어 프레임워크

정의와 목적:
웹 프레임워크는 개발자가 웹 애플리케이션을 더 빠르고 쉽게 구축할 수 있도록 도와주는 코드 라이브러리.
이는 신뢰성 있고 확장 가능하며 유지보수가 용이한 웹 애플리케이션을 구축하기 위한 기본 패턴을 제공.

주요 기능:
웹 프레임워크는 다음과 같은 일반적인 기능을 제공합니다:

유형:
웹 프레임워크는 크게 두 가지 유형으로 나눌 수 있다:

  1. 프론트엔드 프레임워크: 사용자 인터페이스(UI) 개발에 사용되며, HTML, CSS, JavaScript를 주로 사용.
  2. 백엔드 프레임워크: 서버 측 로직과 데이터베이스 상호작용을 처리.

장점:

파이썬의 웹프레임워크인 Django, Flask, FastAPI 비교

특성DjangoFlaskFastAPI
기본 정보
유형풀스택 웹 프레임워크마이크로 웹 프레임워크현대적 고성능 웹 프레임워크
철학Battery-included (모든 기능 포함)마이크로지만 확장 가능빠르고, 현대적이며, 타입 안전
첫 출시2005년2010년2018년
아키텍처 및 기술
아키텍처 패턴MTV(Model-Template-View)자유로운 구조ASGI 기반 비동기
데이터베이스 지원내장 ORM, PostgreSQL, MySQL, SQLite, Oracle 공식 지원ORM 없음 (SQLAlchemy 권장)ORM 없음 (SQLAlchemy, Tortoise-ORM 등 선택)
템플릿 엔진Django Template Language (DTL)Jinja2없음 (Jinja2 등 통합 가능)
관리자 인터페이스자동 생성 제공없음 (확장 필요)없음
성능 및 기능
API 문서화DRF 문서화 도구Swagger/OpenAPI 통합 가능OpenAPI(Swagger) 자동 생성
비동기 지원제한적 (ASGI 부분 지원)제한적완벽한 비동기 지원
성능중간 (오버헤드 존재)좋음 (최소 오버헤드)매우 높음 (Node.js 수준)
보안 기능강력한 내장 보안기본 보안, 확장 필요기본 보안, 확장 가능
개발 특성
학습 곡선가파름낮음중간
확장성중간매우 높음높음
유연성중간 (프레임워크 규칙 준수)매우 높음 (자유로운 구성)높음
개발 속도빠름 (많은 내장 기능)중간 (직접 구현 필요)빠름 (자동화 도구)
커뮤니티 및 생태계
커뮤니티 규모매우 큼큼빠르게 성장 중
써드파티 패키지매우 풍부다양함성장 중
문서화 품질우수우수우수
적합한 프로젝트
대규모 프로젝트매우 적합부적합적합
마이크로서비스부적합적합매우 적합
API 서버적합적합매우 적합
실시간 애플리케이션부적합부적합매우 적합
장단점
주요 장점- 풍부한 생태계
- 완성된 기능 제공
- 강력한 ORM
- 관리자 기능		- 가볍고 유연함
- 쉬운 학습
- 자유로운 구조
- 명확한 코드		- 최고 수준 성능
- 자동 문서화
- 비동기 처리
- 타입 안전성
주요 단점- 무거운 구조
- 유연성 제한
- 가파른 학습곡선
- 오버헤드		- 기능 직접 구현
- 구조화 작업 필요
- 대형 프로젝트 부적합
- 보일러플레이트		- 작은 생태계
- 비동기 이해 필요
- 새로운 기술
- 풀스택 기능 부족

대표적인 파이썬의 웹프레임워크

Django

기본 정보
핵심 특징
RESTful API 구현 예시
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

# Django REST Framework 예시

# 1. 설치 및 설정
'''
pip install django djangorestframework
django-admin startproject myproject
cd myproject
python manage.py startapp users
'''

# settings.py
INSTALLED_APPS = [
    ...
    'rest_framework',
    'users',
]

# users/models.py
from django.db import models

class User(models.Model):
    username = models.CharField(max_length=100, unique=True)
    email = models.EmailField(unique=True)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.username

# users/serializers.py
from rest_framework import serializers
from .models import User

class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['id', 'username', 'email', 'created_at']

# users/views.py
from rest_framework import viewsets
from .models import User
from .serializers import UserSerializer

class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer

# urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from users.views import UserViewSet

router = DefaultRouter()
router.register(r'users', UserViewSet)

urlpatterns = [
    path('api/', include(router.urls)),
]

# 실행
'''
python manage.py makemigrations
python manage.py migrate
python manage.py runserver
'''\

Flask

기본 정보
핵심 특징
RESTful API 구현 예시
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

# Flask RESTful API 예시

# 설치
'''
pip install flask flask-sqlalchemy flask-restful
'''

# app.py
from flask import Flask
from flask_restful import Api, Resource, reqparse
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///users.db'
api = Api(app)
db = SQLAlchemy(app)

# 모델 정의
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(100), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

# API 리소스
class UserResource(Resource):
    def get(self, user_id=None):
        if user_id:
            user = User.query.get_or_404(user_id)
            return {
                'id': user.id,
                'username': user.username,
                'email': user.email,
                'created_at': str(user.created_at)
            }
        users = User.query.all()
        return [{
            'id': user.id,
            'username': user.username,
            'email': user.email,
            'created_at': str(user.created_at)
        } for user in users]

    def post(self):
        parser = reqparse.RequestParser()
        parser.add_argument('username', required=True)
        parser.add_argument('email', required=True)
        args = parser.parse_args()

        user = User(username=args['username'], email=args['email'])
        db.session.add(user)
        db.session.commit()
        return {
            'id': user.id,
            'username': user.username,
            'email': user.email,
            'created_at': str(user.created_at)
        }, 201

# 라우트 등록
api.add_resource(UserResource, '/api/users', '/api/users/<int:user_id>')

if __name__ == '__main__':
    with app.app_context():
        db.create_all()
    app.run(debug=True)

FastAPI

기본 정보
핵심 특징
RESTful API 구현 예시
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

# FastAPI REST API 예시

# 설치
'''
pip install fastapi[all] sqlalchemy
'''

# main.py
from fastapi import FastAPI, HTTPException, Depends
from sqlalchemy import create_engine, Column, Integer, String, DateTime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, Session
from pydantic import BaseModel
from datetime import datetime
from typing import List, Optional

# 데이터베이스 설정
SQLALCHEMY_DATABASE_URL = "sqlite:///./users.db"
engine = create_engine(SQLALCHEMY_DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

# SQLAlchemy 모델
class UserDB(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True, index=True)
    username = Column(String, unique=True, index=True)
    email = Column(String, unique=True, index=True)
    created_at = Column(DateTime, default=datetime.utcnow)

# Pydantic 모델
class UserBase(BaseModel):
    username: str
    email: str

class UserCreate(UserBase):
    pass

class User(UserBase):
    id: int
    created_at: datetime

    class Config:
        orm_mode = True

# 데이터베이스 생성
Base.metadata.create_all(bind=engine)

# FastAPI 앱
app = FastAPI(title="User API")

# 의존성
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

# API 엔드포인트
@app.post("/api/users/", response_model=User)
async def create_user(user: UserCreate, db: Session = Depends(get_db)):
    db_user = UserDB(**user.dict())
    db.add(db_user)
    try:
        db.commit()
        db.refresh(db_user)
        return db_user
    except Exception:
        db.rollback()
        raise HTTPException(status_code=400, detail="Username or email already exists")

@app.get("/api/users/", response_model=List[User])
async def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    users = db.query(UserDB).offset(skip).limit(limit).all()
    return users

@app.get("/api/users/{user_id}", response_model=User)
async def read_user(user_id: int, db: Session = Depends(get_db)):
    user = db.query(UserDB).filter(UserDB.id == user_id).first()
    if user is None:
        raise HTTPException(status_code=404, detail="User not found")
    return user

# 실행
'''
uvicorn main:app --reload
'''

적합한 프로젝트 유형

Django

Flask

FastAPI

참고 및 출처