장고(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/

 

https://simpleisbetterthancomplex.com/packages/2016/10/08/isort.html

 

How to Use Python isort Library

isort is a Python utility / library to sort imports alphabetically, and automatically separated into sections. It’svery useful in Django projects, specially ...

simpleisbetterthancomplex.com

 

https://github.com/PyCQA/isort#readme

 

GitHub - PyCQA/isort: A Python utility / library to sort imports.

A Python utility / library to sort imports. Contribute to PyCQA/isort development by creating an account on GitHub.

github.com

 

Git의 pre-commit 훅(hook)은 우리가 작성한 코드를 커밋할 때 마다 자동으로 특정 작업을 실행해줍니다.

 

많은 프로젝트들이 이를 통해 포멧터(formatter)를 실행하여 코드 스타일을 통일하고, 린터(linter)를 실행하여 코드에 잠재하고 있는 문제들을 찾아냅니다.

 

이번 포스팅에서는 Git의 pre-commit hook을 편리하게 사용할 수 있도록 도와주는 pre-commit라는 도구에 대해서 알아보겠습니다.

1. 설치

pre-commit은 자신의 컴퓨터에 파이썬이 설치가 되어 있다면 파이썬의 패키지 매니저인 pip를 사용하여 설치할 수 있습니다.

$ pip install pre-commit
Collecting pre-commit
  Downloading pre_commit-2.8.2-py2.py3-none-any.whl (184 kB)
     |████████████████████████████████| 184 kB 3.2 MB/s
Collecting toml
  Downloading toml-0.10.2-py2.py3-none-any.whl (16 kB)
Requirement already satisfied: pyyaml>=5.1 in /opt/virtualenvs/python3/lib/python3.8/site-packages (from pre-commit) (5.3.1)
Collecting cfgv>=2.0.0
  Downloading cfgv-3.2.0-py2.py3-none-any.whl (7.3 kB)
Collecting nodeenv>=0.11.1
  Downloading nodeenv-1.5.0-py2.py3-none-any.whl (21 kB)
Collecting virtualenv>=20.0.8
  Downloading virtualenv-20.1.0-py2.py3-none-any.whl (4.9 MB)
     |████████████████████████████████| 4.9 MB 4.6 MB/s
Collecting identify>=1.0.0
  Downloading identify-1.5.9-py2.py3-none-any.whl (97 kB)
     |████████████████████████████████| 97 kB 7.4 MB/s
Collecting distlib<1,>=0.3.1
  Downloading distlib-0.3.1-py2.py3-none-any.whl (335 kB)
     |████████████████████████████████| 335 kB 43.6 MB/s
Requirement already satisfied: six<2,>=1.9.0 in /opt/virtualenvs/python3/lib/python3.8/site-packages (from virtualenv>=20.0.8->pre-commit) (1.15.0)
Requirement already satisfied: appdirs<2,>=1.4.3 in /opt/virtualenvs/python3/lib/python3.8/site-packages (from virtualenv>=20.0.8->pre-commit) (1.4.4)
Collecting filelock<4,>=3.0.0
  Downloading filelock-3.0.12-py3-none-any.whl (7.6 kB)
Installing collected packages: toml, cfgv, nodeenv, distlib, filelock, virtualenv, identify, pre-commit
Successfully installed cfgv-3.2.0 distlib-0.3.1 filelock-3.0.12 identify-1.5.9 nodeenv-1.5.0 pre-commit-2.8.2 toml-0.10.2 virtualenv-20.1.0
WARNING: You are using pip version 20.1.1; however, version 20.2.4 is available.
You should consider upgrading via the '/opt/virtualenvs/python3/bin/python3 -m pip install --upgrade pip' command.

 

파이썬이 설치되어 있지 않다면, 운영체제의 패키지 매니저를 통해서도 설치할 수 있습니다.

예를 들어, MacOS 사용자는 Homebrew를 사용하면 됩니다.

$ brew install pre-commit

 

설치가 제대로 되었는지 확인해보기 위해서 버전을 출력해봅니다.

$ pre-commit -V
pre-commit 2.8.2

2. 설정

pre-commit은 .pre-commit-config.yaml이라는 설정 파일을 필요로 합니다.

터미널에 샘플 설정을 출력해주는 커맨드를 이용하여 설정 파일을 생성해보겠습니다.

$ pre-commit sample-config > .pre-commit-config.yaml

 

생성된 설정 파일을 열어보면, 4개의 훅(hook)이 설정되어 있는 것을 볼 수 있습니다.

# See https://pre-commit.com for more information
# See https://pre-commit.com/hooks.html for more hooks
repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v3.2.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-yaml
      - id: check-added-large-files

 

pre-commit 도구는 인터넷에 공개되어 있는 Git 저장소로 부터 hook을 내려받아서 실행을 합니다.

즉, 우리는 실행하고 싶은 hook이 어느 Git 저장소에 위치하는지 알아야 합니다.

 

pre-commit 공식 홈페이지의 Supported hooks 페이지를 방문하시면 커뮤니티에서 제공하는 다양한 pre-commit hook을 만나볼 수 있습니다.


3. 실행

$ pre-commit run
[INFO] Initializing environment for https://github.com/pre-commit/pre-commit-hooks.
[INFO] Installing environment for https://github.com/pre-commit/pre-commit-hooks.
[INFO] Once installed this environment will be reused.
[INFO] This may take a few minutes...
Trim Trailing Whitespace.............................(no files to check)Skipped
Fix End of Files.....................................(no files to check)Skipped
Check Yaml...........................................(no files to check)Skipped
Check for added large files..........................(no files to check)Skipped

 

보통 초기 셋업 단계에서는 직접 pre-commit를 실행해보면서 설정이 잘 되었는지 확인이 필요합니다.

수동으로 pre-commit을 실행해주는 커맨드를 터미널에서 실행해보겠습니다.

 

설정 파일에 등록된 모든 hook이 설치된 후, 체크할 파일이 없어서 모든 hook의 실행이 생략되는 것을 볼 수 있습니다.

설정 파일을 스테이징 영역에 추가하고 다시 pre-commit 도구를 실행해보겠습니다.

 

$ git add .pre-commit-config.yaml
$ pre-commit run -a
Trim Trailing Whitespace.................................................Passed
Fix End of Files.........................................................Passed
Check Yaml...............................................................Passed
Check for added large files..............................................Passed

 

이번에는 모든 hook이 통과했다고 나오는 것을 확인할 수 있습니다.

 

$ git commit -m "creates .pre-commit-config.yaml"
[master (root-commit) d262bdb] creates .pre-commit-config.yaml
 1 file changed, 10 insertions(+)
 create mode 100644 .pre-commit-config.yaml

본격적인 테스트를 위해 설정 파일을 커밋하겠습니다.

 

4. 테스트

설정한 hook이 제대로 동작하는지 체크하기 위해서,

일부로 불필요한 공백(trailing whitespace)을 넣어서 test.txt 파일을 생성해보겠습니다.

$ echo "test " > test.txt

 

생성된 파일을 스테이징 영역에 추가하고,

pre-commit 도구를 실행해보면 trailing-whitespace hook이 실패한 것을 확인할 수 있습니다.

$ git add test.txt
$ pre-commit run
Trim Trailing Whitespace.................................................Failed
- hook id: trailing-whitespace
- exit code: 1
- files were modified by this hook

Fixing test.txt

Fix End of Files.........................................................Passed
Check Yaml...........................................(no files to check)Skipped
Check for added large files..............................................Passed

 

이렇게 hook이 실패한 파일은 자동으로 수정해 주기 때문에 변경분을 스테이징 영역에 추가 후,

다시 pre-commit를 실행하면 모든 hook이 통과하는 것을 볼 수 있습니다.

$ git status
On branch master
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

        new file:   test.txt

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

        modified:   test.txt

$ git add test.txt
$ pre-commit run
Trim Trailing Whitespace.................................................Passed
Fix End of Files.........................................................Passed
Check Yaml...........................................(no files to check)Skipped
Check for added large files..............................................Passed

5. 자동화

pre-commit를 사용하는 최종 목적은 Git으로 커밋(commit)을 남길 때 마다 특정 작업을 자동으로 실행하는 것입니다. 이를 위해서는 프로젝트의 모든 개발자들이 Git 저장소를 클론받은 후에 제일 먼저 pre-commit install 커맨드를 실행해야 합니다.

$ pre-commit install

pre-commit installed at .git/hooks/pre-commit

 

이 명령어를 실행한 후에는 매번 pre-commit run 커맨드를 실행하지 않아도,

커밋을 할려고할 때 마다 자동으로 pre-commit이 실행이 됩니다.

$ echo "test " > test.txt
$ git add test.txt
$ git commit -m "adds test"
Trim Trailing Whitespace.................................................Failed
- hook id: trailing-whitespace
- exit code: 1
- files were modified by this hook

Fixing test.txt

Fix End of Files.........................................................Passed
Check Yaml...........................................(no files to check)Skipped

6. 마치면서

이상으로 pre-commit 도구를 어떻게 사용하는지에 대해서 간단히 살펴보았습니다.

pre-commit의 가장 큰 장점은 Git이 언어에 구애받지 않듯이, pre-commit도 언어와 상관없이 사용할 수 있다는 것입니다. 추후 기회가 되면 언어별로 자주 사용되는 hook에 대해서 다뤄보도록 하겟습니다.

 


출처

https://www.daleseo.com/pre-commit/

 

pre-commit 도구로 Git Hook 사용하기

Engineering Blog by Dale Seo

www.daleseo.com

 

'Django > TIL etc' 카테고리의 다른 글

스웨거란? Open API  (0) 2022.01.31
[Django 패키지] isort  (0) 2022.01.21
[Django 패키지] flake8 사용법  (0) 2022.01.21
파이썬 패키지 관리툴 poetry 소개  (0) 2022.01.21
Poetry 와 장고 프로젝트  (0) 2022.01.21

Django 프로젝트에서 파이썬 코드 스타일을 통일하기 위한 코드 정적 분석기인 flake8을 사용하는 방법에 대해서 알아봅시다.


1. 개요

Django로 서버사이드를 개발하면서 다른 개발자분들과 협업을 하게 되었습니다.

여러 개발자가 협업을 하므로, 코드의 스타일을 통일하고,

잠재적인 버그를 줄이기 위해, 코드 정적 분석기인 flake8을 도입하기로 했습니다.

이번 블로그 포스트에서는 Django 프로젝트에 flake8을 설정하고 사용하는 방법에 대해서 설명합니다.

 

Flake8: Your Tool For Style Guide Enforcement — flake8 4.0.1 documentation

If you want Flake8 to be installed for your default Python installation, you can instead use: Note It is very important to install Flake8 on the correct version of Python for your needs. If you want Flake8 to properly parse new language features in Python

flake8.pycqa.org


2. flake8 설치

Django에서 flake8을 사용하기 위해서는 우선, flake8을 설치할 필요가 있습니다.

다음 명령어를 사용하여 flake8을 설치합니다.

pip install flake8

 

설치를 하였다면, 잊지말고 requirements.txt에 저장해 둡니다.

pip freeze > requirements.txt

 

이것으로 flake8을 설치하는 방법에 대해서 알아보았습니다.


3. flake8 사용법

다음 명령어를 실행하여 flake8을 실행할 수 있습니다.

flake8

 

Django 프로젝트 폴더에서 flake8을 실행하면 다음과 같은 내용을 확인할 수 있습니다.

./venv/lib/python3.8/site-packages/pyflakes/checker.py:153:31: F821 undefined name 'PercentFormat'
./venv/lib/python3.8/site-packages/pyflakes/checker.py:160:9: F821 undefined name 'Generator'
./venv/lib/python3.8/site-packages/pyflakes/checker.py:160:9: F821 undefined name 'PercentFormat'
./venv/lib/python3.8/site-packages/pyflakes/checker.py:180:47: F821 undefined name 'Optional'
./venv/lib/python3.8/site-packages/pyflakes/checker.py:759:35: F821 undefined name 'List'
./venv/lib/python3.8/site-packages/pyflakes/checker.py:760:35: F821 undefined name 'Dict'

flake8의 결과를 보면 

checker.py:153:31: F821 undefined name 'PercentFormat'와 같이 

파일명:에러위치 에러ID 에러 내용을 확인할 수 있습니다.


4. flake8 설정하기

저는 djanog 프로젝트 폴더에 virtualenv를 생성하여 사용하고 있습니다.

그래서, flake8이 불필요하게 virtualenv 폴더까지 분석하고 있으니,

flake8이 virtualenv 폴더를 분석하지 않도록 설정할 필요가 있었습니다.

 

falke8이 virtualenv 폴더를 무시할 수 있도록 설정하기 위해,

flake8 파일을 Django 프로젝트 폴더에 생성하고 다음과 같이 수정하였습니다.

[flake8]
exclude =
    .git,
    .gitignore,
    *.pot,
    *.py[co],
    __pycache__,
    venv,
    .env

 

이렇게 설정하고, 설정이 잘 적용되었는지 확인하기 위해 아래에 명령어를 사용하여 flake8을 실행해 봅니다.

flake8

 

그럼 이전과는 다르게 다음과 같은 결과를 확인할 수 있습니다.

./petmeeting/settings.py:98:80: E501 line too long (91 > 79 characters)
./petmeeting/settings.py:101:80: E501 line too long (81 > 79 characters)
./petmeeting/settings.py:104:80: E501 line too long (82 > 79 characters)
./petmeeting/settings.py:107:80: E501 line too long (83 > 79 characters)
./petmeeting/settings.py:132:33: W292 no newline at end of file

 

flake8은 많은 내용을 체크하지만, 일반적으로 생각하지 않아도 되는 부분까지 에러로 표시하는 경우가 있습니다.

이런 부분들을 무시하기 위해서 저는 다음과 같이 무시할 내용들을 추가하였습니다.

[flake8]
exclude =
    .git,
    .gitignore,
    *.pot,
    *.py[co],
    __pycache__,
    venv,
    .env

ignore =
    E121,
    E126,
    E127,
    E128,
    E203,
    E225,
    E226,
    E231,
    E241,
    E251,
    E261,
    E265,
    E302,
    E303,
    E305,
    E402,
    E501,
    E741,
    W291,
    W292,
    W293,
    W391,
    W503,
    W504,
    F403,
    B007,
    B950,

max-line-length = 200

이 내용은 Sider라는 회사에서 추천하는 규칙을 적용한 내용입니다.

 

GitHub - sider/runners: Sider Runners 🏃🏃‍♀️💨

Sider Runners 🏃🏃‍♀️💨. Contribute to sider/runners development by creating an account on GitHub.

github.com

이 규칙은 단순히 정한건 아닌거 같고, 이 회사에서 연구한 결과를 바탕으로 추천하고 있는거 같습니다.

자세한 내용은 아래에 링크를 참고하시기 바랍니다.

 

Recommended Ruleset | Sider Documentation

Static analysis with its default configuration typically reports many issues, and some of them don't fit your projects. Most analysis tools have the capability to let users enable/disable analysis rules for users to avoid such "false positives." But, a hug

help.sider.review


5. 완료

이것으로 Django 프로젝트에서 flake8을 사용하는 방법에 대해서 알아보았습니다.

또한 불필요한 규칙들과 폴더를 무시하기 위한 설정 방법에 대해서도 알아보았습니다.

앞으로 다른 개발자들과 협업하면서 이렇게 설정한 flake8이 많은 도움이 되기를 기대해 봅니다.

1. poetry 소개

poetry는 파이썬 의존성 관리 툴입니다.

단순하게 의존성 관리만 잘하는 툴이라면 추천할 이유가 별로 없을 것입니다. 

 

poetry는 단순하게 잘 한다 정도를 넘어서서 매우 잘 지원 해줍니다. 

poetry.lock을 사용해서 프로젝트의 의존성을 다른 환경에서도 동일하게 유지할 수 있고, 각 환경에서의 자동완성도 꽤나 잘 지원합니다.

 

또한, 기존 파이썬 패키지 관리 툴에서 볼 수 없었던, build와 publish까지 지원해주고 있어서,

실제로 프로젝트를 만들고 저장소에 배포까지 하고자 하는 사람에게는 굉장히 좋은 도구라고 생각됩니다.

 

깃헙의 python-poetry 라는 계정에서 관리되는데, poetry 하나를 위해서 따로 만든 프로젝트가 있을 정도로 꽤나 정성스럽게 만든 프로젝트입니다.

 

또한 사용법도 기존에 npm을 사용해 본적이 있다면 아주 친숙한 명령어들로 구성되어 있습니다.

단점이라면 새로 커맨드를 익혀야 하는 문제가 있으며, 기존의 프로젝트에 적용하기에는 약간 부담스러울 수 있다는 것입니다.

 

개인적으로는 새로만드는 프로젝트라면 주저없이 poetry를 써보라고 추천하고 싶습니다.

본 문서는 poetry의 설치 및 기본적인 사용법을 정리해서 조금이라도 많은 분이 좋은 프로젝트 환경을 구축하도록 돕기위한 글입니다. 시간이 지나면 본 문서의 내용과 달라질 수 있으므로 최대한 공식 사이트의 문서 를 참고하도록 합시다.

 

2. 설치

(1) 리눅스에서 설치 하기

curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python

 

(2) pip 로 설치

pip install --user poetry

 

설치를 하게되면 poetry 명령이 설치됩니다. 

poetry 명령어는 $HOME/.poetry/bin 에 저장되는데, PATH 환경 변수에도 추가가 됩니다.

추가가 되지 않았다면, .bash_profile 등의 파일에 PATH 의 환경변수에 추가해주세요.

 

패스에 추가하지 않고 바로 사용하려면 아래 명령어를 입력해주세요.

source $HOME/.poetry/env

 

(3) 탭완성(tab completion) 활성화하기

poetry 는 Bash, Fish, Zsh 에서 탭완성을 지원합니다. 

poetry help completions 명령어를 사용하면 각 쉘환경별 도움말을 확인할 수 있습니다.

 

귀찮으시면 아래 커맨드들을 확인하시면 됩니다.

# Bash
poetry completions bash > /etc/bash_completion.d/poetry.bash-completion

# Bash (Homebrew)
poetry completions bash > $(brew --prefix)/etc/bash_completion.d/poetry.bash-completion

# Fish
poetry completions fish > ~/.config/fish/completions/poetry.fish

# Fish (Homebrew)
poetry completions fish > (brew --prefix)/share/fish/vendor_completions.d/poetry.fish

# Zsh
poetry completions zsh > ~/.zfunc/_poetry

# Zsh (Homebrew)
poetry completions zsh > $(brew --prefix)/share/zsh/site-functions/_poetry

# Zsh (Oh-My-Zsh)
mkdir $ZSH/plugins/poetry
poetry completions zsh > $ZSH/plugins/poetry/_poetry

# Zsh (prezto)
poetry completions zsh > ~/.zprezto/modules/completion/external/src/_poetry

zsh 에서는 ~/.zshrc compinit 앞에 fpath+=~/.zfunc 을 추가해줍니다.

oh-my-zsh 에서는 ~/.zshrc 의 plugins에 poetry 를 추가해줘야 합니다.

plugins(
    poerty
    ...
)

 

 

3. 간단 사용법

(1) 프로젝트 셋업

poetry new my-project

위의 명령으로 프로젝트를 생성하면 아래와 같은 구조의 프로젝트가 생성됩니다.

 

my-project tree
.
├── README.rst
├── my_project
│   └── __init__.py
├── pyproject.toml
└── tests
    ├── __init__.py
    └── test_my_project.py

위에 보이는 pyproject.toml 파일이 바로 의존성을 관리하는 파일입니다. 열어보면 아래와 같이 생겼습니다.

 

[tool.poetry]
name = "my-project"
version = "0.1.0"
description = ""
authors = ["andy.sg"]

[tool.poetry.dependencies]
python = "^3.8"

[tool.poetry.dev-dependencies]
pytest = "^5.2"

[build-system]
requires = ["poetry>=0.12"]
build-backend = "poetry.masonry.api"

의존성은 [tool.poetry.dependencies]  [tool.poetry.dev-dependencies] 에서 관리하고 있습니다.

의존성을 추가하고 싶다면 add 서브 커맨드를 사용하면 됩니다. 장고를 한번 추가해보도록 하겠습니다.

 

$ poetry add django

아래와 같이 출력이 나오게 됩니다.

 

Using version ^3.0.7 for django

Updating dependencies
Resolving dependencies... (7.1s)

Writing lock file


Package operations: 1 install, 9 updates, 0 removals

  - Updating pyparsing (2.4.6 -> 2.4.7)
  - Updating six (1.13.0 -> 1.15.0)
  - Installing asgiref (3.2.7)
  - Updating more-itertools (8.1.0 -> 8.3.0)
  - Updating packaging (20.1 -> 20.4)
  - Updating pytz (2019.3 -> 2020.1)
  - Updating sqlparse (0.3.0 -> 0.3.1)
  - Updating wcwidth (0.1.8 -> 0.2.3)
  - Updating django (2.2.9 -> 3.0.7)
  - Updating pytest (5.3.5 -> 5.4.3)

Writing lock file 에서 생성되는 파일이 바로 poetry.lock 파일인데, poetry.lock 파일이 있으면 내가 작성하고 있는 프로젝트의 의존성과 완전히 동일한 의존성을 가지도록 할 수 있습니다.

그러니 poetry.lock 파일을 꼭 저장소에 커밋 하도록 합시다.

pyproject.toml 을 보면 아래와 같이 django 의존성이 추가되어 있습니다.

 

[tool.poetry.dependencies]
python = "^3.8"
django = "^3.0.7"

 

(2) 버전 제약사항

django 의존성 설정을 보면 "^3.0.7" 이라고 되어 있습니다.

여기서 ^(캐럿) 의 의미는 ( >= 3.0.7, < 4.0.0) 의 의미입니다.

 3.9999....99999 버전까지도 설치가 된다는 얘기입니다.

의존성 스펙 문서를 보면 좀더 자세히 나와 있습니다.

 

4. 의존성을 최신으로 업데이트하기

아래의 커맨드를 입력하면 됩니다. $ poetry update

위 커맨드는 poetry.lock 파일을 삭제후 poetry install 하는 것과 동일합니다.

 

5. 패키징

poerty를 사용해서 tarball wheel 같은 배포가 가능한 파일로 빌드할 수 있습니다.

poerty build

 

 

위에서 만든 my-project 에서 실행하면 아래와 같이 나옵니다.

Building my-project (0.1.0)
 - Building sdist
 - Built my-project-0.1.0.tar.gz

 - Building wheel
 - Built my_project-0.1.0-py3-none-any.whl

 

실행후 dist 디렉토리에 가보면 아래와 같이 압축된 파일들이 있습니다.

my-project-0.1.0.tar.gz
my_project-0.1.0-py3-none-any.whl

 

6. 명령어들

(1) new

new 명령어로 새로운 프로젝트를 만들 수 있습니다.

poetry new my-site

위 명령어를 실행하면 아래와 같은 기본 디렉토리 구성을 만들어줍니다.

my-site
├── pyproject.toml
├── README.rst
├── src
│   └── my_site
│       └── __init__.py
└── tests
    ├── __init__.py
    └── test_my_site.py

 

(2) init

init 커맨드는 pyproject.toml 파일을 인터렉티브 하게 만들 수 있도록 도와줍니다.

poetry init

 

(3) install

install 커맨드는 현재 프로젝트의 pyproject.toml 파일을 읽어서 의존성 패키지를 설치해줍니다. poetry.lock 이 없으면 만들어주고 있으면 해당파일을 사용하게됩니다.

# 의존성 설치
poetry install

# 개발환경의 의존성은 빼고 설치
poetry install --no-dev

# -E 또는 --extras 로 추가 의존성을 설정가능
poetry install --extras "mysql redis"
poerty install -E mysql -E redis

 

 

(4) update

의존성 패키지의 버전을 업데이트하고 poetry.lock 파일을 업데이트 합니다.

# 패키지 업데이트
poerty update

# 하나씩 지정해서 업데이트도 가능
poetry update requests toml

# 업데이트는 하지 않고 poetry.lock 만 업데이트
poerty update --lock

 

 

(5) add

패키지설정을 pyproject.toml 에 추가합니다.

poetry add django

# 개발환경에서 필요한 패키지 설치
poetry add pytest factory-boy --dev

# 버전을 지정가능
poetry add django@^3.0.0
poetry add "django=3.0.0"

# 최신버전을 설치
poetry add django@latest

# 깃 저장소에 있는 패키지 설치
poetry add git+https://github.com/django/django.git

# 깃 저장소의 패키지에서 브랜치를 지정
poetry add git+https://github.com/django/django.git#stable/2.2.x

# 로컬에 디렉토리의 파일로 설치하기
poetry add ./my-package/
poetry add ./my-package/dist/my-package-0.1.0.tar.gz
poetry add ./my-package/dist/my-package-0.1.0.whl

 

 

(6) remove

패키지 삭제

poetry remove flask

# 개발환경 패키지 삭제
poetry remove pytest

 

 

(7) show

# 설치된 모든 패키지를 보여준다.
poetry show

# 개발환경용 제외하고 보여준다.
poetry show --no-dev

# 특정패키지를 지정하면 상세내용을 보여줍니다.
poetry show django

# 최신 버전을 보여준다.
poetry show --latest (-l)

# 업데이트를 해야하는 패키지들을 보여준다.
poetry show --outdate (-o)

# 의존성 트리를 보여준다.
poetry show --tree

 

 

(8) build

위에도 적었지만 소스를 배포가능한 형태로(tarball, wheel)빌드합니다.

poetry build

 

 

(9) publish

아래 명령어로 PyPI에 배포할 수 있습니다.

poerty publish

배포를 하려면 PyPI 계정이 필요합니다. 계정이 없다면 여기를 클릭 하시고 하나 만드셔도 좋습니다. 프로젝트명이 겹치면 배포를 할 수 없으니, 자신만의 독특한 프로젝트 명을 정해서 배포를 해보도록 합시다.

 

(10) config

config 커맨드로 poetry 관련 설정을 변경할 수 있습니다.

# 설정보기
poetry config --list


# 설정법
poetry config [options] [setting-key] [setting-value1] ... [setting-valueN]

 

 

(11) run

프로젝트의 virtualenv 에 커맨드를 전달하여 실행하게 됩니다.

poetry run python -V

 

 

(12) check

pyproject.toml 의 유효함을 체크하는 명령어입니다.

 

(13) search

패키지를 찾기위한 커맨드입니다.

예를들어 beautifulsoup 의 패키지명의 철자가 기억이 안나고 beautiful 만 기억나면 아래와 같이 할 수 있습니다 .

$ poetry search beautiful | grep soup

---------------------------------
# output
beautifulsoup (3.2.2)
beautifulsoup4 (4.9.1)

 

 

(14) lock

pyproject.toml 에 설정된 의존성들에 대한 lock 파일을 생성합니다. (설치X)

 

(15) export

export 명령어는 lock 파일을 사용해서 다른 의존성 포맷으로 변경할 수 있습니다.

poetry export -f requirements.txt > requirements.txt

 

7. 가상 환경 관리하기

poetry 로 가상환경(virtualenv)을 관리 할 수 있습니다.

일반적으로 아래와 같이 사용합니다.

$ poetry env use {파이썬경로}

만약에 python3 이 패스에 잡혀 있는 상황이라면 모든 경로를 적어주지 않아도 됩니다.

$ poetry env use python3

(1) 가상환경 정보보기

poetry env info 커맨드로 환경 정보를 확인할 수 있습니다.

저의 경우는 아래와 같이 출력되었습니다.

Virtualenv
Python:         3.8.1
Implementation: CPython
Path:           /Users/gyus/Library/Caches/pypoetry/virtualenvs/my-project-0CozYJQl-py3.8
Valid:          True

System
Platform: darwin
OS:       posix
Python:   /Users/gyus/.pyenv/versions/3.8.1

단순하게 가상환경의 path만 알고 싶은 경우라면 --path 옵션을 주면 됩니다.

$ poetry env info --path

 

(2) 가상환경 리스트 보기

만들어진 가상환경의 리스트는 아래의 명령어로 확인 가능합니다.

$ poetry env list

 

(3) 가상환경 삭제하기

삭제는 아래의 명령어로 가능합니다.

$ poetry env remove {python경로}

 

8. 마무리

파이썬은 nodejs, ruby 보다는 상대적으로 프로젝트 환경 관리가 용이하지 않다고 느낀적이 많이 있는데, 

poetry 는 기존에 사용하던 pyenv, virtualenv를 추가적인 연동 작업없이 자연스럽게 사용할 수 있게 해줍니다.

거기다 패키징과 배포를 쉽게 할 수 있도록 커맨드를 만들어 둔 점이 좋다고 생각합니다.

 

나온지 오래되지 않은 툴이기에 기존에 사용하던 프로젝트에 적용시에는 조심히 적용해야하겠지만,

새로만드는 프로젝트라면 과감히 적용해보는 것은 어떨까요?!

 

pipenv, pyenv, virutalenv 등등 많은 버전관리, 패키지 관리 툴들을 사용해보았지만,

파이썬에서 앞으로의 프로젝트 및 패키지 관리는 poetry 를 사용하는 사람들이 많아질 것 같습니다.

부족한 글이지만, poetry 사용에 도움이 되었으면 좋겠습니다.

 


출처

https://blog.gyus.me/2020/introduce-poetry/

 

+ Recent posts