프로젝트가 끝난 후 바로 회고를 작성하려했지만 심각한 체력고갈로 휴식을 취한 후 바로 기업협업이 시작되어서 회고작성이 늦어졌다. 그래도 나에게는 어떻게 보면 JU-LABO 프로젝트보다 의미있는 프로젝트였기 때문에 틈틈히 회고를 써보려한다.

OVERVIEW

• 클론 사이트

마이리얼트립 https://www.myrealtrip.com/?utm_source=google&utm_medium=search_pc&utm_campaign=44443142579&utm_term=%EB%A7%88%EC%9D%B4%EB%A6%AC%EC%96%BC%ED%8A%B8%EB%A6%BD&gclid=CjwKCAiAjoeRBhAJEiwAYY3nDLcfCANyxmilDiwyi18ydINRHY-_uqMJOoH78YqbbZjp95K1tNIomxoC-TIQAvD_BwE

• 사이트 소개

• 마이리얼트립은 여행을 떠나기 위해 필요한 모든 것을 한 곳에서 검색하고 예약할 수 있는 국내 최고의 Travel Super App 이다.

• 여행 준비, 항공, 숙박, 현지 교통, 현지 경험 (투어, 티켓, 특가 여행, 패키지) 등 모든 여행 경험을 연결하여 새로운 여행 방식을 만들어간다.

• 프로젝트 기간

2022/02/14 ~ 2022/02/25

INTRODUCE TEAM(팀 소개)

• 팀명

MY-JEJU-STAY (마이제주스테이)

• 팀원들

• Frontend - 정수진, 석정도, 임채현, 김지윤

• Backend - 최창현, 모휘정

MY-JEJU-STAY GOALS(목표)

• 단순히 숙소 예약 서비스를 제공하는 사이트는 많기 때문에 회의를 통해 “제주한달살기”라는 기획 아이디어를 내었다.

핵심 서비스

• 제주 한달살기에 적합한 숙소(&체험) 예약 및 결제를 도와주는 서비스를 제공한다.

제공하는 메인 서비스

• 로그인, 회원가입 (소셜 로그인)

• 메인 페이지

• 숙소 리스트&지도

• 숙소 디테일

• 숙소 예약

• 숙소 예약정보 확인

필수 구현 사항(구현 완료)

1. 회원가입&로그인
2. 소셜로그인
3. 숙소 리스트&지도 페이지
4. 숙소 리스트&지도 페이지 필터링 적용
5. 숙소 상세 페이지
6. 예약 기능
7. UNITTEST

추가 구현 사항(구현 완료)

1. 마이 페이지
2. 예약 정보 확인
3. AWS S3 버킷을 활용한 이미지&영상 업로드
4. AWS&DOCKER 배포

USED STACK(사용된 기술)

Backend

• Python , Django , MySQL , CORS Header, Bcrypt, pyJWT

Frontend

• HTML/CSS, JavaScript(ES6+), React, SASS

Communication Tool

• Trello, Slack, Git, Github

Arcitecture

• Docker, AWS EC2, AWS RDS, AWS S3, Postman, dbdiagram.io, httppi

INTRODUCE MY-JEJU-STAY

Database Modeling

초기 세팅

1. 가상환경, DATABASE 생성
2. git repository clone
3. django install
4. django cors-headers install
5. mysqlclient install
6. git branch 생성
7. django project 생성
8. settings.py 생성
9. requirement.txt 생성
10. gitignore 생성
11. runserver 동작 확인

내가 작성한 API 목록

• users/LoginView

• users/KakaoLoginView

• users/SignUpView

• users/ReservationInfoView

KakaoLogin

• 인기 상품과 카테고리 메뉴 반환

Search & Filter(창현)

• 상품 검색 기능 ( 키워드가 포함된 상품) icontains를 사용하여 키워드와 상품의 이름을 비교하여 검색 기능을 구현했다.

• Type(ml)을 통한 상품 리스트 필터 상품 리스트 페이지에서 ml별로 상품을 필터할 수 있도록 기능을 구현했다.

Popular Product(창현)

• 인기상품을 구별하기 위한 기능 user테이블과 product 테이블 사이에 중간 테이블을 만들어서 user가 product를 조회(클릭)했을 때 테이블에 user_id와 product_id를 저장하도록 구현했다. get_or_create를 사용해 user의 중복클릭을 방지 했다.

좋았던 점

'첫 번째 팀 프로젝트' 라는게 나에게 가장 좋았던 점이였다. 혼자 알고리즘 문제를 푸는것도 재미있지만 팀 프로젝트를 경험해보니 나에게는 사람들과 함께 개발하는 환경이 더 즐겁다는걸 느꼈다. 물론 우리 팀원들이 좋은 사람이였던것도 있지만 목적지를 항해 함께 달려가는 동료가 있어서 프로젝트를 별탈없이 마무리할 수 있었던 것 같다.

또한 피어리뷰또한 색다른 즐거움이였다. 다른사람의 코드를 보는것이 익숙하진 않았지만 코드를 살펴보는 것만으로도 배우는게 많다는 것을 느꼈다.

아쉬운 점

돌이켜보면 좋았던 점보다 아쉬운 점이 많았다. 주라보 프로젝트는 PM이 없이 진행됐다. PM이 필요하다는것도 거의 마지막에 알게되었다. 첫 프로젝트이다보니 서로 기능 개발하기 바빠서도 이유 중 하나일것이다. 나도 팀에게 도움이되고 싶어서 열심히 기능개발에만 몰두했었다. 하지만 좋은기능을 빨리 만든다고 팀에게 큰 도움이 되는것만은 아니다. 백엔드가 api를 미리 만들어두어도 함께 일하는 프론트가 준비되지 않았다면 의미가 없는것처럼 말이다.

마무리

정말 좋은 기억으로 남는 1차 프로젝트였다. 추가 기능 구현도 성공적으로 해내서 정말 만족스럽다고 생각한다. 하지만 좋은 기억보단 아쉬웠던 점들을 상기하며 2차 프로젝트를 준비하려한다.

Docker compose란, 여러 개의 컨테이너로부터 이루어진 서비스를 구축, 실행하는 순서를 자동으로 하여, 관리는 간단히하는 기능이다.

Docker compose에서는 compose 파일을 준비하여 커맨드를 1회 실행하는 것으로, 그 파일로부터 설정을 읽어들여 모든 컨테이너 서비스를 실행시키는 것이 가능하다.

docker compose 사용 단계

docker compose를 사용하기 위해서는, 크게 나눠 아래의 세 가지 순서로 이루어진다.

1. 각각의 컨테이너의 dockerfile을 작성한다(기존에 있는 이미지를 사용하는 경우는 불필요)
2. docker-compose.yml를 작성하고, 각각 독립된 컨테이너의 실행 정의를 실시한다(경우에 따라 구축 정의도 포함).
3. 'docker-compose up' 커맨드를 실행하여 docker-compose.yml으로 정의한 컨테이너를 개시한다.

docker compose는 start,stop,status, 실행 중의 컨테이너의 로그 출력, 약간의 커맨드의 실행 같은 기능도 가지고 있다.

docker-compose.yml 파일?

coker compose.yml 파일은 아래와 같이 yaml으로 docker 컨테이너에 관한 실행 옵션(build 옵션도 포함되어 있는 경우도 있다)를 기재한 파일이 된다.

이 파일에 기재되어 있는 내용은 기본적으로 docker build, docker run 커맨드 지정하는 것이 가능한 옵션이 되지만, Docker compose의 yaml 파일로써 기술하는 것으로 여러 개의 컨테이너로부터 만들어진 서비스를 조감하여 보는 것도 가능해져, 보존성의 수고를 가볍게 한다.

Fast API?

Fast API 설치

pip install fastapi
pip install uvicorn[standard]

위 두가지 패키지 설치가 필요하다.

# Fast API 서버 구현

일단 예제로 main.py를 만들어보자!
코드는 다음과 같이 작성해주면 된다.

>```
from typing import Optional
>
from fastapi import FastAPI
>
app = FastAPI()
>
@app.get("/")
def read_root():
    return {"Hello": "World"}
>
@app.get("/items/{item_id}")
def read_item(item_id: int, q: Optional[str] = None):
    return {"item_id": item_id, "q": q}

작성했다면 바로 서버를 실행해보자!

uvicorn main:app --reload

위의 명령어를 실행하면 서버가 실행된다.
서버가 제대로 켜졌는지 확인하기 위해 127.0.0.1:8000 주소로 들어가보자.

# 대화형 API 문서
http://127.0.0.1:8000/docs 로 들어가면 자동 대화형 API 문서를 확인할 수 있다.

http://127.0.0.1:8000/redoc 로 들어가면 다른 자동 문서도 확인할 수 있다.

정신없이 몰두했던 첫번째 프로젝트가 끝난 후 회고를 해보려한다. 너무 좋은 팀원들을 만났지만, 서로 협업이 어색한 상황에서 기능구현과 처음보는 에러와 복합적인 여러가지 일들이 벌어졌었다. 하지만 우리는 포기하지 않았고 좋은 결과물을 만들어냈다고 생각한다. (주라보 팀원들 사랑해) 서론은 길면 안되니까 바로 회고를 시작해보자!

OVERVIEW

• 클론 사이트

LE LABO https://www.lelabofragrances.com/

• 사이트 소개

• 2006년 프랑스 출신의 두 창립자 에디 로시와 파브리스 페노가 뉴욕 놀리타에서 시작한 니치 향수 브랜드이다.

• 브랜드 명은 프랑스어로 ‘실험실’이라는 단어를 그대로 따온 이름으로 조향사의 연구실에서 일어나는 다양한 일에서 영감을 얻어 만든 컬트 향수 브랜드 명이다.

• 원재료에 대한 존중을 기반으로 르라보의 이름을 알린 ‘상탈 33’, 머스크와 살냄새의 조화를 이룬 ‘어나더 13’ 등 매력적이고 유니크하며 매니악한 향수 스펙트럼을 눈여겨 볼 수 있다.

• 특히 구매자가 라벨에 원하는 이름, 문구를 새길 수 있는 ‘라벨링 서비스’를 이용 할 수 있다.

• 프로젝트 기간

2022/02/24 ~ 2022/02/11 (설날 연휴 포함)

INTRODUCE TEAM(팀 소개)

• 팀명

JU-LABO(주라보) 술 주(酒) 를 사용해서 주라보라고 이름을 지었다.

• 사랑하는 팀원들

• Frontend - 윤남주, 김지연, 석정도

• Backend - 최창현, 최형택, 김지연

JU LABO GOALS(목표)

• 우리팀은 르 라보의 웹 페이지의 디자인과 기능을 최대한 비슷하게 개발하거나 개선하는것을 목표로 삼았다.

핵심 서비스

• 계절 별 술 큐레이션

제공하는 메인 서비스

👉 로그인, 회원가입을 활용한 쇼핑 기능(장바구니 기능 포함)

상품 리스트 페이지(카테고리별)

상품 상세정보 페이지

계절에 맞는 주류 추천

상품별 필터

인기 상품 추천

검색기능 추천

필수 구현 사항(구현 완료)

1. 회원가입
2. 로그인
3. 상품 리스트 페이지, 상품 목록
4. 상품 리스트 페이지, 상품 목록 필터링 적용
5. 상품 상세 페이지
6. 장바구니 기능
7. 주문 기능
8. 프로젝트 배포

추가 구현 사항(구현 완료)

1. 메인 페이지
2. 상품 검색 - 검색결과/인기순
3. 제품 추천
4. 어바웃 페이지 (http://www.elcakorea.com/brand/le_labo)
5. AWS 배포

USED STACK(사용된 기술)

Backend

• Python , Django , MySQL , CORS Header, Bcrypt, pyJWT

Frontend

• HTML/CSS, JavaScript(ES6+), React, SASS

Communication Tool

• Trello, Slack, git, github

Arcitecture

• AWS EC2, AWS RDS, Postman, dbdiagram.io, httppi

INTRODUCE JU LABO

Database Modeling

초기 세팅

1. 가상환경, DATABASE 생성
2. git repository clone
3. django install
4. django cors-headers install
5. mysqlclient install
6. git branch 생성
7. django project 생성
8. settings.py 생성
9. requirement.txt 생성
10. gitignore 생성
11. runserver 동작 확인

JU LABO 메인 화면 소개

• (우리팀 프론트엔드 자랑ㅎㅎ)

내가 작성한 API 목록

• categories/SubcategoriesView

• products/ProductListView

• users/PopularProductView

url 엔드포인트/코드/

Header & Product List(창현)

• 인기 상품과 카테고리 메뉴 반환
• 상품 리스트 반환

Search & Filter(창현)

• 상품 검색 기능 ( 키워드가 포함된 상품) icontains를 사용하여 키워드와 상품의 이름을 비교하여 검색 기능을 구현했다.

• Type(ml)을 통한 상품 리스트 필터 상품 리스트 페이지에서 ml별로 상품을 필터할 수 있도록 기능을 구현했다.

Popular Product(창현)

• 인기상품을 구별하기 위한 기능 user테이블과 product 테이블 사이에 중간 테이블을 만들어서 user가 product를 조회(클릭)했을 때 테이블에 user_id와 product_id를 저장하도록 구현했다. get_or_create를 사용해 user의 중복클릭을 방지 했다.

기억에 남는 코드 & 어려웠던 점

소개하고 싶은 코드가 너무 많지만 가장 기억에 남는 두가지 코드를 소개해 볼까한다.

productlist API

원래 productlistview/typeview/productsearchview/productorderingview 와 같이 4가지 뷰로 위 사진의 기능이 나눠져 있었는데 멘토님이 비슷한 결과를 리턴하는것 같다고 하셔서 뷰를 하나로 합치게 되었다. 기능들이 합쳐지면서 if문을 통한 분기점이 생기긴 했지만 개인적으로 만족스런 로직이였다.

popularproduct API

르 라보 홈페이지에서는 인기 상품이 노출되어있는데, 어떤식으로 인기 상품을 구현할까 고민하다가 생각하게된 코드이다. 유저가 상품을 클릭하면 유저 id와 상품 id가 데이터베이스에 쌓이고 중복 클릭을 막기위해 get_or_create를 사용하였다.

좋았던 점

'첫 번째 팀 프로젝트' 라는게 나에게 가장 좋았던 점이였다. 혼자 알고리즘 문제를 푸는것도 재미있지만 팀 프로젝트를 경험해보니 나에게는 사람들과 함께 개발하는 환경이 더 즐겁다는걸 느꼈다. 물론 우리 팀원들이 좋은 사람이였던것도 있지만 목적지를 항해 함께 달려가는 동료가 있어서 프로젝트를 별탈없이 마무리할 수 있었던 것 같다.

또한 피어리뷰또한 색다른 즐거움이였다. 다른사람의 코드를 보는것이 익숙하진 않았지만 코드를 살펴보는 것만으로도 배우는게 많다는 것을 느꼈다.

아쉬운 점

돌이켜보면 좋았던 점보다 아쉬운 점이 많았다. 주라보 프로젝트는 PM이 없이 진행됐다. PM이 필요하다는것도 거의 마지막에 알게되었다. 첫 프로젝트이다보니 서로 기능 개발하기 바빠서도 이유 중 하나일것이다. 나도 팀에게 도움이되고 싶어서 열심히 기능개발에만 몰두했었다. 하지만 좋은기능을 빨리 만든다고 팀에게 큰 도움이 되는것만은 아니다. 백엔드가 api를 미리 만들어두어도 함께 일하는 프론트가 준비되지 않았다면 의미가 없는것처럼 말이다.

마무리

정말 좋은 기억으로 남는 1차 프로젝트였다. 추가 기능 구현도 성공적으로 해내서 정말 만족스럽다고 생각한다. 하지만 좋은 기억보단 아쉬웠던 점들을 상기하며 2차 프로젝트를 준비하려한다.

기본적으로 스택은 넣을 때는 한쪽 끝에서 밀어넣어야 하고(push), 꺼낼 때에는 같은 쪽으로 뽑아 꺼내야한다.(pop) 간단히 그림으로 나타내면 다음과 같다.

이와 비슷한 선형 자료구조 큐(Queue)는 좀 다르다. 큐는 '선입선출'의 구조로서, 먼저 들어간 요소가 가장 먼저 나오는 구조이다. 기본적으로 스택은 한쪽에서 꺼내고 빼고를 하는 반면, 큐는 한쪽으로 들어가면 다른쪽에서 나온다! 그리고 스택은 가장 마지막에 들어간 가장 먼저 나온다. (후입선출)

스택에는 정해진 저장 공간이 있다. 따라서 비어있는 스택에서 원소를 꺼내려 하거나, 꽉찬 스택에 데이터 원소를 넣으려고 할 때 문제가 발생한다. 이러한 문제들을 각각 Stack underflow, Stack overflow라고 칭한다.

• 스택의 연산 및 구현

스택의 연산에는 총 5가지가 있다. 각각은 다음과 같다.

• Size: 현재 스택에 들어있는 원소의 수를 반환

• isEmpty(): 현재 스택이 비어있는지를 판단
• push(x): 데이터 원소 x를 스택에 추가
• pop(): 스택의 맨 위에 저장된 원소를 제거 (맨 마지막에 들어온게 맨 먼저 나옴)
• peek(): 스택의 꼭대기(맨 마지막으로 push된, 앞으로 pop의 대상이 되는) 원소를 반환

이들은 각각 Python의 배열과 양방향 연결리스트로 구현될 수 있다.

#python의 리스트로 스택 구현하기

class ArrayStack:
>
    def size(self):
        return len(self.data)
>
    def isEmpty(self):
        return self.size==0
>
    def push(self, item):
        self.data.append(item)
>
    def pop(self):
        return self.data.pop()
>
    def peek(self):
        return self.data[-1]

양방향 연결리스트로도 동일한 작업을 수행할 수 있다.

# 양방향 연결리스트 정의
class Node:
    def __init__(self, item):
        self.data = item
        self.prev = None
        self.next = None # 양방향으로 연결된 모습
>
class DoublyLinkedList:
    def __init__(self, item):
        self.nodeCount = 0
        self.head = None(None)
        self.tail = None(None)
>
        self.head.prev = None
        self.head.next = self.tail
        self.tail.prev = self.head
        self.tail.next = None
>
# 양방향 연결리스트로 스택 구현
class LinkedListStack:
    def __init__(self):
        self.data = DoublyLinkedList()
>
    def size(self):
        return self.data.getLength()
>
    def isEmpty(self):
        return self.size() == 0
>
    def push(self, item):
        node = None(item)
        self.data.insertAt(self, size() +1, node)
>
    def pop(self):
        return self.data.popAt(self.size())
>
    def peek(self):
        return self.data.getAt(self.size()).data

Linked 리스트의 기본구조에 대해서 알아보자!

각 연결리스트는 Node로 구성되어있고, Node안에는 data와 link로 구성되어있다. 안에 들어있는 data는 그림에 나와있는 정수형 말고도 문자, 레코드 등 여러 구조가 가능하다.

Node를 코드로 구성해보면 다음과 같다.

class Node:
    def __init__(self, item):
        self.data = item # data
        self.next = None # next link (다음 인자를 가리킨다.)

여기서 next는 다음 노드에 접근하는 방법이다.

>```
P.head == a
a.next == b
b.next == c

또한, 연결리스트에서 중요한 속성은 크게 셋으로 나뉜다.

*Head *Tail *Number of Nodes

class LinkedList:
    def __init__(self):
        self.nodeCount = 0
        self.head = None
        self.tail = None

# 연결리스트의 연산 정의
연결리스트의 연산은 크게 특정 원소 참조, 순회, 원소 삽입, 삭제, 연결이 있다.

* 특정 원소를 참조할 때
pos번째의 node를 가리키고 싶을 때 쓰는 메서드이다.

>```
def getAt(set, pos):
    if pos <= 0 or pos > self.nodeCount:
        return None  #특정 경우 제외
    i = 1
    curr =  self.head # 연결리스트의 첫번째 노드
>
    # 앞에서부터 하나하나 탐색하기 때문에 선형탐색과 유사
    while i<pos:
        curr = curr.next
        i += 1
    return curr

단, pos의 예외 범위를 if로 지정해줘야한다!

• 리스트를 순회할 때

연결리스트에 들어있는 data를 리스트의 요소로 하나하나 append하고, 최정 리스트를 반환한다. 주의해야 할 점은, 리스트 안에 append 되어야 할 것이 node 자체가 아니라 node안의 data라는 것이다!

def traverse(self):
    t_list = []
    curr_node = self.head # 첫 노드에 접근

while curr_node != None # tail이 되면 none이 됨
    t_list.append(curr_node.data) # 노드가 아니라 item을 넣음
    curr_node = curr_node.next # 다음 노드에 접근

return t_list 

* 원소 삽입

연결리스트의 pos 위치에 원소를 삽입하는 기본 코드는 다음과 같다.
마지막에 nodeCount는 1을 더해준다!

>```
def insertAt(self, pos, newNode):
    prev = self.getAt(pos-1) # post 이전의 노드를 prev로 설정
       newNode.Next = prev.next
    prev.next = nextNode
    self.nodeCount += 1

근데 위 코드에는 예외 처리가 필요하다. 왜냐하면 삽입 위치가 맨 앞, 맨 끝일대를 처리하지 못하기 때문이다. 그래서 head와 tail을 따로 조정해주는 코드가 필요하다!

def insertAt(self, pos, newNode):
    # pos 예외 범위 지정
    if pos<1 or pos>self,nodeCount:
        return False

# 리스트 맨 앞 삽입할 때
if pos==1:
    newNode.next = self.head # 기존 head가 newNode의 next로 밀려남
    self.head = newNode
else:
    prev = self.getAt(pos-1) # post 이전의 노드를 prev로 설정
    newNode.next = prev.next
    prev.next = nextNode

# 리스트 맨 뒤 삽입할 때
if pos==self.nodeCount +1:
    self.tail = newNode

self.nodeCount += 1
return True

하지만 여기서 tail을 찾으려면 앞에서부터 차근차근 찾아야한다.
그럼 선형 배열과 비슷한 복잡도가 발생하므로, 비효율적일 수 있다!
따라서 다음과 같이 코드를 수정해볼 수 있다.

>```
def insertAt(self, pos, newNode):
    if pos<1 or pos>self.nodeCount:
        return False
>
    if pos==1:
        newNode.next = self.head
        self.head = newNode
>
    # prev를 미리 지정
    else:
        if pos == self.nodeCount +1:
            prev = self.tail
        else:
            prev = self.getAt(pos-1)
>
        newNode.next = prev.next
        prev.next = newNode
>
>
    if pos == self.nodeCount + 1:
        self.tail = newNode
>
    self.nodeCount += 1
    return True   

이전 코드의 else: 부분을 tail일때와 tail이 아닐때로 나누어 tail연산이 구분되어 일어나도록 한다.

• 이때 연결리스트의 원소 삽입 복잡도는 다음과 같다. 맨 앞 삽입 : O(1) 중간 삽입 : O(n) 맨 끝 삽입 : O(1) # tail 포인터 때문

• 원소 삭제

pos 위치에서 pop을 하면, 그 데이터를 리턴하게 한다. 기본 코드는 다음과 같다.

def popAt(self, pos):
    if pos<1 or pos>self.nodeCount:
        raise IndexError

curr = self.getAt(pos) #제거할 node
prev = self.getAt(pos-1) #이전 node

prev.next = self.getAt(pos+1)
self.nodeCount -= 1
return curr.data

하지만 위 코드에도 예외 처리를 해줘야한다.
역시 맨 앞, 맨 뒤를 제거할 때 유일한 리스트 원소를 제거할 때를 처리하지 못한다!
해결 방법은 다음과 같다.

>```
def popAt(self, pos):
    if pos<1 or pos>self.nodeCount:
        raise IndexError
>
    curr = self.nodeCount == 1 & pos ==1: # 유일한 리스트
        self.head = None
        self.tail = None
>
    elif pos == 1: # 유일하지 않지만 맨 앞 삭제
        self.head = self.getAt(pos+1)
>
    else:
        prev = self.getAt(pos-1)

        if self.nodeCount != pos: # 맨 뒤가 아닐 때
            prev.next = self.getAt(pos+1)
        else:
            self.tail = prev
            prev.next = None
>
    self.nodeCount -= 1
    return curr.data

• 두 리스트 연결

#L : 이어붙일 리스트
def concat(self. L):
    self.tail.next = L.head # 원래 리스트의 맨 끝이 이어붙일 리스트의 처음

# L에 주어진 리스트가 빈 리스트일 때 예외처리

if L.tail:
    self.tail = L.tail # 내 원래 tail을 이어붙인 리스트의 tail로 가게함

self.nodeCount += L.nodeCount # count 두개를 합한 만큼

• Hash Table이란 키(key)에 데이터(value)를 저장하는 데이터 구조다.
• key를 통해 데이터를 바로 받아올 수 있어 속도가 빠르다.
• 파이썬 딕셔너리(dictionary) 타입이 해쉬 테이블의 예이다.
• 보통 배열로 미리 Hash Table 사이즈만큼 생성 후 사용한다. (공간과 탐색 시간을 맞바꾸는 기법)
• 파이썬에서는 딕셔너리가 있기 때문에 해쉬를 별도로 구현할 필요가 없다.

해쉬 테이블 용어설명

• 해쉬(Hash) : 임의 값을 고정 길이로 변환하는 것
• 해쉬 테이블(Hash Table) : 키값의 연산에 의해 직접 접근이 가능한 데이터 구조
• 해싱 함수(Hashing Function) : Key에 대해 산술 연산을 이용해 데이터 위치를 찾을 수 있는 함수
• 해쉬 값(Hash Value) 또는 해쉬 주소(Hash Address) : Key를 해싱 함수로 연산해서 해쉬 값을 알아내고, 이를 기반으로 해쉬 테이블에서 해당 Key에 대한 데이터 위치를 일관성 있게 찾을 수 있음
• 슬롯(slot): 한 개의 데이터를 저장할 수 있는 공간
• 저장할 데이터에 대해 Key를 추출할 수 있는 별도 함수도 존재할 수 있음

해쉬 테이블 만들기

직접 코드로 구현해보자!

hash_table = list([i for i in range(10)])
print(hash_table) # [0,1,2,3,4,5,6,7,8,9]

# 해쉬 함수
* 다양한 해쉬 함수 고안 기법 중, 가장 간단한 방식은 Division 법(나누기를 통한 나머지 값을 사용하는 기법)

>```
def hash_func(key):
    return key % 5

이제 해쉬 테이블에 저장해보자.

• 데이터에 따라 필요시 key 생성 방법 정의가 필요하다.

data1 = 'changhyeon'
data2 = 'choi'
data3 = 'star'
data4 = 'bucks'

print(ord(data1[0]), ord(data2[0]), ord(data3[0])) # 99 99 115 print(ord(data1[0]), hash_func(ord(data1[0]))) # 99 4 print(ord(data1[0]), ord(data4[0])) # 99 98

!해쉬 테이블 값 저장 예시
* data: value와 같이 data와 value를 넣으면, 해당 data에 대한 
key를 찾아서, 해당 key에 대응하는 해쉬주소에 value를 저장하는 예

>```
def storage_data(data, value):
    key = ord(data[0])
    hash_address = hash_func(key)
    hash_table[hash_address] = value
>
storage_data('changhyeon', '19950807')

!데이터 읽어보기

def get_data(data):
    key = ord(data[0])
    hash_address = hash_func(key)
    print(hash_table[hash_address])

get_data('changhyeon') # 19950807

# 해쉬 테이블의 장단점
* 장점
데이터 저장/읽기 속도가 빠름(검색 속도 빠름!)
해쉬는 키에 대한 데이터가 있는지(중복) 확인이 쉬움
* 단점
일반적으로 저장공간이 좀 더 많이 필요함
여러 키에 해당하는 주소가 동일할 경우, 충동을 해결하기 위한 별도 자료구조가 필요
* 주요 용도s
검색이 많이 필요한 경우
저장, 삭제, 읽기가 빈번한 경우
캐쉬 구현시(중복 확인이 쉽기 때문)

# 해쉬 테이블의 시간 복잡도
* 일반적인 경우(Collision이 없는 경우)
O(1)
* 최악의 경우(Collision이 모두 발생하는 경우)
O(n)

# 해쉬 테이블 구현해보기
리스트 변수를 활용해서 해쉬 테이블을 구현해보자!
* 해쉬 함수: key ^% 8
* 해쉬 키 생성: hash(data)

>

hash_table = list([0 for i in range(8)]) print(hash_table) #[0, 0, 0, 0, 0, 0, 0, 0]

def get_key(data): return hash(data)

get_key('changhyeon') # -470506737412036400

def hash_func(key): return key % 8

def save_data(data, value): hash_address = hash_func(get_key(data)) hash_table[hash_address] = value

def read_data(data): hash_address = hash_func(get_key(data)) print(hash_address) print(hash_table[hash_address])

save_data('changhyeon', '01091616424') save_data('ch', '01012345678')

read_data('changhyeon') #4 #01012345678 read_data('ch') #4 # 01012345678

print(hash_table) #[0, 0, 0, 0, '01012345678', 0, 0, 0]

list comprehension은 리스트를 쉽게 생성하기 위한 방법이다. python에서 보편적으로 사용되는 기능으로 다양한 응용이 가능하다.

일반적인 리스트 작성방식을 코드로 살펴보자!

list = []
for i in range(10):
    list.append(i)
print(list)
#[0,1,2,3,4,5,6,7,8,9]

## list comprehension의 기본형
list comprehension을 사용한다면 append 메서드를 사용하지 않고 한줄의 코드로
같은 위와 동일한 리스트를 작성할 수 있다. list comprehension의 기본적인 형태는 다음과 같다.

> [식 for 변수명 in iterable객체]

리스트나 튜플 등 iterable한 객체의 각 요소를 임의의 변수로 꺼내 식을 적용하여 그 결과가 요소가 되는 새로운 리스트가 리턴되는 방식이다.

처음 살펴봤던 리스트 작성코드를 list comprehension 을 활용해서 다시 작성해보자!

>```
list = [i for i in range(10)]
print(list)
#[0,1,2,3,4,5,6,7,8,9]

if로 조건분기하는 list comprehension

같은 줄에 조건(if)을 설정하여 원하는 결과를 가진 list를 만들 수 있다.

list = [i for i in range(10) if i % 2 == 0]
print(list)
#[0,2,4,6,8]

## 삼항 연산자의 활용 (if else등의 처리)

if로만 조건을 처리하면 조건을 만족하는 요소만 리스트에 포함되어 반환되고
조건을 만족하지 못한 요소는 삭제된다. 그러나 if else와 같이 조건을 만족하지 않은 요소에 대해서도 별도의 처리가 필요한 경우 삼항 연산자를 이용하여 if else와 같은 처리를 할수 있다.

삼항 연산자를 활용한 list comprehension의 예시는 다음과 같다.

> [조건과 일치했을 때의 값 if 조건식 else 불일치시의 값 for 변수명 in iterable객체]

>```
list = ['odd' if i %2 == 1 else'even' for i in range(10)]
#['even', 'odd, 'even', 'odd, 'even', 'odd, 'even', 'odd, 'even', 'odd,]

중첩 for문의 활용

중첩된 for문을 한 줄로 정의하는 것도 가능하다. for 루프를 중첩하여 복수의 iterable 객체를 결합할 수 있다.

중첩 for문을 활용한 list comprehension의 예시는 다음과 같다.

[식 for 변수명1 in iterable객체1 for 변수명2 in iterable객체2]

list = [(i,j) for i in range(10) for j in range(i, 10)]
print(list)
#[(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 6), (6, 7), (6, 8), (6, 9), (7, 7), (7, 8), (7, 9), (8, 8), (8, 9), (9, 9)]

## zip(), enumerate()와의 결합

for 문에서 자주 사용되는 편리한 함수로 복수의 reternal을 모아주는 zip()이나 인덱스와 값을 return하는 enumerate()가 있다.

zip()이나 enumerate()를 list comprehension에 사용하는 것도 물론 가능하다. 특수한 문법을 사용하는 것이 아니므로 for 문과의 대응을 생각하면 그렇게 어렵지 않다.

먼저 zip()의 활용방법을 살펴보자!

>```
list1 = ['a','b','c']
list2 = ['x','y','z']

list_zip = [(l1,l2) l1,l2 in zip(list1, list2)]
print(list_zip)
#[('a','x'), ('b','y'), ('c','z')]

다음으로 enumerate()의 활용방법을 살펴보자!

list = ['a','b','c']
list_enumerate = [(i, j) for i, j in enumerate(list)]
print(list_enumerate)
#[(0,'a'),(1,'b'),(2,'c')]

## Dict Comprehension

dict 객체도 comperhension으로 생성할 수 있다.
{} 안에 식의 부분에 키와 값 2개를 '키:값' 형태로 지정하여 작성하면 된다.

> {키:값 for 변수명 in iterable객체}

키와 값에는 임의의 식을 지정할 수 있다.

>```
list = ['aa', 'bbb', 'cccc']
dict = {i: len(i) for i in list}
print(dict)
#{'aa': 2 , 'bbb' : 3, 'cccc': 4}

키와 값 각각의 리스트로부터 새로운 사전을 만들고 싶은 경우는 zip()를 사용하면 된다.

keys = ['a', 'b', 'c']
values = [1,2,3]
dict = {k: v for k,v in zip(keys,values)}
print(dict)
#{'a':1, 'b':2, 'c':3}

실행하려는 method 데코레이터는 사용자가 구조를 수정하지 않고 기존 객체에 새로운 기능을 추가 할 수 있도록하는 python의 디자인 패턴이다.

먼저 간단한 예제로 이해해보자!

def decorator(func):
    def wrapper(*args, **kwargs):
        print('Hello!') # 전처리
        print(func(*args, **kwargs))
        print('GoodBye~') #후처리
    return wrapper
>>>
@decorator
def myFunc():
    return 'What is your name?'

위 코드의 실행 결과는 다음과 같다.

Hello!
What is your name?
GoodBye~

``` 코드에 작성한 주석을 살펴보면 decorator를 왜 쓰는지 가볍게 이해 할 수 있다.

전처리와 후처리

예를 들어보자! 내가 만드는 서버에서 insertUser, deleteUser, updateUser라는 메소드가 있다고 했을 때 처리 순서는 다음과 같을 것이다.

1. (전처리) 권한체크
2. (본 로직) 요청에 대한 처리
3. (후처리) 로그나 오류등등 처리

위와 같은 작업이 전,후로 반복된다. 이걸 데코레이터를 사용한다면 다음과 같다.

사용하는 이유

사실 성능이 나아지거나 하는건 없다. 하지만 시스템이 커질수록 관리하기 편하고, 런타임에 validation 하기 좋고(로깅 시) 소스코드 또한 주요 로직만 보게되니 가독성도 좋아진다.

iterable는 member를 하나씩 차례로 반환 가능한 object를 의미한다. iterable의 예로는 sequence type인 list,str,tuple이 대표적이다.

for i in range(5):
    print i

0 1 2 3 4

당연하게 사용했던 위와 같은 for 문도 사실 range()로 생성된 list가 iterable하기 때문에 순차적으로 member들을 불러서 사용이 가능했던 것이다.

non-sequence type인 dict나 file도 iterable 하다고 할 수 있다.
dict 또한 for 문을 이용해 순차적으로 접근이 가능하다.

>```
>>> x = {'a':1, 'b':2, 'c':3}
>>>
>>> for i in x:
    print(i)
a
b
c

또한 iter() 나 getitem() 메소드로 정의된 class는 모두 iterable 하다고 할 수 있다. iterable 은 for loop 말고도 zip(), map()과 같이 sequence 한 특징을 필요로 하는 작업에 유용하게 사용된다. zip() 이나 map() 함수의 경우 iterable을 argument로 받는 것으로 정의되어 있다.

iterator(이터레이터)

iterator는 next() 메소드로 데이터를 순차적으로 호출 가능한 object이다. 만약 next()로 다음 데이터를 불러올 수 없을 경우(가장 마지막 데이터인 경우) StopIteration exception을 발생시킨다. 그렇다면 iterable한 object들은 iterator일까? 결론부터 말하자면, iterable 이라고 해서 반드시 iterator인 것은 아니다.

>>> x = [1,2,3]
>>> next(x)
Traceback (most recent call last)
file"<stdin>", line 1, in <module>
TypeError: list object is not an iterator

iterator 가 아니라는 에러 메시지가 출력되는것을 확인할 수 있다. list 는 iterable 이지만, 위와 같이 next() 메소드로 호출해도 동작하지 않는다.

만약, iterable 을 iterator로 변환하고 싶다면, iter() 라는 built-in function을 사용하면 된다.

>>> x = [1,2,3]
>>> type(x)
<type 'list'>
>>> y = iter(x)
>>> type(y)
<type 'listiterator'>

위와 같이 iter() 함수를 사용하여 list를 listiterator 타입으로 변경할 수 있다.

>>> next(y)
1
>>> next(y)
2
>>> next(y)
3
>>> next(y)
Traceback (most recent call last):
    File "<stdin>",line 1, in <module>
StopIteration

이제 next()를 이용해 list의 정보를 하나씩 꺼낼 수 있다. 그리고 마지막 정보를 호출 한 이후에 next()를 호출하면 StopIteration 이라는 exception 이 발생됨을 볼 수 있다.

하지만, 우리가 list 나 tuple같은 iterable한 object를 사용할 때 굳이 iter() 함수를 사용하지 않아도 for 문을 이용하여 순차적으로 접근이 가능했다. 이것은 for 문으로 looping 하는 동안, python 내부에서 임시로 list를 iterator로 자동 변환해주었기 때문이다!

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

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

def generator_squares():
    for i in range(3):
        yield i ** 2
print("gen object=", end=""), print(generator_squares())
>>gen object=<generator object generator_squares at 0x000001BA64555AC0>

---

# Yield?
yield는 제네레이터 함수에서 값을 반환할 때 사용되며 yield 호출후에 다시
next가 호출될때 까지 현재의 상태에서 머물고 있다가 next 함수가 호출되면
이전의 상태에 이어서 다음 연산을 수행한다.
generator를 dir로 함수종류를 확인해보면 이터레이터와는 다르게 __iter__와 __next__함수가 둘다 들어있는 것을 확인할 수 있다.

>```
print("dir gen=", end=""), print(dir(generator_squares()))
>>>dir gen=['__class__', '__del__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__name__', '__ne__', '__new__', '__next__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'close', 'gi_code', 'gi_frame', 'gi_running', 'gi_yieldfrom', 'send', 'throw']

그래서 이터레이터에서 처럼 iter를 호출한 후에 next 함수를 호출하지 않아도 next 를 바로 호출할 수 도 있다.

gen = generator_squares()
print(gen.__next__())
print(gen.__next__())
print(gen.__next__())
print(gen.__next__())
>>0
1
4
Traceback (most recent call last):
File "C:\Users\Choi\AppData\Local\Programs\Python\Python39\practice.py", line 17, in <module>
print(gen.__next__())
StopIteration

이터레이터와 마찬가지로 __next__함수로 값을 꺼내올 수 있고 for 문이 끝나게 되면
StopIteration 이 발생한다. 그리고 제너레이터 함수는 실행중에 send 함수를 통해서
값을 전달받을 수 있다.

send함수로 값을 전달하는 코드는 다음과 같다.

>```
def generator_send():
    received_value = 0
    while True:
        received_value = yield
        print("received_value = ", end=""), print(received_value)
        yield received_value * 2
gen = generator_send()
next(gen)
print(gen)
print(gen.send(2))
next(gen)
print(gen.send(3))
>>>
<generator object generator_send at 0x000001FE12B4BC10>
received_value = 2
4
received_value = 3
6

generator_send 함수는 yield로 send를 통해서 받은 값을 received_value에 할당하고 그 값의 2배 수를 리턴받고 있다. 제네레이터에서는 이처럼 yield를 이용해서 제네레이터 함수 실행중 값을 전달할 수 있고, 응용하면 제네레이터 함수를 사용해서 main 실행 루프에서 연산결과에 따라 호출도 제어할 수 있다.

제네레이터 표현식(generator expression)

제네레이터 함수 외에도 제네레이터 표현식이 있다. 제너레이터 표현식은 Lazy evalution을 위해 사용될 수 있다. Lazy evaluation은 말그대로 실행을 지연시킨다는 의미이다.

def factorial(n):
    # 여기에 코드를 작성해주세요.
    result = 1
    for i in range(1,n+1):
        result *= i
    return result

def move_zeroes(nums):
    for i in range(len(nums)):
        if 0 in nums: # 만약 0 이 nums 리스트에 있다면
            nums.remove(0) # 리스트에서 0을 삭제
            nums.append(0) # 리스트에서 0을 추가
    return nums

def min_path_sum(grid):
    for i in range(1,len(grid)): 
        grid[0][i] += grid[0][i-1] 
        grid[i][0] += grid[i-1][0]
    for i in range(1, len(grid)):
        for j in range(1, len(grid)):
            grid[i][j] += min(grid[i][j-1], grid[i-1][j])             
    return grid[-1][-1]

def reverse_string(s):
    s.reverse() #인자로 넘겨받은 리스트 문자열을 뒤집기
    return s

def complex_number_multiply(a, b):
  a1 = int(a.split('+')[0])# 인자 a를 +기준으로 split해서 인덱스 0 값을 정수형으로 변환하여 a1에 저장
  b1 = int(b.split('+')[0])# 인자 b를 +기준으로 split해서 인덱스 0 값을 정수형으로 변환하여 b1에 저장 
  a2 = int(a.split('+')[1].replace('i', ''))# 인자 a를 +기준으로 split해서 인덱스 1값의 i를 replace로 제거하고 a2에 저장
  b2 = int(b.split('+')[1].replace('i', ''))# 인자 b를 +기준으로 split해서 인덱스 1값의 i를 replace로 제거하고 b2에 저장
  return f'{(a1 * b1) + (a2 * b2)*(-1)}+{(a1 * b2) + (a2 * b1)}i'

```

def get_max_area(height):
    areas = []
    for i in range(len(height)-1):
        for j in range(i+1, len(height)):
            print(i,j)
            temp_height = min(height[i],height[j])
            temp_width = abs(i-j)
            area = temp_width * temp_height
            areas.append(area)
    return max(areas)

def more_than_half(nums):
    dic = {} # 빈 딕셔너리 변수 선언
    result = []
    for i in nums: 
        if i not in dic:     # i가 nums안에 없으면
            dic[i] = 1         # dic의 키 i 에 value 1 저장
        else:                 #i가 nums안에 있으면
            dic[i] += 1         # dic의 키 i의 value에 1 더하기
        for i in range(k):
            dic_max = max(dic.keys() , key= dic.get) #dic에서 가장 큰 value값의 키값
               result.append(key_max)
            del dic[key_max]
    return dic_max

def is_valid(string):
    left = ['[', '(', '{'] # 여는 괄호들을 left 리스트에 저장
    right = [']', ')', '}'] # 닫는 괄호들을 right 리스트에 저장
    stack = [] # 빈 리스트 선언
    for i in string: # string에서 문자들을 하나씩 가져옴
        if i in left: # 문자 i 가 left 리스트에 존재한다면
            stack.append(i) # stack 리스트에 문자 i 를 추가
        elif i in right: #문자 i 가 right 리스트에 존재한다면
            if left.index(stack.pop()) != right.index(i): # left 리스트의 인덱스와 right 리스트의 인덱스가 같지 않으면 False를 리턴
                return False
    return len(stack) == 0 #stack 리스트의 길이가 0이면 True 리턴

def more_than_half(nums):
    dic = {} # 빈 딕셔너리 변수 선언
    for i in nums: 
        if i not in dic:     # i가 nums안에 없으면
            dic[i] = 1         # dic의 키 i 에 value 1 저장
        else:                 #i가 nums안에 있으면
            dic[i] += 1         # dic의 키 i의 value에 1 더하기
    dic_max = max(dic.keys() , key= dic.get) #dic에서 가장 큰 value값의 키값
    return dic_max