나만의 개발 블로그

그래프

내만 — Tue, 20 Dec 2022 18:08:10 +0900

728x90

‍♂️ 그래프

그래프란 노드와 그 노드를 모아놓은 간선을 하나로 모은 자료구조

하나의 객체와 다른 객체가 연결되어 있는 구조

종류

무방향 그래프 > 간선에 방향이 없음

방향 그래프 > 간선에 방향이 있음

가중치 그래프 > 간선에 가중치가 할당된 그래프, 네트워크라고도 부른다.

부분 그래프 > 특정 그래프에서 일부분을 때어낸 그래프

용어

노드, 간선, 인접 정점

차수 > 연결되어 있는 간선 수

무방향 그래프 : 차수의 합 == 간선 * 2

방향 그래프 : 진입차수와 진출차수가 존재함. 모든 진입차수의 합은 간선의 수

단순경로 - 경로 중 반복되는 간선이 없는 경로

사이클 - 시작 정점과 종료 정점이 동일한 경로

연결 그래프 - 모든 정점들 사이에 경로가 존재하는그래프

트리 - 사이클을 가지지 않는 연결 그래프, 실제로 루트를 정하면 트리모양으로 만들 수 있음

완전 그래프 - 모든 정점 간에 간선이 존재할 때

구현

인접 행렬 or 인접 리스트 or 노드와 같이 리스트로

제일 좋은 것은 딕셔너리와 set을 활용하여 구현

"""
A - C - E - G
|   |       |
B - D - F   H
"""
graph = {
    'A':set(['B','C']),
    'B':set(['A','D']),
    'C':set(['A','D','E']),
    'D':set(['B','C','F']),
    'E':set(['C','G','H']),
    'F':set(['D']),
    'G':set(['E','H']),
    'H':set(['G']),
}

graph['C']

탐색

DFS ( 깊이 우선 탐색)

def dfs(graph,start,visited=set()):
    if start not in visited:
        visited.add(start)
        print(start, end=' => ')
        subt = graph[start] - visited
        for v in subt:
            dfs(graph,v,visited)

"""
A - C - E - G
|   |       |
B - D - F   H
"""
dfs(graph,'A')

BFS ( 너비 우선 탐색 )

import collections
def bfs(graph,start):
    visited = set([start])
    queue = collections.deque([start])
    while queue:
        vertex = queue.popleft()
        print(vertex, end=" => ")
        subt = graph[vertex] - visited
        for v in subt:
            visited.add(v)
            queue.append(v)
"""
A - C - E - G
|   |       |
B - D - F   H
"""
bfs(graph,'A')

연결 성분

최대로 연결된 부분 그래프들을 구함

"""
C - A - B   > graph
D - E       > graph
"""

graph = {
    'A':set({'B','C'}),
    'B':set({'A'}),
    'C':set({'A'}),
    'D':set({'E'}),
    'E':set({'D'}),
}

def find_com(graph):
    allvisited = set()
    g_com = []
    
    for v in graph:
        if v not in allvisited:
            visited = set()
            dfs(graph,v,visited)
            allvisited.update(visited)
            g_com.append(visited.copy())
            print(visited)
find_com(graph)

신장 트리

그래프 내의 모든 정점을 포함하는 트리

사이클 x

graph = {
    'A':set(['B','C']),
    'B':set(['A','D']),
    'C':set(['A','D','E']),
    'D':set(['B','C','F']),
    'E':set(['C','G','H']),
    'F':set(['D']),
    'G':set(['E','H']),
    'H':set(['G']),
}

import collections
def bfs(graph,start):
    visited = set([start])
    queue = collections.deque([start])
    while queue:
        vertex = queue.popleft()
#         print(vertex, end=" => ") bfs에서 이건 지워지고
        subt = graph[vertex] - visited
        for v in subt:
            print(f"({vertex}, {v})", end=" => ")
            visited.add(v)
            queue.append(v)
"""
A - C - E - G
|   |       |
B - D - F   H
"""
bfs(graph,'A')

위상정렬

방향 그래프에 대한 정점들의 선행 순서를 위배하지 않으면서 모든 정점을 나열하는 것

[자료구조] 트리 - 탐색 트리

내만 — Tue, 20 Dec 2022 11:23:55 +0900

728x90

‍♂️ 이진 탐색 트리

탐색트리는 탐색을 위한 트리 기반의 자료 구조입니다.

이진 탐색 트리란 효율적인 탐색을 위한 이진트리 기반의 자료구조.

위와 같이 정렬할 수 있음.

힙트리와 이진탐색트리의 차이점

힙트리 : 최댓값이나 최솟값을 빠르게 검색하기 위한 목적

이진탐색트리 : 특정 값을 빠르게 탐색하기 위한 목적

#binary search tree
class BSTNode:
    def __init__(self, key, value):
        self.key=key
        self.value=value
        self.left=None
        self.right=None

연산

탐색연산

logn의 연산속도를 갖음.

def search(n,key):
    if n==None:
        return None
    elif n.key == key:
        return n
    elif n.key > key:
        return search(n.left, key)
    elif n.key < key:
        return search(n.right, key)

def search_max(n):
    while n != None and n.right !=None:
        n = n.right
    return n

def search_min(n):
    while n != None and n.left !=None:
        n = n.left
    return n

삽입연산

def insert(root,n):
    if n.key < root.key:
        if root.left is None:
            root.left = n
            return True
        else:
            return insert(root.left,n)
    elif n.key > root.key:
        if root.right is None:
            root.right = n
            return True
        else:
            return insert(root.right,n)
    else:
        return False

삭제연산

case 1 : 단말 노드 삭제

def delete_case1(parent,n,root):
    if parent is None:
        root = None
    else:
        if parent.left == n:
            parent.left=None
        else:
            parent.right = None
    return root

case 2 : 자식이 하나인 노드 삭제

def delete_case2(parent,n,root):
    if n.left is not None:
        child = n.left
    else:
        child = n.right
    
    if n == root:
        root = child
    else:
        if n is parent.left:
            parent.left = child
        else:
            parent.right = child
    return root

case 3 : 두 개의 자식을 가진 노드 삭제

def delete_case3(parent,n,root):
    succ_p = n
    succ = n.right
    while succ.left != None:
        succ_p = succ
        succ = succ.left
        
    if succ_p.left == succ:
        succ_p.left = succ.right
    else:
        succp.right = succ.right
    n.key = succ.key
    n.value = succ.value
    return root

전체 코드

def delete_all(root,key):
    if root == None:
        return None
    
    parent = None
    node = root
    while node is not None and node.key is not key:
        parent = node
        if key < node.key:
            node = node.left
        else:
            node = node.right
    if node == None:
        return None
    if node.left == None and node.right == None:
        root = delete_case1(parent,node,root)
    elif node.left == None or node.right == None:
        root = delete_case2(parent,node,root)
    else:
        root = delete_case3(parent,node,root)
        
    return root

맵(map)

원하는 탐색키를 가진 레코드 값을 찾는 자료구조

파이썬의 dictionary와 같음.

class BSTMap():
    def __init__(self):
        self.root = None
    def isEmt(self): return self.root == None
    def search(self,key):
        return search(self.root,key)
    def findMax(self):
        return search_max(self.root)
    def findMin(self):
        return search_min(self.root)
    def insert(self, key, value=None):
        n = BSTNode(key,value)
        if self.isEmt():
            self.root=n
        else:
            insert(self.root, n)
    def inorder(self,n):
        if n is not None:
            self.inorder(n.left)
            print(f'({n.key},{n.value})',end=" ")
            self.inorder(n.right)
    
    def levelorder(self,n):
        import queue  
        q = queue.Queue()
        q.put(n)
        while q.empty() == False:
            next_n = q.get()
            if next_n is not None:
                print(f'({next_n.key},{next_n.value})',end=" ")
                q.put(next_n.left)
                q.put(next_n.right)
            
    def display_sort(self):       #오름차순 출력(중위 순회)
        print("MAP : ",end=" ")
        self.inorder(self.root)
        print()
        
    def display_tree(self):       #트리 레벨을 출력
        print("MAP-lv : ",end=" ")
        self.levelorder(self.root)
        print()
        
    def delKey(self,key):
        self.root = delete_all(self.root, key)
            
b_map = BSTMap()
key_data = [35,18,68,7,26,99,3,12,22,30]
for key in key_data:
    b_map.insert(key)

b_map.display_sort()
b_map.display_tree()

print("key 26 : ",b_map.search(26))
print("key 26 : ",b_map.search(28))
print(b_map.findMax().key)

b_map.delKey(18)
b_map.display_sort()
b_map.display_tree()

‍♂️ 균형 이진 탐색 트리

AVL 균형이진탐색트리

모든 경우에 log n 시간복잡도를 보장합니다.

균형 인수가 1~ -1이 넘어가면 안됩니다.

균형인수는 왼쪽 서브트리 높이 - 오른쪽 서브트리 높이입니다.

회전 방법

1. LL 회전 방법

def rotateLL(A):
    B=A.left
    A.left = B.right
    B.right = A
    return B

2. RR 회전 방법

def rotateRR(A):
    B=A.right
    A.right = B.left
    B.left = A
    return B

3. RL 회전 방법

def rotateRL(A):
    B = A.right
    A.right = rotateLL(B)
    return rotateRR(A)

4. LR 회전 방법

def rotateLR(A):
    B = A.left
    A.left = rotateRR(B)
    return rotateLL(A)

[자료구조] 트리 - 일반 트리, 이진 트리, 결정트리, 힙

내만 — Tue, 20 Dec 2022 01:29:45 +0900

728x90

‍♂️일반 트리

트리 : 계층적인 자료의 표현에 적합한 자료 구조다.

최상위 노드를 루트 노드라 부름.

자식을 갖지 못하는 노드 = 단말 노드

class TNode:
    def __init__(self,data, left, right):
        self.data = data
        self.left = left
        self.right = right
        
d = TNode('D',None,None)
e = TNode('E',None,None)
f = TNode('F',None,None)
b = TNode('B',d,e)
c = TNode('C',f,None)
a = TNode('A',b,c)

‍♂️이진 트리

이진 트리 : 모든 노드가 2개의 서브 트리를 갖는 트리

완전 이진트리 : 왼쪽부터 꽉찬 경우

포화 이진트리 : 모든 노드가 꽉차있는 경우

이진트리의 특징1 : 노드의 개수가 n개면 간선의 개수는 n-1이다.

이진트리의 특징2 : 높이가 h이면 h~2^h-1개의 노드를 가짐.

> 반대로 생각하면 n개 노드의 이진 트리 높이는 log2(n+1) ~ n이다.

표현법

1.배열 표현법

2. 연결된 구조

배열 표현법

장점 - 구현이 쉬움

단점 - 메모리 낭비가 심함.

연결된 구조

공간의 제약이 적습니다.

순회

순회란 트리에 속하는 모든 노드를 한 번씩 방문하는 것입니다.

1. 전위 순회

2. 중위 순회

3. 후위 순회

4. 레벨 순회

전위 순회 : 루트 > 왼쪽 서브트리 > 오른쪽 서브트리

특징 - 부모를 처리한 다음에 자식을 처리하는 경우

class TNode:
    def __init__(self,data, left, right):
        self.data = data
        self.left = left
        self.right = right

def pre(n):
    if n is not None:
        print(n.data, end=" ")
        pre(n.left)
        pre(n.right)

#   A
# B   C
#DE  F

d = TNode('D',None,None)
e = TNode('E',None,None)
f = TNode('F',None,None)
b = TNode('B',d,e)
c = TNode('C',f,None)
a = TNode('A',b,c)

pre(a)

중위 순회 : 왼쪽 서브트리 > 루트 > 오른쪽 서브트리

특징 - 이진탐색트리의 경우 제일 작은 값이 왼쪽 아래에 위치하게 되어서 정렬에 용이합니다.

def inO(n):
    if n is not None:
        inO(n.left)
        print(n.data, end=" ")
        inO(n.right)

inO(a)

후위 순회 : 왼쪽 서브트리 > 오른쪽 서브트리 > 루트

def post(n):
    if n is not None:
        post(n.left)
        post(n.right)
        print(n.data, end=" ")
        
post(a)

레벨 순회 : 노드를 레벨 순으로 검사하는 순회 방법

큐를 이용해서 구현할 수 있음.

from queue import Queue
def level(root):
    queue = Queue()
    queue.put(root)
    while not queue.empty():
        n = queue.get()
        if n is not None:
            print(n.data, end=" ")
            queue.put(n.left)
            queue.put(n.right)
            
level(a)

연산

노드 개수 : 아래에서 위로 각 자식의 후손 노드 수를 합해서 올라가서 최종적으로 루트 노드에서 총 합을 구하게 되는 방식입니다.

def cntN(n):
    if n is None:
        return 0
    else:
        return cntN(n.left) + cntN(n.right)+1
        
cntN(a)

단말 노드의 수 : 단말 노드인 경우만 sum

def cntL(n):
    if n is None:
        return 0
    elif n.left ==None and n.right ==None:
        return 1
    else:
        return cntL(n.left) + cntL(n.right)
        
cntL(a)

트리의 높이 : 좌우 서브 트리 중 더 큰 서브트리에 1을 더해서 높이 구함.

def tree_H(n):
    if n is None:
        return 0
    
    return max([tree_H(n.left),tree_H(n.right)])+1

tree_H(a)

‍♂️ 결정 트리

여러 단계의 복잡한 조건을 갖는 문제에 대해 조건과 그에 따른 해결 방법을 트리 형태로 나타낸 것.

모스부호를 통한 실습 :

모스 부호 테이블

table = [('A', '.-'), ('B', '-...'),
         ('C', '-.-.'), ('D', '-..'), ('E', '.'),
         ('F', '..-.'), ('G', '--.'), ('H', '....'),
         ('I', '..'), ('J', '.---'), ('K', '-.-'),
         ('L', '.-..'), ('M', '--'), ('N', '-.'),
         ('O', '---'), ('P', '.--.'), ('Q', '--.-'),
         ('R', '.-.'), ('S', '...'), ('T', '-'),
         ('U', '..-'), ('V', '...-'), ('W', '.--'),
         ('X', '-..-'), ('Y', '-.--'), ('Z', '--..')]

결정 트리 생성

def d_tree():
    root = TNode(None,None,None)
    for mrs in table:
        code = mrs[1]
        node = root
        
        for c in code:
            if c == ".":
                if node.left == None:
                    node.left = TNode(None,None,None)
                node = node.left
            elif c == "-":
                if node.right == None:
                    node.right = TNode(None,None,None)
                node = node.right
        node.data = mrs[0]
    return root
    
mrsTree = d_tree()

문자열 > 모스부호 인코딩

def enc(text):
    code_lst = []
    for c in text:
        idx = ord(c) - ord('A')
        code = table[idx][1]
        code_lst.append(code)
    return code_lst
    
python_code = enc("PYTHON")
print(python_code)

모스부호 > 문자열 디코딩

def decode(mrsTree, code_lst):
    text = ""
    for code in code_lst:
        node = mrsTree
        for c in code:
            if c == '.':
                node = node.left
            elif c == "-":
                node = node.right
        text = text+node.data
    return text
    
    
print(decode(mrsTree,python_code))

‍♂️ 힙

힙은 완전이진트리 기반의 자료구조, 최대값 혹은 최소값을 root에 올리고 이를 바탕으로 빠르게 값을 찾는 트리입니다.

1. 최대 힙

2. 최소 힙

3. 힙이 아님

최대힙

class MaxHeap:
    def __init__(self):
        self.heap=[]
        self.heap.append(0)
    def size(self): return len(self.heap) -1
    def isEpt(self): return self.size() == 0
    def Parent(self, i):
        return self.heap[i//2]
    def Left(self, i):
        return self.heap[i*2]
    def Right(self, i):
        return self.heap[i*2+1]
    def display(self):
        print("heap : ",self.heap[1:])

연산

1. 삽입연산

삽입연산은 힙이여서 가능한거임 즉 완전이진트리라 가능

삽입한 노드와 루트 노드 크기 비교해서 삽입한 노드가 크다면 루트노드와 교환

def insert(self,n):
        self.heap.append(n)
        i = self.size()
        while (i != 1 and n > self.Parent(i)):
            self.heap[i]=self.Parent(i)
            i=i//2
        self.heap[i]=n
        
        
heap = MaxHeap()
heap.insert(2)
heap.display()
heap.insert(5)
heap.display()
heap.insert(4)
heap.display()
heap.insert(8)
heap.display()

2. 삭제 연산

def delete(self):
    if not self.isEmt():
        hroot = self.heap[1] #삭제할 값
        last = self.heap[self.size()] #힙의 제일 마지막 값이 최상단으로 
        self.heap.pop(-1)    #삭제함

        i=1
        while(i*2<=self.size()):
            max_idx = 0 #좌
            if i*2+1 < self.size() and self.Left(i) < self.Right(i):
                max_idx=1 #우
            if last >= self.heap[i*2 + max_idx]:  #최상단으로 간 마지막값과 자식 중 큰 값이랑 비교
                break                             #last가 크져서 더 이상 노드를 변경하지 않아도 되는 경우 탈출
            self.heap[i] = self.heap[i*2+max_idx]      #last가 있던 값과 교환당하는 코드
            i = i*2 + max_idx        # i 값에 더큰 자식 노드 저장
        self.heap[i] = last
        return hroot
            
            
            
            
heap = MaxHeap()
heap.insert(2)
heap.display()
heap.insert(5)
heap.display()
heap.insert(4)
heap.display()
heap.insert(8)
heap.display()

print(heap.delete())
heap.display()

[웹 크롤링 프로젝트] 06. 구름 IDE로 Fast API 간단 배포

내만 — Fri, 2 Dec 2022 16:43:42 +0900

728x90

‍♂️ 환경설정

0. 구름 IDE

https://ide.goorm.io/my/dashboard

goorm

구름은 클라우드 기술을 이용하여 누구나 코딩을 배우고, 실력을 평가하고, 소프트웨어를 개발할 수 있는 클라우드 소프트웨어 생태계입니다.

goorm.co

깃허브 아이디로 구름 IDE에 로그인 하시면 하나의 컨테이너를 항상 켜둘 수 있습니다.

별다른 설명 할 것 없이 그냥 플러스 버튼을 클릭하며 새 컨테이너를 만들어주고

1. FastAPI를 위한 패키지 설치

Fast API를 위한 패키지를 설치해줍니다.

그리고 추가로 API에서 필요한 라이브러리들을 설치해줍니다. 저 같은 경우에는 크롤링 API이기 때문에 BeuatifulSoup4를 설치해줬습니다.

2. Fast API 코드 작성

from typing import Union

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: Union[str, None] = None):
    return {"item_id": item_id, "q": q}

저는 위의 코드를 사용하지는 않았지만 예시 코드가 필요하신 분들은 위의 코드를 사용하셔도 됩니다.

이렇게 켤 수 있음

밑에 터미널을 통해서 api 서버 여는 코드를 치면

uvicorn index:app --reload

화면의 우측 아래에 URL로 배포되고 있는 것입니다.

이제 끄면 되겠다 싶지만 사실 그렇지 않습니다. 마지막 제일 중요한 설정을 해야 합니다.

nohup uvicorn index:app --reload > /dev/null

nohup라는 명령어를 통해서 API 서버 실행하는 코드를 백그라운드로 실행 시켜주고

> /dev/null 코드를 통해서 nohup 실행에 따른 다른 파일이 생성되지 않도록 합니다.

그러면 이제 배포에 성공하게 됩니다!

추가로 Fast API에 CORS 문제를 겪고 계시면

https://velog.io/@wlsdud2194/cors

위 게시물을 참고하시면 될 것 같습니다.

[pygame] 10. 깃허브에 올리기

내만 — Sun, 27 Nov 2022 23:05:56 +0900

728x90

‍♂️ Git Hub에 올리는 절차

1. 해당 경로로 이동

2. README.md 파일 생성

$ echo "# py-shooting-game" >> README.md

3. git init 하기

$ git init

4. git add 하기

$ git add .

5. 커밋하기

$ git commit -m "first commit"

6. 브랜치 생성

git branch -M main

7. remote 추가

$ git remote add origin https://github.com/kihyun1998/py-shooting-game.git

8. push

$ git push -u origin main

[웹 크롤링 프로젝트] 05. Fast API 도커 배포 - 1 (FastAPI 시작하기 수정)

내만 — Fri, 25 Nov 2022 16:16:49 +0900

728x90

‍♂️ 프로젝트 생성

1. VS Code 가상환경 설정

먼저 VS Code에서 폴더를 선택해주고

VS Code의 터미널에서

python -m venv {가상환경이름}

위의 코드를 통해서 가상환경을 만들어주면 위의 이미지처럼 나오게됩니다.

저는 가상환경 이름을 venvAPI로 했습니다.

2. 가상환경 진입

우선 만든 가상환경 폴더 안에 있는 Scripts라는 폴더로 이동하고

activate를 실행해주면

가상환경에 진입하게 됩니다.

3. 파이썬 가상환경 인식

파이썬 가상환경 인식을 위해 아무 파이썬 파일을 생성하고

우측 하단에 보면 Python 어쩌구 버전이 나오는데 숫자를 클릭해보면

저기에서 추천하는 venv의 파이썬을 쓰겠다는 부분으로 인터프리터를 바꿔주면

가상환경에서 파이썬 인식이 됩니다.

4. 파일 구조 설정

app이라는 폴더를 만들어서 API 코드가 담길 파이썬 파일을 넣어주고

도커 이미지를 만드는 Dockerfile과

테스트에 사용하는 샘플인 docker-compose.yaml파일을 생성해줍니다.

‍♂️ FastAPI 설정

1. FastAPI를 위한 패키지 설치

FastAPI 시작을 위해 두 개의 패키지를 설치해줍니다.

2. FastAPI를 배포를 위한 패키지 리스트 출력

pip freeze > requirements.txt

위 명령어를 통해서 가상환경에 설치된 패키지 리스트를 requirements.txt로 출력하게 됩니다.

내용을 보면 방금 설치한 fastapi와 uvicorn 이외에도 제 컴퓨터에 설치된 다양한 패키지들이 정의되어 있네요.

requirements.txt 파일 위치는 app 폴더 밑으로 옮기겠습니다.

‍♂️ FastAPI 예시 코드 작성

from typing import Union

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: Union[str, None] = None):
    return {"item_id": item_id, "q": q}

main.py에 공식문서에서 제공하는 코드를 입력 후

uvicorn main:app --reload

위의 명령어를 터미널에서 해당 main.py가 있는 파일이 있는 폴더로 입력한 후

입력하면 서버가 얼려서 해당 주소(127,0,0,1:8000)이라고 나오는 저기 주소로 들어가면

Hello World가 출력되는 것을 볼 수 있습니다.

이제 도커로 이미지를 따서 배포하는 방법은 2부에서 정리하도록 하겠습니다.

[웹 크롤링 프로젝트] 04. AWS EC2 서버 사용하기

내만 — Tue, 15 Nov 2022 21:44:11 +0900

728x90

‍♂️ 방법

1. 사이트 들어가기 및 계정 생성

https://aws.amazon.com/ko/

클라우드 서비스 | 클라우드 컴퓨팅 솔루션| Amazon Web Services

개발자, 데이터 사이언티스트, 솔루션스 아키텍트 또는 AWS에서 구축하는 방법을 배우는 데 관심이 있는 모든 사용자용 무료 온라인 교육 AWS 전문가가 구축한 500개 이상의 무료 디지털 교육 과정

aws.amazon.com

2. 가입 완료 후 콘솔로 들어옴

여기서 Tokyo를 서울로 바꿔줘야 합니다.

3. EC2 생성을 위해

Services(모든 서비스) > Compute(컴퓨팅) > EC2를 클릭

4. 주황색 버튼인 Launch instance(인스턴스 시작)을 클릭

5. 사용할 OS 선택

저는 Amazon Linux

6. instance 타입은 자동 선택 됨(공짜로)

7. configure storage 최대 용량으로 30gib

8. Network settings에서 밑에 쪽에 보안 그룹 추가해서

밑에 Security group rule 2 처럼 설정

9. 나머지는 디폴트로 하고 밑에 Launch instance 클릭

10. 이때 나오는 키는 무조건 저장하고 저장위치 기억하기

11. 인스턴스 만들어진 것을 확인할 수 있음.

12. 해당 인스턴스 클릭해서 들어가면 Action > connect를 누르면

SSH 접속 방법이 나와서 이걸로 접속할 수 있습니다.

연결한 모습입니다.

13. 모든 패키지 업데이트

sudo yum update -y

위 명령어로 업데이트

하게 된다면

AWS 사용을 위한 초기 세팅은 끝났습니다.

[웹 크롤링 프로젝트] 03. Fast API 시작하기

내만 — Tue, 15 Nov 2022 21:43:57 +0900

‍♂️ FastAPI

Flast나 Django보다 빠르다고 해서 사용해봅니다.

https://fastapi.tiangolo.com/ko/

FastAPI

FastAPI FastAPI 프레임워크, 고성능, 간편한 학습, 빠른 코드 작성, 준비된 프로덕션 문서: https://fastapi.tiangolo.com 소스 코드: https://github.com/tiangolo/fastapi FastAPI는 현대적이고, 빠르며(고성능), 파이썬

fastapi.tiangolo.com

위 문서를 참고했습니다!

pip install fastapi

pip instal "uvicorn[standard]"

위의 두 패키지를 install 했습니다.

from fastapi import FastAPI
app = FastAPI()

@app.get("/")
async def root():
    return {"msg" : "Hello World"}

위의 코드를 main.py로 만들었습니다.

꼭 main.py로 해야 합니다.(사실 상관없는데 이유는 밑에서)

uvicorn main:app --reload

터미널에서 main.py가 있는 곳까지 가서 명령어를 치면 서버가 실행됩니다.

이 때 API 파일 명을 쳐야합니다.

ex) main.py 라면 위처럼

test.py라면 밑처럼

uvicorn test:app --reload

uvicorn 은 당연히 uvicorn을 쓰는거고

main은 main.py의

app은 FastAPI()가 담긴 변수를 뜻합니다.

--reload는 서버 재시작입니다.

만약 main.py가 아닌 test.py로 하고 했다면

uvicorn test:app --reload

이렇게 실행할 수 있었겠네요.

from fastapi import FastAPI
app = FastAPI()

@app.get("/")
async def root():
    return {"msg" : "Hello World"}

@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str):
    return {"item_id":item_id, "q":q}

암튼 하나를 더 추가하고 서버를 실행해보면

http://127.0.0.1:8000/items/2?q=12345

위 경로로 이동하면

잘 나오는 모습입니다.

http://127.0.0.1:8000/docs

위의 코드로 이동하면

잘 정리된 문서까지 볼 수 있습니다!

[pygame] 09. 텍스트 사용

내만 — Wed, 9 Nov 2022 23:28:18 +0900

728x90

‍♂️ 변수 설정

"""
3. 게임 내 필요한 설정
"""
.
.
.

#적기 격추 = shootDown
shootDown=0

#적기 놓침 = missed
missed=0

#포인트값
#point = (shootDown*100)-(missed-50)
point=0

.
.
.

"""
4. 메인 이벤트
"""
.
.
.
    
    """
    4-3. 입력과 시간에 따른 변화
    """    
    .
    .
    .
    for i in cd_del_enemList:
        del enemList[i]          #적기 제거
        shootDown += 1           #적군 격추 시 증가
        point += 100             #적군 격추 시 포인트 100 증가
        
    for i in del_enemList:
        del enemList[i]
        missed+=1             #적기 놓치면 증가
        point-=50             #적기 놓치면 -50

‍♂️ 텍스트 사용

텍스트를 띄우기 위해서는 3가지 절차가 필요합니다.

1. 폰트설정

2. surface 생성

3. surface 화면에 표시 입니다.

    """
    ================
    텍스트 표시 절차
    """
    #1. 폰트 설정(폰트 주소, 폰트 크기)
    font = pygame.font.Font(r"font\경기천년제목V_Bold.ttf",20)
    
    #2. surface 생성(텍스트, 안티앨리어싱, 폰트 색(rgb))
    #shootDown 값과 missed값 표시
    text_val = font.render(f"Shoot Down : {shootDown}   Missed : {missed}",True, (255,255,255))
    text_point = font.render(f"Point : {point}",True,(255,255,255))
    
    #3. surface 표시(표시할 이미지, 위치)
    screen.blit(text_val, (10,5))
    screen.blit(text_point, (650,5))
    
    """
    ================
    """

이런식으로 텍스트를 띄울 수 있습니다.

[자료구조][파이썬으로 쉽게 풀어쓴 자료구조] 05 큐 문제풀기

내만 — Tue, 25 Oct 2022 19:55:32 +0900

728x90

‍♂️리스트

"""
리스트
"""

class ArrayList:
    def __init__(self):
        self.items=[]
    def insert(self,pos,elem):
        self.items.insert(pos,elem)
    def delete(self,pos):
        return self.items.pop(pos)
    def isEmpty(self):
        return self.size()==0
    def getEntry(self,pos):
        return self.items[pos]
    def size(self):
        return len(self.items)
    def clear(self):
        self.items=[]
    def find(self,item):
        return self.items.index(item)
    def replace(self,pos,elem):
        self.items[pos]=elem
    def sort(self):
        self.items.sort()
    def merge(self,lst):
        self.items.extend(lst)
    def display(self, msg='ArrayList:'):
        print(msg,"항목수=",self.size(),self.items)

나만의 개발 블로그

그래프

‍♂️ 그래프

종류

용어

구현

탐색

[자료구조] 트리 - 탐색 트리

‍♂️ 이진 탐색 트리

연산

탐색연산

삽입연산

삭제연산

맵(map)

‍♂️ 균형 이진 탐색 트리

회전 방법

[자료구조] 트리 - 일반 트리, 이진 트리, 결정트리, 힙

‍♂️일반 트리

‍♂️이진 트리

표현법

순회

연산

‍♂️ 결정 트리

‍♂️ 힙

연산

[웹 크롤링 프로젝트] 06. 구름 IDE로 Fast API 간단 배포

‍♂️ 환경설정

0. 구름 IDE

1. FastAPI를 위한 패키지 설치

2. Fast API 코드 작성

[pygame] 10. 깃허브에 올리기

‍♂️ Git Hub에 올리는 절차

1. 해당 경로로 이동

2. README.md 파일 생성

3. git init 하기

4. git add 하기

5. 커밋하기

6. 브랜치 생성

7. remote 추가

8. push

[웹 크롤링 프로젝트] 05. Fast API 도커 배포 - 1 (FastAPI 시작하기 수정)

‍♂️ 프로젝트 생성

1. VS Code 가상환경 설정

2. 가상환경 진입

3. 파이썬 가상환경 인식

4. 파일 구조 설정

‍♂️ FastAPI 설정

1. FastAPI를 위한 패키지 설치

2. FastAPI를 배포를 위한 패키지 리스트 출력

‍♂️ FastAPI 예시 코드 작성

[웹 크롤링 프로젝트] 04. AWS EC2 서버 사용하기

‍♂️ 방법

1. 사이트 들어가기 및 계정 생성

2. 가입 완료 후 콘솔로 들어옴

3. EC2 생성을 위해

Services(모든 서비스) > Compute(컴퓨팅) > EC2를 클릭

4. 주황색 버튼인 Launch instance(인스턴스 시작)을 클릭

5. 사용할 OS 선택

6. instance 타입은 자동 선택 됨(공짜로)

7. configure storage 최대 용량으로 30gib

8. Network settings에서 밑에 쪽에 보안 그룹 추가해서

밑에 Security group rule 2 처럼 설정

[웹 크롤링 프로젝트] 03. Fast API 시작하기

‍♂️ FastAPI

[pygame] 09. 텍스트 사용

‍♂️ 변수 설정

‍♂️ 텍스트 사용

[자료구조][파이썬으로 쉽게 풀어쓴 자료구조] 05 큐 문제풀기

‍♂️리스트

‍♂️리스트 문제