장고(django)의 ORM(Object-Relational Mapping)을 사용하여 데이터를 생성하고 읽고 갱신하고 삭제하는 방법(CRUD - Create Read Update Delete)에 대해서 알아봅시다.


1. 개요

장고(django)의 ORM(Object-Relational Mapping)을 사용하여 데이터베이스에 데이터를 생성(Create)하고, 읽고(Read), 갱신(Update)하고, 삭제(Delete)하는 방법(CRUD - Create Read Update Delete)에 대해서 알아봅니다.

이 블로그는 시리즈로 작성되어 있으며, 아래에 링크를 통해 시리즈의 다른 글을 확인할 수 있습니다.

또한 이 블로그 시리즈에서 다룬 소스는 github에 공개되어 있습니다. 아래에 링크를 통해 확인 가능합니다.


2. ORM이란?

ORM(Object-Relation Mapping)란, 객체(Object)와 관계형 데이터베이스(Relational)을 연결(Mapping)해 주는 것을 의미한다. 간단하게 설명하면 데이터베이스의 테이블을 객체(Object)와 연결하여 테이블에 CRUD를 할 때, SQL 쿼리를 사용하지 않고도, 가능하게 하는 것을 말합니다.

 

우리는 이전 블로그(장고(django) 모델(models) 사용해보기)를 통해 이미 장고(django)의 ORM(Object-Relational Mapping)을 사용하기 위한 준비를 하였습니다. 이전 블로그에서 생성한 Post 모델(Models)은 데이터베이스의 blog_post 테이블과 연결(Mapping)되어 있습니다. 우리는 이 모델(Models)을 사용하여 데이터베이스에 CRUD을 함으로써 장고(django)의 ORM(Object-Relational Mapping)을 이해해 보도록 하겠습니다.

아래에 장고(django) 명령어를 통해 장고(django)가 기본적으로 제공하는 쉘(Shell)을 실행 시킵니다.

# source venv/bin/activate
# cd django_exercise
python manage.py shell

 

아래에 코드로 우리가 이전 블로그에서 만든 Post 모델(Models)을 가져옵니다.

>>> from blog.models import Post

 

 

(1) 데이터 조회(Read)

아래에 코드로 Post의 내용을 조회(Read)합니다.

Post.objects.all()

 

정상적으로 실행되었다면 아래와 같은 결과를 볼 수 있습니다.

>>> Post.objects.all()
<QuerySet [<Post: this is a test1 title>, <Post: this is a test2 title>]>

 

나중에 사용하기 위해, 아래에 코드로 사용자(User) 모델(Models)을 가져오고, 데이터를 조회(Read)하여 변수에 저장합니다.

>>> from django.contrib.auth.models import User
>>> admin = User.objects.get(username='dev-yakuza')

 

(2) 데이터 생성(Create)

아래에 코드를 실행하여 Post의 새로운 데이터를 생성(Create)해 봅니다.

Post.objects.create(author=admin, title='This is a test title from django shell', content='This is a test title from django shell. This is a test title from django shell.')

 

정상적으로 실행되었다면 아래와 같은 결과를 볼 수 있습니다.

>>> Post.objects.create(author=admin, title='This is a test title from django shell', content='This is a test title from django shell. This is a test title from django shell.')
<Post: This is a test title from django shell>

 

(3) 데이터 생성 확인

다시 한번 Post 모델(Models)을 조회하면 아래와 같이 데이터가 잘 추가된 것을 확인 할 수 있습니다.

>>> Post.objects.all()
<QuerySet [<Post: this is a test1 title>, <Post: this is a test2 title>, <Post: This is a test title from django shell>]>

 

새로운 터미널에서 아래에 장고(django) 명령어로 테스트 서버를 실행한 후,

관리자 화면에서 데이터를 확인하면 아래와 같이 데이터가 잘 추가된 것을 확인할 수 있습니다.

# source venv/bin/activate
# cd django_exercise
python manage.py runserver

 

데이터베이스 툴을 사용하여 확인해도 아래와 같이 저장이 잘 된 것을 확인할 수 있습니다.

 

(4) 데이터 업데이트(Update)

아래에 코드로 데이터를 조회(Read)하고 업데이트(Update) 해 봅니다.

post = Post.objects.get(title='This is a test title from django shell')
post.title = 'This is a test title updated from django shell'
post.save()

 

아래에 코드로 업데이트된 내용을 확인할 수 있습니다.

Post.objects.get(title__contains='updated')
# or
Post.objects.filter(title__contains='updated')

 

또한 이전 블로그에서 작성한 Post 모델(Models)의 함수를 통해서도 업데이트가 가능합니다.

post = Post.objects.get(title__contains='updated')
# post.published_at
post.publish()
# >>> post.published_at
# datetime.datetime(2019, 5, 21, 13, 1, 58, 970677)

 

(5) 데이터 삭제(Delete)

아래에 코드로 위에서 만든 데이터를 삭제(Delete)해 봅니다.

post = Post.objects.get(title__contains='updated')
post.delete()
# >>> Post.objects.all()
# <QuerySet [<Post: this is a test1 title>, <Post: this is a test2 title>]>

 

(6) 조회 조건

지금까지 데이터베이스의 CRUD(Create Read Update Delete)에 대해서 살펴보았습니다.

아래는 데이터를 조회(Read)할 때 사용할 수 있는 일반적인 검색 조건에 대해서 설명하고 있습니다.

 

- 조회 조건

 

조회 조건설명사용 방법

__contains 지정한 문자열을 포함하는 데이터 조회 Post.objects.filter(title__contains=’test’)
__icontains 지정한 문자열의 대소문자 구분없이 포함하는 데이터 조회 Post.objects.filter(title__icontains=’this’)
__lt 값이 작은 경우(lt: less than) Post.objects.filter(published_at__lt=timezone.now())
__lte 값이 작거나 같은 경우(lte: less than or equal) Post.objects.filter(published_at__lt=timezone.now())
__gt 값이 큰 경우(gt: greater than) Post.objects.filter(published_at__gt=timezone.now())
__gte 값이 크거나 같은 경우(gt: greater than or equal) Post.objects.filter(published_at__gte=timezone.now())
__in 주어진 리스트에 포함되는 데이터 조회 Post.objects.filter(id__in=[1, 2, 3])
__year 해당 년도 조회 Post.objects.filter(created_at__year=’2019’)
__year 해당 월로 조회 Post.objects.filter(created_at__month=’5’)
__day 해당 일로 조회 Post.objects.filter(created_at__day=’21’)
__isnull 해당 열이 null인 데이터 조회 Post.objects.filter(published_at__isnull=True)
__startswith 해당 문자열로 시작하는 데이터 조회 Post.objects.filter(title__startswith=’This’)
__istartswith 대소문자를 가리지 않고 해당 문자열로 시작하는 데이터 조회 Post.objects.filter(title__istartswith=’this’)
__endswith 해당 문자열로 끝나는 데이터 조회 Post.objects.filter(title__endswith=’title’)
__iendswith 대소문자를 가리지 않고 해당 문자열로 끝나는 데이터 조회 Post.objects.filter(title__iendswith=’title’)
__range 범위를 지정하여 조회(sql의 between) Post.objects.filter(id__range=(1, 10))

 

- 제외 조건(exclude): 아래와 같이 특정 조건을 제외한 데이터를 조회할 수 있다.

Post.objects.all().exclude(title__contains='This')

 

- 여러 조건으로 조회: 아래와 같이 여러 조건을 걸어 데이터를 조회할 수 있다.

Post.objects.filter(title__contains='this', title__endswith='title')
Post.objects.filter(title__contains='this').filter(title__endswith='title')

from django.db.models import Q
Post.objects.filter(Q(title__contains='this') | Q(title__endswith='title'))
Post.objects.filter(Q(title__contains='this') & Q(title__endswith='title'))

 

- 조회 범위: 아래와 같이 가져올 데이터의 범위(limit)을 지정할 수 있다.

Post.objects.all().exclude(title__contains='This')[:1]

 

(7) 정렬

아래와 같이 조회할 데이터를 오름차순 또는 내림차순으로 정렬할 수 있습니다.

  • 오름 차순: Post.objects.order_by(‘created_at’)
  • 내림 차순: Post.objects.order_by(‘-created_at’)

 

(8) 쉘(Shell) 종료

지금까지 장고(django)의 쉘(Shell)을 이용하여 간단하게 장고(django)의 ORM(Object-Relational Mapping)에 대해서 연습해 보았습니다. 아래에 코드로 장고(django)의 쉘(Shell)을 종료합니다.

exit()

 

(9) 완료

이것으로 장고(django)의 ORM(Object-Relational Mapping)에 대해 알아보았습니다.

ORM(Object-Relational Mapping)은 장고(django)이외에도 많은 프레임워크에서 사용되는 개념이므로 잘 기억에 두면 좋을거 같네요. 이것으로 우리는 장고(django)의 모델(Models)을 사용하여 데이터를 읽고 쓰고 업데이트하고 삭제(CRUD - Create Read Update Delete)할 수 있게 되었습니다!


출처

https://dev-yakuza.posstree.com/ko/django/admin/

장고(django)의 URL 관리 기능을 사용하여 웹 서비스의 라우팅(Routing)을 관리해 봅시다.


1. 개요

이제 본격적으로 장고(django)를 사용하여 웹 서비스를 작성하려고 합니다.

웹 서비스를 작성하려면 사용자가 접속하는 URL별 페이지를 만들고 그 페이지를 서비스할 필요가 있습니다.

이 블로그 포스트에서는 장고(django)에서 기본적으로 제공하는 URL 관리 기능을 통해 웹 서비스의 라우팅(Routing)을 관리하는 방법에 대해서 설명합니다.

이 블로그는 시리즈로 작성되어 있으며, 아래에 링크를 통해 시리즈의 다른 글을 확인할 수 있습니다.

또한 이 블로그 시리즈에서 다룬 소스는 github에 공개되어 있습니다. 아래에 링크를 통해 확인 가능합니다.


2. 라우팅 확인

장고(django)는 크게 프로젝트(Project) 단위와 어플리케이션(Application) 단위가 존재합니다.

장고(djanog) 프로젝트는 여러 어플리케이션을 가질 수 있습니다.

 

이것은 곧

프로젝트(Project) 단위의 라우팅(Routing) 관리와

어플리케이션(Application) 단위의 라우팅(Routing) 관리가 존재한다는 것을 의미합니다.

 

우선 장고(django)의 프로젝트 단위의 라우팅(Routing) 관리를 확인하기 위해 

django_exercise/urls.py 파일을 확인 합니다.

...
from django.contrib import admin
from django.urls import path

urlpatterns = [
    path('admin/', admin.site.urls),
]

파일을 열면 위와 같은 화면을 볼수 있습니다.

이전 블로그(장고(django)의 관리자 페이지)에서 http://127.0.0.1:8000/admin URL로 관리자 페이지에 접속하였습니다. 우리가 아무 설정도 하지 않아도 관리자 화면이 표시된 이유는 django_exercise/urls.py 파일에 위와 같은 설정이 기본적으로 설정되어있기 때문입니다. 우리는 이곳에 우리가 만든 새로운 장고(django) 어플리케이션(Application)의 라우팅 파일을 등록하여 어플리케이션(Application)별 라우팅을 관리할 예정입니다.


3. views.py 생성

일단 어플리케이션(Application)의 라우팅(Routing)을 통해 URL에 연결할 뷰(Views)를 생성할 필요가 있습니다. blog/views.py를 열고 아래와 같이 수정합니다.

from django.shortcuts import render

def posts(request):
    return render(request, 'blog/posts.html', {})

4. html 파일 생성

이제 뷰(Views) 파일에서 참고하고 있는 blog/posts.html 파일을 생성해야 합니다. 

blog/templates/blog/posts.html 파일을 생성하고 아래와 같이 코딩합니다.

<html>
  <head>
    <title>Hello World</title>
  </head>
  <body>
    Hello World
  </body>
</html>

이것으로 라우팅(Routing)을 통해 URL에 연결할 화면 준비가 끝났습니다.

이제 실제로 라우팅(Routing)을 통해 URL과 화면을 연결하는 방법에 대해서 알아보겠습니다.


5. 어플리케이션의 라우팅 파일 urls.py 생성

우리가 제작중인 블로그 웹 사이트에 해당하는 장고(django) 어플리케이션(Application)을 위한 라우팅(Routing) 파일을 생성할 필요가 있습니다. blog/urls.py 파일을 생성하고 아래에 내용을 추가합니다.

from django.urls import path
from . import views

urlpatterns = [
    path('', views.posts, name='posts'),
]

6. 어플리케이션의 라우팅 등록

위에서 생성한 장고(django) 어플리케이션(Application)의 라우팅(Routing) 파일인 blog/urls.py를 장고(django) 프로젝트(Project)에 등록할 필요가 있습니다. django_exercise/urls.py 파일을 열고 아래와 같이 수정합니다.

from django.contrib import admin
from django.urls import path, include # <<< here

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('blog.urls')), # <<< here
]

7. 확인

아래에 장고(django) 명령어로 테스트 서버를 실행한 후, 

http://127.0.0.1:8000/에 접속하여 우리가 설정한 라우팅(Routing)이 동작하는지 확인합니다.

# source venv/bin/activate
# pip install -r requirements.txt
# cd django_exercise
python manage.py runserver

브라우저에 Hello World가 잘 표시되는 것을 확인할 수 있습니다.


8. 완료

이것으로 장고(django)의 라우팅(Routing)에 대해서 알아보았습니다.

이제 라우팅(Routing)을 통해 자신이 만든 화면과 URL을 연결할 수 있습니다.

장고(django)에서 기본적으로 제공하는 관리자 페이지를 사용하는 방법에 대해서 알아봅니다.


1. 개요

파이썬(python)의 장고(django)로 서버사이드를 개발해보려고 합니다.

이 블로그 포스트에서는 장고(django)에서 기본적으로 제공하는 관리자 페이지를 사용하는 방법에 대해서 알아보려고 합니다. 장고(django)의 관리자 페이지를 phpmyadmin과 같이 데이터베이스의 정보를 보는 페이지를 의미합니다.

이 블로그는 시리즈로 작성되어 있으며, 아래에 링크를 통해 시리즈의 다른 글을 확인할 수 있습니다.

또한 이 블로그 시리즈에서 다룬 소스는 github에 공개되어 있습니다. 아래에 링크를 통해 확인 가능합니다.


2. 언어 설정

장고(django)가 기본적으로 제공하는 관리자 페이지의 기본 언어를 변경하고 싶으신 분은, django_exercise/settings.py를 열고 아래와 같이 수정합니다.

...
# LANGUAGE_CODE = 'en-us'
LANGUAGE_CODE = 'ko'
...

여기서는 기본 설정인 영어를 그대로 사용하고 진행하겠습니다.


3. 슈퍼 유저 생성

장고(django)가 기본적으로 제공하는 관리자 페이지에 로그인하기 위해서는 슈퍼 유저(superuser)를 만들 필요가 있습니다. 아래와 같이 장고(django) 명령어를 통해 슈퍼 유저(superuser)를 생성합니다.

# source venv/bin/activate
# pip install -r requirements.txt
# cd django_exercise
# python manage.py migrate
python manage.py createsuperuser

위에 명령어를 실행하면 아래와 같이 슈퍼 유저(superuser)를 등록하는 절차가 진행됩니다.

venv > ~/django_exercise/django_exercise > python manage.py createsuperuser
Username (leave blank to use '...'): dev-yakuza
Email address: dev.yakuza@gmail.com
Password:
Password (again):
Superuser created successfully.

절차에 맞게 자신이 사용할 슈퍼 유저(superuser)를 등록합니다.


4. 관리자 페이지 접속

아래에 URL로 들어가 장고(django)가 기본적으로 제공하는 관리자 페이지에 접속할 수 있습니다.

# python manage.py runserver
http://127.0.0.1:8000/admin

 

정상적으로 진행되었다면 아래와 같은 페이지을 볼 수 있습니다.

 

위에서 생성한 슈퍼 유저(superuser) 정보를 입력하고 로그인 하면 아래와 같은 페이지를 볼 수 있습니다.


5. 관리자 페이지에 모델(Models) 등록

장고(django)가 기본적으로 제공하는 관리자 페이지에서 우리가 만든 장고(django) 어플리케이션의 모델(Models)을 관리하기 위해서는 장고(django) 어플리케이션의 모델(Models)을 등록할 필요가 있습니다. 

blog/admin.py 파일을 열고 아래와 같이 우리가 만든 Post 모델을 등록 시킵니다.

 

장고(django)의 모델(Models) 생성에 관해서는 이전 블로그를 참고하시기 바랍니다.

(장고(django) 모델(models) 사용해보기)

from django.contrib import admin
from .models import Post

admin.site.register(Post)

 

그리고 관리자 페이지를 새로고침하면

아래와 같이 우리가 생성한 장고(django) 어플리케이션의 모델(Models)가 화면에 표시되는 것을 확인할 수 있습니다.


6. 관리자 페이지로 블로그 글 작성

장고(django)가 기본적으로 제공하는 관리자 페이지를 활용하여 우리가 만들 블로그 사이트에 글을 작성해 봅시다.

아래와 같은 관리자 메인 페이지에서 BLOG 하단에 Posts 옆에 Add를 눌러줍니다.

 

아래와 같이 테스트용 데이터를 작성합니다.

 

그리고 하단에 있는 Save and add another을 누르고, 추가적으로 테스트 데이터를 더 넣어 줍니다.

이번엔 테스트를 위해 published_at를 작성해서 저장합니다.

 

이번엔 Save를 눌러 저장하고, 저장한 데이터 리스트 화면으로 이동합니다.

위와 같이 데이터가 잘 저장된 것을 확인할 수 있습니다.


7. 확인

데이터가 정말 잘 저장되었는지 확인하기 위해 데이터베이스 툴을 사용하여 직접 데이터베이스안을 확인해 봅니다.

위에서 장고(django)가 기본적으로 제공하는 관리자 페이지로 등록한 데이터가 데이터베이스에 잘 저장된 것을 확인할 수 있습니다.


8. 완료

이것으로 장고(django)가 기본적으로 제공하는 관리자 페이지를 사용하는 방법에 대해서 알아보았습니다.

또한 이전 블로그에서 생성한 장고(django)의 모델(Models)을 관리자 화면에 표시하기 위한 방법도 함께 살펴보았습니다. 이로써 데이터베이스 툴이 없어도 간단하게 데이터를 다룰 수 있게 되었습니다.


출처

https://dev-yakuza.posstree.com/ko/django/admin/

장고(django) 프로젝트에서 어플리케이션을 생성하고 새로운 어플리케이션에 필요한 데이터를 저장할 모델(models)을 생성하고 사용하는 방법에 대해서 알아봅니다.


1. 개요

파이썬(python)의 장고(django)로 서버사이드를 개발해보려고 합니다. 이 블로그 포스트에서는 장고(django) 명령어를 새로운 어플리케이션을 생성하고, 그 어플리케이션에서 사용할 데이터를 저장하기 위해 모델(models)를 생성하고 사용하는 방법에 대해서 알아보려고 합니다.

이 블로그는 시리즈로 작성되어 있으며, 아래에 링크를 통해 시리즈의 다른 글을 확인할 수 있습니다.

 

또한 이 블로그 시리즈에서 다룬 소스는 github에 공개되어 있습니다. 아래에 링크를 통해 확인 가능합니다.


2. 장고(django) 어플리케이션 생성

장고(django)는 큰 단위에 프로젝트가 있고 그 안에 작은 단위로 어플리케이션이 존재합니다.

한 프로젝트에는 여러개의 어플리케이션이 존재할 수 있습니다.

여기에서는 장고(django)로 블로그를 개발한다고 가정하고 진행하도록 하겠습니다.

그럼 본격적으로 장고(django)로 개발하기 위해 아래에 장고(django) 명령어로 blog 어플리케이션을 생성합니다.

# virtualenv venv
# source venv/bin/activate
# pip install -r requirements.txt
# django-admin --version
# 2.2
python manage.py startapp blog

 

장고(django)의 어플리케이션이 잘 생성되었다면 아래와 같은 폴더 구조를 확인할 수 있습니다.

|-- django_exercise
|   |-- __init__.py
|   |-- settings.py
|   |-- urls.py
|   |-- wsgi.py
|-- blog
|   |-- __init__.py
|   |-- admin.py
|   |-- apps.py
|   |-- models.py
|   |-- tests.py
|   |-- views.py
|-- manage.py

 

새로 생성된 어플리케이션 하단의 파일들은 아래와 같은 역할을 합니다.

  • admin.py: 장고(django)에서 기본적으로 제공하는 관리화면 설정
  • apps.py: 어플리케이션 메인 파일
  • models.py: 어플리케이션의 모델(models) 파일
  • tests.py: 테스트 파일
  • views.py: 어플리케이션의 뷰(views) 파일

 

이 밖에도 아래와 같이 장고(django)에서 사용하는 파일들이 있습니다.

  • urls.py: 어플리케이션의 url 관리
  • forms.py: 입력 폼 관리
  • behaviors.py: 모델 믹스인 위치에 대한 옵션
  • constants.py: 어플리케이션 상수 관리
  • decorators.py: 데코레이터 관리
  • factories.py: 테스트 데이터 팩토리 파일
  • helpers.py: 뷰(views)와 모델(models)을 도와주는 함수 관리
  • managers.py: 커스텀 모델 매니저 파일
  • signals.py: 커스텀 시그널 관리
  • viewmixins.py: 뷰(views) 믹스인 관리

뭔 소리인지 하나도 모르겠네요.

나중에 하나씩 공부하다보면 저절로 알게 될테니 그냥 이런 파일이 있다고 생각하고 넘어가면 될거 같습니다.

장고(django) 어플리케이션을 생성하였으니, 장고(django) 프로젝트에 새롭게 생성한 어플리케이션을 등록해야합니다. 장고(django) 프로젝트를 관리하는 django_exercise/settings.py를 열고 아래와 같이 장고(django) 어플리케이션을 등록합니다.

...
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'blog'
]
...

3. 모델(models) 생성하기

이제부터 블로그 사이트를 개발하기 위해 필요한 모델(models)을 생성합니다.
blog/models.py를 열고 아래의 내용을 추가합니다.

from django.db import models
from django.utils import timezone

class Post(models.Model):
    author = models.ForeignKey('auth.User', on_delete=models.CASCADE)
    title = models.CharField(max_length=100)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    published_at = models.DateTimeField(blank = True, null = True)

    def publish(self):
        self.published_at = timezone.now()
        self.save()

    def __str__(self):
        return self.title

 

작성한 코드를 자세히 살펴보도록 하겠습니다.

  • Post는 author, title, content, created_at, updated_at, published_at 필드를 가지고 있습니다.
  • author는 ForeignKey 함수를 사용하여, 장고(django)에서 기본적으로 제공하는 auth 어플리케이션의 User 모델을 참조하게 만들었습니다.(auth.User: 앱이름.모델)
  • title은 블로그의 제목으로 CharField 함수를 사용하여 길이가 정해진 문자열을 저장하도록 하였습다. max_length 옵션을 사용해 길이가 100인 문자열을 저장하도록 설정하였습니다.
  • content는 블로그의 내용으로 TextField 함수를 통해 길이가 정해져있지 않는 문자열을 저장할 수 있도록 하였습니다
  • created_at은 블로그 생성 날짜로 DateTimeField을 통해 날짜와 시간을 저장할 수 있도록 하였으며, auto_now_add 옵션을 사용하여 데이터 생성시 현재 시간을 저장하도록 하였습니다.
  • updated_at는 블로그 수정일로 역시 DateTimeField을 통해 날짜와 시간을 저장할 수 있도록 하였으며, auto_now 옵션을 사용하여 데이터가 갱신될 때 현재 시간을 저장하도록 하였습니다.
  • published_at는 블로그를 공개한 날짜로 역시 DateTimeField을 통해 날짜와 시간을 저장할 수 있도록 하였습니다.

 

위에서는 설명하지 않은 blank = True, null = True는 별도로 설명하려고 합니다.

  • blank: 유효성(validation) 처리와 관련이 있는 옵션으로, form.is_valid()를 사용하여 입력폼의 유효성 검사를 할때 사용됩니다. 데이터의 공백(blank)을 허용합니다.
  • null: 데이터베이스와 관련이 있는 옵션으로, 데이터베이스의 null을 저장할 수 있도록 하는 옵션(nullable)

 

이 모델에는 publish, __str__ 함수를 가지고 있습니다.

  • publish: 블로그 서비스에서 자주 사용되는 기능인 공개(publish) 기능을 함수로 만들었습니다. 이 함수를 통해 블로그를 공개(publish)할 때 날짜를 갱신하기 위해 만들었습니다.
  • __str__: 표준 파이썬 클래스 메소드이며 사람이 읽을 수 있는 문자열을 반환하도록 합니다.

4. 모델(models)을 이용하여 테이블 생성

지금까지 만든 모델(models)을 가지고 데이터베이스(database)의 테이블을 생성하는 방법에 대해서 알아봅니다.

 

(1) 마이그레이션 파일 생성

우선 아래에 장고(django) 명령어로 우리가 만든 모델(models)로부터 데이터베이스(database)의 테이블을 생성하기 위한 마이그레이션(migration) 파일을 생성합니다.

python manage.py makemigrations blog

 

명령이 제대로 실행되었다면 아래와 같은 결과를 볼 수 있습니다.

 

그리고 폴더를 확인하면 마이그레이션 폴더와 파일이 생성된 것을 확인할 수 있습니다.

|-- django_exercise
|   |-- __init__.py
|   |-- settings.py
|   |-- urls.py
|   |-- wsgi.py
|-- blog
|   |-- migrations
|   |   |-- __init__.py
|   |   |-- 0001_initial.py.py
|   |-- __init__.py
|   |-- admin.py
|   |-- apps.py
|   |-- models.py
|   |-- tests.py
|   |-- views.py
|-- manage.py

 

(2) 테이블 생성

아래에 장고(django) 명령어로 모델(models)로부터 생성한 마이그레이션(migration) 파일을 이용하여 데이터베이스의 테이블을 생성합니다.

python manage.py migrate blog

 

명령어가 잘 실행되면 아래와 같은 결과를 확인할 수 있습니다.

 

데이터베이스 툴을 사용하여 데이베이스를 보면 우리가 모델(models)에 설정한 테이블이 생성된 것을 확인할 수 있습니다.


5. 완료

이것으로 장고(django)에서 모델(models)을 생성하고 생성한 모델(models)을 활용하여 DB 테이블을 생성하는 방법을 알아보았습니다. 이로써 개발에 필요한 정보를 저장할 수 있게 되었습니다. 이제 서비스에 필요한 DB를 설계하고 그에 따른 모델(models)과 마이그레이션(migration)을 생성하여 DB 테이블을 생성해 봅시다!


6. 참고

모델 데이터 타입

아래는 장고(django) 모델에서 사용 가능한 데이터 타입입니다.

Data typeDjango model type

Binary models.BinaryField()
Boolean models.BooleanField()
Boolean models.NullBooleanField()
Date/time models.DateField()
Date/time models.TimeField()
Date/time models.DateTimeField()
Date/time models.DurationField()
Number models.AutoField()
Number models.BigIntegerField()
Number models.DecimalField(max_digits=X,decimal_places=Y)
Number models.FloatField()
Number models.IntegerField()
Number models.PositiveIntegerField()
Number models.PositiveSmallIntegerField()
Number options.SmallIntegerField()
Text models.CharField(max_length=N)
Text models.TextField()
Text (Specialized) models.CommaSeparatedIntegerField(max_length=50)
Text (Specialized) models.EmailField()
Text (Specialized) models.FileField()
Text (Specialized) models.FilePathField()
Text (Specialized) models.ImageField()
Text (Specialized) models.GenericIPAddressField()
Text (Specialized) models.SlugField()
Text (Specialized) models.URLField()
Text (Specialized) models.UUIDField()

출처

https://dev-yakuza.posstree.com/ko/django/models/

장고(django)의 명령어를 통해 장고(django) 프로젝트를 생성하고 시작해 봅시다. 또한 설정, DB(mysql) 연동을 통해 실제로 장고(django)로 프로젝트를 개발할 수 있는 상태를 만들어 봅시다.


1. 개요

파이썬(python)의 장고(django)로 서버사이드를 개발해보려고 합니다.

이 블로그 포스트에서는 장고(django) 명령어를 통해 장고(django) 프로젝트를 설치하고 시작하는 방법에 대해서 알아봅니다.

이 블로그는 시리즈로 작성되어 있으며, 아래에 링크를 통해 시리즈의 다른 글을 확인할 수 있습니다.

또한 이 블로그 시리즈에서 다룬 소스는 github에 공개되어 있습니다. 아래에 링크를 통해 확인 가능합니다.

 

GitHub - dev-yakuza/django_exercise

Contribute to dev-yakuza/django_exercise development by creating an account on GitHub.

github.com


2. 장고(django) 프로젝트

아래에 명령어로 파이썬(python)의 가상 환경(Virtual Environment)를 실행하고 장고(django)가 잘 설치되어있는지 확인합니다.

source venv/bin/activate
django-admin --version
# 2.2

 

파이썬(python)의 가상 환경(Virtual Environmet) 설정이나 장고(django) 설치에 대한 내용은 이전 블로그를 참고해 주세요.

 

아래에 명령어로 장고(django) 프로젝트를 생성합니다.

django-admin startproject django_exercise

3. 기본 폴더 구조

장고(django) 명령어로 프로젝트를 생성하면 아래와 같이 폴더가 생성되는 것을 확인할 수 있습니다.

|-- django_exercise
|   |-- __init__.py
|   |-- settings.py
|   |-- urls.py
|   |-- wsgi.py
|-- manage.py

 

각 파일은 아래와 같은 기능을 합니다.

  • django_exercise/settings.py: 전반적인 설정을 가지고 있는 파일
  • django_exercise/urls.py: 프로젝트의 url을 관리하는 파일
  • django_exercise/wsgi.py: 웹서버(apache, nginx등)과 연동하기 위한 파일
  • manage.py: 프로젝트를 관리. 예를 들어, DB의 migration 생성 및 실행, 로컬에서 다른 설치없이 웹 서버를 기동 등

4. 설정

설정 파일인 django_exercise/settings.py을 열고 아래와 같이 타임존을 설정합니다.

...
TIME_ZONE = 'Asia/Seoul'
...
USE_TZ = False
...

 

위에서 설정한 USE_TZ 옵션은 True인 경우, templates와 forms에서만 위에서 설정한 타임존을 따르게 됩니다. 

False인 경우, models에서도 타임존을 따르게 되므로 모든 곳에서 동일한 타임존을 따르게 됩니다.

또한 static 파일을 다루기 위해 아래와 같이 STATIC_ROOT를 추가합니다.

...
STATIC_URL = '/static/'
...

 

마지막으로, 프로젝트를 실서버에 배포할 경우, 아래와 같이 DEBUG 설정을 False로 변경한 후 배포하시기 바랍니다.

...
DEBUG = False
...

5. DB 설정

여기에서는 장고(django)와 mysql을 연동하는 방법에 대해서 소개합니다.

맥(Mac)에 mysql을 설치하는 방법에 대해서는 아래에 링크를 통해 확인하시기 바랍니다.

 

맥(Mac) 개발 환경 구축(3) - 개발 환경

새로운 맥(Mac)에 개발 환경을 구축하려고 합니다. 지금 현재 개발에 사용하고 개발 환경을 설정하는 방법에 대해서 설명합니다.

dev-yakuza.posstree.com

 

장고(djanog)의 설정 파일인 django_exercise/settings.py를 열고 아래와 같이 수정합니다.

...
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': '...',  # DB name
        'USER': 'root',  # DB account
        'PASSWORD': '...',  # DB account's password
        'HOST': '127.0.0.1',  # DB address(IP)
        'PORT': '3306',  # DB port(normally 3306)
    }
}
...

위에 내용에서 NAME과 PASSWORD는 환경에 맞게 수정하시기 바랍니다.

아래에 명령어로 mysql과 연동하기 위해 필요한 모듈인 mysqlclient를 설치합니다.

pip install mysqlclient

 

만약 설치중에 아래와 같은 에러 메세지가 나오면,

...
ld: library not found for -lssl
clang: error: linker command failed with exit code 1 (use -v to see invocation)
error: command 'clang' failed with exit status 1
...

 

아래에 명령어를 사용하여 mysqlclient를 설치하시기 바랍니다.

LDFLAGS=-L/usr/local/opt/openssl/lib pip install mysqlclient

 

모듈 설치가 완료되었다면 다른 환경에서도 사용할 수 있도록 아래에 명령어로 requirements.txt 파일을 갱신합니다.

# cd django_excercise
pip freeze > requirements.txt

 

Database가 잘 연동되었지 확인하기 위해

장고(django)가 기본으로 제공하는 관리화면에 필요한 기본 테이블을 아래에 명령어를 통해 생성해 봅니다.

python manage.py migrate

 

장고(django)와 mysql 연동을 잘 수행했다면 아래와 같은 화면을 볼 수 있습니다.

 

database 툴을 이용하여 확인하면 아래와 같이 성공적으로 테이블이 생성된 것을 확인할 수 있습니다.


6. 테스트

지금까지 장고(django)에 설정에 대해서 알아보았습니다.

이제 아래에 명령어를 통해 장고(django)에서 지원하는 테스트 웹서버를 기동하여 우리가 만든 프로젝트가 잘 실행되는지 확인합니다.

python manage.py runserver
# http://127.0.0.1:8000/

장고(django) 설치와 설정을 무사히 진행하였다면 아래와 같이 장고(django)에서 지원하는 기본 화면을 확인할 수 있습니다.


7. 완료

이것으로 장고(django)의 명령어를 통해 프로젝트를 생성하고 시작하는 방법에 대해서 알아보았습니다.

간단하게 프로젝트 폴더 구조 설명과 설정에 대해서도 알아보았습니다.

또한 앞으로 사용할 mysql과의 연동과 로컬에서 테스트하기 위해 장고(django)에서 기본적으로 제공하는 웹 서버를 사용하여 프로젝트를 실행해 보았습니다.

 

이제 개발할 준비가 완료되었습니다. 장고(django)를 통해 개발을 시작해 봅시다!


출처

https://dev-yakuza.posstree.com/ko/django/start/

 

장고(django) 프로젝트 시작하기

장고(django)의 명령어를 통해 장고(django) 프로젝트를 생성하고 시작해 봅시다. 또한 설정, DB(mysql) 연동을 통해 실제로 장고(django)로 프로젝트를 개발할 수 있는 상태를 만들어 봅시다.

dev-yakuza.posstree.com

 

장고(django) 개발을 위해 장고(django)를 설치하고 설정하는 방법에 대해서 알아봅니다.


1. 개요

파이썬(python)의 장고(django)로 서버사이드를 개발해보려고 합니다.

이 블로그 포스트에서는 장고(django)로 개발하기 위한 설치와 설정에 대해서 설명합니다.

이 블로그는 시리즈로 작성되어 있으며, 아래에 링크를 통해 시리즈의 다른 글을 확인할 수 있습니다.

또한 이 블로그 시리즈에서 다룬 소스는 github에 공개되어 있습니다. 아래에 링크를 통해 확인 가능합니다.


2. 설치

장고(django)를 사용하기 위해서는 파이썬(python)을 설치해야합니다.

아래에 링크를 통해 자신의 OS에 맞는 파이썬(python)를 다운로드 받은 후 설치합니다.

저는 주로 맥(Mac)을 사용하여 개발합니다. 또한 터미널로는 zsh를 사용하고 있습니다.

아래에 링크를 통해 맥(Mac)과 zsh를 사용하여 파이썬(python)을 설정하는 방법을 확인하세요.

위에 링크를 통해 zsh와 파이썬(python)을 설정하였다면 아래에 명령어로 버전을 확인합니다.

python --version
Python 3.7.2

아래에 명령어를 통해 파이썬의 가상 환경(Virtual Environment)을 간단하게 사용할 수 있게 도와주는 virtualenv 모듈을 설치합니다.

pip install virtualenv pylint autopep8

 

아래에 명령어를 통해 장고(django)를 사용하기 위한 환경을 만듭니다.

mkdir server
cd server
virtualenv venv

 

아래에 명령어로 가상 환경(Virtual Environment)을 활성화시킵니다.

source venv/bin/activate

 

아래 명령어로 장고(django)를 가상 환경(Virtual Environment)에 설치합니다.

pip install django

 

설치가 완료되었다면 아래에 명령어로 장고(django)가 잘 설치되었는지 확인합니다.

django-admin --version
# 2.2

 

아래에 명령어로 설치된 개발 환경을 파일로 저장합니다.

# cd server
pip freeze > requirements.txt

 

설치가 확인되었다면 아래에 명령어로 가상 환경(Virtual Environment)을 종료합니다.

deactivate

 

다시 아래에 명령어를 실행하여 가상 환경(Virtual Environment)가 정상적으로 종료되었는지 확인합니다.

django-admin --version
# zsh: command not found: django-admin

 

위에 명령어를 통해 가상 환경(Virtual Environment)을 이해할 수 있을거 같습니다.

위에서 설치한 장고(django)는 가상 환경(Virtual Enviroment)에 설치하였습니다.

따라서 가상 환경(Virtual Environment)가 종료된 환경에서 장고(django) 명령어를 실행하면 장고(django)를 찾을 수 없다는 에러가 나옵니다. 이처럼 파이썬 가상 환경(python virtual environment)를 사용하여 파이썬(python) 개발 환경을 고립시킬 수 있습니다.


3. 다른 머신에서 사용하기

파이썬(python)의 가상 환경(Virtual Environment)는 말 그대로 환경입니다.

따라서 이 환경을 git로 버전 관리를 할 필요하 없습니다. .gitignore에 아래에 내용을 추가합니다.

# .gitignore
...
venv

 

그리고 git에는 requirements.txt를 저장합니다.

다른 머신에서는 git를 가져오고 명령어로 가상 환경(Virtual Environment)을 설치하고 실행한 후

아래에 명령어로 장고(django)를 설치합니다.

# cd server
pip install -r requirements.txt

 

개발을 하면서 여러 모듈을 설치할텐데,

설치가 완료되면 항상 아래에 명령어를 실행하여 requirements.txt를 갱신합니다.

# cd server
pip freeze > requirements.txt

4. 완료

장고(django)를 사용하기 위해 파이썬(python)과 파이썬(python)의 가상 환경(Virtual Environment)을 구성하고 장고(django)를 설치해 보았습니다. 이로써 장고(django) 개발에 준비를 맞췄습니다. 앞으로는 장고를 사용하여 서버사이드를 개발하는 방법에 대해서 설명하도록 하겠습니다.

 


출처

https://dev-yakuza.posstree.com/ko/django/installation/

 

+ Recent posts