파이썬 패키지 매니저 pip가 필요하다

사용법

가상환경 생성

> mkdir myproject
> cd myproject
> python -m venv env

가상환경 활성화

$ source env/bin/activate

# shell의 환경에 따라 위의 커맨드가 동작하지 않을 때 아래의 명령어를 사용
$ . env/bin/activate

활성화 확인

(env) $

가상환경 비활성화

(env) $ deactivate

설치

가상환경이 활성화된 상태에서 설치한다.

(env) $ pip install "Django~=3.0.0"

File#delete() 메서드로 파일 또는 디렉토리를 삭제할 수 있다. 삭제에 성공한 경우 true, 실패하면 false를 반환한다.

File file = ...

if(!file.delete()) {
    ... 파일 삭제에 실패한 경우
}

디렉토리의 재귀적 삭제

디렉토리를 삭제하는 경우 해당 디렉토리가 비어 있어야 한다. 디렉터리 내에 파일이 존재하는 경우는 다음과 같이 재귀적으로 삭제한다.

private void deleteDirectory(File dir){
    // 디렉토리 내부의 파일 삭제
    for(File file : dir.listFiles()) {
        if(file.isDirectory()) {
            // 디렉토리의 경우 재귀적으로 삭제
            deleteDirectory(file);
        } else {
            // 파일의 경우 삭제
            file.delete();
        }
    }
    // 디렉터리 삭제
    dir.delete();
}

File#exists() 메서드를 사용한다. 파일 또는 디렉터리가 존재하면 true, 존재하지 않으면 false를 반환한다.

```java File file = new File("test.txt");

if(file.exists()) { ... 파일이 존재하는 경우 } else { ... 파일이 존재하지 않는 경우 }

Date 클래스의 생성자를 인수 없이 호출하면 현재 일시를 가진 Date 인스턴스가 생성된다. 또한, Calendar#getInstance() 메서드로 현재 일시의 달력을 생성하고 캘린더에서 Date 인스턴스를 구할 수 있다.

// 실행한 순간의 일시가 생성된다.
Date date1 = new Date();

// 현재 일시를 나타낸는 캘린더에서 Date 인스턴스를 생성
Calendar calendar = Calendar.getInstance();
Date date2 = calendar.getTime();

Calendar#getInstance() 메서드의 인수에는 TimzeZone을 지정할 수 있다. TimeZone은 세계의 시차를 나타내는 것으로 한국의 경우 Asia/Seoul이다. 기본으로 운영체제의 타임존이 설정된다.

// 디폴트 타임존, 로케일 정보를 가진 캘린더 클래스의 생성
Calendar calendar1 = Calendar.getInstance();

// 로케일이 US인 캘린더 생성
Calendar calendar2 = Calendar.getInstance(Locale.US);

// 타임존이 미국 로스엔젤레스인 캘린더 생성
TimeZone timezone = TimeZone.getTimeZone("America/Los_Angeles");
Calendar calendar3 = Calendar.getInstance(timezone);

TimeZone 클래스의 getAvailableDs() 라는 static 메서드를 사용하면 이용 간으한 타임존의 목록을 String 배열로 받을 수 있다.

기본형의 경우는 비교 연산자에서 값의 비교가 가능하지만 참조형인 경우 참조가 동일한지 비교한다. 값을 비교하려면 equals()와 compareTo() 등의 방법을 사용한다.

equals()

값이 같은 경우 true 아니면 false 를 반환한다.

compareTo()

인수 쪽이 큰 경우 음수, 인수와 동일한 경우 0, 인수 쪽이 작은 경우 양수를 리턴한다.

문자열의 비교

String s1 = "123";
String s2 = new String("123");

// 참조 비교
if(s1 == s2){
    System.out.println("s1과 s2는 참조가 같다");
}


// 값이 같은지 비교
if(s1.equals(s2)) {
    System.out.println("s1과 s2는 값이 같다");
}

// 값의 대소를 비교
int result = s1.compareTo(s2);
if(result == 0) {
    System.out.println("값이 같다");
} else if (result < 0) {
    System.out.println("s1은 s2보다 작다");
} else if (result > 0) {
    System.out.println("s1은 s2보다 크다");
}

Java 1.0 부터 있던 java.io.File과 Java 7 부터 도입된 NIO2 두 개의 API가 존재한다.

NIO2이 File보다 좋은점

• 심볼릭 링크나 퍼미션을 다룰 수 있다.
• 파일 덮어쓰기, 이동 및 복사를 간단하게 할 수 있다.
• 파일의 변경을 감시할 수 있다.

java.io.File

파일 경로를 지정하여 인스턴스를 생성한다. 파일이나 디렉터리 조작을 위한 다양한 메서드가 있다.

// 절대 경로
File file1 = new File("C:\\Users\\minsoo\\workspace\\abc.txt");

// 현재 디렉토리 기준
File file2 = new File("abc.txt");
File file3 = new File("..\\workspace\\abc.txt");

// 부모 디렉터리와 짬뽕
File parent = new File("C:\\Users\\minsoo");
File file4 = new File(parent, "workspace\\abc.txt");

// 디렉토리 생성
File dir = new File("dir");
dir.mkdir();

// 파일 생성
File file = new File(dir, "test.txt");
file.createNewFile();

경로 구분 문자는 윈도우즈의 경우 "", 유닉스 계열은 "/"을 사용한다. 따라서 경로를 하드 코딩하지 않기위해 File.separator 속성을 사용한다.

String sep = File.separator;

java.nio.file.Path

NIO2에서는 java.nio.file.Path로 경로를 나타낸다. Path 객체의 생성은 java.nio.file.FileSystem의 getPath() 메서드를 사용한다.

// 파일 시스템 구하기
FileSystem fs = FileSystems.getDefault();

// 절대 경로
Path path1 = fs.getPath("C:\\Users\\minsoo\\workspace\\abc.txt");

// 경로 구분 문자 없이
Path path2 = fs.getPath("C:", "Users", "minsoo", workspace", "abc.txt");

// 현재 디렉토리 기준
Path path3 = fs.getPath("dir", "test.txt");

// java.nio.file.Paths로 Path 객체 생성
Path path = Paths.get("dir", "test.txt");

NIO2는 경로 자체를 나타내는 Path 클래스와 그 경로에 있는 파일이나 디렉토리 조작은 분리되어 있다. 파일이나 디렉터리에 대한 조작을 하려면 java.nio.file.Files의 static 메서드를 이용한다.

// 디렉토리 생성
Path dir = Paths.get("dir");
Files.createDirectory(dir);

// 파일을 작성
Path file = dir.resolve("test.txt");
Files.createFile(file);

File과 Path의 상호 변환

java.io.File과 java.nio.file.Path는 서로 변환이 가능하다.

File file = ...
Path path = file.toPath();

Paht path = ...
File file = path.toFile();

Java 8 부터 java.time 패키지에서 Date and Time API를 제공한다. 해당 API는 ISO 8601이라는 날짜와 시간의 국제 규격에 맞춰져있고, 스레드 세이프하다.

Date and Time API의 주요 클래스

Joda Time

자바 8 이전에는 Joda Time 이라는 라이브러리를 사용하였으나, 8 이상은 java.time 패키지를 활용하는 것이 좋다. 자바 8 이전에는 사실상 표준이었으나, Joda Time 공식 홈페이지에서도 자바 8 이상은 java.time 으로 개발하는 것을 권장한다.

Immutable API

Date and Time API의 클래스는 모두 변하지 않는 클래스이다. java.util.Calendar는 set() 메서드나 add() 메서드 등을 사용하여 해당 인스턴스의 날짜를 변경할 수 있다. 하지만 java.time.LocalDateTime은 plus() 메서드나 minus() 메서드로 날짜를 더하거나 뺄 수 있지만, 자신의 날짜를 바꾸지 않고 새로운 LocalDateTime 인스턴스를 생성하고 반환한다.

Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DAY_OF_MONTH, 1);

LocalDateTime dateTime = LocalDateTime.now();
LocalDateTime result = dateTime.plusDays(1);

Immutable 클래스는 인스턴스가 생성되면 값이 바뀌지 않기 때문에 의도치 않은 수정에 의한 오류를 방지하여 코드의 안정성을 높일 수 있다.

패키지를 사용하여 클래스를 분류한다.

package example.hellopackage

class HelloWorld {
    ...
}

패키지, 클래스 import

// 임포트 하지 않는 경우
java.util.List<String> list = new java.util.ArrayList<>();

// 임포트 하는 경우
import java.util.List;
import java.util.ArrayList;

List<String> list = new ArrayList<>();

// 와일드 카드 사용
import java.util.*;

java.lang 은 항상 임포트 되어 있다. (java.lang.String, java.lang.Integer ...)

java.util.Date, java.sql.Date 처럼 이름이 중복되는 경우 하나만 임포트하고 다른 하나는 전체를 기술해야 컴파일 에러가 없다.

static 멤버 import

import static 키워드로 스태틱 메서드나 필드를 임포트한다.

// static 메서드 호출
long value = Math.round(d);

// static import
import static java.lang.Math.round;

> javac HelloWorld.java

여러 파일 컴파일

> javac HelloWorld.java HelloWorld2.java

와일드 카드 컴파일

> javac *.java

.class 파일 실행하기

> java HelloWorld

컴파일 또는 실행시 클래스 경로의 설정

JAR 파일이나 서드 파티 라이브러리를 사용하여 컴파일이나 실행하는 경우 -cp 옵션을 붙여 클래스 경로를 설정한다.

> javac -cp /home/lib/ojdbc7.jar:/home/workspace/* HelloWorld.java
> java -cp /home/lib/ojdbc7.jar:/home/workspace/* HelloWorld

pip install vritualenv

# 활성화
source venv/bin/activate     # 맥, 리눅스
./venv/Scripts/activate.bat    # 윈도우즈

# 비활성화
deactivate

Flask-RESTful

설치

# flask도 같이 설치된다.
pip install Flask-RESTful

사용

from flask import Flask, request
from flask_restful import Resource, Api

app = Flask(__name__)
api = Api(app)

class Item(Resource):
    def get(self, name): # Path Parameter
        ...
        return {'result': name}, 200 # JSON return, Status Code

    def post(self, name):
        data = request.get_json() 
        pass

api.add_resource(Item, '/item/<string:name>')

app.run(port=5000, debug=True)

Resource를 상속받은 클래스의 함수명은 HTTP Method의 역할을 한다. debug=True를 설정하면 코드 수정 후 저장하면 알아서 재시작한다. request.get_json(silent=True)는 JSON 파싱 에러가 나면 None을 리턴한다.

잠깐 filter()

filter(조건 함수, 순회 가능한 데이터)
filter(lambda x: x['name'] == name, items)
next(filter(lambda x: x['name'] == name, items)) 

이터레이터를 리턴하므로 next() 사용 가능

Flask-JWT

설치

pip install Flask-JWT

사용

# security.py
from werkzeug.security import safe_str_cmp

def authenticate(username, password):
    user = DB에서 유저 가져오기
    if user and safe_str_cmp(user.password, password):
        return user

def identity(payload):
    user_id = payload['identity']
    return DB에서 유저 가져오기 by user_id

# app.py
from flask_jwt import JWT
from security import authenticate, identity

app.secret_key = 시크릿키설정

jwt = JWT(app, authenticate, identity)

app.py의 맨 마지막 코드는 자동으로 /auth 엔드포인트를 만들어준다. 사용자가 유저 이름과 패스워드를 보내면 authenticate 함수로 가서 인증을 하고 JWT 토큰을 리턴해준다. 사용자가 발급받은 토큰을 보내면 identity 함수로 가서 토큰에 담긴 정보 (여기서는 user_id)를 찾아 사용하면 된다.

HTTP 헤더 Authorization에 JWT [토큰] 이라고 써서 보내주어야 한다!

로그인이 필요한 기능 설정

from flask_jwt import jwt_required

@jwt_required()
def get(self, name):
    pass

Flask-RESTful JSON Parser

from flask_restful import reqparse

class Item(Resource):
    parser = reqparse.RequestParser()
    parser.add_argument('price', type=float, 
        required=True, help='This field cannot be blank!')

    def put(self, name):
        data = Item.parser.parse_args()
        ...

parser.add_argument()에 등록된 키만 사용할 수 있다.

Flask-RESTful 공식 문서에 버전 2.0 부터 모든 파서 기능이 사라질 수 있다고 경고되어 있다.

pip install flask

REST API

from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return 'Hello, World!'

app.run(port=5000)

실행

python app.py

엔드포인트 설정

@app.route('/store', methods=['POST'])
def create_store():
    pass

@app.route('/store/<string:name>') 
def get_store(name):
    pass

엔드포인트 리턴

from flask import jsonify

stores = [
    ....
]

@app.route('/store')
def get_stores():
    return jsonify({'stores': stores})

JSON 처리

from flask import request

@app.route('/store', methods=['POST'])
def create_store():
    request_data = request.get_json()
    name = request_data['name']
    ...

장고는 select_related()라는 QuerySet 메서드를 제공한다. 이는 one-to-many 관계의 객체를 검색할 때 사용한다. 이는 복잡한 QuerySet이 될 수 있지만, 연관 관계에 있는 필드에 접근하기 위해 추가적인 쿼리를 날릴 필요가 없게된다. select_related() 메서드는 ForeignKey와 OneToOne 필드에 사용한다. SQL의 JOIN 쿼리를 통해 연관 객체를 가져오게 된다.

class City(models.Model):
    # ...
    pass

class Person(models.Model):
    # ...
    hometown = models.ForeignKey(
        City,
        on_delete=models.SET_NULL,
        blank=True,
        null=True,
    )

class Book(models.Model):
    # ...
    author = models.ForeignKey(Person, on_delete=models.CASCADE)

# Hits the database with joins to the author and hometown tables.
b = Book.objects.select_related('author__hometown').get(id=4)
p = b.author         # Doesn't hit the database.
c = p.hometown       # Doesn't hit the database.

# Without select_related()...
b = Book.objects.get(id=4)  # Hits the database.
p = b.author         # Hits the database.
c = p.hometown       # Hits the database.

만약 argument 없이 select_related()를 호출하면, 모든 ForeignKey 관계의 객체를 검색할 것이다. 그렇기 때문에, 항상 호출 이후에 접근할 관계에 대해서만 select_related()를 사용해야한다.

select_related()를 사용하는 것은 실행 시간을 굉장히 증가시킬 수 있기 때문에 조심해서 사용해야한다.

prefetch_related()

select_related()가 one-to-many 관계의 연관 객체들을 검색하는데 도움을 준다. 하지만 select_related()는 many-to-many 또는 many-to-one 관계 (ManyToMany 또는 역(逆)ForeignKey 필드)에 대해서는 소용이 없다. 장고는 prefetch_related() 메서드를 제공한다. prefetch_related()는 각 관계에 대해서 lookup을 나눠서하고, 파이썬을 이용해서 결과를 합친다. 이 메소드는 GenericRelation과 GenericForeignKey에 대한 prefetching도 지원한다.

class Topping(models.Model):
    name = models.CharField(max_length=30)

class Pizza(models.Model):
    name = models.CharField(max_length=50)
    toppings = models.ManyToManyField(Topping)

class Restaurant(models.Model):
    pizzas = models.ManyToManyField(Pizza, related_name='restaurants')
    best_pizza = models.ForeignKey(Pizza, related_name='championed_by', on_delete=models.CASCADE)

>>> Restaurant.objects.prefetch_related('pizzas__toppings')
# This will result in a total of 3 database queries - one for the restaurants, one for the pizzas, and one for the toppings.
>>> Restaurant.objects.prefetch_related('best_pizza__toppings')
# 2 queries using select_related()
>>> Restaurant.objects.select_related('best_pizza').prefetch_related('best_pizza__toppings')

SQL 표준에서, 각 SQL 쿼리는 하나의 트랜잭션을 시작하게 되어있다. 이런 표준 트랜잭션은 반드시 명시적으로 커밋되거나 롤백 되어야 한다.

이는 애플리케이션 개발자들에게 항상 편리한 기능이 아니다. 이런 불편한 것을 줄이기 위해, 대부분의 데이터베이스는 autocommit 모드를 지원한다. autocommit 모드에서, 어떤 트랜잭션도 active 아닐 때, 각 쿼리는 트랜잭션을 시작하고, 쿼리의 성공 여부에 따라서 자동으로 커밋되거나 롤백된다.

PEP 249, 파이썬 데이터베이스 API 명세서 v2.0은 autocommit을 꺼둔 상태를 요구하지만, 장고는 이를 오버라이드하여 디폴트로 autocommit 모드를 켜둔다.

트랜잭션 관리를 비활성화하기

데이터베이스 옵션에서 AUTOCOMMIT 세팅을 False로 지정하면 장고의 트랜잭션 관리를 비활성화한다. 이렇게 하면, 장고는 어떠한 커밋도 실행하지 않는다.

# settings.py
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': '127.0.0.1',
        'PORT': '5432',
        'AUTOCOMMIT': False
    }
}

장고나, 서드파티 라이브러리와 상관없이, 개발자는 모든 트랜잭션에 커밋을 명시적으로 해주어한다. 그래서 보통 커스텀 트랜잭션-제어 미들웨어를 할 때나 정말 이상한 짓을 하고 싶을 때 비활성화 하면 된다.

장고에서 직접 트랜잭션을 제어하고 싶다면 다음 블로그 내용을 참조하길 바란다.

다음과 같은 경우에 QuerySet은 평가된다:

• 쿼리셋을 처음 반복(iterate)할 때
• 슬라이싱 할 때, Pizza.objects.all()[:3]
• pickle 하거나 cache 할 때
• repr() 이나 len()을 호출 할 때
• list()를 명시적으로 호출할 때
• bool(), or, and, if 와 같은 문장에서 사용될 때

판매자와 구매자를 연결해주는 신발, 패션 리셀링 경매 중개 사이트에요. 판매 상품이 정품인지 인증해주고, 구매자의 결제를 보증해줘요. 수많은 브랜드의 신발과 패션 상품이 등록되어 있어요. 사이즈별로 실시간 경매액을 알 수 있고, 판매자가 원하는 가격에 바로 구매할 수도 있어요! 적당한 가격에 최애 신발을 갖고 싶다구요? 지금 바로 StockX로 고고~ 👍

팀원

FrontEnd (4명)

• 이영섭
• 김동호
• 송다슬
• 류상욱

BackEnd (3명)

• 이충희 (바로 저에요!)
• 이태현
• 왕민욱

프로젝트 기간

2020.08.31 - 2020.09.11

깃헙

• 프론트:
• 백엔드: https://github.com/choonghee-lee/westock-backend

🎬   데모 영상  

!youtube[w1PJ6CLfxf8]

🖥   기술 스택  

개발 도구

• Django 웹 프레임워크로 API를 구현했어요.
• AQueryTool 을 이용하여 데이터베이스 모델링을 했어요.
• Selenium 을 통해 조던 신발 데이터를 크롤링했어요.
• 크롤링한 csv 파일 데이터를 MySQL에 저장해 두었어요.
• 상품이 너무 많아 일부를 캐쉬하는 Redis를 사용했어요.
• Docker 이미지 두 개를 사용하여 AWS EC2 서버에 가동했어요.

협업 도구

• Zoom, Google Meet을 통해 화상 회의를 수시로 하였어요.
• VSCode LiveShare로 서로의 오류를 체크!
• Git & Github 는 개발자의 필수 도구! 💪
• Trello 로 전체적인 일정 관리와 팀원들의 작업 현황을 파악했어요.

🤔   어떤 기능을 클로닝 했나요?  

색깔이 들어간 내용은 직접 구현한 부분입니다!!

백엔드 구현 사항을 말씀 드릴게요!

모델링

• 모델링 URL : https://aquerytool.com:443/aquerymain/index/?rurl=ee256e1a-149a-4b2e-850b-0b961e7ad838& Password : 786v0a

메인 페이지

• 카카오 소셜 로그인
• 구글 소셜 로그인
• 신발 정보를 20개씩 검색해요

상품 페이지

• 쿼리 스트링을 이용한 상품 리스트 필터링!
• 상품 상세 정보 조회 (아래는 사이즈 별로 판매자가 올린 가격의 변동 내역 입니다.)
• 상품 데이터 크롤링 + Mock 데이터 생성

마이 페이지

• 사용자가 구매한 내역 조회

😎   느낀 점  

1. 크롤링 넘나 힘든 것...

크롤링하고 싶은 사이트 띄워서 로그인하고 상품 정보, 사이즈, 이미지, 거래 내역, 경매 내역 등등... 하나의 상품에 딸린 정보가 많아서 시간이 오래걸렸어요. 아무튼, 동작이 잘하니 맥북을 켜두고 쿨하게 자고 일어났더니... 12개 밖에 된 것이 아니겠어요 🤨 ? 중간 중간에 휴먼임을 인증해달라는 페이지가 정말 랜덤하게 나타나서 고생을 좀 했네요. 그냥 크롤링 하지 말아달라고 사이트에서 경고하는 것 같아 가짜 데이터를 만들었어요. 하지만 상품이 없으면 진도를 못나갈 팀원들을 생각하며 끝까지 해냈습니다!

2. 레디스의 활용

우리 팀의 민욱님이 쿼리스트링을 이용하여 상품 리스트 필터링을 만드셨어요. 그런데 상품의 수가 좀 많다보니, 조회하는데 시간이 4~5초 사이가 걸렸어요. 필터에 따라서 정렬을 달리해야하기 때문이지요. 발표가 이틀밖에 남지 않아 레디스를 사용하기로 결정했고, 민욱님께서 캐싱을 통해 0.02초로 만들어 와주셨어요. 캐싱의 힘을 직접 체감했고, 저는 도커에 장고와 레디스 이미지를 AWS EC2 서버에 띄워서 무사히 발표를 잘 할 수 있었어요!

🥳   마무리  

2차 프로젝트 후기를 10월 말에 작성하고 있어서 기억이 많이 무뎌졌어요. 더 적으려면 더 적겠지만 기억을 미화시킬 것 같아서 그만하려고 해요. 두목이라고 장난스레 불렀지만 팀장으로 힘드셨을 영섭님, 묵묵히 할 일 해주신 다슬님, 프론트 엔드의 멘토 동호님, 구현 페이지를 자랑하시면서 재밌어하셨던 상욱님, 상품 필터링 40초 걸릴 때 마음고생 하셨을 민욱님, 회의 시간에 모든 걸 기록해 주셨던 태현님 모두 감사드려요 😊!!

브랜디는 20대 여성을 위한 패션/뷰티 앱으로 알려져 있어요. 하지만 남성 패션 앱 하이버, 쇼핑몰 무료 창업 서비스 헬피, 동대문 D2C(Direct to Consumer) 플랫폼 트랜디까지 동대문 패션 사업에 적극적으로 뛰어들고 있는 기업이랍니다!

주문한 옷이 반나절 만에 도착하는 '하루 배송' 서비스를 만들었고, 업계 최초로 100명 규모의 개발자 채용을 선언하는 등 빠른 성장을 위해 노력하고 있어요.

🤔   무엇을 만들었나요?  

프로젝트 정보

10명의 개발자가 한 팀이 되어, 브랜디의 스테이징 서비스 페이지와, 백오피스 페이지를 클로닝 하였어요. 저는 백오피스의 백엔드 개발자로 참여했어요!

프로젝트 기간

2020-09-14 ~ 2020-10-15 (31일)

깃허브

https://github.com/choonghee-lee/Admin

데모 영상

!youtube[Ntau8sPeA-I]

구현 사항

색깔이 들어간 내용은 직접 구현한 부분입니다!!

모델링 (공통)

AQueryTool을 이용해 모델링을 하였어요. 궁금하신 분들은 아래의 URL에 접속해보세요!

URL : https://aquerytool.com:443/aquerymain/index/?rurl=928d796a-adf1-4ced-b51a-7400d5e8aec3& Password : vm0irt

일반 회원 / 셀러 관리

• 셀러 로그인 / 회원 가입
• 일반 회원 조회
• 셀러 회원 조회

상품 관리

• 상품 리스트 / 상세 조회
• 기간에 따른 전체 상품 / 선택 상품 엑셀 다운로드
• 상품 정보 등록 / 수정 (선분 이력)
• 상품 이미지 업로드 (Amazon S3)

주문 관리

• 주문의 상태(배송완료, 취소, 환불 등)에 따른 주문 조회
• 주문 상세 관리

쿠폰 관리

• 쿠폰 리스트 / 상세 조회
• 쿠폰 시리얼 넘버 csv 다운로드
• 쿠폰 생성 / 수정
• 삭제 (Soft Delete)

기획전 관리

• 기획전 리스트 / 상세 조회
• 기획전 생성 / 수정

기술 스택

• 요청과 응답을 위해 _Flask_를 사용했어요.
• MySQL 과 _RDS_를 사용하여 데이터베이스를 구축했어요.
• _PyMySQL_을 이용하여 데이터베이스 커넥션 관리부터 SQL 사용까지 모두 직접했어요!
• AWS EC2 서버를 통해 배포하였어요.

  1주차   💪

1주차는 모델링만 하면서 보냈어요. 백엔드 인턴 5명 중에 모델링에 대해 경험이 많고 지식이 풍부한 사람이 없어서, 클론할 백오피스 페이지만 보면서 모델링을 했어요. 그러다 보니 정보처리기사 자격증 취득할 때 달달 외웠던 "도부이결다조"의 필요성을 느끼게 되었고, 팀원들과 김기창님의 "관계형 데이터 모델링 프리미엄 가이드" 책을 구매하여 정규화, 비정규화, 이력 관리에 대해 읽어보며 우리의 모델링에 적용해보려고 했어요. 하지만 이론과 현실의 간극을 좁히지 못하고, "어차피 개발하며 계속 바뀔 스키마, 일단 기존의 것과 비슷하게 가자"라는 팀원의 의견을 받아들이기로 했어요. 모델링은 경험치가 중요한 것 같아요 😭.

  2주차   📗

개인적으로 힘든 시기를 보내고 있어서 매일 아침 회의 시간에 저의 상태에 대해 이야기하며 하루를 시작했어요. 팀원들이 저에게 이야기 해주는 것에 진심이 느껴져서 항상 고마웠고 힘을 내지 않을 수가 없었어요 🤟! 팀원들을 위해 무엇을 할 수 있을까 생각해보니 "내 할일 제 시간에 끝내서 다른 사람에게 부담주지 않는 것" 이라 판단하고 시간 관리를 하기 위해 플래너를 작성하기 시작했어요. 그랬더니 앞으로 나아갈 수 있는 힘이 다시 생기고 플래너에 적힌 것을 완료할 때마다 보람도 느끼고, 팀에 도움이 되고 있다는 긍정적인 생각도 다시하게 되었어요 😎!

  3주차   🏙

4주차에 서버를 띄우고 발표 준비도 해야해서 상품 관련 엔드포인트를 모두 만들어야 했어요. 추석에 할머니댁에 가지 못하고 하루에 2~3개 정도의 API를 작성했어요 😅.

상품에서 가장 어려웠던 것은 이미지 수정이었어요. 이미지가 전부 5개라 그냥 다 지워버리고 다시 만들까 생각도 했지만... 셀러들이 이미지 등록을 더 늘려달라고 할 수도 있을 것 같아서, 4가지 이미지 상태를 두어 처리하는 로직을 작성했어요.

• 이미지가 없는 경우
• 기존의 이미지를 계속 사용하는 경우
• 기존의 이미지를 제거하는 경우
• 새로운 이미지를 업로드하는 경우

새로운 이미지를 업로드하는 경우가 가장 어려웠는데, S3에 업로드된 이미지를 제거하고 DB 테이블의 로우를 제거한 후, S3에 새로운 이미지를 업로드하고 DB 테이블에 S3 URL을 가지는 로우를 생성하는 방법을 사용했답니다.

  4주차   👊

일정에 착오가 있어서 5주차까지 해야한다는 소식을 듣고 잠시 정신이 몽롱해졌지만 ㅋㅋ... "기왕 이렇게 된 거 계속해야지" 하는 마음으로 팀원들과 추가 구현 회의를 하고 의지를 다졌어요.

쿠폰 관리를 맡게 되었어요. 기억나는 부분은 쿠폰 시리얼 넘버 CSV 파일 다운로드 였어요. 일단 사용자에게 파일을 주려면, 임시 파일을 만들어야 했어요. 해당 파일명을 중복되지 않게 (여러 요청이 동시에 올 경우 덮어 씌워질 경우가 있어요!) UUID로 작성하고 시리얼 넘버와 사용여부, 날짜 등을 파일에 적어서 저장하였어요. 임시파일은 공간만 차지하므로 사용자에게 보낼 수 있게 메모리에 올려두고 삭제했어요.

  5주차   🤗

AWS EC2 서버에 웹 애플리케이션을 배포하고 PPT 발표 준비를 했어요. 저는 모든 코드를 보여드리기 보다 제가 중요하다고 느낀 코드에 어떤 포인트를 두고 작성하였는지 설명하였어요. 백오피스 프론트 페이지가 준비되지 않아 포스트맨으로 시연했던 점은 아쉬웠어요. 프론트와 실제로 붙여보면 보이지 않던 오류가 보이니까요.

모든 일정이 끝나고 동기들과 치킨, 피자, 맥주 파티를 했어요. 오예~~ 🥳 🍺 🍕 !!!

  감사합니다   🙇🏻‍♂️

이틀마다 돌아오는 코드 리뷰 시간이 있어서 구현물을 항상 들고가야 한다는 부담도 있었지만, 가장 많이 배운 시간이었어요. 제가 생각한 로직의 허점을 깨닫고, 현업에서 어떤 방식을 더 선호하는지 배울 수 있었어요. 역시 회사에서 몸소 느끼며 배워야 한다더니... 인턴 한달만으로도 이렇게 느끼는데, 어서 취직해서 더 많은 것을 해보고 싶어요!

마지막으로, 저를 도와주신 많은 분들께 감사드린다는 말을 하고 싶어요. 힘들 때 본인만의 스트레스 해소법을 공유해 주신 분, 몸 챙기라고 건강 보조 식품을 주신 분, 동기 부여 영상을 찾아주신 분, 다운된 분위기를 항상 일으켜 주시는 분, 프로젝트 관련하여 기술적 피드백을 주신 분, 인턴십 이후의 있을 일을 논의하며 생각을 나누어 주신 분 등등... 정말 많은 분들이 함께해주셨기 때문에 한번 더 성장할 수 있었어요. 모두 사랑합니다 ❤️!

나다 싶으면 내 사랑받아 xD

엥? 어디서 본 것 같은 글이라구요? 위코드 9기 강솔미님의 닥터마틴 1차 프로젝트 후기를 오마주(?) 하였어요. 여윽시 센빠이 👍 감사합니다!

👩🏻‍🏫   프로젝트 소개  

왓챠피디아(WATCHAPEDIA) 는 영화 평가를 기반으로 사용자의 취향을 분석해주고, 이에 따라 추천까지 해주는 서비스에요. 개인적으로 1000개 이상의 영화를 평가했고, 저만의 영화 컬렉션으로 이용하고 있어요 ❤️! 최근에는 왓챠의 스트리밍 서비스와 함께 TV 프로그램, 도서 까지 서비스를 확장했답니다.

• 팀원:

  wecha = { 
  "frontend": ["김동호", "류상욱", "박주엽"],
  "backend" : ["이충희", "이용민"]
  }

• 개발기간: 2020.08.18 ~ 2020.08.28 (10일)
• Frontend Github
• Backend Github

🎞   데모 영상  

조금 더 잘할 수 있었을 텐데, 아쉬워요.. 😓

!youtube[mmjKbSavkXs]

🖥   기술 스택  

개발 도구

• Django 웹 프레임워크로만 API를 구현했어요.
• AQueryTool 을 이용하여 데이터베이스 모델링을 했어요.
• Selenium 을 통해 영화 데이터를 크롤링했어요.
• 크롤링한 csv 데이터를 MySQL 에 저장해 두었어요.
• AWS EC2 서버에 RDS 인스턴스를 연결하여 서비스 하였어요.

협업 도구

• Git / Github 는 개발자의 필수 도구! 💪
• Trello 로 전체적인 일정 관리와 팀원들의 작업 현황을 파악했어요.
• Postman 으로 프론트엔드와 백엔드를 연결할때 소통하기 위해 API 문서를 작성하였어요. - 영화 API 문서, 유저 API 문서

🤔   어떤 기능을 클로닝 했나요?  

색깔이 들어간 내용은 직접 구현한 부분입니다!!

백엔드 구현 사항을 말씀드릴게요!

메인 페이지

• 넷플릭스와 같은 서비스 제공자와 평균 별점으로 영화 랭킹을 제공해요. 서버에서 정렬해서 보내준답니다.
• 사용자의 평가를 기반으로 장르, 국가, 인물별 영화들을 추천해줘요. 쿼리 스트링 으로 고르면 되요!
• 사용자들의 영화 컬렉션 리스트를 조회할 수 있어요.
• 영화 컬렉션의 상세 정보를 조회할 수 있어요. 페이지네이션 을 구현하여 프론트엔드에서 무한 스크롤을 구현할 수 있게 도와줘요.

Navbar & Footer

• 영화를 검색할 수 있어요. 자동완성 기능이 있답니다.
• 전체 평가 수를 보여줘요.

로그인 & 회원가입 모달

• 이메일로 회원가입을 해요. bcrypt 를 사용한 암호화는 필수!
• JWT 로그인을 구현했어요. 데코레이터를 이용한 _Validation_은 필수!

영화 상세 페이지

• 영화 상세 정보를 보여줘요. 평균 별점, 출연진, 리뷰, 이미지 URL, 컬렉션 등을 포함하고 있어요.
• 로그인된 유저는 평가를 하고 코멘트를 남길 수 있어요.

마이 페이지

• 간단한 유저 정보를 보여줘요. 유저 이미지, 유저 네임, 설명 등을 포함해요.
• 유저가 평가한 영화 목록을 보여줘요.

😎   잘한 점  

1. 친해졌다!

처음에 우리팀은 말수가 적은 사람들이 모여있어서 PM인 저로서는 조금 걱정이었어요. 그래서 매일 점심, 저녁 중 한 번은 식사를 꼭 같이해야 한다고 생각을 했어요. 다들 그렇게 생각하셨는지, 밥을 같이 먹으며 프로젝트에 대한 것 뿐만 아니라 개인적인 이야기를 서로 많이 했어요. 어색하게 지내는 사람이 없었다는 것으로 성공적! 😍

2. 목표한 만큼 구현했다!

10일이라는 짧은 기간 동안 우리팀은 각자가 맡은 필수구현 사항을 모두 구현했어요! 처음에 "이게 잘될까? 🤔" 의구심이 들었지만 시간이 지날수록 "오~ 왠지 다 할 수 있겠는걸?" 라는 생각으로 바뀌었어요. 특히 프론트 상욱님께서 무언가 구현할 때 마다 팀원들에게 자랑하는 모습을 보면서 정말로 흐뭇했어요. 한편, 백엔드인 저는 만든걸 보여줘도 팀원들은 시큰둥~ ㅋㅋㅋㅋㅋㅋㅋ 🤣

😔   아쉬운 점  

잘한게 있으면 그렇지 못한것도 있는게 인생이라지만, 이번 프로젝트는 아쉬운 점이 정말 많았어요. 하지만 어쩌겠어요! 앞으로 잘하면 되는걸요 😊!

1. 문서화의 부족

프로젝트 시작할 때, 사이트 분석을 오랜 시간 두고 버튼 하나하나 클릭을 해보면서 했어야 했는데... 😢 이런것들을 문서화 하지 않고 노트에 대충 적어 놓으니 까먹기도 하고 중간에 "충희님, 이런 기능도 있어요!!" 소리를 몇 번 듣기도 했어요. 2차 프로젝트 때는 하루를 모두 써도 좋으니 꼭 문서화를 해야겠어요!!

2. 나는 왜 이리도 침착하지 못했나

코드가 길어지고 중복될 것 같다 싶으면 모듈화하고 함수를 만들고 이런 것들을 머리로 모두 알고 있지만, 막상 실제 코딩할 때는 지키지 못했던 것이 사실이에요. 멘토님에게 코드 리뷰를 받아, 가이드를 따라서 코드가 예뻐지긴 했지만, 처음에 작성한 코드를 생각하면 어휴... 😓 다음번에는 수정 요청 없이 바로 Merge되는 Pull Request 날리기 도-----전!

🥳   보여주고 싶은 코드   🥳

1. 재사용 가능한 함수 작성

이번 프로젝트에는 GET 요청 API를 많이 작성하다 보니 JSON 바디가 굉~~장히 길어지고 중복되는 경우가 많았어요. 그래서 아래와 같이 많은 수의 함수를 만들어두고 여러번 재사용 했답니다. 리스트 컴프리헨션 사용 마스터는 덤! 😎

위의 코드는 이곳에서 확인이 가능해요!

2. DB Hit를 줄이기 위한 노력!

우리 백엔둥이들에게는 데이터베이스에 쿼리를 한번 더 날리냐 덜 날리느냐가 굉장히 중요해요! 장고에서는 select_related(), prefetch_related()와 같은 메서드를 이용하면 된답니다.

select_related() 의 공식 문서 번역이 저의 블로그 에 있어요!

위의 코드 또한 이곳에서 확인이 가능해요!

컬렉션에 담긴 영화 정보를 알고 싶은데 prefetch_related()가 없었다면 아마도 아래와 같은 코드를 작성했을거에요 😭. Oh là là..

collections = Collection.objects.all().order_by('?')[:limit]
for collection in collections:
    film_collections = FilmCollection.objects.filter(collection=collection)
    for film_collection in film_collections:
        print(film_collection.film.korean_title)

👋   마무으리  

먼저 부족한 PM을 커버해준 우리 팀원들에게 고맙다는 말을 해주고 싶어요. 그리고 항상 힘을 주는 위코드 동기들, 멘토님들이 있어서 다행이에요. 혼자였다면, View 하나 만들고 포기했을거에요...ㅋㅋㅋㅋㅋㅋ. 함께해서 WeCode!

엥?? 3개월이요? 저는 이미 개발자입니다만?

그냥 GeeksForGeeks에서 데코레이터 페이지를 번역했다.

서론

파이썬에서, 함수는 first class object 이다. 그 말인즉슨,

• 함수는 객체이다; 변수에 저장되어 질 수 있고, 다른 함수에서 리턴값이 될 수도 있다.
• 함수는 다른 함수 내부에서 선언되어 질 수 있고, 다른 함수의 인자로 넘겨질 수도 있다.

데코레이터는 프로그래머가 함수 또는 클래스의 behavior를 조작한다는 점에서 굉장히 파워풀하고 유용한 파이썬 문법이다. 데코레이터는 직접적으로 함수를 조작하지 않고 함수의 기능을 확장하기 위해 함수를 감싼다.

데코레이터에서 함수는 다른 함수의 인자로 넘겨져 다음 wrapper 함수 내부에서 호출된다.

Syntax for Decorator

@gfg_decorator
def hello_decorator(): 
    print("Gfg") 

'''위의 코드는 다음과 동일하다 - 

def hello_decorator(): 
    print("Gfg") 

hello_decorator = gfg_decorator(hello_decorator)'''

위의 코드에서, gfg_decorator 는 callable 함수이고, 또 다른 callable 함수인 hello_decorator 의 상단에 위치하여 코드를 추가해주고, 그것의 wrapper 함수를 리런한다.

Decorator can modify the behavior

# 데코레이터를 선언한다. 
def hello_decorator(func): 

    # inner1은 func 인자를 호출하는 Wrapper 함수이다.
    def inner1(): 
        print("Hello, this is before function execution") 

        # wrapper 함수의 내부에서 실제 함수를 호출한다. 
        func() 

        print("This is after function execution") 

    return inner1 


# wrapper 함수에서 호출될 함수를 선언한다.
def function_to_be_used(): 
    print("This is inside the function !!") 


# 'function_to_be_used' 함수를 그 기능을 확장하기 위해 데코레이터에 인자로 넘겨준다.
function_to_be_used = hello_decorator(function_to_be_used) 


# 함수를 호출한다.
function_to_be_used() 

결과

Hello, this is before function execution
This is inside the function !!
This is after function execution

"function_to_be_used"가 어떻게 호출되었지는 그 단계를 살펴보자

데코레이터를 사용하는 함수의 실행 시간을 확인하기 위한 다른 예제를 살펴보자.

# importing libraries 
import time 
import math 

# 인자로 들어온 함수의 실행시간을 계산하는 데코레이터
def calculate_time(func): 

    # 함수가 인자를 받는다면 다음과 같이 파라미터를 써준다.
    def inner1(*args, **kwargs): 

        # 함수가 실행되기 전에 시간을 체크한다.
        begin = time.time() 

        func(*args, **kwargs) 

        # 함수가 실행된 후 시간을 체크한다.
        end = time.time() 
        print("Total time taken in : ", func.__name__, end - begin) 

    return inner1 


# 어떠한 함수도 시간 측정이 가능해졌다.
@calculate_time
def factorial(num): 

    # 2초간 sleep을 걸어준다.
    # 이렇게 하면 실제 차이를 볼 수 있다.
    time.sleep(2) 
    print(math.factorial(num)) 

# 함수를 호출한다.
factorial(10)

결과

3628800
Total time taken in :  factorial 2.0061802864074707

What if a function returns something ...

위의 모든 예제의 함수들은 아무것도 리턴하지 않았다. 리턴값이 있을 때의 예제를 살펴본다.

def hello_decorator(func): 
    def inner1(*args, **kwargs): 

        print("before Execution") 

        # 리턴된 값을 받는다.
        returned_value = func(*args, **kwargs) 
        print("after Execution") 

        # 그 값을 다시 리턴한다.
        return returned_value 

    return inner1 


# 함수에 데코레이터를 붙인다.
@hello_decorator
def sum_two_numbers(a, b): 
    print("Inside the function") 
    return a + b 

a, b = 1, 2

# 리턴값을 받는다.
print("Sum =", sum_two_numbers(a, b)) 

결과

before Execution
Inside the function
after Execution
Sum = 3

select_related()

select_related(*fields)

쿼리가 실행될 때 related 객체 데이터를 추가적으로 SELECT 해오고, 외래키 관계를 "따르는 (follow)" 하나의 QuerySet을 리턴한다. 당장은 복잡한 쿼리를 만들지만 나중에 외래키 관계에 따른 추가적인 데이터베이스 쿼리를 생성하지 않게되는 장점이 있다.

아래의 예시는 일반적인 lookup과 select_related() lookup 사이의 차이를 보여준다. 여기에 일반적인 lookup이 있다:

# 데이터베이스에 쿼리를 날린다.
e = Entry.objects.get(id=5)

# Entry와 관계를 맺고 있는 Blog 객체를 가져오기 위해 다시 데이터베이스에 쿼리를 날린다.
b = e.blog

그리고 여기 select_related() lookup이 있다:

# 데이터베이스에 쿼리를 날린다.
e = Entry.objects.select_related('blog').get(id=5)

# 데이터베이스에 쿼리를 날리지 않는다. e.blog는 이미 이전 쿼리에서 가져왔기 (prepopulated) 때문이다.
b = e.blog

어떤 객체의 queryset에도 select_related() 를 사용 할 수 있다:

from django.utils import timezone

# 나중에 포스팅되도록 예정된 엔트리들을 가진 블로그들을 찾는다.
blogs = set()

for e in Entry.objects.filter(pub_date__gt=timezone.now()).select_related('blog'):
    # select_related() 함수가 없었다면, 각 엔트리에 관계된 블로그를 fetch 하기 위해 각 루프 회차때 마다 데이터베이스 쿼리를 날려야한다.
    blogs.add(e.blog)

filter() 와 select_related() 함수 chaining의 순서는 중요하지 않다. 아래의 두 쿼리셋은 동일하다:

Entry.objects.filter(pub_date__gt=timezone.now()).select_related('blog')
Entry.objects.select_related('blog').filter(pub_date__gt=timezone.now())

비슷한 방법으로 외래키의 객체가 포함하는 객체를 쿼리하기 위해 외래키 객체를 참조할 수도 있다. 만약 다음과 같은 모델들이 있다면:

여기서 Book의 외래키는 Person. 외래키 Person의 객체는 City. 결국 City를 참조하기 위해 아래의 예시가 있다.

from django.db import models

class City(models.Model):
    # ...
    pass

class Person(models.Model):
    # ...
    hometown = models.ForeignKey(
        City,
        on_delete=models.SET_NULL,
        blank=True,
        null=True,
    )

class Book(models.Model):
    # ...
    author = models.ForeignKey(Person, on_delete=models.CASCADE)

... Book.objects.select_related('author__hometown').get(id=4) 의 실행은 연관된 Person과 City 객체를 캐쉬한다.

# Book의 author 필드와 Person의 hometown 필드로 조인문을 만들어 데이터베이스에 쿼리를 날린다.
b = Book.objects.select_related('author__hometown').get(id=4)
p = b.author         # 쿼리를 날리지 않는다.
c = p.hometown       # 쿼리를 날리지 않는다.

# select_related() 를 사용하지 않는다면...
b = Book.objects.get(id=4)  # 쿼리를 날린다.
p = b.author                # 쿼리를 날린다.
c = p.hometown              # 쿼리를 날린다.

select_related() 에 전달될 필드 리스트를 통해 ForeignKey 또는 OneToOneField 관계를 참조할 수 있다.

select_related() 에 전달될 필드 리스트를 통해 OneToOneField 의 반대 방향도 참조할 수 있다. - 즉, OneToOneField 타입의 필드를 선언한 객체로 참조가 가능하다는 말이다. 그 필드의 이름을 명시하기 보다는, OneToOneField 타입의 필드를 선언할 때 related_name 옵션을 사용한다.

가끔은 객체 간의 관계가 복잡하게 얽혀있거나, 프로그래머가 그 모든 관계를 파악하지 파악하지 못하고 있을 때, select_related() 를 사용해야할 상황들이 있다. 이러한 경우에는 argument 없이 select_related() 를 호출한다. 그러면 찾을 수 있는 모든 non-null 외래키 데이터를 SELECT 하게 된다 - nullable 외래키들은 반드시 명시해야한다. 이것은 쿼리를 더 복잡하게 만들고 실제로 필요한 경우보다 많은 데이터를 반환할 수 있으므로 대부분의 경우 권장되는 방법은 아니다.

QuerySet에서 과거 select_related() 호출에 의해 추가된 related 필드들을 지워야하는 경우, None을 파라미터로 넘겨줄 수 있다.

without_relations = queryset.select_related(None)

select_related() 를 chaining 하여 호출하는 것도 가능하다. select_related('foo', 'bar') 은 select_related('foo').select_related('bar') 과 동일하다.

Django Rest Framework를 장고 프로젝트에 설정할 수 있어야한다!

모델 클래스

class Toy(models.Model):
    created = models.DateTimeField(auto_now_add=True)
    name = models.CharField(max_length=150, blank=False, default='')
    description = models.CharField(max_length=250, blank=True, default='')
    toy_category = models.CharField(max_length=200, blank=False, default='')
    release_date = models.DateTimeField()
    was_included_in_home = models.BooleanField(default=False)

    class Meta:
        ordering = ('name',)

Serializer 클래스

from rest_framework import serializers
from toys.models import Toy

class ToySerializer(serializers.Serializer):
    pk = serializers.IntegerField(read_only=True)
    name = serializers.CharField(max_length=150)
    description = serializers.CharField(max_length=250)
    release_date = serializers.DateTimeField()
    toy_category = serializers.CharField(max_length=200)
    was_included_in_home = serializers.BooleanField(required=False)

    def create(self, validated_data):
        return Toy.objects.create(**validated_data)

    def update(self, instance, validated_data):
        instance.name = validated_data.get('name', instance.name)
        instance.description = validated_data.get('description', instance.description)
        instance.release_date = validated_data.get('release_date', instance.release_date)
        instance.toy_category = validated_data.get('toy_category', instance.toy_category)
        instance.was_included_in_home = validated_data.get('was_included_in_home', instance.was_included_in_home)
        instance.save()
        return instance

장고 쉘 실행

python manage.py shell

지금 부터 파이썬 쉘에 한줄 한줄 입력해야한다...

imports

from datetime import datetime
from django.utils import timezone
from io import BytesIO
from rest_framework.renderers import JSONRenderer
from rest_framework.parsers import JSONParser
from toys.models import Toy
from toys.serializers import ToySerializer

객체 생성

toy_release_date = timezone.make_aware(datetime.now(), timezone.get_current_timezone())

toy1 = Toy(name='Snoopy talking action figure', 
    description='Snoopy speaks five languages', 
    release_date=toy_release_date, 
    toy_category='Action figures', 
    was_included_in_home=False)
toy1.save()

객체 확인

print(toy1.pk)
print(toy1.name)
print(toy1.created)
print(toy1.was_included_in_home)

파이썬 객체 to 딕셔너리

모델 객체를 파이썬 딕셔너리로 변환한다.

serializer_for_toy1 = ToySerializer(toy1)
print(serializer_for_toy1.data)

{
  'pk': 1,
  'name': 'Snoopy talking action figure',
  'description': 'Snoopy speaks five languages',
  'release_date': '2017-10-09T12:11:37.090335Z',
  'toy_category': 'Action figures',
  'was_included_in_home': False
}

Serialization

JSONRenderer 의 render() 메서드는 위에서 만든 딕셔너리를 바이너리 JSON 형태로 변환해준다.

json_renderer = JSONRenderer()
toy1_rendered_into_json = json_renderer.render(serializer_for_toy1.data)
print(toy1_rendered_into_json)

b'{"pk":1,"name":"Snoopy talking action figure", "description": "Snoopy speaks five languages", "release_date": "2017-10-09T12:11:37.090335Z", "toy_category": "Action figures", "was_included_in_home": false}

Deserialization

JSON 문자열을 바이트 타입으로 바꾸고, ByteIO 객체로 바꾼다. JSONParser 의 parser() 메서드를 이용하여 딕셔너리 형태로 변환한다.

json_string_for_new_toy = '{"name":"Clash Royale play set","description":"6 figures from Clash Royale", "release_date":"2017-10-09T12:10:00.776594Z","toy_category":"Playset","was_included_in_home":false}'
json_bytes_for_new_toy = bytes(json_string_for_new_toy, encoding="UTF-8")
stream_for_new_toy = BytesIO(json_bytes_for_new_toy)
parser = JSONParser()
parsed_new_toy = parser.parse(stream_for_new_toy)
print(parsed_new_toy)

{
    'name': 'Clash Royale play set',
    'description': '6 figures from Clash Royale',
    'release_date': '2017-10-09T12:10:00.776594Z',
    'toy_category': 'Playset',
    'was_included_in_home': False
}

저장

위에서 만든 딕셔너리를 Serializer 객체를 이용해 Toy 객체로 변환하고 데이터베이스에 저장한다.

new_toy_serializer = ToySerializer(data=parsed_new_toy)
if new_toy_serializer.is_valid():
    toy3 = new_toy_serializer.save()

장고 쉘 종료

quit()