브랜디는 20대 여성을 위한 쇼핑앱이다. 여성쇼핑앱에 그치지 않고 남성쇼핑앱 '하이버', 패션 창업인큐베이팅 서비스 '헬피'까지 서비스하며 사업 영역을 확장했다. 동대문 D2C(Direct to Consumer) 플랫폼 트랜디까지 동대문 패션 사업에 적극적으로 뛰어들고 있는 기업이다. 업계 최초로 100명 규모의 개발자 채용을 선언하는 등 빠른 성장을 이루고 있는 회사이다.

프로젝트 정보

총 4명의 백엔드 개발자가 한 팀이 되어 1달간 프로젝트를 진행했다. Flask를 이용하여 'Brandi' 서비스&어드민 페이지 구현했다. 프론트엔드 개발자는 참여하지 않았기 때문에 모든 프론트 구현은 팀장께서 혼자서 하셨다.

진행기간 : 2021.05.10 ~ 2021.06.03 팀원: 백승찬,김현영,서득영,이서진

깃허브 주소

서비스 페이지: https://github.com/poketsc/brandi-service 어드민 페이지: https://github.com/poketsc/brandi-admin

기술스택

Framework

• Flask(1.1.2)

Language

• Python(3.8)

DB

• Mysql
• 로컬 데이터베이스

ERD

• AqueryTool

Communication

• Github
• Slack
• Notion

통신

• Postman

우리팀이 구현한 기능

서비스

• 로그인
• 메인페이지
• 상품상세
• 장바구니
• 배송지
• 주문
• 주문완료

어드민

• 로그인
• 셀러가입
• 회원 관리 > 셀러 계정 관리 (마스터)
• 회원 관리 > 셀러 정보 수정
• 상품 관리 > 상품 등록
• 상품 관리 > 상품 관리
• 상품 관리 > 상품 관리 > 판매, 진열 적용
• 주문 관리 > 상품 준비 관리
• 주문 관리 > 상품 준비 관리 > 배송 처리
• 주문관리 > 주문상세

내가 구현한 기능

서비스

• 상품상세
• 장바구니
• 배송지
• 주문
• 주문완료

진행방식

이번 인턴쉽 프로젝트에서도 다른 프로젝트때와 마찬가지로 Agile(애자일)의 대표 관리 Practice인 Scrum(스크럼) 방법으로 프로젝트를 진행하였다. Scrum은 특정 개발 언어나 방법론에 의존적이지 않으며, 제품 개발 뿐만 아니라 일반적인 프로젝트 관리에도 사용 가능한 프로세스 프레임워크이다. Scrum은 작은 주기(Sprint)로 개발 및 검토를 하며 효율적인 협업 방법을 제공한다. 정보처리기사 공부를 할때 Waterfall 방식과 애자일 방식을 배웠던 기억이 난다. 이번 인턴쉽 프로젝트가 내가 한 다른 프로젝트와 달랐던 점은 백엔드개발자만 있었다는 점이다. 프론트엔드 기능은 전부다 구현이 되어있었기 때문에 우리가 API를 모두 프론트와 통신할수 있었다. 우리 팀은 매일 아침 9시 30분에 만나서 15분~20분간 회의를 진행하였다. 프로젝트를 시작하고 매주 월요일에 중간점검을 가졌다. 우리가 처음 생각했던 기능들을 다 구현할수 있을지 확인하기 위해서였다.

1주차

우리는 모두 Django 프레임워크만 사용해본 개발자들이였다. 우리는 Flask에 대한 이해가 부족했고 Django와는 다르게 Flask는 아키텍처 패턴부터 전부다 구현해야 했다. 득영님이 Flask의 초기세팅을 담당했다. 득영님이 Flask 초기세팅을 혼자서 했기 때문에 고생을 많이 했다. 서진님이 Postman을 활용해서 프론트와 어떻게 통신해서 결과값을 어떻게 주고 받을지에 대해 문서작업을 했고 현영님과 나는 AqueryTool을 사용해서 데이터 모델링을 했다. 이번 데이터 모델링에서 다른 프로젝트와 달랐던 점은 이력관리를 고려했다는 점이다. 우리는 점이력과 선분이력 중에 어떤 방식으로 이력관리를 할지 고민했고 선분이력을 선택했다. 이번에 점 이력이 아닌 선분이력을 선택한 이유는 시작 시점과 종료 시점을 관리함으로써 과거 특정 시점의 데이터 조회를 손쉽게 할 수 있는 장점이 있기 때문이였다. 이번 데이터모델링은 실제 현업에서 사용하는 방법과 유사하게 구현했다. 이력관리로 인해 테이블의 개수가 2배는 늘어난것 같다.

우리가 구현한 데이터모델링이다. 1주차에 완성한 모델링은 아니다. 기능을 구현하면서 많은 컬럼 추가와 관계 수정이 있었다. 우리는 처음으로 역정규화를 사용했는데 역정규화(denormalization)는 정규화된 데이터베이스에서 성능을 개선하기 위해 사용되는 전략이다. 일부 컬럼의 데이터를 중복 추가함으로써 데이터베이스의 읽기 성능을 개선하려는 의도였다. 팀장님께서 역정규화를 하는데 있어서 명확한 이유가 있어야 한다고 하셨다.

위에 테이블에서 address_histories 테이블에 있는 배송지주소, 배송지추가정보, 우편번호가 shipment_histories 테이블에도 있는것을 볼수있다. shipment_histories에도 똑같은 컬럼을 추가한 이유는 유저가 address 정보를 바꾸면 주문 했을 당시에 주소를 알수가 없어서 중복 추가 했다. 이 역시도 수정을 통해 완성된 모습이다. 한번에 완벽하게 데이터모델링을 하는것은 아직 불가능한것 같다. 많은 경험이 필요한것 같다.

AqueryTool 주소 : https://aquerytool.com:443/aquerymain/index/?rurl=4ee0ca00-2098-427d-b86d-cfad789e32c0 password : 7vu8c5

2주차

Flask 초기세팅, API 문서작업, 데이터 모델링을 끝내고 우리는 API 기능 구현을 시작했다. 백앤드 api의 아키텍처에는 여러가지가 있을것이지만 우리는 가장 널리 사용되는 레이어드 아키텍처에 맞게 프로젝트를 3가지 section으로 나누었다.

view

프로젝트에서 backend endpoint경로를 처리해주는 부분이다. 클라이언트에게서 온 request를 처리했다. db를 열고 닫는다.

service

api에서 로직을 담당하는 영역이다. 프론트로부터 받는 키값에 대한 에러처리를 제외한 대부분의 에러처리는 service영역에서 처리했다.

model

raw query를 사용해서 데이터베이스와 직접적으로 통신하는 영역이다.

내가 처음으로 구현한 API 기능은 장바구니(POST) 였다.

view에서 먼저 프론트로부터 받은 데이터 형식이 올바른지 확인해주었다. 여러개의 상품이 한번에 담길수 있어서 for문으로 각각의 상품에 대한 형식을 체크했다. 그렇게 체크가 끝난후에 db를 열어주고 로직을 담당하는 post_cart 함수를 실행한다.

서비스 부분에서는 여러가지 경우의 수가 존재하기 때문에 if, else 문으로 경우의 맞게 처리하였다. 여기서 나는 하나의 dao 에서는 하나의 query문만을 쓰기 위해서 여러개의 dao를 만들어서 호출했다.

이 코드는 dao에서 선분 이력을 관리하기 위한 코드이다. 장바구니에 같은 상품이 이미 존재하면 시간을 업데이트 하기 위해서 만든 쿼리문이다.

이 코드는 시간을 업데이트 한 정보를 복사한 후 수정하기 위한 코드이다. 재사용성을 위해서 조건문을 사용했다. 어떻게 이력을 관리할까를 고민하다가 이렇게 두개의 dao를 통해서 이력관리를 하였다. 이 한개의 기능을 구현하는데 오랜 시간이 걸렸다. 처음 사용해본 레이어드 아키텍쳐였고 프로젝트에 raw query를 처음 사용해보았기 때문에 익숙하지 않았다.

3주차

3주차때는 2주차때와 다르게 속도가 많이 빨라졌다. 처음 접해본 Flask라서 이해하는데 시간이 좀 걸렸던것 같다. 프레임워크는 어려운것은 없다고 생각한다. 다만 익숙하지 않을뿐이다. 내가 구현한 기능들의 대부분은 3주차에 다 만든것 같다. 그리고 본격적으로 팀장님과 기능을 붙여보기 시작했다. 3주차에 제일 기억에 남는것은 Postman의 거짓말이였다! Postman에서 잘 작동되던 코드가 프론트와 통신할때는 제대로 작동되지 않았다.

이 코드는 2주차때 수정하기 전 처음 만든 코드이다. where절에 ch.end_time = %(now)s 로 설정했을때 Postman에서는 문제가 없이 잘 돌아갔지만 프론트와 통신하는 과정에서 여러번의 요청이 들어왔을때 같은 시간으로 입력되서 데이터가 생성되는것을 알았다. 이론상으로는 같은 시간이 찍힐수가 없다고 생각했지만 문제가 발생했다.

문제를 해결하기 위해서 ch.id = %(cart_history_id)s를 넣는 방법을 택했다. primary Key를 이용하기 때문에 훨씬 안정적인 방법이였다. 이렇게 수정한 후에는 원하는대로 정상적으로 작동했다. 지금까지 Postman에서 잘 작동된 기능들은 프론트와 통신할때 문제를 발생시키지 않았다. 하지만 이번 경험을 통해서 100% 신뢰할 수 없다는 것을 깨달았다.

4주차

4주차에는 내가 구현한 모든 기능들을 프론트와 통신하고 주석을 다는데 시간을 썼다. 내가 그동안 했던 프로젝트에서는 주석을 사용하지 않았지만 이번 프로젝트에서는 각 코드가 어떤 의미를 갖는지, 어떤 데이터 값을 받고, 어떤 데이터를 결과값으로 리턴하는지 설명했다. 주석을 사용하면 코드는 깔끔해보이지는 않지만 어떤 의미로 기능을 구현했는지, 호출한 함수는 어떤 함수인지를 시간이 지난 후에도 좀더 쉽게 이해할수 있었다. 마지막날 내가 인턴쉽을 통해 배우고 구현한 기능들을 ppt로 만들어서 발표했다. ppt를 만드는데 시간을 좀더 투자했다면 더 멋진 발표가 되었을텐데 시간이 부족했다. 그 부분에서 많은 아쉬움이 남는다. 발표를 하면서 기억에 남는 질문은 왜 이력을 관리할때 END_DATE = '9999-12-31 23:59:59' 로 설정했는지 물어보셨다. 일반적으로 '9999-12-31 23:59:59'가 아닌 Null로 처리를 한다고 말씀해주셨다.

느낀점

내가 했던 마켓컬리, 여기어때 프로젝트는 2주짜리 짧은 프로젝트였지만 이번 프로젝트는 가장 길었던 1달짜리 프로젝트였다. 이전 프로젝트 경험으로 이번 프로젝트에서는 완성도 높은 결과물을 기대했다. 하지만 raw query, flask, 선분이력으로 인해서 새롭게 공부해야되는 내용들이 너무 많았다. 데이터모델링 과 flask 초기세팅에 많은 시간이 들어가면서 실제로 기능을 구현하고 프론트와 통신하는 시간이 부족했다. 결국에는 프레젠테이션을 준비하는 시간도 부족했다. 어떤 새로운 문제가 발생했을때 고민하는데 시간을 너무 많이 투자하면 그만큼 완성도가 떨어질 수 있겠다라는 생각을 했다. 우리가 해야하는 프로젝트는 시간이 정해져있었다. 시간을 효율적으로 분배하고 너무 많은 고민보다는 빠른 판단력이 필요했던 것 같다. 기업협업을 통해서 많이 성장한 것 같다. 앞으로는 효율적인 sql 작성을 위해서 책을 읽으면서 공부할 것이다.

종합숙박 O2O서비스 '여기어때'를 모티브로 한 프로젝트

개발 기간 : 2021.04.26 ~ 2021.05.07 팀 명 : 야, 여기어때(BetterChoice) 팀 인원 : 6명 프론트엔드 : 김효진, 박단비, 박성은 백엔드 : 백승찬, 신지원, 황수민

백엔드 깃허브 주소 : https://github.com/poketsc/19-2nd-betterChoice-backend

기술스택

Framework

• Django

  Language

• Python

  DB

• Mysql
• RDS

  Communication

• Github
• Slack
• Trello
• Notion

  배포 및 통신

• EC2
• Docker
• Postman
• httpie
• JSON

  ERD

• AqueryTool

Trello 와 Notion을 이용한 의사소통

Trello

Notion

ERD

URL : https://aquerytool.com:443/aquerymain/index/?rurl=9f3b4eae-ec1e-475c-b6aa-ccc73c62ed70 password : i706x8

우리팀이 구현한 Endpoint

내가 한 일

• 회원가입 시 핸드폰 인증(네이버 클라우드) 기능 구현
• 회원가입 기능 구현 (bcrypt를 이용한 비밀번호 해싱 후 저장)
• 로그인 기능 구현 (jwt를 활용하여 인증 기능 구현)
• AWS(S3)를 이용한 사진 업로드 기능 구현
• 모든 구현 기능 unittest 완료
• Docker 와 AWS(EC2)를 활용하여 배포

이번 프로젝트 목표

이번 프로젝트에서는 마켓컬리 프로젝트와는 다르게 많은 기능보다는 적은 기능이지만 소셜 기능과 unittest를 해보는것을 목표로 했다. 마켓컬리 프로젝트에서는 간단한 기능을 많이 해봤다면 이번 여기어때 프로젝트에서는 난이도가 조금 있는 기능들을 구현하려고 했다. 그래서 데이터모델링도 마켓컬리 프로젝트보다 훨씬 간단하게 구현했다. 마켓컬리 프로젝트와 똑같이 2주 프로젝트지만 unittest를 하기위해서 최대한 빠르게 데이터모델링을 끝내려고 했다.

재밌었던 api 기능

마켓컬리 프로젝트에서는 email로 비밀번호 찾기를 구현했었는데 핸드폰인증 기능을 구현해보면 재밌을것같아 구현해본 기능이다. 핸드폰 인증으로 네이버 클라우드를 선택한 이유는 가격이 저렴했기 때문이였고 100000만 포인트를 지급받아서 프로젝트를 하는데 있어서 사실상 무료로 사용할수 있었기 때문이다.

핸드폰 번호를 입력한후 핸드폰 인증버튼을 누르면 utils.py 에 직접만든 auth_number() 함수를 실행시켜 4자리의 난수를 받는다. update_or_create 메서드로 같은 핸드폰번호로 이미 데이터를 생성한적이 있으면 난수를 수정하고 데이터를 생성한적이 없으면 핸드폰번호와 생성된 난수로 인스턴스를 생성한다. 그리고 utils.py에 만들어진 send_sms() 함수를 호출하고 인자값으로 phone_number, 난수값을 입력한다. send_sms() 함수에서 URL,ACCESS_KEY,FROM_PHONE_NUMBER 등은 보안을 위해서 my_settings.py에 저장시킨후 불러왔다. make_signature() 와 send_sms() 함수는 네이버 클라우드에서 제공하는 api를 사용한것인데 그대로 사용하면 작동이 안된다. uri도 수정해야했고 몇번의 시행착오 끝에 실행 가능한 코드를 구현할수 있었다. 인증번호를 사용자에게 보낸후 사용자가 확인후에 인증번호를 입력하면 데이터베이스에 저장된 정보와 확인후에 일치하면 성공 메세지를 프론트에게 전달한다. 처음으로 구현해본 소셜 기능이였고 핸드폰으로 인증번호가 왔을때는 정말 신기하고 이게 진짜 되는구나라는 생각을 했다.

또다른 재밌었던 api 기능

마켓컬리 프로젝트에서는 사진업로드가 되지않는 글만 입력할수 있게 review api를 만들었었다. 이번 프로젝트에서는 사진업로드가 가능한 api를 구현해 보고 싶어 AWS(S3)를 사용해 보았다.

S3_CLIENT 에는 aws_access_key_id, aws_secret_access_key 등의 정보가 들어가 있는데 보안을 위해서 my_setting.py에 저장한 후 불러왔다. AWS_S3_BUCKET_NAME도 보안을 위해서 my_setting.py에 저장한 후 불러왔다. 사진을 한장이 아닌 여러장을 올릴수 있게 하기 위해서 리스트로 받은 값을 for문으로 처리해 하나하나 S3에 업로드 시켰다. S3에 업로드 후에 데이터베이스에 업로드된 이미지 url을 저장하기 위해서 url이 만들어지는 패턴을 이용해서 f-string으로 url을 만든후에 데이터베이스에 저장한다. f'https://{my_settings.AWS_S3_BUCKET_NAME}.s3.ap-northeast-2.amazonaws.com/{file.name}' 이때, 데이터베이스 hit을 최소화하고 속도를 향상 시키기 위해서 bulk_create를 사용했다.

나를 힘들게 했던 unittest!!!

처음 해본 unittest지만 외부 api가 필요없는 기능에서는 unittest가 어렵지 않았다. 하지만 외부 api를 사용해야하는 기능에서는 mocking 기법을 사용해야했다. 그 이유는 운영 환경 대비 제약이 많은 테스트 환경에서는 실제 데이터베이스와 연동하거나 실제 외부 API를 호출하기가 불가능한 경우가 많기때문이다. 가령 가능하더라도, 이렇게 외부 서비스에 의존하는 테스트는 해당 서비스에 문제가 있을 경우 깨질 수 있으며 실행 속도도 느릴 수 밖에 없다. mocking 기법을 사용하지 않으면 test인데 실제로 파일이 s3가 올라가거나 핸드폰인증에서 실제로 메세지가 전송된다. 따라서 단위 테스트를 작성할 때 외부에 의존하는 부분을 임의의 가짜로 대체하는 기법이 자주 사용되는데 이를 mocking 이라고 한다. 다시 말해, 모킹(mocking)은 외부 서비스에 의존하지 않고 독립적으로 실행이 가능한 단위 테스트를 작성하기 위해서 사용되는 테스팅 기법이다. 특히 s3를 이용해야하는 기능에서는 mocking 기법도 사용해야하고 multipart form data로 데이터를 받아야해서 unittest 하는데 가장 어려웠던 부분이였다. Multipart form data로 값을 전달받는 과정에서 정말 많은 시행착오가 있었다. 위 코드는 이렇게 많은 시행착오 끝에 만들어진 unittest중에 여러개의 사진을 올렸을때 성공하는 테스트이다.

느낀점

BetterChoice의 PM으로써 부족한점이 많았지만 팀원들의 밝은 에너지가 있어서 잘 마무리 할수 있었던것 같다. 팀원들을 많이 도와드리고 싶었지만 나도 처음해보는 기능들이여서 절대적인 시간투자가 필요했다. 특히 수민님, 질문에 대한 제대로된 답변을 드리지 못해 죄송해요!!! 2차 프로젝트라서 더 많이하고 잘할수 있었을것만 같았는데 역시 새로 해야되는 추가사항들이 있었다. unittest,docker,외부 api.... 어려웠지만 기능들이 마켓컬리 프로젝트에 비해 훨씬 재미었다. 특히 핸드폰인증 성공했을때 자랑하려고 사람들에게 핸드폰번호 물어봤었던 기억이 있다. 개발을 하면서 불가능한것은 없다고 느낀다. 다만 익숙하지 않을뿐이라고 생각한다. 이번 프로젝트를 통해서도 많이 성장한것 같아서 뿌듯하다.

프론트엔드 깃헙 주소 https://github.com/wecode-bootcamp-korea/19-1st-Market-ChoKurly-frontend

백엔드 깃헙 주소 https://github.com/wecode-bootcamp-korea/19-1st-Market-ChoKurly-backend

진행기간 : 2021.04.12 ~ 2021.04.23 팀명 : MarketChokurly 팀원 : 프론트엔드 : 이예원,서동이,채준형 백엔드 : 백승찬,안정현,김영훈

기술스택

Framework

• Django

  Language

• Python

  DB

• Mysql
• RDS
• AqueryTool
• CSV

  Communication

• Github
• Slack
• Trello
• Notion

  배포 및 통신

• EC2
• Postman
• httpie
• JSON

백엔드 팀이 구현한 기능

1. users

• 회원가입
• 아이디 찾기
• 비밀번호 찾기
• 로그인
• 리뷰
• 좋아요

2. products

• 카테고리
• 상품리스트
• 상품상세정보
• 상품검색

3. orders

• 주문하기
• 주문상세정보
• 장바구니

내가 구현한 기능

• 아이디 찾기

• 비밀번호 찾기
• 리뷰
• 좋아요
• 카테고리
• 상품리스트
• 상품검색

진행방식

Agile(애자일)의 대표 관리 Practice인 Scrum(스크럼) 방법으로 프로젝트를 진행하였다. Scrum은 특정 개발 언어나 방법론에 의존적이지 않으며, 제품 개발 뿐만 아니라 일반적인 프로젝트 관리에도 사용 가능한 프로세스 프레임워크이다. Scrum은 작은 주기(Sprint)로 개발 및 검토를 하며 효율적인 협업 방법을 제공한다. 정보처리기사 공부를 할때 Waterfall 방식과 애자일 방식을 배웠던 기억이 난다. 이론적으로는 어떤 차이가 있는지는 알고 있었지만 이번에 프로젝트를 하면서 애자일의 방식인 Scrum 방식을 사용함으로써 개발자들이 어떤 환경에서 어떤 방식으로 일을 하는지 느낄 수 있었던 값진 시간이였다. 우리 팀은 매일 아침 11시 10분에 만나서 15분~20분간 회의를 진행하였다. 프로젝트를 시작하고 1주일뒤에 중간점검을 가졌다. 2주차에 더 나은 진행방식을 위해 1주일간 진행된 프로젝트 결과물을 보면서 지난 1주일을 되돌아보는 시간을 가졌다.

중간점검을 통해 발견된 Django의 이해부족

내게는 개발자로서 첫번째 프로젝트였던 만큼 얼마나 빠른속도로 좋은 결과물을 만들어 내는가 보다는 팀원끼리의 코드리뷰가 더 중요하다고 생각했었다. 우리는 모델링을 통해 3개의 앱으로 기능을 나누었다. users, products, orders 앱들로 구성된 프로젝트를 3명의 백엔드 멤버들이 어떻게 나누어서 진행을 할까를 고민하다가 서로 코드를 리뷰 해줄수 있는 방식으로 진행하기 위해 하나의 앱에서 뷰를 나누어 작성하는 방식으로 진행하였다. 각각의 앱을 한개씩 맡는 방법도 생각했지만 서로 한번도 해보지않은 기능에 대해서 팀원이 질문하면 대답을 못해줄것 같았다. 그때는 View는 기능 단위로 짜야한다는 말을 제대로 이해하지 못했던 시간이였다. 1주일이 지나고 중간점검을 통해서 내가 View에 대한 이해가 부족했었다는것을 깨달았다. 프론트엔드 멤버들과 매일 소통하면서 나도 모르게 내 머릿속에 기능 단위가 아닌 페이지 단위로 기능을 구현하려고 했었다. 아이디찾기, 비밀번호 찾기 기능을 구현하는 순간에도 내 머릿속에는 아이디 찾기 페이지, 비밀번호 찾기 페이지를 떠올렸던것 같다.

기능 단위를 이해한 후의 나의 모습

난 기능을 하고 있는 View를 작성하고 있다고 생각 했지만 중간점검을 통해 멘토님에게 자신있게 보여주었던 View의 이름이 MainPageView였다. 그전에 내가 만들었던 View는 아이디 찾기와 비밀번호 찾기 였는데 이 두개의 View에서는 문제가 되지 않았는데 그럴수 있었던 이유가 이 두 개는 페이지가 달랐기 때문이였다. 만약 내가 기능이라는 말을 제대로 이해했다면 아이디 찾기와 비밀번호 찾기를 만든 후에 MainPageView라는 View를 만들지 않았을 것이다. 주말을 이용해서 열심히 만든 내 코드가 어떠한 기능을 위한것이 아닌 메인 페이지를 구현하기 위해서 만들어진 코드였다. 다른 웹사이트에서는 모르겠지만 마켓컬리 사이트의 경우 메인페이지를 위한 코드는 상품을 보여주는 View 하나면 가능했다. 이것을 깨닫고 난 후에 팀원들과 하나의 앱을 나누어서 같이 개발하자고 생각했던것이 효율성이 떨어진다는것을 깨달았다. 처음 만들어보는 app에서 우리가 처음부터 정확하게 기능을 나누는것도 어떻게 보면 어려운 일이였다. 예를 들어, 하나의 View를 만들면서 다른사람이 만들고 있는 View도 구현 할 수 있는 경우가 생겼다. 그래서 중간점검이 있고난 후에는 app별로 나누어서 개발하려고 했다.

내가 발전할 수 있었던 코드

class MainPageView(View):
    def get(self,request):
        products = Product.objects.order_by('?')[:21]
        this_products = []
        for product in products:
            this_products.append(
                {
                    "id"    : product.id,
                    "name"  : product.name,
                    "price" : product.price,
                    "discount_rate" : product.discount_rate.discount_rate,
                    "discounted_price" : product.price - (product.price * product.discount_rate.discount_rate),
                    "thumbnail_image": product.thumbnail_image,
                    "sticker":product.sticker.name
                }
            )
        # this_products

        high_discount_products = Product.objects.order_by('-discount_rate')[:7]
        affordable_products = []
        for high_discount_product in high_discount_products:
            affordable_products.append(
                {
                    "id" : high_discount_product.id,
                    "name" : high_discount_product.name,
                    "price" : high_discount_product.price,
                    "discount_rate" : high_discount_product.discount_rate.discount_rate,
                    "discounted_price" : high_discount_product.price - (high_discount_product.discount_rate.discount_rate * high_discount_product.price),
                    "thumbnail_image" : high_discount_product.thumbnail_image,
                    "sticker": high_discount_product.sticker.name
                }
            )

        # affordable_products


        sub_category = SubCategory.objects.get(pk=2)
        product_sets = sub_category.product_set.all()
        product_sets = product_sets.order_by('?')[:7]
        md_recommends = []
        for product_set in product_sets:
            md_recommends.append(
                {
                    "id" : product_set.id,
                    "name" : product_set.name,
                    "price" : product_set.price,
                    "discount_rate" : product_set.discount_rate.discount_rate,
                    "discounted_price" : product_set.price - (product_set.price * product_set.discount_rate.discount_rate),
                    "thumbnail_image" : product_set.thumbnail_image,
                    "sticker": product_set.sticker.name
                }
            )

        # md_recommends


        products = Product.objects.order_by('created_at')[:id]
        today_new_products = []
        for product in products:
            today_new_products.append(
                {
                    "id" : product.id,
                    "name" : product.name,
                    "price" : product.price,
                    "discount_rate" : product.discount_rate.discount_rate,
                    "discounted_price" : product.price - (product.price * product.discount_rate.discount_rate),
                    "thumbnail_image" : product.thumbnail_image,
                    "sticker": product.sticker.name
                }
            )

        # today_new_products

        products = Product.objects.order_by('-stock')[:7]
        hot_products = []
        for product in products:
            hot_products.append(
                {
                    "id"   : product.id,
                    "name" : product.name,
                    "price" : product.price,
                    "discount_rate" : product.discount_rate.discount_rate,
                    "discounted_price" : product.price - (product.price * product.discount_rate.discount_rate),
                    "thumbnail_image" : product.thumbnail_image,
                    "sticker": product.sticker.name
                }
            )

        # hot_products

        products = Product.objects.order_by('price')[:7]
        lowest_price_products = []
        for product in products:
            lowest_price_products.append(
                {
                    "id"   : product.id,
                    "name" : product.name,
                    "price" : product.price,
                    "discount_rate" : product.discount_rate.discount_rate,
                    "discounted_price" : product.price - (product.price * product.discount_rate.discount_rate),
                    "thumbnail_image" : product.thumbnail_image,
                    "sticker": product.sticker.name
                }
            )

        # lowest_price_products

        return JsonResponse({'this_products':this_products, 'affordable_products':affordable_products,
        'md_recommends':md_recommends, 'today_new_products':today_new_products, 'hot_products':hot_products,
        'lowest_price_products':lowest_price_products}, status=200)

내가 주말에 열심히 만들었던 MainPageView이다. 총 6개의 기능을 하는 View인데 신상품,최저가 등등을 메인페이지에서 보여주기 위해서 만든 코드이다. 이렇게 만들고 나서 메인페이지 뷰가 있을 필요가 없다는 것을 깨달았다. 사실 6개의 기능은 한개의 로직으로 구성된 뷰에서 전부 처리가 가능했다.

class ProductListView(View):
    def get(self,request):
        category_id     = request.GET.get('category_id', None)
        sub_category_id = request.GET.get('sub_category_id', None)
        order_by_type   = request.GET.get('order_by_type', None)
        page            = int(request.GET.get('page', 1))
        limit           = int(request.GET.get('limit', 8))
        start           = (page - 1) * limit
        end             = page * limit

        if not category_id and not sub_category_id:
            products = Product.objects.order_by(order_by_type)[start:end]
        if category_id:
            products = Product.objects.filter(category_id=category_id).order_by(order_by_type)[start:end]
        if sub_category_id:
            products = Product.objects.filter(sub_category_id=sub_category_id).order_by(order_by_type)[start:end]

        results = [{

            "id": product.id,
            "name": product.name,
            "original_price": int(product.price),
            "discount_rate": float(product.discount_rate.discount_rate) if product.discount_rate else None,
            "discounted_price": int(product.price - (product.price * product.discount_rate.discount_rate)) if product.discount_rate else None,
            "thumbnail_image": product.thumbnail_image,
            "sticker": product.sticker.name if product.sticker else None,
            "comment": product.productinformation.comment if category_id or sub_category_id else None

        } for product in products]

        return JsonResponse({'RESULTS':results}, status=200)

이 코드는 쿼리 파라미터를 이용해서 원하는 정렬 방식, 원하는 상품의 갯수, 원하는 페이지 상품 등을 프론트엔드로 부터 받아서 원하는 데이터를 보내주는 코드이다. ProductListView를 통해서 어느 페이지에 있는 상품 리스트든 전부 다 이 View 하나로 처리가 가능해졌다. MainPageView라는 이름으로 View를 만든것이 View는 기능단위라는 것을 제대로 인지하지 못했었다는것을 깨닫게 해주는 순간이였다. 그리고 쿼리,패스 파라미터가 얼마나 개발의 속도를 빠르게 만들어주는지도 깨닫는 순간이였다. 만약 쿼리,패스 파라미터가 없었다면 얼마나 많은 View를 만들어야하고 얼마나 많은 중복된 코드가 존재할지 생각만해도 끔찍하다.

class UserLikeView(View):
    @login_required
    def get(self,request):
        product_id = request.GET.get('product_id')

        if not product_id:
            return JsonResponse({'MESSAGE':'INVALID_PRODUCT_ID'}, status=400)

        user       = request.user
        user_check = UserLike.objects.filter(user=user, product=product_id).exists()
        like_count = UserLike.objects.filter(product=product_id).count()
        product    = Product.objects.get(id=product_id)

        if not user_check:
            user.product.add(product)
            user.save()
            like_count += 1
            return JsonResponse({'RESULTS':like_count}, status=200)

        UserLike.objects.filter(user=user, product=product).delete()
        like_count -= 1
        return JsonResponse({'RESULTS':like_count}, status=200)

마지막에 내가 구현한 좋아요 기능이다. UserLike인데 Product와 User 테이블이 다대다 관계를 형성하면서 만들어진 중간 테이블인데 처음에 내가 구현할때는 좋아요를 누르고 취소하고를 반복할때 데이터를 추가하고 삭제하고를 반복하면 될거라고 생각했다. 하지만 데이터를 추가하고 삭제하는것을 반복하면 그만큼 DB관리에는 효율적이지 못하다는것을 알게 되었다. 또 한번 모델링 수정이 필요한 순간이였다.

class UserLikeView(View):
    @login_required
    def get(self,request):
        product_id = request.GET.get('product_id')

        if not product_id:
            return JsonResponse({'MESSAGE':'INVALID_PRODUCT_ID'}, status=400)

        user = request.user
        like, like_check = UserLike.objects.get_or_create(user=user,product=product_id)

        if not like_check:
            if like.is_like:
                like.is_like = False
            else:
                like.is_like = True

        like.save()
        total = UserLike.objects.filter(product=product_id, is_like=True).count()

        return JsonResponse({'RESULTS': total}, status=200)

데이터를 추가하고 반복하고를 하지않고 좋아요 기능을 구현한 코드이다. 우선 Product와 User의 중간 테이블인 UserLike 테이블에 is_like라는 BooleanField를 추가했다. 좋아요를 누르면 True 좋아요를 취소하면 False로 처리하기 위해서였다. 이렇게되면 데이터를 추가하고 삭제하고를 하지않고 좋아요 기능을 구현할 수 있다. get_or_create 메소드를 처음으로 사용해본 코드였다. 인스턴스가 생성된 적이 없으면 True를 반환하고, 생성된 적이 없으면 False를 반환한다.

백엔드도 보여줄것이 있었던 코드

class FindPasswordView(View):
    def random_choices(self):
        length      = 8
        string_pool = string.ascii_letters + string.digits
        auth_num    = ''

        for i in range(length):
            auth_num += random.choice(string_pool)

        return auth_num

    def post(self, request):
        data     = json.loads(request.body)
        auth_num = self.random_choices()

        try:
            name = data['name']
            identification = data['identification']
            email = data['email']

            if not User.objects.filter(Q(name=name) & Q(identification=identification) & Q(email=email)).exists():
                return JsonResponse({'MESSAGE':'INVALID_USER'}, status=400)

            salt = bcrypt.gensalt()
            hashed_password = bcrypt.hashpw(auth_num.encode('utf-8'), salt)
            hashed_password = hashed_password.decode('utf-8')

            user = User.objects.get(email=email)
            user.password = hashed_password
            user.save()

            email = EmailMessage('[CHOKURLY] 이메일 인증번호', auth_num, to=[email])
            email.send()

            return JsonResponse({'MESSAGE':'SUCCESS'}, status=200)

        except KeyError:
            return JsonResponse({'MESSAGE':'KEY_ERROR'}, status=400)

이 코드는 개인적으로 재밌었던 코드이다. 프론트엔드에 비해서 보여줄것이 없는 백엔드 입장에서는 흥미로웠던 코드였다. 사용자가 비밀번호를 찾을때 사용자 이메일로 직접 인증번호를 보내는 코드인데 진짜 이메일로 내가 원하는 제목과 내용으로 보내진다. 발표할때 많은 사람들이 신기해 했던 기능이다. 몇가지 셋팅이 필요한 코드이다. my.settings.py 에서 필요한 설정을 입력한 후에 gmail 계정의 보안등급을 낮춰야 사용이 가능했다. 2차 프로젝트때는 핸드폰 인증하는법을 구현해 봐야겠다.

파이썬의 간결함

나는 java,c의 문법을 공부한 적이 있다. 파이썬으로 알고리즘 문제를 풀면서 파이썬이 간결한 언어임은 깨닫고 있었지만 이번 프로젝트를 하면서 더 많이 느낀것 같다. 특히 이번 프로젝트에서 list comprehension을 많이 사용하면서 왜 list comprehension을 파이썬의 꽃이라고 하는지 알 것 같았다.

results = [{

            "id": product.id,
            "name": product.name,
            "original_price": int(product.price),
            "discount_rate": float(product.discount_rate.discount_rate) if product.discount_rate else None,
            "discounted_price": int(product.price - (product.price * product.discount_rate.discount_rate)) if product.discount_rate else None,
            "thumbnail_image": product.thumbnail_image,
            "sticker": product.sticker.name if product.sticker else None,
            "comment": product.productinformation.comment if category_id or sub_category_id else None

        } for product in products]

        return JsonResponse({'RESULTS':results}, status=200)

상품 리스트를 list comprehension으로 구현한 코드이다. results 리스트에 담아서 프론트에게 전달하는 코드인데 여기서 깨달은 점은 list compreshension으로 인해 중복코드를 줄일 수 있고 중첩 for문을 가독성 있게 표현 할 수 있다는 점이다. 중첩 for문을 쓰는것보다 list comprehension을 사용하면 어떤 데이터가 담기는지 한번에 알아보기 쉬워진다. 리스트 안에 딕셔너리를 담는 형태인데 만약 위의 코드처럼 딕셔너리 값에 조건문을 사용할 수 없다면 아마 중복 코드가 밑에 많이 생겨날 것이다. 파이썬의 간결함을 느꼈다.

모델링의 중요성

프로젝트를 시작할때 모델링을 빠르게 끝내고 View 작성하는데 많은 시간을 투자 해야겠다고 생각했다. 하지만 내 생각과는 다르게 모델링은 빨리 끝나지 않았고 많은 수정을 해야만했다. 우리팀은 프로젝트가 끝나는 금요일 하루 전에도 모델링 수정을 해야만했다. 사실 이 과정들은 너무나도 당연했다. 경험이 쌓이면 모델링을 하면서 View 로직이 보인다고 말씀하셨던 멘토님이 떠오른다. 우리가 모델링을 할때 View에서 어떤 로직으로 구현할지에 대해 전혀 생각 하지 못했다. 그저 이것은 일대다, 다대다, 일대일 관계일 것이다 라는 관점만 생각했기 때문에 모델링은 완벽할 수 없었다. View를 만들면서 모델링이 잘못됬구나 라는것을 깨닫고 많은 수정을 하게 되었다. 아마 2차 프로젝트를 하면서는 모델링 수정이 1차 프로젝트보다는 많이 줄지 않을까 라는 생각을 해본다.

프로젝트를 하면서 느낀점

과도한 목표 설정

나는 이번 프로젝트에서 가장 중요하게 생각했던것이 많은 기능을 구현 하는 것이였다. 기능 구현에만 집중 하다보니 프론트와의 소통이 많이 이루어지지 않았다. 물론 매일같이 얘기를 나누고 노력한것은 사실이지만 기능을 구현했을때 빠르게 통신을 해보려고 하지 않았다. 그렇게 하다가 보니 프로젝트를 마무리 하는 과정, 즉 전체적인 기능을 확인해보는 상황에서 많은 시간이 지체되었고 급하게 마무리한 느낌이 들었다. 실제로 ppt로 발표한 내용보다 백엔드는 더 많은 기능이 구현되었지만 함께 프로젝트를 하면서 더 많은 기능을 구현하는것이 팀 프로젝트를 하면서 좋은 방향이였을까에 대한 의문이 남는다. 많은 기능 구현보다 프론트와 소통을 더 중요하게 생각했다면 조금 더 완성도 높은 결과물을 만들어냈을것 같다. 실제로 ppt 발표하는날에 배포를 하지 못해 local server로 발표를 진행하였다. 2차 프로젝트때는 기능 구현에 대한 욕심을 조금 줄이고 프론트와 더 많은 소통을 통해 완성도 높은 결과물을 만들어내려고 노력해야겠다.

내가 맡은 일에만 집중한 것

팀 프로젝트 였지만 각자 맡은 부분이 달랐고 내가 맡은 일을 하기에도 어떻게보면 많이 버거웠었던것도 사실이지만 돌이켜서 생각해보면 나는 조금 더 시간이 남았던것 같다. 나와 맞춰봐야 하는 프론트엔드 예원님과 늦게까지 연락하면서 Visual Studio Code의 Live Share 를 통해서 통신한 결과 다른 팀원보다 일찍 구현이 완료 되었다. 그때 나는 추가 구현에 대한 욕심이 있었고 하나라도 더 해봐야지 라는 생각이 들었다. 그래서 더 많은 기능을 구현하기 위해서 혼자만 너무 앞서 나갔던것 같다. 그때 추가 구현을 하지 않고 팀원들의 부족한 점에 더 많은 관심을 기울이고 수정하는데 도움을 더 주었다면 마지막에 시간이 부족하지 않았을것 같다는 생각이 든다. 그렇게 했다면 발표 준비에도 더 많은 시간을 투자할 수 있었고 배포까지 해서 더 완성도 있게 프로젝트를 마무리 했을것 같다.

같이 일하고 싶은 개발자

1차 프로젝트를 끝내고 지친 몸으로 세션을 들었을때 ppt 마지막 slide 내용이 같이 일하고 싶은 개발자였다. 많은 생각이 들게한 문장이였다. 사실 개발자는 팀으로 일을 하기 때문에 주니어 면접은 인성면접이라는 말이 나올 정도로 실력보다는 같이 일하고 싶은 사람이 채용에 큰 영향을 준다는 말을 들은적이 있다. 나는 그 말을 들었을때 나는 사람들하고 잘 지내기 때문에 아무런 문제 없을것 같다는 생각이 들었다. 하지만 프로젝트를 끝내고 '같이 일하고 싶은 개발자'라는 문장을 보았을때 나를 돌이켜보면서 팀원들이 나를 진짜 같이 일하고 싶은 개발자라는 말에 동의를 할까 라는 궁금증이 생겼다. 물론 싸운적이 없고 함께 즐겁게 프로젝트를 진행했다. 하지만 어떤 사람은 과정을 중시하고 어떤 사람은 결과를 중요하게 생각 할수도 있다. 멘토님이 우리팀을 어떤 목적으로 구성했을지는 모르겠지만 프로젝트를 진행하면서 내가 백엔드 팀을 이끌어야 하는 포지션이 되어버렸다. 내가 잘해서가 아니라 단순히 다른 팀원에 비해 조금 더 적극적이였고 질문이 많았으며 말을 많이 하는 성격탓에 그렇게 되어버린것 같다. 같이 일하고 싶은 개발자는 무엇일까? 재밌는 사람, 성격이 좋은사람, 다른사람의 의견을 받아들일수 있는 사람 등등 많은 이유가 있겠지만 내가 생각하는 같이 일하고 싶은 개발자는 같은 목표를 향해서 같은 열정으로 함께 만들어가는 것이라고 생각한다. 지난 2주를 돌아보면 정말 최선을 다했고 후회는 없다. 지금 당연히 조금 향상된 실력으로 2주 전으로 돌아간다면 더 잘할 수 있겠지만 그건 욕심인것같다. 같이 일하고 싶은 개발자가 되려면 다른사람들과 같은 보폭으로 나아가는것도 중요한것 같다. 그 전에는 단순하게 생각했던것 같다. 잘하는 사람하고 일하면 좋겠지 라는 생각을 했지만 내게 팀원 5명을 뽑아서 프로젝트를 진행하게 해준다면 난 단순히 잘하는 사람만을 뽑을것 같지는 않다. 앞으로 2차 프로젝트가 남았고 기업협업도 남았다. 진짜 함께 일하고 싶은 개발자는 어떤 사람일까에 대해서 더 많은 생각을 해보고 그런 사람이 되려고 더 많이 노력해야겠다.

def top_k(nums, k):
  nums_number = list(set(nums))
  final_list = []
  count_dict = {}

  for i in nums_number:
    count_dict[i] = nums.count(i)

  dict_tuple = count_dict.items()
  sorted_dict_tuple = sorted(dict_tuple, reverse=True, key=lambda x:x[1])

  for i in range(k):
      final_list.append(sorted_dict_tuple[i][0])

  return final_list

이 문제를 해석해보면 가장 많이 반복되는 숫자 순으로 k개가 리스트에 담겨져서 반환되어야 한다. 처음에는 리스트를 이용해서 구현하려고 했지만 잘 되지 않았다. 그래서 생각해 낸것이 딕셔너리이다. 일단, list(set(nums))으로 중복된 숫자를 제거하고 리스트에 담는다. 그리고 그 리스트에 담겨져 있는 숫자의 개수만큼 for문을 돌려서 딕셔너리 형태로 ex) {'1':개수, '2':개수} 만든다. count_dict.items()를 사용하면 {('1':개수), ('2':개수)} 이런식으로 만들어지는데 그렇게 되면 딕셔너리도 리스트처럼 index를 사용할 수 있게 된다. 그렇게 만들어진 딕셔너리를 sorted 메소드를 사용해서 value 값이 큰 순으로 정렬 시킨다. sorted(dict_tuple, reverse=True, key=lambda x:x[1]) -> x:x[1] 의 의미가 value 값을 의미한다. x:x[0]으로 사용하면 key값을 의미하게 된다.

그렇게 정렬된 딕셔너리를 for문으로 k번 돌려서 key값을 차례로 뽑으면 된다. 이렇게 하기 위해서 value 값이 큰 순으로 정렬 시켰다.

def is_valid(string):
    type_match = {'(': ')', '[': ']', '{': '}'}
    type_check = ['(', '[', '{']
    string_list = []
    string_final = []

    if len(string) <= 1:
        return False

    if string[0] in type_check:
        for i in range(len(string)):
            if string[i] in type_check:
                string_list.append(string[i])
                string_final.append(string[i])
            else:
                if len(string_list) == 0:
                    return False
                else:
                    string_final.append(type_match[string_list[-1]])
                    string_list.pop()
    else:
        return False

    if len(string_list) != 0:
        for i in range(len(string_list)):
            string_final.append(string_list[i])


    return ''.join(string_final) == string

이 문제를 읽었을때 많은 고민을 했다. s = "(){}" 와 같이 같은 타입이 반복되는 경우에는 쉽게 구현할 수 있지만 s = "{[]}" 와 같이 두개씩 비교를 할수 없는 경우로 인해 많이 힘들어진것 같다.

나는 이 문제를 풀기 위해서 어떤 값이 들어왔을때 올바른 값을 만들어서 올바르게 만들어진 값과 들어온 값을 비교해서 True or False를 리턴 시켰다.

예를들어, "({{)" 이 값이 들어온 경우, 올바른 값은 "({{}})" 이다 그래서 올바른 값을 나오게 구현하고 입력값과 비교해서 True or False를 반환하도록 구현한 코드이다.

def more_than_half(nums):
  for i in range(len(nums)):
    if nums.count(nums[i]) > (len(nums)/2):
      return nums[i]

이 문제는 굉장히 간단했다. 리스트의 길이만큼 for문을 돌려주고 나오는 값들의 개수가 리스트 길이의 절반보다 큰지 묻고 크다면 바로 그 값을 리턴시키면 된다.

def get_prefix(strs):
    answer = ''
    if strs == []:
        return answer

    check = min(strs)
    final = []

    if not check:
        return answer

    strs.sort(key=lambda x:len(x))

    for i in range(1, len(strs)):
        answer = ''
        for j in range(len(check)):
            if check[j] == strs[i][j]:
                answer += check[j]
            else:
                break
        final.append(answer)

    return min(final)

문제를 봤을때 어렵지 않은 문제라고 생각했다. 글자를 한개씩 비교만 하면 된다고 생각 했는데 [] 일때와 ['abc','abd',''] 와 같은 경우도 같이 생각해야 했다. 앞부분에서 먼저 strs = [], strs = ['abc','abcd',''] 같은 경우를 먼저 판단해주고 그다음에 strs에 담긴 문자들을 짧은 길이 순으로 정렬 시킨다. 그리고 가장 길이가 짧은 문자길이 만큼 for 문을 for 문 안에 중첩으로 넣는다. 그렇게 하나씩 제일 짧은 길이의 문자랑 한개씩 비교하면서 같은 문자들을 final에 append 시킨다. 그렇게 len(strs) 만큼 반복시키고 난 후에 final 리스트에 담긴 문자들중 가장 짧은 길이의 문자를 리턴하면 된다.

인스타그램에서 로그인을 할때 email+password , nickname+password, phone_number+password 방식이 있다.

첫번째로 작성한 코드는 말 그대로 email+password, nickname+password, phone_number+password로 로그인 한다고 생각해서 email로 입력했을때, nickname을 입력했을때, phone_number를 입력했을때를 세가지 변수 각각 경우의 수를 따져서 코드를 구현했다. 작동은 되지만 비효율적인 코드라는것을 깨달았다.

그래서 생각한것이 두번째 방식인데, 생각해보면 사용자가 페이지에서 로그인을 할때 원하는값을 그냥 입력한다. nickname='sdafv', email='asdf@gmail.com', phone_number='010-1234-5689' 이런식으로 나누어서 입력해서 로그인하지 않는다. id 입력칸에 원하는 타입의 id 값을 입력하고 password 칸에 password를 입력한다. 그래서 생각한것이 그냥 어떤 타입으로 입력을하든 id 라는 변수로 받는것이다. id 값으로 입력을 받고 그 id가 데이터베이스의 email or phone_number or nickname에 매칭되는것이 있는지 확인한 후 있으면 유저 정보를 가져오는 방식으로 구현했다. 이렇게 해도 코드는 첫번째 방식보다 훨씬 짧아졌다.

세번째 방식은 Q를 사용한것인데 SQL 문의 where 절과 의미가 비슷하다고 생각하면 된다. Q를 사용하면 여러 if 문으로 구현한 코드가 두번의 if 만으로도 구현이 가능해진다. 가독성이 좋고 간결한 코드로 구현할 수 있다.

그렇게 id가 데이터베이스에 매칭되는것이 있다면 password를 체크하게 되는데 우리가 회원가입을 할때 암호화 시킨 비밀번호를 decode해서 데이터베이스에 저장시켰다. 그래서 로그인 할때 비밀번호가 맞는지 확인하려면 데이터베이스에 decode된 비밀번호를 encode 시킨후에 입력된 비밀번호를 암호화시켜서 서로 똑같은지 비교한다. 비밀번호가 똑같다고 인정되면 'SUCCESS'를 반환한다.

http 요청을 받으면 views.py에서 요청을 처리하고 응답한다.

우선 회원가입을 위해서는 이메일 형식, 비밀번호 형식, 전화번호 형식이 웹사이트가 요구하는 형식이 맞는지 확인해야한다. 그래서 정규표현식을 사용해서 check 변수들을 만들었다. try 안에서 email,phone_number,password,name,nickname 변수들을 선언했으므로 하나라도 정보가 입력되지 않으면 KeyError가 발생한다.

모든 변수들을 다 입력했으면 그 다음부터 에러사항을 하나하나 체크해 나간다.

if User.objects.filter(email=email).exists():
                return JsonResponse({'MESSAGE':'EMAIL_ALREADY_EXIST'}, status=400)

-> 같은 이메일이 데이터 베이스에 이미 존재하면 이메일이 이미 존재한다는 에러 메세지를 보낸다. 여기서 exists()를 사용한 이유는 exists()는 데이터 베이스 안에 정보가 있는지 없는지만 체크하므로 데이터를 가져오지 않는다 (효율성이 좋다)

if not email_check.match(email):
                return JsonResponse({'MESSAGE':'INVALID_EMAIL'}, status=400)

-> 정규표현식을 사용해서 입력한 email이 올바른 형식으로 입력이 되었는지 확인하고 잘못된 형식으로 입력되었으면 에러메세지를 보낸다.

다른 if문들은 전부다 비슷한 의미를 나타내므로 따로 언급하지 않겠다.

이렇게 if 문으로 에러메세지를 보내는데 중복된 email,nickname,phone_number가 없고 원하는 타입 형식으로 제대로 입력이 되었으면 비밀번호 암호화를 시행한다.

bcrypt는 데이터베이스에 유저의 정보를 저장할 때, 비밀번호와 같이 암호화가 필요한 데이터를 쉽게 다룰 수 있도록 해주는 password hashing 라이브러리다.

먼저, 암호화를 위해서는 bcrypt를 설치해야하는데

pip install bcrypt로 설치한후 import bcrypt 한다.

salt = bcrypt.gensalt()

salt를 추가함으로써 암호를 더 복잡하게 만들어준다. 쉽게 말해, 해커들이 해킹하기 더 어렵게 만들어준다.

hashed_password = bcrypt.hashpw(password.encode('utf-8'), salt)

이렇게 hashpw를 사용해서 salt와 함께 encode 시키게 되면 단방향 암호화가 이루어지는데 단방향 암호화란 내가 입력한 비밀번호를 되찾을수 없다. 다시말해, 비밀번호를 까먹으면 그 비밀번호를 찾을수 없다는 뜻이다.

예를들어, 내가 비밀번호를 '1234'로 설정한다면 저 코드로 인해 비밀번호가 데이터베이스에 '1234'로 저장되지 않고

b'$2b$12$4n5NY.agqiRfh.eNlcIJEuFif2gY.m0jIgK4HbwZpJO.FS5U8.vg.' 이렇게 암호화된 비밀번호로 저장된다. 그래서 회원가입할때 유저가 비밀번호를 '1234'를 입력했다는것을 알 수 없다.

hashed_password = hashed_password.decode('utf-8')

encode로 인해서 비밀번호 타입이 'bytes'가 되었는데 데이터베이스에 저장할때는 decode를 한후 'str'타입으로 바꾸고 저장한다.

이렇게 암호화를 시킨후

User.objects.create(
                email        = data['email'],
                phone_number = data['phone_number'],
                password     = hashed_password,
                name         = name,
                nickname     = nickname
            )
            return JsonResponse({'MESSAGE':'SUCCESS'}, status=200)

create문으로 회원가입을 완료한다.

회원가입이 잘 되었다면 {'MESSAGE':'SUCCESS'} 메세지를 리턴하도록 구현했다.

project 폴더에 user app을 만들어 models.py 에 User 클래스를 만들었다. email,phone_number,password,name,nickname 을 컬럼으로 만들었다. password는 비밀번호 암호화를 위해서 max_length를 500으로 잡았다. (처음에는 암호화를 고려하지 않아서 max_length=45로 했는데 그렇게 되면 암호화를 시키면 길이가 너무 길어서 에러가 발생했다.)

   class Meta:
        db_table = 'users'

이 코드는 데이터베이스에 만들어지는 테이블 이름을 지정할 수 있게 만들어준다. 나는 'users'로 만들었다. 클래스 Meta를 사용하지 않으면 데이터베이스 테이블 이름을 내 마음대로 정할 수 없다. 일반적으로 class 명의 소문자 형태 + 복수형으로 만든다. 예) User -> users

나는 http 요청으로 회원가입을 하려고한다. 그러기 위해서는 일단 brew install httpie 명령어로 httpie를 설치해야한다.

httpie를 설치하면 http POST localhost 형식으로 명령어를 보낼 수 있는데 이 명령어를 수행하려면 views.py를 작성해야한다. 다음 TIL 에서 자세하게 다룰것이다.

def solution(answers):
    answers = [str(i) for i in answers]
    answer = ''.join(answers)
    a1 = [1,2,3,4,5]
    a2 = [2, 1, 2, 3, 2, 4, 2, 5]
    a3 = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5]
    counta1 = 0
    counta2 = 0
    counta3 = 0
    totcount = []

    for i in range(len(answers)):
        if int(answer[i]) == a1[i%5]:
            counta1 += 1
        if int(answer[i]) == a2[i%8]:
            counta2 += 1
        if int(answer[i]) == a3[i%10]:
            counta3 += 1

    totcount.append(counta1)
    totcount.append(counta2)
    totcount.append(counta3)

    final = []

    for i in range(3):
        if totcount[i] == max(totcount):
            final.append(i+1)

    return final

이 문제는 효율성을 별로 중요하게 생각하지 않는거같다. 효율적으로 풀지 못한것 같았는데 정답으로 인정되었다. answers의 길이가 바뀔수 있으니 i%5, i%8, i%10 이렇게 길이만큼 나눈 나머지를 계산했다. 밑에 final를 리턴하는 for문은 좀더 효율적인 코드가 되도록 생각을 더 해봐야 될 것 같다.

def same_reverse(num):

    answer = True
    for i in range(len(str(num))):
        if str(num)[i] != str(num)[-1-i]:
            answer = False

    return answer

숫자로 받은 num을 str 타입으로 바꾸고 길이 만큼 for문을 돌린다. 처음과 끝 글자가 같지 않으면 answer 에 False를 넣어준다. i 가 1씩 증가하면서 비교를 반복한다. 한번이라도 같지 않는 경우가 생기면 answer는 False 를 리턴한다.

def get_len_of_str(s):
    word = []
    answer = []
    a = ''
    for i in range(len(s)):
        if i == 0:
            word.append(s[i])
            a += s[i]
        elif s[i] != word[-1]:
            word.append(s[i])
            a += s[i]
        elif s[i] == word[-1]:
            answer.append(a)
            word.append(s[i])
            a = ''
            a += s[i]
    answer.append(a)

    b = len(answer[0])
    for i in range(1,len(answer)):
        if len(answer[i]) > b:
            b = len(answer[i])

    return b

이 코드는 내가 잘못푼 코드이다 나는 같은 문자가 연속해서 나오는것만 안되는줄 알았다. 하지만 한 문자열안에 같은 문자가 있으면 안되는 문제였다. 그렇게 되면 내가 처음에 생각했던 코드보다 비교적 쉽게 문제를 해결할 수 있다.

def get_len_of_str(s):
    answer = []
    a = ''
    for i in s:
        if i not in a:
            a += i
        else:
            answer.append(a)
            a = ''
            a += i
    answer.append(a)

    b = len(answer[0])
    for i in range(len(answer)):
        if len(answer[i]) > b:
            b = len(answer[i])

    return b

이것은 정답으로 인정된 내가 푼 코드이다. a = '' 할당하고 포문으로 문자열을 돌려서 a 에 문자가 없으면 a 에 문자를 더해주고 문자가 안에 존재하면 거기서 멈춘후 answer 리스트에 a를 넣어준다. 그리고 a를 빈 문자열로 다시 선언하고 다시 a 에 해당 문자가 있는지 확인 후 없으면 a에 문자를 더해준다. 그리고 마지막엔 무조건 a를 answer 리스트에 넣어준다.

그렇게 한 후 answer 리스트에서 길이가 제일 긴 문자열의 길이를 반환하면 끝이다.

def reverse(number):
    answer = 0
    if number < 0:
        answer = int(str(number)[1:][::-1]) * -1
    else:
        answer = int(str(number)[::-1])
    return answer

[::-1] 은 리스트를 역순으로 정렬시켜준다. [1:] 0번째 인덱스 값을 제외한 나머지 값들이 나온다.

이 두가지만 알고 있으면 이 문제는 쉽게 풀수 있는 문제였다.

def solution(numbers):
    sum = 0
    total = []
    for i in range(len(numbers)):
        for j in range(i+1,len(numbers)):
            sum = numbers[i] + numbers[j]
            if sum not in total:
                total.append(sum)
    total.sort()
    return total

처음에 내가 푼 방식은 2중 for문으로 두개의 숫자의 합을 한개씩 뽑아내면서 not in 을 사용하여 total 리스트에 그 값이 없을때 추가하도록 구현했다. 하지만 set 함수를 사용하면 not in을 사용하지 않고 더 간결한 코드로 구현할 수 있다는것을 깨달았다.

def solution2(numbers):
    answer = []
    for i in range(len(numbers)):
        for j in range(i+1, len(numbers)):
            answer.append(numbers[i] + numbers[j])
    return sorted(list(set(answer)))

2중 for문으로 돌리고 answer 배열에 합들을 모두 추가한 후 set을 이용하여 중복을 제거할 수 있다. 그리고 list로 바꾼뒤 정렬 시키면 된다. 훨씬 더 깔끔한 코드인것 같다.

import timeit

start = timeit.default_timer()

# solution 1

 def two_sum(nums, target):
     answer = []
     for i in range(len(nums)):
         for j in range(i+1,len(nums)):
             if nums[i] + nums[j] == target:
                 answer.append(i)
                 answer.append(j)
                 break

     return answer


# solution 2

def two_sum(num,target):
    for i in num:
        val1 = target - i
        if val1 in num:
            a = num.index(i)
            b = num.index(val1)
            return [a,b]

two_sum([1,2,3,4,5,6,7,8,9],17)

end = timeit.default_timer()

print(end-start)

1번처럼 이중 포문으로 풀고나서 조금 더 효율적인 코드는 없을까를 생각해보다가 for문을 한번만 쓰고 풀수 있을거 같다는 생각이 들었다. 주어진 target을 이용해서 한번 풀어보려고 노력했다. 리스트 값들 중에 한개를 뽑아서 target 에서 뺀 뒤 in 을 사용해서 값을 찾는 방법이였다. 코드 반복이 줄여 효율적인 코드라고 생각했지만 리스트에서는 in 이 O(n)의 시간 복잡도를 가진다는것을 알게 되었다. 결국 in 으로 인해 하나하나 값들을 확인하면서 값을 찾아내므로 내가 원하는 효율적인 코드가 아니였다. 오히려 이중포문보다 더 늦게 결과가 도출되었다.

1번 1.30초 , 2번 4.37초 둘다 테스트는 통과한다.

Django에서는 데이터베이스를 설계하는데 있어서 app 디렉토리에 있는 models.py 파일에서 모든것이 이루어진다고 말할 수 있다.

from django.db import models

# Create your models here.

class Menu(models.Model):
        name = models.CharField(max_length=20)
        class Meta:
            db_table = "Menus"


class Category(models.Model):
        name = models.CharField(max_length=20)
        menu = models.ForeignKey('Menu', on_delete=models.CASCADE)
        class Meta:
            db_table = "Categories"


class Drink(models.Model):
    korean_name = models.CharField(max_length=100)
    english_name = models.CharField(max_length=100)
    category = models.ForeignKey('Category', on_delete=models.CASCADE)
    description = models.TextField()

    class Meta:
        db_table = "Drinks"

class Allergy(models.Model):
    name = models.CharField(max_length=100)
        drink = models.ManyToManyField('Drink', through='Allergy_drink')

    class Meta:
        db_table = "Allergies"




class Allergy_drink(models.Model):
    allergy = models.ForeignKey('Allergy', on_delete=models.CASCADE)
    drink = models.ForeignKey('Drink', on_delete=models.CASCADE)

    class Meta:
        db_table = "Allergy_drinks"



class Nutrition(models.Model):
    one_serving_kca = models.DecimalField(max_digits = 5, decimal_places = 2)
    sodium_mg = models.DecimalField(max_digits = 5, decimal_places = 2)
    saturated_fat_g = models.DecimalField(max_digits = 5, decimal_places = 2)
    sugars_g = models.DecimalField(max_digits = 5, decimal_places = 2)
    protein_g = models.DecimalField(max_digits = 5, decimal_places = 2)
    caffeine_mg = models.DecimalField(max_digits = 5, decimal_places = 2)
    drink = models.ForeignKey('Drink', on_delete=models.CASCADE)
    size_mi = models.CharField(max_length=20)
    size_fluid_ounce = models.CharField(max_length=20)

    class Meta:
        db_table = "Nutritions"


class Image(models.Model):
    image_url = models.CharField(max_length=500)
    drink = models.ForeignKey('Drink', on_delete=models.CASCADE)

    class Meta:
        db_table = "Images"

이렇게 models.py 에서 만들어진 class 는 Database에서 테이블로 생성된다고 생각하면 된다. 여기서는 각각의 입력값들이 무엇을 의미하는지에 대해서는 언급하지 않을 것이다. Django를 공부하면서 느낀것이 sql 문법을 알지 못해도 파이썬 문법만으로 데이터베이스를 생성하고 관리할 수 있다는 것이다.

Django에서 데이터베이스를 관리하는데 있어서 중요한 역할을 하는것이 makemigrations, migrate 명령어인데 이 두개의 명령어는 ORM을 가능하게 해주는 명령어이다.

ORM은 Object Relational Mapping의 줄임말인데 한글로는 객체-관계 매핑 즉, 객체를 관계형 데이터베이스와 연결해주는 개념이라고 생각하면 된다.

객체지향에서는 클래스라는 개념이 있지만, 관계형 데이터베이스에는 테이블이라는 개념이 있다.

프로그래밍 쪽에서는 웬만해서는 객체지향 패러다임으로 만드는 경우가 많은데, 관계형 데이터베이스를 이용하면서도 객체에 대한 표현에 제약을 받지 않고 객체처럼 사용하기 위해서 사용되는 기술이라고 이해하면 좋을것 같다.

위에서 선언된 class 들을 데이터베이스에 연동해 테이블로 만들고 싶을때 manage.py가 있는 디렉토리에서 python manage.py makemigrations '만든 app 이름' 을 입력하면 makemigrations 을 실행시킴으로서, 내가 models.py에서 모델을 변경시킨 사실(class 생성이 될수도 있고, 수정이 될수도 있고 삭제가 될수도 있다.)을 migration으로 저장시키고 싶다는 것을 Django에게 알려준다. 이렇게 되면

class Migration(migrations.Migration):

    initial = True

    dependencies = [
    ]

    operations = [
        migrations.CreateModel(
            name='Category',
            fields=[
                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('name', models.CharField(max_length=20)),
            ],
            options={
                'db_table': 'Categories',
            },
        ),
        migrations.CreateModel(
            name='Menu',
            fields=[
                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('name', models.CharField(max_length=20)),
            ],
            options={
                'db_table': 'Menus',
            },
        ),
        migrations.CreateModel(
            name='Drink',
            fields=[
                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('korean_name', models.CharField(max_length=100)),
                ('english_name', models.CharField(max_length=100)),
                ('description', models.TextField()),
                ('category', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='products.category')),
            ],
            options={
                'db_table': 'Drinks',
            },
        ),
        migrations.AddField(
            model_name='category',
            name='menu',
            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='products.menu'),
        ),
    ]

migrations 디렉토리가 생성이 된다. 위에서 보이는것처럼 코드가 저절로 만들어진다. makemigrations 명령어를 입력했을때는 아직 데이터베이스에 적용되기 전이다!

python manage.py migrate를 입력하면 위에 만들어진 코드를 바탕으로 sql구문으로 저절로 바꿔주면서 데이터베이스에 적용된다. 즉, 테이블들이 생성된다.

이렇게 우리는 makemigrations,migrate을 통해서 sql 문법을 알지 못해도 데이터베이스를 컨트롤 할 수 있다.

pip install django
# 이후에 MySQL server에 접속하기 위한 package
$ pip install mysqlclient
  (중요)mysql 부터 설치해주세요!!

$ django-admin startproject westarbucks
$ cd westarbucks

$ python manage.py startapp products

startproject '프로젝트명' 으로 프로젝트를 생성하고 manage.py가 있는 디렉토리에서 startapp 'app 이름' 으로 app을 생성한다.

$ mysql.server start

$ mysql -u root -p

mysql> create database "NAME" character set utf8mb4 collate utf8mb4_general_ci;

데이터베이스를 설정하지 않으면 Django는 sqlite3으로 데이터베이스를 자동으로 설정하는데 mysql을 사용하는게 훨씬 좋아서 mysql을 설정해서 사용하기로 결정했다. mysql에 접속해서 create database "NAME" character set utf8mb4 collate utf8mb4_general_ci; 을 입력해서 데이터 베이스를 만든다.

ALLOWED_HOSTS = ['*']


# Application definition

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

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
#    'django.middleware.csrf.CsrfViewMiddleware',
#    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

처음에 startproject로 프로젝트를 만들면 settings.py 파일이 자동적으로 설치되는데 여기로 들어가서 몇가지 설정을 바꿀 필요가 있다.

현재 나는 admin,auth 설정이 필요가 없어서 주석처리를 했고 HOSTS = ['*'] 값을 넣었다. admin,auth를 사용하지 않는데 주석처리를 하지 않으면 데이터베이스에 필요없는 테이블들이 생성되기 때문에 데이터베이스를 가볍게 만들기 위해서 주석처리했다.

INSTALLED_APPS를 보면 'products'가 입력된것을 볼 수 있는데 이것은 내가 만든 app의 이름이다. 이것을 반드시 입력시켜야 한다. 입력시키지 않으면 Django는 'products'라는 app을 만들었다는것을 알지 못한다.

DATABASES = {
    'default' : {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'DATABASE 명',
        'USER': 'root',
        'PASSWORD': 'mysql 비밀번호',
        'HOST': 'localhost',
        'PORT': '3306',
    }
}
SECRET = {
        'secret':'=6xvu3t)6+8k8vi@b-(g4=2ah$@vi*^f@h#fraf)mc-_3@xw8t',
}

settings.py에 위에 값을 입력해도 되지만 개인정보 노출을 막기위해서 manage.py가 있는 디렉토리에 my_settings.py 파일을 만들어서 위에 값을 입력하면 된다.

import my_settings
from pathlib import Path

DATABASES = my_settings.DATABASES

입력후에 setting.py 파일로 돌아와서 import my_settings를 입력후에 DATABASES = my_settings.DATABASES 를 입력한다.

from django.urls import path

urlpatterns = [
]

admin, auth를 주석처리 했기 때문에 urls.py 파일에서 설정값을 위에 나와있는 것처럼 바꿔 놓으면 된다.

처음에는 설정값 입력하는것도 어려웠는데 2번정도 해보니 별로 어렵지 않았다.

리스트 컴프리헨션을 사용하면 가독성이 좋아지는 장점도 있지만 일반적인 for문을 사용해서 리스트를 만들때보다 출력되는 속도가 빨라지는 장점이 있다.

1.다음과 같은 도시목록의 리스트가 주어졌을때, 도시이름이 S로 시작하지 않는 도시만 리스트로 만들 때 리스트 컴프리헨션을 사용하여 함수를 작성해 보세요.

cities = ["Tokyo", "Shanghai", "Jakarta", "Seoul", "Guangzhou", "Beijing", "Karachi", "Shenzhen", "Delhi" ]

cities_no_s = [ i for i in cities if i[0] != 'S']

print(cities_no_s)

2.다음과 같은 도시, 인구수가 튜플의 리스트로 주어졌을때, 키가 도시, 값이 인구수인 딕셔너리를 딕셔너리 컴프리헨션을 사용한 함수를 작성해 보세요.

population_of_city = [('Tokyo', 36923000), ('Shanghai', 34000000), ('Jakarta', 30000000), ('Seoul', 25514000), ('Guangzhou', 25000000), ('Beijing', 24900000), ('Karachi', 24300000), ( 'Shenzhen', 23300000), ('Delhi', 21753486) ]

dict_info_city = {population_of_city[i][0]:population_of_city[i][1] for i in range(len(population_of_city))}

print(dict_info_city)

1번, 2번 출력값

이터레이터

이터레이터는 값을 순차적으로 꺼내올 수 있는 객체 입니다.

기본적으로 리스트에는 iter 함수가 존재한다. 만약 l = [1,2,3] 이라는 리스트가 있다고 가정하고 dir(l)을 입력하면 아래와 같이 리스트에 어떠한 함수가 있는지 확인해 볼 수 있는데, iter가 목록에 있는것을 확인할 수 있다.

['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

iter() 함수를 출력해보면 print(l.iter())

<list_iterator object at 0x7fd0ed1c9f10>

이터레이터 객체임을 확인할 수 있다.

그리고 L2 = l.iter() 이터레이터를 변수에 담고 dir를 확인해보면

print(dir(L2))

['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__length_hint__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__']

print문으로 확인해보면 next 함수가 들어있는 것을 확인할 수 있다. next 함수는 이름처럼 다음 요소를 하나씩 꺼내오는 함수이다.

next함수를 호출하면서 동작을 확인해보면, 리스트안에 1,2,3 3개의 값이 들어있으므로 3번이상 호출한다.

print(iterator_L.__next__())
print(iterator_L.__next__())
print(iterator_L.__next__())
print(iterator_L.__next__())

1,2,3 이 출력되고 StopIteration 이 발생하는 것을 확인할 수 있다. 즉, 리스트의 인덱스를 벗어나서 가져올 값이 없으면 StopIteration이 발생하는 것을 알 수 있다.

딕셔너리도 반복가능한 객체라서 앞서본 리스트와 같이 iter함수와 next함수를 사용할 수 있고 파이썬 기본함수인 iter, next 또한 사용할 수 있습니다. 다음의 간단한 키를 출력하는 딕셔너리에 대한 for 문을 while문으로 구현해 보세요.

D = {'a':1, 'b':2, 'c':3}
for key in D.keys():
    print(key)

코드:

d = iter(D)
while True:
    try:
        i = next(d)
    except StopIteration:
        break
    print(i, end=' ')

이렇게 while문으로 구현을 해보면 StopIteration이 발생 했을때 break 시켜주면 a b c 가 출력되는것을 확인할 수 있다.

제너레이터

파이썬에서 보통의 함수는 값을 반환하고 종료 하지만 제너레이터 함수는 값을 반환하기는 하지만 산출(yield)한다는 차이점이 있다. 그리고 제너레이터는 쉽게 얘기하면 이터레이터를 생성해주는 함수라고도 볼 수 있다.

다음 코드를 보면 함수안에서 yield를 사용하여 리스트의 제곱을 산출하는 함수가 있고, 이 함수를 print문으로 확인해보면 generator object 임을 확인할 수 있다.

아래의 코드를 분석해보겠습니다.

리스트 컴프리헨션으로 출력했을때와 제너레이터로 출력했을때의 차이점은?

L = [ 1,2,3] 가 있다고 가정해보면,

comprehension_list= sleep 1s sleep 1s sleep 1s 1 2 3

generator_exp= sleep 1s 1 sleep 1s 2 sleep 1s 3

두개의 출력값이 다르다는것을 확인할 수 있는데 컴프리헨션 리스트인 경우에는 lasy_return이 3번 출력되면서 return 되는 num을 리스트에 저장시킨 후 print_iter 함수를 통해서 한번에 출력된다.

반면에 제너레이터는 값을 저장하지 않고 한번씩 번갈아 가면서 출력되는것을 볼 수 있다. 쉽게 말하면, lazy_return 을 통해서 1이 출력이 되면 바로 print_iter에 1을 대입시켜 출력하고 다시 lazy_return 값을 출력시켜 2의 값을 바로 print_iter 함수에 대입해 한번씩 번갈아 가면서 값을 출력 시킨다. 이 반복을 리스트 길이 만큼 반복한다.

제너레이터를 사용하는 이유는 무엇일까?

위에서 처럼, 리스트 컴프리헨션을 사용했을때와 제너레이터를 사용했을때의 메모리 사용값을 확인해보면 제너레이터는 실제 데이터를 만드는것이 아니기 때문에 10개, 100개, 1000개의 값들을 넣어도 리스트 컴프리헨션과 달리 메모리 사용이 증가하지 않는것을 확인할 수 있다.

lambda expressions

람다는 인라인 함수를 정의할 때 사용하며 익명 함수(anonymous functions) 또는 람다 표현식(lambda expression)이라고 부른다. 람다 표현식을 잘 사용하면 코드가 깔끔해지는 장점이 있다.

다음과 같이 비밀번호의 길이와 대문자가 포함된것을 확인하는 간단한 함수가 있다.

이함수에 있는 if문 두개를 람다표현식을 이용하여 다음과 같은 형식으로 작성해 보세요.

아래의 lambdas 리스트안에 두개의 람다표현식을 작성해야하며 주석으로 표시된 프린트가 출력결과로 나와야 합니다.

람다의 기본 문법:

lambdas = [lambda x: "SHORT_PASSWORD" if len(x) < 8 else None,
           lambda x: "NO_CAPITAL_LETTER_PASSWORD" if not any(c.isupper()
                 for c in x) else None]

이렇게 람다 식으로 코드를 작성하면 print값이 잘 나온다.

SHORT_PASSWORD NO_CAPITAL_LETTER_PASSWORD True

sys.modules

1. 파이썬이 모듈이나 package를 찾기위해 가장 먼저 확인하는 곳이다.
2. sys.modules은 단순한 dictionary 형태이다.
3. 이미 import된 모듈과 package를 저장하고 있다.
4. import가 되어있는 모듈과 패키지의 경로가 저장되어 있어 다시 찾지 않아도 된다. (새로 import 하는 모듈은 sys.modules 에서 찾을 수 없음)

sys.path

1. 파이썬이 마지막으로 보는 곳이다.
2. sys.path는 기본적으로 list형태이며 string 요소들을 가지고 있는 list 이다.
3. 각 list의 경로를 하나하나 확인하면서 해당 경로에 import하고자 하는 package가 위치해 있는지 확인한다.

sys 도 import 해야하는 모듈입니다. 파이썬은 sys 모듈의 위치를 어떻게 찾을 수 있을까?

sys 모듈은 파이썬에 포함되어 있는 내장 모듈이고 파이썬 설치시 기본적으로 내장 모듈에 대한 path정보가 default 값으로 지정되어있다. sys 모듈도 python에 내장된 built-in 모듈중 하나이므로 경로 검색순서에 따라 쉽게 찾을 수 있다.

Absolute path와 relative path의 차이점

absolute path는 어느 파일, 어느 위치에서 import 하던지 경로가 항상 동일하게 되므로 absolute path 라고 한다.

1. Absolute path는 최상단 디렉토리를 기준으로 path 설정.

2. Absolute path는 최상위 루트부터 경로를 표시해야 하므로 경로가 길어질 수 있다.

Relative path 는 absolute path와 다르게 프로젝트의 최상단 디렉토리를 기준으로 경로를 잡는게 아니라 import 하는 위치를 기준으로 경로를 정의한다.

1. Relative path는 실행파일이 위치한 디렉토리를 기준으로 path를 설정한다.

2. Relative path는 선언해야 하는 경로의 길이를 줄여준다는 장점은 있지만 헷갈리기 쉽고, 파일의 위치가 변경되면 경로 위치도 변경되어야 한다는 단점이 있다.

absolute path를 사용하는것을 권장!

calculator 패키지 만들어 보기

main.py에서 상대경로로 add_and_mutiply 를 임포트 했을 때 발생하는 에러를 확인하고, 다음의 파이썬 공식 문서를 참고해서 main module 에서는 패키지의 모듈을 어떻게 임포트 해야하는가?

https://docs.python.org/3/tutorial/modules.html#intra-package-references

파이참 환경에서 실행시켜보니 ImportError: attempted relative import with no known parent package 라는 오류 메세지가 나온걸 확인할 수 있다.

위에 나와있는 파이썬 공식 홈페이지에 들어가보면,

상대경로로 import 시 현재 module의 이름을 기반으로 한다. main 모듈의 이름은 항상 "main"이기 때문에, 파이썬 어플리케이션은 항상 절대경로를 사용해야 한다고 나와있다.

위 문구처럼 calculator 파일구조에서 main은 package에 속한 파일이 아니다. 그렇기 때문에 main.py가 속한 module은 'main'이 된다. 결국 절대경로로 calculator package를 최상단 디렉토리로 언급해야한다.

from calculator.add_and_multiply import add_and_multiply

이렇게 수정해야 한다.

add_and_multiply.py에서 multiply함수를 절대경로와 상대경로도 각각 임포트 해보고 main 모듈과 차이점은 무엇인가?

(상대경로) from .multiplication import multiply

(절대경로) from calculator.multiplication import multiply

둘다 실행된다.

기본 모듈은 다른 패키지나 모듈을 불러올때 절대경로로 불러와야 하며 기본 모듈이 아닌경우는 절대경로든 상대경로든 상관이 없다.

init.py 파일의 역할

init.py란 디렉토리가 패키지로 인식되도록 하는 역할도 하고, 이름 그대로 패키지를 초기화하는 역할을 한다. 즉, import로 패키지를 가져오면 init.py 파일이 실행되므로 이 파일에서 from . import 모듈 형식으로 현재 패키지에서 모듈을 가져오게 만들어야 한다.

디렉터리에 __init.py 파일이 없다면 패키지로 인식되지 않을 수 있다.

하지만, 3.3부터는 init 이 없어도 인식 가능하다.