콩스토리

[Django] URL 단축 서비스 만들기

올콩 — Wed, 10 Jun 2026 22:29:03 +0900

Django 강의에서 URL 단축 서비스 실습을 진행했다.

URL 단축 서비스는 긴 웹 주소를 짧은 주소로 변환해 주는 서비스이다.

예를 들어 아래와 같은 긴 URL이 있다고 가정해보자.

http://www.climate-skeptic.com/2008/10/global-warming-accelerating.html

이 주소를 다음과 같이 짧게 줄일 수 있다.

https://bit.ly/x

사용자는 짧은 URL로 접속하지만, 실제로는 원래의 긴 URL로 이동하게 된다.

프로젝트 생성

먼저 URL 단축 서비스를 만들기 위한 Django 프로젝트를 생성한다.

가상환경 생성
- `python3.13 -m venv .short_url`
가상환경 활성화
- Mac: `source .short_url/bin/activate`
- Windows: `source .short_url\Scripts\activate`
Django 설치
- `pip install django`
프로젝트 디렉토리 생성
- `mkdir short_url`
Django 프로젝트 생성
- `django-admin startproject config short_url`
프로젝트로 이동
- `cd short_url`
서버 실행
- `python manage.py runserver`

앱 생성

사용자 기능과 URL 단축 기능을 분리하기 위해 두 개의 앱을 생성했다.

`python manage.py startapp user`
`python manage.py startapp shortener`

생성한 앱은 `settings.py`의 `INSTALLED_APPS`에 등록한다.

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'user.apps.UserConfig',
    'shortener.apps.ShortenerConfig',
]

CustomUser 추가

Django 프로젝트에서는 기본 User 모델을 그대로 사용할 수도 있지만, 이후 확장 가능성을 고려해서 CustomUser를 정의했다.

from django.contrib.auth.models import AbstractUser

class CustomUser(AbstractUser):
    pass

그리고 `settings.py`에 사용할 User 모델을 지정한다.

`AUTH_USER_MODEL = "user.CustomUser"`

User 모델을 변경했으면 마이그레이션을 적용해야 한다.

`python manage.py makemigrations`
`python manage.py migrate`

API 설계

URL 단축 서비스에서 사용할 기능은 다음과 같이 설계했다.

Method	URL	설명
GET	/	홈 화면, 모든 Short URL 목록
POST	/short-urls/	새로운 Short URL 생성
GET	/<str:short_url>/	원래 URL로 리디렉트
DELETE	/<str:short_url>/	Short URL 삭제

예를 들어 `http://127.0.0.1:8000/b7ea4iQ/` 주소로 접속하면 `b7ea4iQ`에 해당하는 원래 주소로 이동한다.

ShortURL 모델

URL 단축 정보를 저장하기 위해 `ShortURL` 모델을 만들었다.

import string
import random

from django.db import models

class ShortURL(models.Model):
    code = models.CharField(max_length=8, unique=True)
    original_url = models.URLField(max_length=200)
    access_count = models.PositiveIntegerField(default=0)
    created_at = models.DateTimeField(auto_now_add=True)

    # {app_label}_{클래스 이름 소문자}
    # db table: shortener_ shorturl -> short_url
    class Meta:
        app_label = "shortener"
        db_table = "short_url"
    
    @staticmethod
    def generate_code():
        characters = string.ascii_letters + string.digits
        return "".join(random.choices(characters, k=8))

`code` 필드에는 `unique=True` 적용
- 데이터베이스에 Unique 제약 조건을 생성한다는 의미
- 동일한 `code` 값을 가진 데이터가 중복 저장되지 않음

Form 사용의 한계

HTML Form 기반 요청에서는 기본적으로 `GET`과 `POST` 메서드만 사용할 수 있다.

즉, RESTful하게 설계한 아래 요청은 HTML Form만으로는 바로 보내기 어렵다.

`DELETE /<str:code>/`

그래서 브라우저에서 Form을 사용할 때는 삭제 요청을 어떻게 처리할지 고민이 필요하다.

해결 방법

1. RESTful한 API 디자인 포기하고 URL 변경

삭제 요청을 DELETE가 아니라 POST로 처리한다.

` POST /<str:code>/delete/`

HTML Form에서 `POST` 요청을 보내고, Django View에서는 이를 삭제 요청으로 처리한다.

<form method="post" action="/abc123/delete/">
  {% csrf_token %}
  <button type="submit">삭제</button>
</form>

간단하게 사용할 수 있지만, RESTful하지 않아 아쉽다.

2. Form에서 POST로 요청하고, Django에서 DELETE로 처리

Django Middleware를 사용하는 방법이다.

Form은 POST로 보내되, hidden input을 추가해서 실제 의도를 표시한다.

<form method="post" action="/abc123/">
  {% csrf_token %}
  <input type="hidden" name="_method" value="DELETE">
  <button type="submit">삭제</button>
</form>

Django에서는 _method 값을 확인해서 삭제 로직을 실행한다.

Middleware를 사용하면 요청이 View에 도달하기 전에 공통 로직을 처리할 수 있다.

예를 들어 Form에서 `_method=DELETE` 값을 보내면 Middleware가 이를 확인하고 요청 메서드를 DELETE로 바꿀 수 있다.

Django MiddleWare

Middleware는 요청과 응답 사이에서 실행되는 중간 처리 계층이다.

사용자의 요청은 View에 도달하기 전에 Middleware를 거친다.

Request → Middleware → View → Middleware → Response

따라서 로그인 확인, 보안 처리, 공통 예외 처리, 요청 데이터 가공 같은 작업을 Middleware에서 처리할 수 있다.

이번 프로젝트에서는 Form에서 보낸 _method 값을 확인해 요청 메서드를 바꾸는 용도로 활용할 수 있다.

ShortURL 삭제 처리

HTML Form은 DELETE 요청을 직접 보낼 수 없기 때문에 hidden input을 사용했다.

<form action="{% url 'short_url_detail' short_url.code %}" method="post">
    {% csrf_token %}
    <input type="hidden" name="_method" value="DELETE">
    <button type="submit" class="btn btn-danger">삭제</button>
</form>

View에서는 다음과 같이 처리할 수 있다.

class ShortURLDetailView(View):
    # localhost:8000/abc12345 -> original_url
    def get(self, request, code):
        short_url = get_object_or_404(ShortURL, code=code)    
        short_url.access_count = F("access_count") + 1
        short_url.save()  
        return redirect(short_url.original_url)

    def delete(self, request, code):
        short_url = get_object_or_404(ShortURL, code=code)
        short_url.delete()
        return redirect("home")

이렇게 하면 실제 HTTP 요청은 POST이지만, 서버에서는 삭제 요청으로 해석할 수 있다.

[참고] 실전! Django 입문 강의

[Django] Kakao 소셜 로그인

올콩 — Tue, 9 Jun 2026 22:15:16 +0900

일반 회원가입은 사용자가 아이디와 비밀번호를 직접 생성해야 한다.

하지만 최근 대부분의 서비스는 Google, Kakao, Naver 같은 외부 플랫폼 계정을 이용해 간편하게 로그인할 수 있는 기능을 제공한다.

소셜 로그인(Social Login)

사용자가 별도의 회원가입 없이 이미 가입된 서비스의 계정을 사용하여 웹사이트나 애플리케이션에 로그인할 수 있도록 지원하는 인증 방식
Google, Facebook, Naver, Kakao 등의 계정을 통해 다른 서비스에 접속

소셜 로그인 동작 과정

1. 사용자 동의 과정

사용자가 "카카오 로그인" 버튼을 클릭하면 카카오 로그인 페이지로 이동한다.

class KakaoSocialLoginView(View):
    def get(self, request):
        return redirect(
            f"https://kauth.kakao.com/oauth/authorize"
            f"?client_id={settings.KAKAO_REST_API_KEY}"
            f"&redirect_uri={settings.KAKAO_CALLBACK_URL}"
            f"&response_type=code"
        )

이때 사용자는 카카오에게 다음과 같은 동의를 요청받는다.

이메일 정보 제공
프로필 정보 제공
기타 서비스에서 필요한 정보

사용자가 동의하면 카카오는 우리 서비스가 지정한 Callback URL로 이동시킨다.

2. 사용자 정보 조회

사용자가 동의했다고 해서 바로 사용자 정보를 받을 수 있는 것은 아니다.

OAuth 인증 과정에서는 다음 두 가지 개념이 등장한다.

인가 코드(authorization code)
- 사용자의 정보 조회 권한 요청이 성공했다는 것을 확인하는 임시 중개 수단
- 예시: `http://localhost:8000/users/social/kakao/callback/?code=abcd1234`
  - 여기서 `code` 값이 인가 코드
access token
- 소셜 인증 제공자(Kakao) 서버에 API 요청을 할 수 있는 권한 제공
auth code와 access token을 분리하는 이유
- auth code를 access token으로 교환하는 과정은 인증 서버와의 직접적인 통신으로 이루어지기 때문에 access token 탈취 위험 감소
- auth code는 일회성으로 사용되고 짧은 시간만 유효
- access token이 브라우저에 직접 노출되는 것을 방지하여 보안성 높아짐

사용자
↓
Authorization Code
↓
우리 서버
↓
Access Token 요청
↓
카카오 서버

3. 회원가입 및 로그인

이제 받은 사용자 정보를 기반으로 회원가입 또는 로그인을 수행한다.

카카오 사용자 ID를 기반으로 사용자명을 생성
이미 가입된 사용자라면 바로 로그인
회원이 존재하지 않는 경우 새 계정 생성
비밀번호는 사용자가 직접 입력하지 않기 때문에 임의의 값을 생성하여 저장
Django Session이 생성되면서 로그인 상태가 유지

class KakaoSocialCallbackView(View):
    def get(self, request):
        # kakao -> django
        auth_token = request.GET.get("code")

        # access_token 교환
        response = requests.post(
            "https://kauth.kakao.com/oauth/token",
            data={
                "grant_type": "authorization_code",
                "client_id": settings.KAKAO_REST_API_KEY,
                "redirect_uri": settings.KAKAO_CALLBACK_URL,
                "code": auth_token,
            },
            headers={
                "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8"
            }
        )

        if response.ok:
            access_token = response.json().get("access_token")

            # 사용자의 카카오 프로필 조회
            profile_response = requests.get(
                "https://kapi.kakao.com/v2/user/me",
                headers={
                    "Authorization": f"Bearer {access_token}"
                }
            )

            if profile_response.ok:
                # 사용자 프로필 정보 => 회원가입/로그인
                kakao_user_id = profile_response.json()["id"]
                username = f"K#{kakao_user_id}"

                try:
                    # 기존 회원 여부
                    user = User.objects.get(username=username)
                except User.DoesNotExist:
                    # 새로 회원가입
                    email = profile_response.json()["kakao_account"]["email"]
                    user = User.objects.create_user(
                        username=username,
                        email=email,
                        password=str(uuid.uuid4()),
                        social_provider="kakao",
                    )
                
                login(request, user)
                return redirect("home")

        return JsonResponse({"error": "Social login failed."})

카카오 애플리케이션 등록

카카오 로그인을 사용하려면 먼저 카카오 애플리케이션을 생성해야 한다.

카카오 개발자 사이트: https://developers.kakao.com/

Kakao Developers

카카오 API를 활용하여 다양한 어플리케이션을 개발해 보세요. 카카오 로그인, 메시지 보내기, 친구 API, 인공지능 API 등을 제공합니다.

developers.kakao.com

필수 설정

애플리케이션 생성
카카오 로그인 활성화
Redirect URI 등록
이메일 동의 항목 설정
- 비즈앱 전환 필요
REST API 키 복사

[참고] 실전! Django 입문 강의

[Django] 장고 회원 시스템 (Session과 User Model)

올콩 — Mon, 8 Jun 2026 00:02:14 +0900

Django Session

Django는 로그인 상태를 유지하기 위해 Session 기능을 제공한다.

Session은 사용자의 상태 정보를 서버에 저장하여 HTTP의 무상태성(Stateless)을 해결하는 역할을 한다.

HTTP의 무상태성(stateless)

서버가 클라이언트의 이전 요청에 대한 상태 정보를 저장하지 않는 특성
각 요청은 독립적이며, 서버는 요청마다 클라이언트를 식별할 수 있어야 함

HTTP는 기본적으로 상태를 저장하지 않는 프로토콜이다.

즉, 서버는 이전 요청을 기억하지 않는다.

예를 들어 사용자가 로그인 요청을 보냈다고 가정해 보자.

1. 로그인 요청
2. 메인 페이지 요청
3. 마이페이지 요청

각 요청은 서로 독립적으로 처리된다.

따라서 별도의 방법이 없다면 서버는 현재 요청을 보낸 사용자가 누구인지 알 수 없다.

이러한 특징을 HTTP의 무상태성(Stateless)이라고 한다.

Session의 역할

Session은 사용자의 상태 정보를 서버에 저장한다.

로그인에 성공하면 Django는 Session을 생성하고 사용자 정보를 저장한다.

login(request, user)

위 코드를 실행하면 Django가 자동으로 Session을 생성한다.

이후 사용자가 다른 페이지를 요청할 때 Session 정보를 확인하여 로그인 상태를 유지할 수 있다.

request.user

덕분에 사용자는 매 요청마다 아이디와 비밀번호를 입력하지 않아도 된다.

User Model 확장

Django는 기본 User 모델을 제공한다.

하지만 실제 서비스를 개발하다 보면 기본 User 모델만으로는 부족한 경우가 많다.

예를 들어 다음과 같은 요구사항이 생길 수 있다.

프로필 이미지 추가
전화번호 추가
닉네임 추가
생년월일 추가
이메일을 로그인 ID로 사용

이처럼 사용자 정보를 확장해야 하는 경우가 많다.

AbstractUser

Django는 User Model 확장을 위해 AbstractUser를 제공한다.

Custom User를 만들 때는 기본 User 모델을 직접 수정하는 것이 아니라 AbstractUser를 상속받아 새로운 모델을 정의한다.

InconsistentMigrationHistory 에러 발생

이미 프로젝트 전체에 기본 User를 사용하도록 적용되어 있기 때문에 프로젝트 중간에 User 모델을 변경하는 것은 매우 까다롭다.

쉬운 해결법: 데이터베이스 삭제하고 처음부터 다시 생성
- db.sqlite3 파일 삭제 후, 다시 mgirate

그렇기에 새로운 Django 프로젝트 생성 시, User 모델 확장이 필요하지 않더라도 미래의 혹시 모를 변경을 위해 CustomUser를 정의하는 것을 권장한다.

from django.contrib.auth.models import AbstractUser

class CustomUser(AbstractUser):
    pass

[참고] 실전! Django 입문 강의

[Django] 장고 회원 시스템 (User 모델과 Admin 페이지)

올콩 — Sun, 7 Jun 2026 15:45:08 +0900

장고는 기본적으로 회원 시스템이 기본적으로 제공된다.

장고는 로그인, 로그아웃, 회원가입, 비밀번호 관리 같은 기능을 위한 인증(Authentication) 시스템을 내장하고 있다.

장고의 기본 User 모델과 관리자 페이지(Admin)에 대해 알아보자.

Django User

장고는 기본적으로 회원 시스템을 내장
- 로그인, 로그아웃, 회원가입, 비밀번호 변경 같은 기능 제공
User Model
- `from django.contrib.auth.models import User`

User 모델

필드명	설명
username	사용자 ID
email	이메일 주소
password	암호화된 비밀번호
is_staff	관리자 여부
is_superuser	슈퍼 관리자 여부
is_active	계정 활성화 여부
date_joined	계정 생성일
last_login	마지막 로그인 시간

비밀번호

User 모델의 password 필드는 비밀번호를 그대로 저장하지 않고 해시(hash)된 값을 저장
- ` pbkdf2_sha256$...`
- 관리자도 실제 비밀번호 확인 불가
AUTH_PASSWORD_VALIDATORS
- 비밀번호 검증 기능 (조건)
- 비밀번호 길이, 흔한 비밀번호, 숫자로만 이루어진 비밀번호, 사용자 정보와 지나치게 유사한 비밀번호 등

일반 사용자 / 관리자 / 슈퍼 관리자

사용자를 권한에 따라 구분

일반 사용자

서비스에 가입한 일반 회원
로그인, 로그아웃, 게시글 작성, 댓글 작성 등 서비스에서 허용한 기능 사용

관리자 (staff)

`is_staff=True`인 사용자
Django Admin 페이지에 접근 가능
모든 권한을 가지는 것은 아니고 모델별로 권한 별도 부여 가능

슈퍼 관리자 (superuser)

`is_superuser=True`인 Django의 최고 권한 사용자
모든 모델에 대한 조회, 생성, 수정, 삭제 권한 소유
슈퍼 유저 생성 명령어: `python manage.py createsuperuser`

Django Admin

관리자 페이지 기본 제공
서버 실행 후 다음 주소로 접속 가능
- `http://localhost:8000/admin/`

데이터베이스를 직접 확인 하지 않아도 조회, 생성, 수정, 삭제 작업 수행 가능

[참고] 실전! Django 입문 강의

[Python] 프로그래머스 42576번: 완주하지 못한 선수 (Lv.1)

올콩 — Sat, 6 Jun 2026 13:34:59 +0900

Problem

문제 보러 가기

수많은 마라톤 선수들이 마라톤에 참여하였습니다. 단 한 명의 선수를 제외하고는 모든 선수가 마라톤을 완주하였습니다.

마라톤에 참여한 선수들의 이름이 담긴 배열 participant와 완주한 선수들의 이름이 담긴 배열 completion이 주어질 때, 완주하지 못한 선수의 이름을 return 하도록 solution 함수를 작성해주세요.

제한사항

마라톤 경기에 참여한 선수의 수는 1명 이상 100,000명 이하입니다.
completion의 길이는 participant의 길이보다 1 작습니다.
참가자의 이름은 1개 이상 20개 이하의 알파벳 소문자로 이루어져 있습니다.
참가자 중에는 동명이인이 있을 수 있습니다.

입출력 예

participant	completion	return
["leo", "kiki", "eden"]	["eden", "kiki"]	"leo"
["marina", "josipa", "nikola", "vinko", "filipa"]	["josipa", "filipa", "marina", "nikola"]	"vinko"
["mislav", "stanko", "mislav", "ana"]	["stanko", "ana", "mislav"]	"mislav"

입출력 예 설명

예제 #1

"leo"는 참여자 명단에는 있지만, 완주자 명단에는 없기 때문에 완주하지 못했습니다.

예제 #2

"vinko"는 참여자 명단에는 있지만, 완주자 명단에는 없기 때문에 완주하지 못했습니다.

예제 #3

"mislav"는 참여자 명단에는 두 명이 있지만, 완주자 명단에는 한 명밖에 없기 때문에 한명은 완주하지 못했습니다.

✏️ Solution

내가 푼 방식 (정렬 후 비교)

def solution(participant, completion):
    participant.sort()
    completion.sort()
    
    for i in range(len(completion)):
        if participant[i] != completion[i]:
            return participant[i]
    return participant[-1]

정렬하면 같은 이름끼리 같은 위치에 오게 되기 때문에 앞에서부터 비교했을 때 끝까지 같으면 마지막 참가자가 미완주자, 중간에 다르면 그 위치의 참가자가 미완주자이다.

다른 방식 (hash)

def solution(participant, completion):
    temp = 0
    dic = {}
    
    for p in participant:
        dic[hash(p)] = p
        temp += hash(p)
        
    for c in completion:
        temp -= hash(c)

    return dic[temp]

참가자 이름들의 hash 값을 전부 더하고, 완주자 이름들의 hash 값을 전부 빼면, 남는 값이 미완주자 이름의 hash 값이 된다.

hash("eden") + hash("kiki") + hash("leo")
- hash("eden") - hash("kiki")
= hash("leo")

다른 방식 (딕셔너리 카운팅)

from collections import Counter

def solution(participant, completion):
    return list((Counter(participant) - Counter(completion)).keys())[0]

Counter를 써서 참가자 명단에서 완주자 명단을 빼면, 남는 값이 미완주자이다.

[Django] Function-Based View와 Class-Based View

올콩 — Thu, 4 Jun 2026 22:06:52 +0900

Django에서 View는 사용자의 요청을 받아 처리하고 응답을 반환하는 역할을 한다.

이전 글에서는 함수를 사용하여 View를 작성하는 Function-Based View(FBV)를 살펴보았다.

이번에는 Function-Based View의 한계와 이를 개선하기 위해 등장한 Class-Based View(CBV)에 대해 알아보자.

Function-Based View(FBV)

함수를 사용하여 View를 작성하는 방식
하나의 함수에서 두 가지 이상의 기능 처리(GET, POST 등)
쉬우나 코드가 길어지고 복잡도 증가

from django.shortcuts import render

def post_create_view(request):
    if request.method == "GET":
        return render(request, "post_create.html")

    elif request.method == "POST":
        # 게시글 저장 로직
        ...

Classed-based View

객체지향 프로그래밍(OOP)의 상속과 메서드 오버라이딩 활용
코드 중복을 줄이고 재사용 가능성 높임
HTTP 메서드 별로 기능을 명시적으로 분리

class LoginRequiredView(View):
    def dispatch(self, request, *args, **kwargs):
        # 로그인 검사 ...
        
class PostCreateView(LoginRequiredView):
    def get(self, request):
        return render(request, "post_create.html")
        
    def post(self, request):
        # 저장 ...

HTTP 메서드별(`get()`, `post()` 등)로 로직을 명확하게 분리할 수 있다.

공통 로직을 부모 클래스에 작성하여 다른 View에서 상속받아 사용할 수 있다.

-> 중복 코드 줄이고 유지보수성 up

[참고] 실전! Django 입문 강의

[Django] 좋아요 기능 구현과 F Expression

올콩 — Wed, 3 Jun 2026 22:55:09 +0900

좋아요 기능은 단순히 게시글의 좋아요 수를 1 증가시키는 기능이다.

하지만 여러 사용자가 동시에 좋아요를 누를 수 있기 때문에 단순히 Python 코드에서 `+= 1`을 사용하는 방식은 주의가 필요하다.

좋아요 View 구현

def post_like_view(request, post_id):
    post = get_object_or_404(Post, id=post_id)
    
    post.points = F("points") + 1 # post.points = F()
    post.save()
    
    post.refresh_from_db()
    
    return render(
        request, template_name="post_detail.html", context={"post": post}
    )

get_object_or_404()

` post = get_object_or_404(Post, id=post_id)`

데이터가 존재하지 않으면 DoesNotExist 예외를 직접 처리하지 않고, 자동으로 404 응답 반환

F Expression

`F()`: Django에서 제공하는 표현식

Python에서 값을 계산하는 것이 아니라 데이터베이스에서 직접 값을 계산하도록 SQL을 만들어줌

post.points = F("points") + 1
post.save()

# 위 코드는 아래와 유사하게 동작

UPDATE post
SET points = points + 1
WHERE id = 1;

경쟁 상태(Race Condition)

두 개 이상의 프로세스나 스레드가 공유 자원(데이터, 파일 등)에 접근하여 이를 읽거나 쓰는 과정에서 실행 순서에 따라 예상치 못한 결과가 발생하는 상황

만약, 사용자 A와 사용자 B가 동시에 좋아요를 누를 경우, 둘 다 동일한 값을 읽어 +1을 했기 때문에 계산이 누락될 수 있다.

`F()`를 사용하면 Python에서 값을 읽고 계산하는 것이 아니라, 데이터베이스가 직접 현재 값을 기준으로 증가시키므로 동시에 요청이 들어와도 안전하다.

refresh_from_db()

`F()`를 사용해 저장한 직후에는 Python 객체의 post.points 값이 실제 숫자가 아니라 F("points") + 1 표현식 상태로 남아 있을 수 있다.

따라서 변경된 값을 다시 확인하거나 템플릿에 최신 값을 넘기려면 데이터베이스에서 값을 다시 가져와야 하는데 `refresh_from_db()`를 사용한다.

이 코드를 실행하면 DB에 저장된 최신 값으로 post 객체가 갱신된다.

[참고] 실전! Django 입문 강의

[Django] ORM으로 데이터 생성, 조회, 수정, 삭제(CRUD) 해보기

올콩 — Tue, 2 Jun 2026 22:45:01 +0900

ORM(Object-Relational Mapping)

데이터베이스의 테이블을 Python 객체처럼 다룰 수 있도록 도와주는 기술
편리한 데이터베이스 스키마(테이블, 컬럼 등) 생성/수정/삭제 지원
Python을 통해 데이터를 쉽게 조회/변경할 수 있도록 지원

ORM의 장점

SQL 직접 작성 X
데이터베이스 종류에 크게 의존 X
Python 코드로 데이터를 쉽게 조회, 생성, 수정, 삭제 가능
데이터베이스 스키마 관리 편리

Django Shell 실행

`python manage.py shell`
shell: Django 프로젝트 환경이 적용된 Python 콘솔

기존 모델 참고

class Post(models.Model):
    title = models.CharField(max_length=128)
    body = models.CharField(max_length=1024)
    author_name = models.CharField(max_length=32)
    points = models.PositiveIntegerField(default=0)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return f"{self.id}, {self.title}"

ORM QuerySet

Django ORM에서 데이터를 조회하면 대부분 QuerySet 반환
- ` >>> Post.objects.all()`
- `<QuerySet [...]>`
iterable하므로 반복 가능한 형태
Lazy Loading(지연 로딩) 사용
- 값이나 객체의 계산을 우리가 실제로 필요할 때까지 연기하는 프로그래밍 기법
- 생성되는 즉시 SQL를 실행하지 않고 실제로 데이터가 필요할 때 쿼리 실행

QueryDict

요청 데이터를 담는 객체

	QuerySet	QueryDict
역할	DB 조회 결과	HTTP 요청 데이터
사용 위치	ORM(Model)	View(Request)
생성 주체	Django ORM	Django Request
예시	Post.objects.filter()	request.GET, request.POST
담고 있는 것	Model 객체들	사용자가 보낸 데이터

데이터 생성(Create)/조회(Read)

$ python manage.py shell
13 objects imported automatically (use -v 2 for details).

Python 3.13.12 (tags/v3.13.12:1cbe481, Feb  3 2026, 18:22:25) [MSC v.1944 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)

# Model 가져오기
>>> from post.models import Post

# 전체 게시글 조회
>>> Post.objects.all()
<QuerySet []>

# 새로운 게시글 생성
>>> new_post = Post(title="제목", body="본문", author_name="작성자")

# 결과: 데이터 없음
>>> new_post
<Post: Post object (None)>
>>> Post.objects.all()
<QuerySet []>

# 객체 생성했다고 데이터베이스에 저장되지 않음
# save()로 데이터 저장 필요
>>> new_post.save()
>>> Post.objects.all()
<QuerySet [<Post: Post object (1)>]>

# Primary Key 자동 생성 (id와 pk는 동일)
>>> new_post.id
1
>>> new_post.pk
1

# 저장 전에는 id(pk) 존재하지 않음
# save()가 실행되는 순간 데이터베이스에서 발급
>>> new_post_2 = Post(title="제목2", body="본문2", author_name="작성자2")
>>> new_post_2.id
>>> new_post_2.id is None
True

ORM 데이터 수정(Update)

$ python manage.py shell
13 objects imported automatically (use -v 2 for details).

Python 3.13.12 (tags/v3.13.12:1cbe481, Feb  3 2026, 18:22:25) [MSC v.1944 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)

>>> from post.models import Post
>>> Post.objects.all()
<QuerySet [<Post: 1, 제목>]>
>>> Post.objects.all()[0]
<Post: 1, 제목>

# 조건에 맞는 데이터 조회
>>> Post.objects.get(id=1)
<Post: 1, 제목>
>>> post = Post.objects.get(id=1)
>>> post
<Post: 1, 제목>

# 데이터 수정
>>> post.title
'제목'
>>> post.title="새로운 제목"
>>> post.title
'새로운 제목'
>>> post.save()
>>> post = Post.objects.get(id=1)
>>> post.title
'새로운 제목'
>>> post
<Post: 1, 새로운 제목>

# 자동 생성된 값 확인
>>> post.points
0
>>> post.created_at
datetime.datetime(2026, 5, 30, 19, 25, 35, 223307, tzinfo=datetime.timezone.utc)

ORM 데이터 조회(filter)

조건에 맞는 데이터를 조회할 때 사용
Post.objects.filter(title="새로운 제목")
`startswith`: 특정 문자열로 시작하는 조회
- Post.objects.filter(title__startswith="새")
`lt`: Less Than, 미만
- Post.objects.filter(points__lt=10)
`gte`: Greater Than or Equal, 이상
- Post.objects.filter(points__gte=10)

get()과 filter()의 차이

`get()`: 조건에 맞는 데이터를 하나만 조회
- `post = Post.objects.get(id=1)`
- 객체(Object) 반환
- 조건에 맞는 데이터가 반드시 1개여야 함(2개 이상이면 예외 발생)
- 데이터가 없으면 예외 발생(DoesNotExist)
- 즉시 쿼리 실행
`filter()`: 조건에 맞는 데이터를 조회
- QuerySet 반환
- 데이터가 여러 개여도 가능
- 데이터가 없어도 예외 발생 X
- Lazy Loading

ORM 데이터 삭제(Delete)

`post.delete()`
조건에 맞는 데이터 여러 개 삭제: `Post.objects.filter(title="제목").delete()`

ORM과 SQL 비교

ORM	SQL
Post.objects.all()	SELECT * FROM post
Post.objects.get(id=1)	SELECT * FROM post WHERE id=1
Post.objects.filter(title="제목")	SELECT * FROM post WHERE title='제목'
post.save()	INSERT 또는 UPDATE
post.delete()	DELETE FROM post

[참고] 실전! Django 입문 강의

[Django] 장고 Model과 Migration 이해하기

올콩 — Mon, 1 Jun 2026 23:10:50 +0900

Django Model

데이터베이스의 테이블을 Python 클래스로 표시한 것 (테이블 구조 정의)

예를 들어 게시글 데이터를 저장할 때,

게시글에는 <제목, 본문, 작성자 이름, 좋아요 수, 생성 시간> 등의 정보가 필요

이러한 정보를 데이터베이스에 저장하기 위해 모델을 사용

Django 모델 생성 방법

models.Model을 상속받아 class 정의
타입에 맞는 field를 통해 속성 정의

from django.db import models

# 게시물
# - 제목, 본문, 작성자 이름, 좋아요 개수, 게시물 생성 시간

class Post(models.Model):
    title = models.CharField(max_length=128)
    body = models.CharField(max_length=1024)
    author_name = models.CharField(max_length=32)
    points = models.PositiveIntegerField(default=0)
    created_at = models.DateTimeField(auto_now_add=True)
    
    def __str__(self): # 모델 객체를 문자열로 출력
        return f"{self.id}, {self.title}"

Migration 생성

데이터베이스의 스키마(테이블 구조 등)를 관리하는 데 사용되는 파일
모델의 변화를 파일을 통해 순차적으로 기록
migration 생성 방법: `python manage.py makemigrations`
migrate 명령어를 통해 데이터베이스를 특정 상태로 변경하거나 이전 상태로 롤백

`makemigrations`를 실행하면 장고가 모델의 변경 사항을 감지하여 Migration 파일 생성

post/
└── migrations/
└── 0001_initial.py

데이터베이스에 반영

Migration 파일 생성 후 실제로 데이터베이스에 적용하려면 migrate 실행 필요
- `python manage.py migrate`

Migration 동작 과정

Model 작성
↓
makemigrations
↓
Migration 파일 생성
↓
migrate
↓
DB 테이블 생성

[참고] 실전! Django 입문 강의

[Django] 장고 App 생성과 등록

올콩 — Sun, 31 May 2026 06:55:54 +0900

Django Project와 App의 차이

Project: 하나의 웹 서비스
App: 프로젝트 안에서 특정 기능을 담당하는 모듈

Project (게시판 서비스)
├── user App      (회원 관리)
├── post App      (게시글 관리)
├── comment App   (댓글 관리)
└── chat App      (채팅 기능)

Django App 생성

`python manage.py startapp post`
앱(app): Django 프로젝트 내에서 특정 기능을 담당하는 독립적인 모듈
프로젝트를 어떻게 논리적으로 구성할 건지에 따라서 앱 생성
- 예: user(회원 관리) 앱, post(게시글 관리) 앱 등

Django App 구조

post/ (앱 디렉토리)
├── __init__.py
├── admin.py (관리자 기능 설정 파일)
├── apps.py (앱의 메타데이터와 설정 값을 정의하는 파일)
├── migrations/    (데이터베이스 스키마 변경 내역 디렉토리)
│   └── __init__.py
├── models.py   (데이터베이스 테이블을 정의하는 파일)
├── tests.py
└── views.py (웹 요청에 대한 응답을 처리하는 파일)

Django App 생성 후 작업

App을 생성했다고 바로 사용할 수 있는 것은 아니고 Django가 해당 App을 인식할 수 있도록 등록 필요

1️⃣ settings.py에 App 등록

settings.py 안의 INSTALLED_APPS에 AppConfig 추가
- Django가 앱을 인식하고 그 앱에 대한 여러 기능들을 활성화
- INSTALLED_APPS: Django 프로젝트에서 사용하는 애플리케이션을 관리하는 목록

# settings.py

INSTALLED_APPS = [
    'django.contrib.admin',          # 관리자 사이트
    'django.contrib.auth',           # 인증 시스템
    'django.contrib.contenttypes',   # 콘텐츠 타입 프레임워크
    'django.contrib.sessions',       # 세션 관리
    'django.contrib.messages',       # 메시징 프레임워크
    'django.contrib.staticfiles',    # 정적 파일 관리
    'post.apps.PostConfig',          # Post 앱
]

Django는 `INSTALLED_APPS`에 등록된 App만 관리한다.

등록해야 다음 기능들이 동작한다.

Model 인식
Migration 생성
Admin 등록
Template 탐색
Static 파일 관리

2️⃣ view 작성

Django View

웹 애플리케이션의 비즈니스 로직을 처리하는 부분
클라이언트의 요청을 받아서 적절한 응답을 반환하는 역할
(Spring의 Controller 역할)

<클라이언트-서버> 모델

작업을 요청하는 클라이언트와 요청을 처리하고 결과를 제공하는 서버의 상호작용
- 요청: 게시물 조회, 회원가입, 로그인과 같이 서버의 특정 데이터를 요청하는 과정
- HTTP: 웹상에서 인터넷을 통해 데이터를 주고받는 규칙

사용자가 회원가입 버튼을 클릭하거나 상세 정보를 보기 위해 게시글을 클릭하는 등의 액션을 취했을 때 이런 사용자의 신호를 클라이언트가 감지해서 사용자를 대신해 의도에 맞는 HTTP 요청을 서버로 전송
서버는 요청에 맞는 처리를 한 뒤 HTTP 응답을 통해 요청의 결과를 클라이언트에게 전송
- 요청에 맞는 처리: 회원가입의 경우 사용자가 보낸 아이디와 비밀번호를 데이터베이스의 저장하여 사용자를 기록하는 과정

[참고] 실전! Django 입문 강의