URI(Uniform Resource Identifier)

• 통합 자원 식별자
• 위치나 이름, 또는 둘 다를 기준으로 자원을 식별한다.
• URI에는 URL, URN이 존재한다.(URI의 하위 개념이 URL, URN)
  • URN과 URL은 모두 URI이며, 특정 URI는 URL이자 URN이 될 수 있다.
  • URL는 URI이다.
  • URI가 반드시 URL일 필요는 없다.

URL(Uniform Resource Locator)

• 식별된 자원을 사용할 수 있는 위치와 이를 검색하는 매커니즘을 지정하는 URI의 하위 집합
• 자원을 얻을 수 있는 방법을 정의
• 식별된 자원의 가용성을 의미하지 않는다.

• protocol(scheme): 통신 프로토콜
• host: 웹 페이지, 이미지, 동영상 등의 파일이 위치한 웹 서버, 도메인 또는 IP
• port: 웹 서버에 접속하기 위한 통로
• path: 웹 서버의 루트 디렉토리로부터 웹 페이지, 이미지, 동영상 등의 파일 위치까지의 경로
• query string: 웹 서버에 전달하는 추가 질문

URN(Uniform Resource Name)

• 리소스를 영구적이고 유일하게 식별할 수 있는 URI
• URN 체계를 사용하는 URI
• URN이 “what”을 의미한다면, URL은 “where”를 의미한다.
• urn : '이름공간식별자' : '이름공간에 대한 특별 문자열' 과 같은 형태로 구성된다.

URL: ftp://ftp.is.co.za/rfc/rfc1808.txt
URL: http://www.ietf.org/rfc/rfc2396.txt
URL: ldap://[2001:db8::7]/c=GB?objectClass?one
URL: mailto:John.Doe@example.com
URL: news:comp.infosystems.www.servers.unix
URL: telnet://192.0.2.16:80/
URN (not URL): urn:oasis:names:specification:docbook:dtd:xml:4.1.2
URN (not URL): tel:+1-816-555-1212 (disputed, see comments)

아래와 같은 방법을 통해 file의 mime type을 알 수 있다.

probeContentType

• Files.probeContentType(path)
  • OS에 따라 작동하지 않을 수 있음을 주의해야 한다.

class ProbeTest {
    @Test
    public void whenUsingJava7_thenSuccess() {
        Path path = new File("product.png").toPath();
        String mimeType = Files.probeContentType(path);

        assertEquals(mimeType, "image/png");
    }
}

URLConnetion

• getContentType()
  • 속도가 느리다는 단점이 있다.

class UrlConnectionTest {
    @Test
    public void whenUsingGetContentType_thenSuccess() {
        File file = new File("product.png");
        URLConnection connection = file.toURL().openConnection();
        String mimeType = connection.getContentType();

        assertEquals(mimeType, "image/png");
    }
}

• guessContentTypeFromName()
  • 내부의 FileNameMap을 통해 type을 알아내는 방식

class UrlConnectionTest2{
    @Test
    public void whenUsingGuessContentTypeFromName_thenSuccess(){
        File file = new File("product.png");
        String mimeType = URLConnection.guessContentTypeFromName(file.getName());

        assertEquals(mimeType, "image/png");
    }

• getFileNameMap()
  • URLConnection을 활용해서 Mime Type을 찾는 방식 중 빠른 방식

class UrlConnectionTest2{
    @Test
    public void whenUsingGetFileNameMap_thenSuccess(){
        File file = new File("product.png");
        FileNameMap fileNameMap = URLConnection.getFileNameMap();
        String mimeType = fileNameMap.getContentTypeFor(file.getName());

        assertEquals(mimeType, "image/png");
    }
}

• 내장된 테이블은 JRE_HOME/lib의 content-types.properties를 활용하는데, type이 다소 제한된다는 점이 있다.

• content.types.user.table property를 활용하여 사용자 테이블을 설정할 수 있다.

    System.setProperty("content.types.user.table","<path-to-file>");

MimeTypesFileTypeMap

• Java 6에서 온 클래스로, JDK 1.6에서 편리하다.
• mime.types 파일을 찾아 타입을 알아내는 방식으로, 파일을 찾을 수 없으면 application/octet-stream을 반환한다.
  • mime.types 파일을 찾는 방식은 다음과 같다.

class UrlConnectionTest2{
    @Test
    public void whenUsingMimeTypesFileTypeMap_thenSuccess() {
        File file = new File("product.png");
        MimetypesFileTypeMap fileTypeMap = new MimetypesFileTypeMap();
        String mimeType = fileTypeMap.getContentType(file.getName());

        assertEquals(mimeType, "image/png");
    }
}

jMieMagic

• build.gradle 에 추가한 이후 활용
  • net.sf.jmimemagic:jmimemagic

class JMimeMagicTest{
    @Test
    public void whenUsingJmimeMagic_thenSuccess() {
        File file = new File("product.png");
        Magic magic = new Magic();
        MagicMatch match = magic.getMagicMatch(file, false);

        assertEquals(match.getMimeType(), "image/png");
    }
}

Apache Tika

• build.gradle에 추가한 이후 활용
  • org.apache.tika:tika-core
  • Mime type을 찾는 메서드만 활용하기 위해, tika-core 적용

class TikaTest{
    @Test
    public void whenUsingTika_thenSuccess() {
        File file = new File("product.png");
        Tika tika = new Tika();
        String mimeType = tika.detect(file);

        assertEquals(mimeType, "image/png");
    }
}

REFERENCE

• https://www.baeldung.com/java-file-mime-type

원격 저장소에 이미 업로드 된 파일을 지우는 방법

• 로컬에서는 지우지 않고, 원격에서만 지우는 방법
• 원격 저장소에 이미 push된 파일을 .gitignore에 추가하는 경우 자주 사용
• 하단에 써있는 방법은 캐시를 통째로 날리는 방법

$ git rm -r --cached .
$ git add .
$ git commit -m "commit message"
$ git push

위 코드에서, 핵심은 다음 코드이다.

$ git rm -r --cached .

현재 코드 상으로는 원격 저장소의 전체 파일을 삭제하는 방식이며, . 자리에 지우고자 하는 디렉토리나 파일이 오게 설정할 수도 있다.

$ git rm -r --cached <file>

Redis

• Redis❓
• Redis 사용 용도🔍
• Redis 특징🔍
• 주의사항⚠

Redis❓

Redis는 Remote dictionary server의 약자로써, 키-값구조의 비정형 데이터를 저장하고 관리하기 위한 오픈 소스 기반의 비관계형 데이터베이스 관리 시스템(DBMS)이다. 모든 데이터를 메모리에 저장하고 조회하기에 빠른 Read, Write 속도를 보장하는 비 관계형 데이터베이스이다.

• 크게 5가지 형식을 지원한다.
  • String, Set, Sorted Set, Hash, List
• I/O가 빈번히 발생해 다른 저장 방식을 사용하면 효율이 떨어지는 경우에 사용

Redis 사용 용도🔍

• Message Queue
• Shared Memory
• Remote Dictionary
  • RDBMS의 캐시 솔루션으로 사용 용도가 높음
  • Disk에서 데이터를 꺼내오는 것이 Memory에서 읽어들이는 것보다 천 배 가량 더 느림

Redis 특징🔍

• 영속성(Persistance)을 지원하는 인메모리 데이터 저장소
  • Redis는 데이터를 disk에 저장할 수 있음
  • 저장하는 방식으로 snapshot, AOF 방식 활용
  • Redis 공식문서의 권장사항은 두 방식을 혼용해서 사용하는 것
    • 주기적으로 snapshot으로 백업하고, 다음 snapshot까지의 저장을 AOF방식으로 수행

snapshot: 특정 시점의 데이터를 disk에 옮겨담는 방식으로, Blocking 방식의 SAVE와 Non-blocking 방식의 BGSAVE가 있음

AOF: Redis의 모든 write/update 연산 자체를 모두 log 파일에 기록하는 형태, 서버가 재시작할 시 write/update를 순차적으로 재실행, 데이터를 복구

• 읽기 성능 증대를 위한 서버 측 복제를 지원
• 쓰기 성능 증대를 위한 클라이언트 측 샤딩(Sharding)을 지원
• 다양한 데이터 타입
• C언어로 작성되어 가비지 컬렉션 동작에 따른 성능 문제 등에서 자유로움

주의사항⚠

• 서버에 장애가 생기는 경우, 데이터 유실이 발생하므로, snapshot과 AOF기능을 통한 복구 시나리오를 제대로 세워야 함
• 잘못된 데이터가 캐싱되지 않아야 함
  • 레디스와 캐싱하고자 하는 데이터 저장소의 데이터가 서로 일치하는지 주기적인 모니터링과 솔루션 필요
• 생성한 키를 선택적으로 삭제하기 어려움
  • 일괄 삭제, 일정 시간 이후 삭제, 기간 만료 후 삭제 등 3가지 방법을 활용해 키를 삭제할 수 있음

REFERENCE

• 레디스(Redis)는 언제 어떻게 사용하는 게 좋을까
• [Redis, 레디스] 레디스 소개 및 아키텍처, 주의할 점(Redis Overview, Redis Architecture, Tool Tip)
• 레디스(Redis)란 무엇인가?
• 레디스

• Trie❓
• 시간 복잡도⏱
• Code in Python🖋
• Test

Trie❓

입력되는 문자열을 트리 형식으로 만들어 보다 빠르게 문자열 검색을 가능하게 한 자료구조로, radix tree, 또는 prefix tree라고도 한다.

문자열을 검색할 때, 문자열이 많을 경우 자주 사용되며, 시간복잡도가 빠르기 때문에 검색엔진 사이트에서 제공하는 자동 완성 및 검색어 추천 기능에서도 사용되는 경우가 있다. 하지만, 각 노드에서 자식들에 대한 포인터들을 배열로 모두 저장하고 있다는 점에서 저장 공간의 크기가 크다는 단점도 존재한다.

• Tree 구조로 이루어져 있다.
• root 노드는 비어있다.
• 문자열의 끝을 알리는 flag가 존재

시간 복잡도⏱

• 문자열의 길이가 m이라고 하였을 때, O(m)의 시간 복잡도를 가진다.

Code in Python🖋

• 클래스 Node, Trie가 필요
• Node는 key, data, children으로 이루어져 있음
  • key: 현재 노드가 가지고 있는 문자
  • data: 문자열이 끝난 경우, 해당 문자열을 data에 기록
    • default값으로 None을 가지고 있음
  • children: 자식 노드들이 저장되는 딕셔너리
    • key는 문자, value는 해당 문자를 key로 가진 노드
• Trie는 head만 가지고 있으며, insert, search함수가 기본적으로 존재
  • head는 루트 노드를 의미
  • insert: word를 추가하는 함수, 각 문자열을 하나씩 확인하며, 없는 경우 새로운 노드를 연결하여 추가하는 방식, 마지막 노드의 data에 word를 저장
  • search: Trie에 해당 word가 존재하는 지 유무를 확인, 각 문자를 하나씩 탐색하며 끝까지 도달한 후, 해당 노드의 data에 word가 저장된 경우만 True로 반환

class Node:
    def __init__(self, key, data=None):
        self.key = key # 현재 노드의 문자
        self.data = data # 단어가 끝나는 경우, 해당 단어를 data에 저장
        self.children = {} # 자식 노드들이 저장되는 딕셔너리, key는 문자, value는 노드


class Trie:
    def __init__(self):
        self.head = Node(None) # 루트 노드

    def insert(self, word): # 단어 추가용 함수
        current = self.head

        for w in word:
            if w not in current.children: # 해당 문자열이 없는 경우, 노드 생성 후 자식에 추가
                current.children[w] = Node(w)
            current = current.children[w] # 자식 노드로 이동
        current.data = word # 마지막 노드에 데이터 저장

    def search(self, word): # 단어 탐색용 함수
        current = self.head

        for w in word:
            if w in current.children: # 자식에 문자열이 있는 경우, 자식노드로 이동
                current = current.children[w]
            else: # 없는 경우, 단어가 없으므로 False
                return False

        if current.data: # 데이터가 저장되어 있는 경우에만 단어가 존재
            return True
        else: # 데이터가 저장되어 있지 않으면, 마지막 노드가 아니므로 False
            return False

Test

trie = Trie()
words = ['cart', 'cow', 'call', 'cartoon']
for word in words:
    trie.insert(word)

print(trie.search('cart')) # True
print(trie.search('car')) # False
print(trie.search('calling')) # False

REFERENCE

• 트라이, 컴퓨팅
• 트라이 알고리즘 개념 및 파이썬 구현하기
• [Python/파이썬] Trie 알고리즘
• 트라이(Trie)

📌풀이

내가 쓴 풀이(성공)

• Bit Masking 사용하여 경우의 수 판단
• 계산한 높이 tmp가 B보다 크거나 같으면서 가장 낮은 탑 res보다 낮은 경우, tmp를 res에 저장

T = int(input())
for tc in range(1, T+1):
    N, B = map(int, input().split())
    emps = list(map(int, input().split()))

    res = 10000*N # 변수 초기화

    # Bit Masking
    for i in range(1, 2**N): 
        tmp = 0
        for j in range(N):
            if i & (1<<j):
                tmp += emps[j]

        if tmp >= B and res > tmp :
            res = tmp

    print(f'#{tc} {res-B}')

📌후기

비트마스킹을 써본 횟수가 적어서 아쉬웠는데, 이 기회에 비트마스킹을 써볼 수 있어서 좋았다. 다른 경우에서도 더 많이 활용해 봐야겠다!

Load Balancing

• Load Balancing❓, Load Balancer❓
• Scale-up & Scale-out🔍
• Load Balancing의 종류🔍
• Load Balancer 주요 기능✔
• Load Balancer 동작 방식🔍
• Load Balancing Algorithm🔍
• Load Balancer 오류 대비⚠

Load Balancing❓, Load Balancer❓

로드밸런싱(load balancing, 또는 부하 분산)은 컴퓨터 네트워크 기술의 일종으로, 둘 혹은 셋 이상의 중앙처리장치 혹은 저장치와 같은 컴퓨터 자원들에게 작업을 나누는 것을 의미한다.

쏟아지는 트래픽을 여러 대의 서버로 분산해주는 기술이 없다면, 한 곳의 서버에 모든 트래픽이 몰리는 상황이 발생한다. 아무리 성능이 뛰어난 서버도 모든 트래픽을 감당할 수 없기에, 여러 대의 서버를 구축하여 수많은 트래픽을 효과적으로 다뤄야 할 필요성이 있다. 이 때 필요한 기술이 로드 밸런싱이다.

로드밸런서는 서버에 가해지는 부하를 분산해주는 장치 또는 기술을 말한다.

• 클라이언트와 서버풀(분산 네트워크를 구성하는 서버들의 그룹) 사이에 위치
• 한 대의 서버로 부하가 집중되지 않도록 트래픽을 관리해 각각의 서버가 최적의 퍼포먼스를 보일 수 있도록 함

Scale-up & Scale-out 🔍

사업의 규모가 확장되고, 클라이언트의 수가 늘어나면 기존 서버로 증가된 트래픽에 대처할 수 없다. 이 때, 대처할 수 있는 방법은 크게 2가지가 있는데, 그것이 바로 Scale-up, Scale-out 이다.

• Scale-up
  • 서버가 더 빠르게 동작하기 위해 하드웨어 성능을 올리는 방식
  • 서버 자체의 성능을 확장
• Scale-out
  • 기존 서버와 동일하거나 낮은 성능의 서버를 두 대 이상 증설하여 운영
  • 로드밸런싱이 반드시 필요

Load Balancing의 종류🔍

• OSI 7계층에 따라 나뉨
  • L2(Data Link): MAC 주소 기반 로드 밸런싱
  • L3(Network): IP주소 기반 로드 밸런싱
  • L4(Transport): 포트 번호 기반 로드 밸런싱
  • L7(Application): URL, HTTP 헤더, 쿠키 등 사용자의 요청을 기준으로 로드 밸런싱

L4 Load Balancer

• TCP/UDP 포트 정보를 바탕으로 함
• 데이터를 들여다보지 않고 패킷 레벨에서 로드를 분산하기 때문에 속도가 빠르고 효율이 높음
• 데이터의 내용을 복호화할 필요가 없어 안전함
• 패킷의 내용을 볼 수 없어 섬세한 라우팅 불가능
• 사용자의 IP가 수시로 바뀌는 경우라면 연속적인 서비스를 제공하기 어려움

L7 Load Balancer

• TCP/UDP 정보는 물론 HTTP의 URL, FTP의 파일명, 쿠키 정보 등을 바탕으로 함
• 상위 계층에서 로드를 분산하므로 섬세한 라우팅 가능
• 캐싱 기능 제공
• 비정상적인 트래픽 사전에 필터링할 수 있어 서비스 안정성이 높음
• 클라이언트가 로드밸런서와 인증서를 공유하기 때문에 공격자가 로드밸런서를 통해 클라이언트의 데이터에 접근할 수 있는 보안 상의 위험성 존재

Load Balancer 주요 기능✔

• NAT(Network Address Translation)
  • IP주소를 변환해주는 기능
  • Private IP를 Public IP로 변경(반대도 가능)
• Tunneling
  • 데이터를 캡슐화해서 연결된 상호 간에만 캡슐화된 패킷을 구별하여 해제 가능
• DSR(Direct Server Routing)
  • 서버에서 클라이언트로 되돌아가는 경우(요청에 대한 응답), 목적지를 클라이언트로 설정한 다음 네트워크 장비나 로드밸런서를 거치지 않고 바로 클라이언트로 찾아감
  • 로드밸런서의 부하를 줄여줌

Load Balancer 동작 방식🔍

• Bridge/Transparent Mode
  1. 유저가 로드 밸런서로 요청 전송
  2. 로드 밸런서는 NAT 적용하여 IP/MAC 주소 변조, 실제 서버로 트래픽 요청
  3. 서버가 받은 요청에 대한 응답 전송
  4. 로드 밸런서는 NAT 적용하여 출발지 IP주소를 로드밸런서의 가상 IP주소로 변조하여 유저에게 전달
• Router Mode
• One Arm Mode
• DSR Mode

Load Balancing Algorithm🔍

• 라운드 로빈(Round Robin)
  • 서버에 들어온 요청을 순서대로 돌아가며 배정하는 방식
  • 여러 대의 서버가 동일한 스펙을 갖고 있고, 서버와의 연결이 오래 지속되지 않는 경우 적합
• 가중 라운드 로빈(Weighted Round Robin)
  • 각각의 서버마다 가중치를 매기고 가중치가 높은 서버에 요청을 우선적으로 배분
  • 서버들의 트래픽 처리 능력이 다른 경우 사용되는 방식
• IP 해시(IP Hash, Source Hash Scheduling)
  • 클라이언트의 IP주소를 특정 서버로 매핑하여 요청
  • 사용자가 항상 동일한 서버로 연결되는 것을 보장
• 최소 연결(Least Connection)
  • 요청이 들어온 시점에 가장 적은 연결상태를 보이는 서버에 우선적으로 배분
  • 세션이 길어지거나, 분배된 트래픽이 일정하지 않은 경우에 적합
• 최소 리스폰 타임(Least Response Time)
  • 서버의 현재 연결 상태와 응답 시간을 고려하여 트래픽 배분
  • 가장 적은 연결 상태와 가장 짧은 응답시간을 보이는 서버에 우선적으로 로드를 배분

Load Balancer 오류 대비⚠

• Load Balancer를 이중화하여 장애를 대비

• 이중화된 Load Balancer들은 서로 Health Check를 함
• Primary Load Balancer가 동작하지 않으면, 여분의 Load Balancer로 변경 후 운영

REFERENCE

• 부하분산-위키백과
• 로드밸런서(Load Balancer)의 개념과 특징
• 로드 밸런서(Load Balancer)란?
• 로드밸런서란?(L4, L7)
• 로드밸런서의 종류와 동작방식
• 네트워크의 부하분산, 로드밸런싱(Load Balancing) 그리고 로드밸런서(Load Balancer)

Proxy Server

• Proxy Server❓
• Forward Proxy🔍
• Reverse Proxy🔍

Proxy Server❓

프록시 서버(Proxy Server)는 클라이언트가 자신을 통해서 다른 네트워크 서비스에 간접적으로 접속할 수 있게 해주는 컴퓨터 시스템이나 응용 프로그램을 가리킨다. 서버와 클라이언트 사이에 중계기로서 대리로 통신을 수행하는 것을 가리켜 '프록시', 그 중계 기능을 하는 것을 프록시 서버라고 부른다.

• 인터넷에서 유저를 대신해서 가져오는 서버
  • 클라이언트와 서버 사이의 통신에 중계 역할
  • 클라이언트 - 프록시 서버 - 서버 의 구조를 지님

• 프록시 서버 중 일부는 서버에 요청된 내용들을 캐시를 이용하여 저장

  • 캐시 안의 정보를 요청하는 경우, 바로 정보를 제공함으로써 시간 절약

• 외부와의 트래픽을 줄이게 됨으로써 네트워크 병목 현상 방지

• 프록시 서버를 활용함으로써, 클라이언트 또는 서버의 정보를 숨길 수 있음

Forward Proxy🔍

클라이언트가 인터넷에 직접 접근하는 것이 아닌, Forward Proxy Server가 요청을 받고, 인터넷에 연결하여 결과를 다시 클라이언트에 전달해준다.

• 클라이언트가 요청하는 End Point: 실제 서버 도메인
• Forward Proxy에서는 클라이언트의 정보가 감춰짐
  • 요청을 받는 서버는 클라이언트가 누구인지 알 수 없음

Reverse Proxy🔍

클라이언트가 인터넷에 데이터를 요청하면 Reverse Proxy Server가 요청을 받아 내부 서버에서 데이터를 받은 후 클라이언트에 전달

• 클라이언트가 요청하는 End Point: 프록시 서버의 도메인
• Reverse Proxy에서는 서버의 정보가 감춰짐
  • 클라이언트는 실제 서버의 정보를 알 수 없음

Reference

• 프록시 서버
• 프록시 서버란? 원리와 사용 목적
• Forward Proxy, Reverse Proxy 정의와 차이점

https://programmers.co.kr/learn/courses/30/lessons/81303?language=python3

📌풀이

내가 쓴 풀이(실패)

• 리스트의 인덱스를 활용하여 구현
• C의 경우, O이 나올때까지 현재 위치에서 뒤로 밀다가 없으면 앞쪽에서 찾는 방식 활용
  • 사라진 인덱스는 trash에 저장
  • 해당 인덱스의 table값은 X로 변경
• Z의 경우, trash에 저장한 인덱스를 꺼내 table의 값을 O로 변경
• U, D의 경우, X인 경우를 배제하고 움직이는 횟수를 활용하여 구현
• 정확도는 통과하였으나, 효율성에서 5개의 테스트 케이스만 통과

def solution(n, k, cmd):
    table = ['O' for _ in range(n)]
    trash = []
    for c in cmd :
        if c == 'C':
            trash.append(k)
            table[k] = 'X'
            # k 위치 변경
            while k < n and table[k] == 'X' :
                k += 1
            if k == n:
                k -= 1
            while 0 <= k and table[k] == 'X':
                k -= 1

        elif c == 'Z':
            table[trash.pop()] = 'O'
        else:
            flag = 1 if c[0] == 'D' else 0
            move, cnt = int(c[2:]), 0
            while cnt < move :
                k = k+1 if flag else k-1
                if table[k] == 'O':
                    cnt += 1



    return ''.join(table)

내가 쓴 풀이(성공)

• 링크드 리스트 활용
  • 딕셔너리의 key를 인덱스값으로, value를 [앞의 값, 뒤의 값] 의 쌍으로 구현
• C의 경우, 해당 인덱스를 trash에 저장
  • 결과값도 X로 변경
  • 앞의 노드와 뒤의 노드를 연결
  • 현재 노드가 맨 앞, 맨 뒤인 경우를 고려하며, k값도 맞춰서 이동
• Z의 경우, trash에서 pop
  • 결과값 O로 변경
  • 꺼내온 노드의 위치를 파악하여 사이에 넣고 연결
• U, D의 경우, 이전, 이후 값들을 보며 노드를 횟수만큼 이동

def solution(n, k, cmd):
    res = ['O' for _ in range(n)]
    linked_list = {i:[i-1,i+1] for i in range(n)}
    trash = []

    for c in cmd:
        now = c[0]
        if now == 'D':
            move = int(c[2:])
            for _ in range(move):
                k = linked_list[k][1]
        elif now == 'U':
            move = int(c[2:])
            for _ in range(move):
                k = linked_list[k][0]
        elif now == 'C':
            pre,nex = linked_list[k][0], linked_list[k][1]
            trash.append(k)
            res[k] = 'X'
            if pre >= 0:
                linked_list[pre][1] = nex

            if nex < n :
                linked_list[nex][0] = pre
                k = nex
            else :
                k = pre

        else :
            now = trash.pop()
            res[now] = 'O'
            pre, nex = linked_list[now][0], linked_list[now][1]
            if pre >= 0 :
                linked_list[pre][1] = now

            if nex < n:
                linked_list[nex][0] = now

    return ''.join(res)

📌후기

링크드 리스트를 쉽게 구현할 수 있는 방법을 알았던 문제였다. 문제를 해결하는 동안, 정말 많은 시간이 소요되었지만 링크드 리스트 활용법을 알게 되었다는 점은 상당히 만족스럽다. 이전에 링크드 리스트를 활용할 때는 객체를 직접 만들어 활용하였는데, 간단한 경우 딕셔너리를 통해 쉽게 만들 수 있다는 것을 알게 되었다! 효율성과 같은 문제에서 자주 활용할 수 있을 것이라고 생각한다.

카카오 테크 블로그의 풀이를 보면서, Fenwick Tree를 활용하여 문제를 해결할 수 있다는 것도 읽었는데, 아직 그 방법에 대해서는 잘 모르겠다. 한번 연구해 봐야 겠다!

https://programmers.co.kr/learn/courses/30/lessons/77484

📌풀이

내가 쓴 풀이(성공)

• 공통으로 가지고 있는 숫자, 0의 개수를 통해 등수를 판단 가능

• same : set을 활용하여 공통적으로 갖고 있는 숫자의 개수를 확인

• offset: lottos에서 0의 갯수 확인

• minimum: 일치하는 숫자가 2 미만인 경우 6등, 이외의 경우는 7-same

• maximum: offset이 6인 경우 무조건 1등, 그 외의 경우는 minimum-offset

def solution(lottos, win_nums):
    same = len(set(lottos) & set(win_nums))
    offset = lottos.count(0)
    minimum = 7-same if same > 1 else 6
    maximum = minimum - offset if offset < 6 else 1
    return [maximum, minimum]

📌후기

레벨1 문제, 무난하게 해결했다!

📌HTTP & HTTPS

• HTTP
  • HTTP의 정의
  • HTTP의 특징
  • HTTP의 문제점
• HTTPS
  • HTTPS의 정의
  • 공개키/개인키
• HTTP, HTTPS의 차이

HTTP❓

HTTP란 HypterText Transfer Protocol의 약자로, 웹 상에서 클라이언트와 서버가 서로 정보를 주고받을 수 있는 프로토콜입니다. TCP/IP 기반으로 서버와 클라이언트 간의 요청과 응답을 전송한다. HTTP에서는 80번 포트를 통해 클라이언트는 자원을 요청하고, 서버는 자원을 제공한다.

HTTP의 특징🔍

• TCP 기반의 통신
• 비연결 지향 (connectionless)
  • 서버는 요청에 대한 응답을 보낸 후 연결을 끊음
• 무상태 (stateless)
  • 연결을 끊는 순간 클라이언트와 서버 간의 통신이 끝나며 상태 정보가 유지되지 않음
  • 클라이언트와 서버가 주고 받는 메세지들은 서로 완전히 독립적
• 클라이언트와 서버의 지속적인 관계 유지를 위해, 쿠키와 세션이 존재

HTTP의 문제점⚠

• 완전성을 증명할 수 없어 변조 가능
• 도청 가능
• 통신 상대를 확인하지 않기에 위장 가능

HTTPS❓

HTTPS란 HyperText Transfer Protocol over Secure socket layer의 약자입니다. 일반 HTTP 프로토콜에서는 서버에서 브라우저로 전송되는 정보가 암호화되지 않는다는 문제점이 존재하였는데, 이를 SSL이나 TSL 프로토콜을 활용해 보안을 강화시킨 프로토콜이다. 즉, HTTP에 데이터 암호화가 추가된 프로토콜이라고 볼 수 있으며, HTTPS에서 HTTP는 SSL과 통신하고, SSL이 TCP와 통신하게 된다. HTTP와 다르게 443번 포트를 활용하며, 네트워크 상에서 중간에 제 3자가 정보를 볼 수 없도록 공개키 암호화를 지원하고 있다.

HTTPS는 HTTP 자체를 암호화하는 것이 아니라, HTTP를 사용해서 운반하는 내용(Body)를 암호화한다. HTTP Header는 암호화하지 않는다.

• SSL이 점차 폭넓게 사용되면서, 표준화 기구인 IETF의 관리로 TLS라는 이름으로 바뀌었다.
  • TLS 1.0은 SSL 3.0을 계승함
• SSL(TLS)에서 사용하는 인증서로 상대방을 확인

공개키/개인키🔍

• HTTPS는 공개키/개인키 암호화 방식을 사용하여 데이터를 암호화하며, 공개키와 개인키는 서로를 위한 1쌍의 키이다.
• HTTPS에서는 대칭키 암호화 기법을 사용한다.
  • 공개키의 신뢰성을 위해 CA 인증서를 사용
  • 인증 과정
    1. 서버의 공개키를 인증 기관(CA)에 등록
    2. 인증 기관은 해당 서버의 유효성을 판단한 후, 인증 기관의 비밀키로 서버의 공개키에 디지털 서명으로 공개키 인증서를 작성 후 등록 공개키 인증서 = 서버의 공개키 + 인증 기관의 디지털 서명+ 암호화 된 사이트 정보 인증 기관의 공개키는 사전에 브라우저에 내장되어 있음
    3. 클라이언트가 서버에 접속요청을 하면 서버는 인증 기관에서 받은 인증서를 전송
    4. 클라이언트는 브라우저에 내장된 인증 기관의 공개키로 디지털 서명을 검증해 신뢰할 수 있는 공개키인지 확인
    5. 클라이언트는 대칭키 생성(공개키, 비밀키)
    6. 클라이언트는 생성한 공개키를 서버의 공개키로 암호화해 서버에게 전송
    7. 서버는 자신의 비밀키로 해당 내용을 복호화하고 그 대칭키를 가지고 리소스 교환

HTTP, HTTPS의 차이(정리)✔

• HTTP는 암호화가 추가되지 않아 보안에 취약함

• HTTPS는 안전하게 데이터를 주고 받을 수 있음

• HTTPS는 HTTP에 비해 처리 속도가 느림

  • SSL을 통해 통신이 이루어지는 과정에서 리소스를 소비하며, 통신 속도가 떨어짐
  • 최근에는 CPU의 성능 향상, 메모리의 용량 증가로 속도의 차이가 줄어듦

• HTTPS는 인증서를 발급하고, 유지하기 위한 추가 비용 발생

REFERENCE

• (Web) HTTP와 HTTPS 및 차이점
• HTTP, 그리고 HTTPS의 이해
• HTTP VS HTTPS 차이, 알면 사이트의 레벨이 보인다
• HTTP, HTTPS
• HTTP와 HTTPS

https://programmers.co.kr/learn/courses/30/lessons/72414

📌풀이

내가 쓴 풀이(성공)

• time_to_sec : 00:00:00로 표기된 시간을 초로 변환
• sec_to_time: 초로 표기된 시간을 00:00:00의 형태로 변환
• DP를 활용하여 해결
• logs의 값들을 통해 시작 시간, 끝나는 시간을 확인하고, 초기화 한 리스트 times에 추가
  • 시작 시간 + 1, 끝나는 시간 -1
  • 모든 logs의 내용을 처리한 후, times의 값을 처음부터 읽으며 값을 누적시킴
• times의 시간들을 읽어가며, 최대값이 나타나는 구간을 확인
  • 그 때의 시작 값을 00:00:00의 형태로 리턴
  • 앞의 값을 빼주고, 뒤에 값을 더해주는 과정으로 진행

# 시간을 초로 변환
def time_to_sec(time):
    return int(time[:2])*3600 + int(time[3:5])*60 + int(time[6:])

# 초를 시간으로 변환
def sec_to_time(sec):
    hour, sec = sec//3600, sec%3600
    minute, sec = sec//60, sec%60
    hour = str(hour).rjust(2, '0') # 일의 자리인 경우를 고려
    minute = str(minute).rjust(2, '0')
    sec = str(sec).rjust(2,'0')
    return f'{hour}:{minute}:{sec}'

def solution(play_time, adv_time, logs):
    # 플레이 시간, 광고 시간을 초로 변환
    # 전체 플레이 시간 기준으로 dp 구현
    play_sec = time_to_sec(play_time)
    adv_sec = time_to_sec(adv_time)
    times = [0 for _ in range(play_sec+1)]

    # 시작점에 +1, 끝점에 -1 설정
    for log in logs:
        start, end = log[:8], log[9:]
        times[time_to_sec(start)] += 1
        times[time_to_sec(end)] -= 1

    # 앞서 설정한 값들을 기준으로, 해당 시간대의 총 재생기록 표시
    for idx in range(1, play_sec+1):
        times[idx] += times[idx-1]

    # 0초 기준으로 초기화
    now = sum(times[:adv_sec]) # 현재 누적 재생 시간
    result = now # 최대 누적 재생 시간
    answer = 0 # 최적의 위치
    for idx in range(1, play_sec+2-adv_sec) :
        now += times[idx+adv_sec-1]-times[idx-1] # 맨 앞 값 제거, 맨 뒤 값 추가
        if result < now : # 크기 비교
            answer, result = idx, now

    return sec_to_time(answer)

📌후기

마지막의 최대 값을 구하는 과정에서, 처음에 sum을 다수 활용했었는데, 시간 초과 이슈가 발생했었다. 이러한 문제를 해결하고자, 인덱스를 이동하며 sum을 하는 과정을 앞의 값을 빼고, 뒤의 값을 더하는 방식으로 구현하였다. 전체적인 구조는 DP를 활용하여 잘 해결할 수 있었다.

📌풀이

내가 쓴 풀이(성공)

• 각 방향 이동 방법을 저장한 리스트 d
• 격자의 값이 R, L인 경우, 경로의 변경 방법이 적힌 딕셔너리 left, right
  • ex) right에서 key인 0은 d[0]을 말하고, d[0] 방향은 right을 만나면 value인 3, 즉 d[3] 방향으로 바뀜을 의미
• 각 격자에서 모든 방향 탐색을 하였는지 판단하기 위한 리스트 case
  • 모든 값을 1로 초기화
• 각 격자에서 모든 방향을 탐색(Brute Force)
  • 해당 case값이 0인 경우, 이미 탐색한 경로이므로 continue
  • 탐색하지 않은 경우, 길이 판단을 위해 변수 cnt를 0으로 설정
  • 경로를 계속 이동하며, 처음 위치로 돌아올 때 까지 while문 진행
  • 위치를 계속 바꾸기 위한 변수 tx, ty, ti
    • ti는 방향을 말함
  • tx, ty, ti가 격자를 만나며 다음 경로와 방향을 다시 tx, ty, ti에 저장

def solution(grid):
    # 이동 방향용 리스트 d
    d = [[-1, 0], [1, 0], [0, 1], [0, -1]]
    # 격자의 값에 따른 방향 이동 방법
    right = {0: 3, 1: 2, 2: 0, 3: 1}
    left = {0: 2, 1:3, 2: 1, 3: 0}

    answer = []
    w, h = len(grid[0]), len(grid)
    # 각 격자에서의 모든 방향을 이동하였는지 판단하는 리스트 case
    cases = [[[1]*4 for _ in range(w)] for _ in range(h)]
    for y in range(h):
        for x in range(w):
            for i in range(4):
                # 이미 이동한 적 있는 방향은 판단 X
                if not cases[y][x][i]:
                    continue
                cnt = 0 # 길이 판단을 위한 변수
                ty, tx, ti = y, x, i # 위치 ty, tx, 방향 ti
                while True:
                    cases[ty][tx][ti] -= 1
                    cnt += 1
                    now = grid[ty][tx]
                    # 현재 격자의 값을 확인하여 방향 결정
                    if now == 'L':
                        ti = left[ti]
                    elif now == 'R' :
                        ti = right[ti]
                    tx, ty = (tx+d[ti][1])%w, (ty+d[ti][0])%h
                    # 처음 출발점에 도착하면 완료
                    if tx == x and ty == y and ti == i:
                        break
                answer.append(cnt)

    # 값을 정렬 후 리턴
    answer.sort()
    return answer

📌후기

문제를 처음 해결할 당시, 잘 해결이 되지 않아 상당히 고민했던 문제였다! 결과적으로는 문제를 제대로 읽지 않아서 처음에 한동한 해결하지 못했었다.... 문제를 똑바로 봐야 한다는 것을 다시 한 번 확실히 깨달은 문제였다!

완전 탐색을 통해 해결하였는데, 당시 문제를 풀 때 1등분이 엄청 빠르게 해결하던데,,,, 방법이 무엇인지 알고 싶다!

https://www.acmicpc.net/problem/1018

📌풀이

내가 쓴 풀이(성공)

• 범위 내에서 가능한 모든 체스판 확인(Brute Force)
• tmp1은 W로 시작하는 체스판, tmp2는 B로 시작하는 체스판
• c1은 tmp1로 색칠할 때 바꿔야 하는 판 개수, c2는 tmp2로 색칠할 때 바꿔야 하는 판 개수
• 가장 작은 판 개수 찾아서 출력

n, m = map(int, input().split())
l1, l2 = 'WB'*4, 'BW'*4
arr = [input() for _ in range(n)]
res = 64
for iy in range(n-8+1):
    for ix in range(m-8+1):
        c1, c2 = 0, 0

        for y in range(8):
        #tmp1은 W로 시작하는 체스판, tmp2는 B로 시작하는 체스판
            if y % 2: 
                tmp1, tmp2 = l1, l2
            else:
                tmp2, tmp1 = l1, l2
            for x in range(8):
                if arr[iy+y][ix+x] != tmp1[x]:
                    c1 += 1
                elif arr[iy+y][ix+x] != tmp2[x]:
                    c2 += 1

        res = min(res, c1, c2)

print(res)

📌후기

완전 탐색으로 해결하였다! 탐색하는 방법이 어렵지 않아서 무난하게 해결할 수 있었다!

https://www.acmicpc.net/problem/1260

📌풀이

내가 쓴 풀이(성공)

• 각 정점에 연결된 정점들의 리스트를 딕셔너리로 구현
• 정점의 번호가 작은 것부터 탐색한다고 하였으므로, 각 리스트들을 정렬
• dfs, bfs 진행

from collections import deque

n, m, v = map(int, input().split())
connected = {i: [] for i in range(1, n + 1)}
for _ in range(m):
    n1, n2 = map(int, input().split())
    connected[n1].append(n2)
    connected[n2].append(n1)

for n in range(1, n+1):
    connected[n].sort()


def bfs(v):
    res = []
    visited = [0] * n
    dq = deque()
    dq.append(v)
    while dq:
        now = dq.popleft()
        res.append(now)
        visited[now - 1] = 1
        for node in connected[now]:
            if not visited[node - 1] and node not in dq:
                dq.append(node)
    return res


def dfs(v, visited=[]):
    visited.append(v)
    for node in connected[v]:
        if node not in visited:
            dfs(node, visited)
    return visited


print(*dfs(v))
print(*bfs(v))

📌후기

Django 공부하느라 알고리즘 감이 다 죽었다.... 문제를 더 많이 풀어야 겠다ㅠㅠㅠㅠ

https://programmers.co.kr/learn/courses/30/lessons/72413

📌풀이

내가 쓴 풀이(성공)

• 플로이드-워셜 알고리즘 활용

from math import inf

#플로이드-워셜 알고리즘 활용

def solution(n, s, a, b, fares):
    answer = inf
    # 경로의 최소값을 저장하기 위한 리스트
    costs = [[inf]*n for _ in range(n)]

    # fares에서 불러온 경로값을 저장
    for c, d, f in fares :
        costs[c-1][d-1] = costs[d-1][c-1] = f

    for i in range(n):
        costs[i][i] = 0 # 본인에서 본인으로 가는 경로는 0

    for k in range(n):
        for i in range(n):
            for j in range(n):
                # 더 작은 값이 있는 경우, 이를 저장
                #costs[i][j] = min(costs[i][j], costs[i][k] + costs[k][j])
                if costs[i][j] > costs[i][k] + costs[k][j] :
                    costs[i][j] = costs[i][k] + costs[k][j]

    # 다른 경로를 거쳐서 가는 방법 중 가장 작은 경우 확인
    for i in range(n):
        #answer = min(answer, costs[s-1][i] + costs[i][a-1] + costs[i][b-1])
        if answer > costs[s-1][i] + costs[i][a-1] + costs[i][b-1]: 
            answer = costs[s-1][i] + costs[i][a-1] + costs[i][b-1]


    return answer

📌후기

이전에 풀어볼 때는 다익스트라, 힙 구조를 활용하여 풀었었는데, 다른 사람들의 풀이 중 플로이드-워셜 알고리즘을 활용하여 해결한 경우가 있어 이를 적용하여 보았다. 다른 사람들의 풀이를 보면서 배워야 할 점이 상당히 많음을 다시 한 번 느낄 수 있었고, 코드를 구현하는 과정에서 min을 활용하는 것보다 if문을 활용하여 min 역할을 하게 하는 것이 시간적인 측면에서 더 효율적이라는 결과도 볼 수 있었다.

itertools의 product를 활용하는 알고리즘도 있었는데, 이 방법도 한번 찾아봐야겠다!

Kruskal Algorithm

• 최소 비용 신장 부분 트리를 찾는 알고리즘
• 그래프의 모든 정점들을 최소의 비용으로 연결하기 위해 사용
• Greedy 알고리즘 기반

✔시간 복잡도

• 간선의 개수 E, 정점의 개수 V를 기준으로, O(ElogV)의 시간복잡도를 가지고 있다.

🔍신장 트리와 MST

• 신장 트리(Spanning Tree)

신장 트리(Spanning Tree)는 그래프 내의 모든 정점을 포함하고, 사이클이 없는 그래프를 말합니다.

n개의 정점(Vertex)가 있다면, 신장 트리의 간선(Edge) 수는 n-1이 됩니다.

• MST(Minimum Spanning Tree)

최소 신장 트리(Minimum Spanning Tree)는 각 간선이 가지고 있는 가중치의 합이 최소가 되는 신장 트리를 말합니다.

📌진행 방식

• 그래프의 간선들로 이루어진 리스트가 있다고 가정
• 그래프 간선들의 가중치를 오름차순으로 정렬, 가중치가 가장 적은 간선부터 탐색

1. 가장 작은 가중치의 간선을 리스트에서 빼냄
2. 해당 간선이 어떤 두 트리를 연결한다면, 합쳐서 하나의 트리로 바꿈(Union & Find)
3. (2)의 조건을 만족하지 않는다면, 버림

• 위의 1~3의 과정을 진행하면서, n 개의 정점 기준 n-1 개의 간선이 남게 된다.

🖋 Code

• 코드는 프로그래머스: 섬 연결하기 문제를 따왔다.
  • MST를 찾고, 그때의 모든 가중치의 합을 구하는 문제
• cost인 가중치를 작은 값 기준으로 정렬
• 부모 노드를 설정하는 parent 리스트
  • 초기 값은 본인으로 설정
• union 함수와 find 함수를 통해 Union&Find 구현
  • Union: 서로 다른 두 트리를 합치는 함수(루트 노드를 하나로 설정)
  • Find: 해당 노드의 루트 노드를 찾는 함수
• 간선에서의 두 노드의 루트 노드가 다른 경우, 하나의 트리로 합치고, 해당 가중치를 추가

def solution(n, costs):
    answer = 0
    parent = [i for i in range(n)] # 부모 노드를 설정하기 위한 리스트
    costs.sort(key=lambda x:x[2]) # cost가 작은 값 기준으로 정렬

    def find(a): # 루트 노드를 찾는 함수
        if parent[a] == a: # 본인이 루트 노드인 경우
            return a
        parent[a] = find(parent[a])
        return parent[a] # 루트노드를 찾아 저장하고 리턴

    def union(a, b): # Tree 두개를 합치는 과정
        pa, pb = find(a), find(b) # 각 노드의 루트 노드
        if pa == pb : # 루트 노드가 같다는 것은 같은 트리
            return
        elif pa < pb : # 노드값이 더 낮은 트리쪽으로 합침
            parent[pb] = pa
        else :
            parent[pa] = pb
        return   

    for n1, n2, c in costs:
        if find(n1) != find(n2): # 루트 노드가 다르면 연결 후 경로 값 추가
            union(n1, n2)
            answer += c

    return answer

https://programmers.co.kr/learn/courses/30/lessons/77485

📌풀이

내가 쓴 풀이(성공)

• 값을 확인하기 위해, box 행렬 구현
• 문제에서 주어진 조건처럼 값을 회전시키고, 가장 작은 값 answer에 추가

def solution(rows, columns, queries):
    answer = []
    box =[] # 행렬 값 설정
    for i in range(rows) :
        box.append([])
        for j in range(columns) :
            box[i].append((i)*columns+j+1)

    for y1, x1, y2, x2 in queries:
        # x, y : 현재 인덱스 위치
        # tmp에 값을 저장하며 위치를 변경
        # 변경하는 과정에서 더 작은 값이 나오면 num을 변경
        x, y = x1-1, y1-1
        num = tmp = box[y][x]
        for _ in range(x2-x1):
            nx = x+1
            box[y][nx], tmp = tmp, box[y][nx]
            x = nx
            num = min(num, tmp)
        for _ in range(y2-y1):
            ny = y+1
            box[ny][x], tmp = tmp, box[ny][x]
            y = ny
            num = min(num, tmp)
        for _ in range(x2-x1):
            nx = x-1
            box[y][nx], tmp = tmp, box[y][nx]
            x = nx
            num = min(num, tmp)
        for _ in range(y2-y1):
            ny = y-1
            box[ny][x], tmp = tmp, box[ny][x]
            y = ny
            num = min(num, tmp)
        answer.append(num)    # num 추가

    return answer

📌후기

코드가 너무 투박한 것 같다....

https://programmers.co.kr/learn/courses/30/lessons/42861

📌풀이

내가 쓴 풀이(성공)

• kruskal 알고리즘 활용
  • costs를 cost가 작은 값 기준으로 정렬
• 부모 노드를 저장하는 리스트 parent 활용
• find: 해당 노드의 루트 노드를 찾는 함수(재귀 활용)
• union: 두 노드의 루트 노드를 확인하고, 다른 경우 하나로 합치는 함수

def solution(n, costs):
    answer = 0
    parent = [i for i in range(n)] # 부모 노드를 설정하기 위한 리스트
    costs.sort(key=lambda x:x[2]) # cost가 작은 값 기준으로 정렬

    def find(a): # 루트 노드를 찾는 함수
        if parent[a] == a: # 본인이 루트 노드인 경우
            return a
        parent[a] = find(parent[a])
        return parent[a] # 루트노드를 찾아 저장하고 리턴

    def union(a, b): # Tree 두개를 합치는 과정
        pa, pb = find(a), find(b) # 각 노드의 루트 노드
        if pa == pb : # 루트 노드가 같다는 것은 같은 트리
            return
        elif pa < pb : # 노드값이 더 낮은 트리쪽으로 합침
            parent[pb] = pa
        else :
            parent[pa] = pb
        return   

    for n1, n2, c in costs:
        if find(n1) != find(n2): # 루트 노드가 다르면 연결 후 경로 값 추가
            union(n1, n2)
            answer += c

    return answer

📌후기

kruskal 알고리즘이 무엇인지 배운 적이 있는데, 오랜 시간이 지나 사용하는 방법이나 활용하는 방법을 잊었었다. 이 문제를 통해 다시 한 번 이해할 수 있었고, kruskal 알고리즘과 관련된 내용을 정리해야겠다고 생각했다!

사전 설정

.gitignore

• .gitignore (선택)
• git에 업로드 하는 과정에서, git에 올리지 않을 내용들을 설정

가상환경을 위한 venv, 언어 환경을 위한 Python, Django, VisualStudioCode, Windows 추가

https://www.toptal.com/developers/gitignore 접속 후 프로젝트에 맞는 설정 적용

생성된 결과를 .gitignore파일을 프로젝트 폴더에 생성 후 작성

가상환경 venv

• venv

bash 창에 venv 생성 커맨드 작성

cmd 창 표시를 위해 $ 를 해놨으므로, 실제로 bash에 작성을 할 때는 쓰지 말 것

$ python -m venv venv

• 가상 환경 활성화

$ source venv/Scripts/activate

상단에 (venv) 표시를 통해 가상환경 활성화 여부 확인 가능

• Django 모듈 설치 후 pip list를 통해 설치 여부 확인

$ pip install django

• 설치된 모듈 확인 방법

$ pip list

• 설치된 모듈 리스트를 저장하는 방법(requirements.txt 에 저장)

$ pip freeze > requirements.txt

• 주어진 모듈 리스트들을 통해 모듈을 설치하는 방법 (requirements.txt에 저장되어있다는 가정)

$ pip install -r requirements.txt

📌프로젝트 시작하기

• Project
  • Application의 집합
  • 여러 앱이 포함될 수 있음
  • 앱은 여러 프로젝트에 있을 수 있음

• 프로젝트 이름은 crud 로 많이 설정

$ django-admin startproject crud .

프로젝트가 생성되면, 다음과 같이 crud 폴더와 manage.py 파일이 생성된 것을 확인할 수 있다.

• __init__.py

Python에게 이 디렉토리를 하나의 Python 패키지로 다루도록 지시

• asgi.py

Asynchronous Server Gateway Interface django 어플리케이션이 비동기식 웹 서버와 연결 및 소통하는 것을 도와줌

• settings.py

어플리케이션의 모든 설정(중요✔)

• urls.py

사이트의 url과 적절한 views의 연결을 지정

• wsgi.py

Web Server Gateway Interface Django 어플리케이션이 웹서버와 연결 및 소통하는 것을 도와줌

• manage.py

Django 프로젝트와 다양한 방법으로 상호작용하는 커맨드라인 유틸리티

📌Application 생성

• Application
  • 실제 요청을 처리하고 페이지를 보여주는 등의 역할 담당
  • 하나의 프로젝트는 여러 앱을 가짐
  • 일반적으로 앱은 하나의 역할 및 기능 단위로 작성

• Application 이름은 복수형 권장

예시는 articles로 구현

$ python manage.py startapp articles

Application이 생성되면, 앱 이름으로 된 폴더가 생성된 것을 확인할 수 있다.

• admin.py

관리자용 페이지를 설정

• apps.py

앱의 정보가 작성된 곳

• models.py

앱에서 활용하는 Model을 정의

• tests.py

프로젝트의 테스트 코드를 작성

• views.py

view 함수들 정의

Application 등록

• 반드시 생성 후 등록
  • 먼저 작성하고 생성하려면 앱이 생성되지 않음
• settings.py의 INSTALLED_APPS에 추가
  • Local apps, Third party apps, Django apps의 순서로 등록하는 것을 권장

정상적인 생성 여부 확인

• 서버실행

$ python manage.py runserver

• http://127.0.0.1:8000/ 를 통해 정상적으로 생성되었는지 확인 가능

📌base.html 생성

• html파일들에서 공통적인 형식이 나타남

• 반복적으로 작성하는 것을 줄이고자 base.html생성

• templates 폴더를 생성 후, base.html 파일 생성

base.html

• Bootstrap을 활용하기 위해, css, js 파일 적용
• body쪽 파트에, 내용을 넣고자 block 생성

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Document</title>
  <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-EVSTQN3/azprG1Anm3QDgpJLIm9Nao0Yz1ztcQTwFspd3yD65VohhpuuCOmLASjC" crossorigin="anonymous">
</head>
<body>
  <div class="container">
    {% block content %}
    {% endblock content %}
  </div>

  <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js" integrity="sha384-MrcW6ZMFYlzcLA8Nl+NtUVF0sA7MsXsP1UyJoMp4YLEuNSfAP+JcXn/tWtIaxVXM" crossorigin="anonymous"></script>
</body>
</html>

디렉토리 추가

• settings.py의 TEMPLATES에 디렉토리 추가
• DIRS에 추가
• BASE_DIR은 가장 앞쪽 디렉토리를 말함
  • 현재 위치의 parent(crud)의 parent

• 추가한 결과