읽었을 때 이해하기 쉽다. (가독성)

• 변수명, 함수명, 클래스명 등이 명확하고 직관적이어야 한다.
• 코드의 구조가 잘 정리되어 있어야 한다.
• 주석을 적절히 사용해서 코드의 의도를 설명한다. (과도한 주석 X)

유지보수가 쉽다.

• 코드의 변경 및 확장이 용이해야 한다.
• 기능별로 나눠진(모듈화 된) 코드 구조는 수정이 용이하다.
• 코드의 의존성을 최소화하고, 재사용 가능한 모듈(중복 코드 제거 효과)을 작성해야 한다.

  코드 의존성이란? ex) A가 B를 이용하고 있다면, A는 B에게 의존하고 있는 것이다. A는 B없이 작동할 수 없다. B가 변하면 A도 영향을 받는다.

성능 측면에서 효율적이다.

• 메모리 사용, 실행 시간 등을 고려하여 최적화된 알고리즘을 사용하는 것이 필요하다.
• 성능 최적화는 위의 가독성과 유지보수성을 해치지 않는 선에서 이뤄져야 한다.

테스트하기 쉬워야 한다.

• 유닛 테스트, 통합 테스트 등을 통해서 코드의 기능을 테스트 할 수 있어야 하며, 테스트를 자동화할 수 있는 구조를 갖추는 것이 좋다.
• 코드의 신뢰성을 높이는데 도움이 된다.

  테스트 종류

  • 유닛 테스트 (Unit Test)
  • 통합 테스트 (Integration Test)
  • 인수 테스트 (Acceptance Test)

코딩 스타일 및 규칙이 일관되게 유지되어야 한다.

• 규칙과 스타일을 정하고 이를 유지해야 팀원 간 협업이 원활하게 유지될 수 있다.

문서화

• 다른 개발자가 코드를 이해하고 사용하는 데 도움이 된다.
• 히스토리 관리에도 도움이 된다.

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

python

# 모든 사람은 친구 관계로 연결되어져 있다.

import sys


def solution():
    for k in range(N):
        for i in range(N):
            for j in range(N):
                if graph[i][k] + graph[k][j] < graph[i][j]:
                    graph[i][j] = graph[i][k] + graph[k][j]


if __name__ == "__main__":
    INF = 1e6

    # N: 사람 수 / M: 친구 관계 수
    N, M = map(int, input().split())

    # 친구 연결 관계
    graph = [[INF] * N for _ in range(N)]
    for i in range(N):
        graph[i][i] = 0

    # 친구 연결 관계 초기 세팅
    for _ in range(M):
        a, b = map(int, sys.stdin.readline().split())
        a -= 1
        b -= 1

        graph[a][b] = 1
        graph[b][a] = 1

    # 최단 관계수 구하기
    solution()

    min_value = INF
    result = 0
    for idx, friend_info in enumerate(graph):
        sum_value = sum(friend_info)
        if sum_value < min_value:
            min_value = sum_value
            result = idx

    print(result + 1)

# input

100 132
1 2
1 3
2 4
3 4
4 5
4 6
5 7
6 7
7 8
7 9
8 10
9 10
10 11
10 12
11 13
12 13
13 14
13 15
14 16
15 16
16 17
16 18
17 19
18 19
19 20
19 21
20 22
21 22
22 23
22 24
23 25
24 25
25 26
25 27
26 28
27 28
28 29
28 30
29 31
30 31
31 32
31 33
32 34
33 34
34 35
34 36
35 37
36 37
37 38
37 39
38 40
39 40
40 41
40 42
41 43
42 43
43 44
43 45
44 46
45 46
46 47
46 48
47 49
48 49
49 50
49 51
50 52
51 52
52 53
52 54
53 55
54 55
55 56
55 57
56 58
57 58
58 59
58 60
59 61
60 61
61 62
61 63
62 64
63 64
64 65
64 66
65 67
66 67
67 68
67 69
68 70
69 70
70 71
70 72
71 73
72 73
73 74
73 75
74 76
75 76
76 77
76 78
77 79
78 79
79 80
79 81
80 82
81 82
82 83
82 84
83 85
84 85
85 86
85 87
86 88
87 88
88 89
88 90
89 91
90 91
91 92
91 93
92 94
93 94
94 95
94 96
95 97
96 97
97 98
97 99
98 100
99 100

# output

49

불변 객체(immutable object) 설명

• 불변 객체란? 생성 후에는 내부 상태를 변경할 수 없는 객체이다.

• 종류:

  • 숫자형: int, float 등등
  • 문자열: str
  • 튜플: tuple
  • fronzenset

• 예시:

  a = 10
  a = 20  # 새로운 객체를 할당, 이전 객체는 변경되지 않음
  
  b = "hello"
  b = "world"  # 새로운 문자열 객체가 생성되고 b가 이를 참조하게 됨
  
  c = (1, 2, 3)
  # c[0] = 10  # 튜플은 불변 객체이므로 변경 불가, 이는 에러를 발생시킴

  python의 id 함수는 객체의 주소를 반환한다. 처음 객체를 할당받을 때와 새로운 객체를 할당 받을때 id값을 확인해보면 각각 다른것을 확인할 수 있는데, 이는 내부 상태를 변경한 것이 아니라 다른 객체를 새로 참조한 것으로 보면 된다. (a를 예로 들면 10이라는 값 자체를 변경한 것이 아니라, 20 이라는 값으로 참조를 변경한 것을 보면 된다.)

가변 객체(mutable object) 설명

• 가변 객체란? 생성 후에도 내부 상태를 변경할 수 있는 객체이다.

• 종류:

  • 리스트: list
  • 딕셔너리: dict
  • 집합: set

• 예시:

  a = [1, 2, 3]
  a[0] = 10  # 리스트의 첫 번째 요소를 10으로 변경
  
  b = {'key1': 'value1'}
  b['key2'] = 'value2'  # 딕셔너리에 새로운 키-값 쌍을 추가
  
  c = {1, 2, 3}
  c.add(4)  # 세트에 새로운 요소 추가

  수정 전과 후의 객체 id 값을 확인하면 동일하다. 이는 해당 객체의 내부 상태값을 변경한 것이다.

⎷ 함수 인자가 가변 객체를 받는 경우에 대하여

예시:

def solution(local_list):
    # 인자로 받은 가변 객체의 상태를 변경
    local_list[0] = 100


global_list = [1, 2, 3, 4, 5]
solution(global_list)

global_list를 호출할 경우 어떤 값이 나오는가?

print(global_list)

# 1) [1, 2, 3, 4, 5] 
# 2) [100, 2, 3, 4, 5]

정답은 2) [100, 2, 3, 4, 5]

설명:

변경한 것은 로컬 변수인 local_list 인데, 왜 외부에 있는 global_list 변수가 영향을 받은 것인가? 이는, 함수의 인자로 가변 변수를 받았기 때문이다.

• 참조에 의한 전달:

  • 파이썬에서 리스트와 같은 가변 객체는 함수의 인자로 전달될 때 객체의 참조(reference)가 전달된다. 즉, 함수 안에서 인자로 받은 리스트(=local_list)는 원래의 리스트(=global_list)를 가리킨다.

• 참조를 통한 변경:

  • solution(global_list)를 호출하면 global_list의 참조가 solution 함수의 매개변수 local_list로 전달된다. 이로 인해 global_list와 local_list가 같은 리스트를 참조하게 되는 것이다. (id값 동일)
  • 즉, local_list[0] = 100 으로 변경하는 것은 실제로 global_list[0]을 변경하는 것과 같다.

요약:

파이썬의 리스트와 같은 가변 객체는 함수에 전달될 때 참조에 의해 전달되므로, 함수 내부에서 리스트의 요소를 변경하면 원래 리스트에도 그 변경이 반영된다.

인자로 받은 원래의 리스트를 변경하지 않고, 새로운 리스트를 반환하도록 하려면?

파이썬에서 함수가 인자로 받은 리스트를 변경하지 않고 새로운 리스트를 반환하도록 하려면, 리스트의 복사본을 생성한 후 해당 복사본을 수정하고 반환하면 된다. 이를 통해 원본 리스트는 변경되지 않고, 수정된 새 리스트를 얻을 수 있다.

def solution(local_list):
    # 인자로 받은 가변 객체의 상태를 변경
    local_list = local_list.copy()
    local_list[0] = 100


global_list = [1, 2, 3, 4, 5]
solution(global_list)

print(global_list)

# output

[1, 2, 3, 4, 5]

가변 객체의 구조에 따라, 얕은 복사가 아닌 깊은 복사를 사용해야 한다.

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

회고:

• 플로이드 와샬 알고리즘으로 해결

python

import sys


def solution(graph: list):
    # graph: 간선 정보 / n: 도시 개수
    n = len(graph)

    for k in range(n):
        for i in range(n):
            for j in range(n):
                if graph[i][k] + graph[k][j] < graph[i][j]:
                    graph[i][j] = graph[i][k] + graph[k][j]

    # 이동 불가 지역은 비용을 0 으로 설정
    for i in range(n):
        for j in range(n):
            if graph[i][j] == INF:
                graph[i][j] = 0

    return graph


if __name__ == "__main__":
    INF = int(1e9)

    # 도시 개수
    N = int(input())

    graph = [[INF] * N for _ in range(N)]
    for i in range(N):
        graph[i][i] = 0

    for _ in range(int(input())):
        start, end, cost = map(int, sys.stdin.readline().split())
        start -= 1
        end -= 1

        graph[start][end] = min(graph[start][end], cost)

    result = solution(graph)
    for i in result:
        sys.stdout.write(" ".join(map(str, i)) + "\n")

# input

5
14
1 2 2
1 3 3
1 4 1
1 5 10
2 4 2
3 4 1
3 5 1
4 5 3
3 5 10
3 1 8
1 4 2
5 1 7
3 4 2
5 2 4

# output

0 2 3 1 4
12 0 15 2 5
8 5 0 1 1
10 7 13 0 3
7 4 10 6 0

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

회고:

• 모든 정점에서 모든 정점까지의 가능한 경로를 찾아야 하는 문제이므로, 플로이드 와샬 알고리즘을 사용했다.
• 다만, 경로 유무만 파악하면 되기 때문에 최단 거리까지는 구하지 않았다.

python

import sys


def solution(graph):
    N = len(graph)

    is_exist = "1"

    # k: 거쳐가는 노드
    for k in range(N):
        # i: 출발 노드
        for i in range(N):
            #  j: 도착 노드
            for j in range(N):
                # k를 거쳐가는 노드가 있는지 구한다.
                if graph[i][k] == is_exist and graph[k][j] == is_exist:
                    graph[i][j] = is_exist

    return graph


if __name__ == "__main__":
    # 정점의 개수
    N = int(input())

    # 노드 간 연결 정보
    graph = []
    for i in range(N):
        graph.append(sys.stdin.readline().split())

    result = solution(graph)
    for row in result:
        sys.stdout.write(" ".join(row) + "\n")

# input

7
0 0 0 1 0 0 0
0 0 0 0 0 0 1
0 0 0 0 0 0 0
0 0 0 0 1 1 0
1 0 0 0 0 0 0
0 0 0 0 0 0 1
0 0 1 0 0 0 0

# output

1 0 1 1 1 1 1
0 0 1 0 0 0 1
0 0 0 0 0 0 0
1 0 1 1 1 1 1
1 0 1 1 1 1 1
0 0 1 0 0 0 1
0 0 1 0 0 0 0

• 모든 정점에서 모든 정점으로의 최단 경로를 구한다.
• 다익스트라 알고리즘이 가장 적은 비용부터 하나씩 선택하는 특징이 있는 반면, 플로이드 와샬 알고리즘은 거쳐가는 정점을 기준으로 알고리즘을 수행하는 특징이 있다.
• 다익스트라 알고리즘은 다이나믹 프로그래밍을 기반으로 한다.

방법

1. 2차원 배열을 만들어서 각 정점에서, 각 정점까지의 비용을 담는다. (해당 테이블은 현재까지 계산된 최소 비용을 의미한다. 해당 2차원 배열을 반복적으로 갱신해서 최종적으로는 모든 정점에서 모든 정점으로의 최단 경로를 구하는 것이다. 반복의 기준은 거쳐가는 정점이다.)

2. 노드 1번을 거쳐가는 경우에 대한 최소 경로값을 갱신한다.

   • ex) X→Y 가는 최소 비용 vs X→1 가는 비용 + 1→X 가는 비용
   • 2차원 배열에서 1번 노드가 포함되지 않은 행열에 대해서 위와 같이 비교를 해주면 되며, 더 작은 값으로 갱신한다.

3. 2번을 마지막 노드까지 반복한다.

예시 및 코드(python)

python

def floyd(graph):
    # 노드 개수
    N = len(graph)

    # k: 거쳐가는 노드
    for k in range(N):
        # i: 출발 노드
        for i in range(N):
            # j: 도착 노드
            for j in range(N):
                if graph[i][k] + graph[k][j] < graph[i][j]:
                    graph[i][j] = graph[i][k] + graph[k][j]

    return graph


if __name__ == "__main__":
    INF = 1e8

    graph = [
        [0, 5, INF, 8],
        [7, 0, 9, INF],
        [2, INF, 0, 4],
        [INF, INF, 3, 0]
    ]

    result = floyd(graph)
    for i in result:
        print(i)

[0, 5, 11, 8]
[7, 0, 9, 13]
[2, 7, 0, 4]
[5, 10, 3, 0]

참고 링크

• https://www.youtube.com/watch?v=9574GHxCbKc

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

회고:

• 모든 노드를 최소 비용으로 연결하는 문제로, 크루스칼 알고리즘을 사용하면 됨

python

# 가장 비용이 낮은 선 부터 선택하되, 사이클이 생기지 않도록 한다.
# union-find를 이용해서 사이클 생기지 않도록 방지

import sys


def solution(N: int, links: list):
    # union-find 중 find 함수
    def get_parent(node: int) -> int:
        if node == parents[node]:
            return node
        else:
            return get_parent(parents[node])

    # union-find 중 union 함수
    def union_parent(parent_node_a: int, parent_node_b: int):
        nonlocal parents
        parents[max(parent_node_a, parent_node_b)] = min(parent_node_a, parent_node_b)

    # 연결된 부모 노드 (초기엔 자기 자신으로 초기화)
    parents = [i for i in range(N + 1)]

    # 비용 낮은 순서로 정렬
    links.sort(key=lambda x: x[2])

    count = 0  # 연결된 선 개수
    result = 0  # 총 비용
    for node_a, node_b, cost in links:
        # 부모 노드 확인
        parent_node_a = get_parent(node_a)
        parent_node_b = get_parent(node_b)

        # 사이클이 생기지 않는다면 연결한다.
        if parent_node_a != parent_node_b:
            result += cost
            count += 1
            # 부모 노드 변경
            union_parent(parent_node_a, parent_node_b)

        # 선은 N-1개 만큼 연결함
        if count == N - 1:
            break

    return result


if __name__ == "__main__":
    # 컴퓨터 수
    N = int(input())

    # 연결할 수 있는 선의 수
    M = int(input())

    # 연결 비용 정보 (노드1, 노드2, 비용)
    links = [tuple(map(int, sys.stdin.readline().split())) for _ in range(M)]

    print(solution(N, links))

#  input

6
9
1 2 5
1 3 4
2 3 2
2 4 7
3 4 6
3 5 11
4 5 3
4 6 8
5 6 8

# output

23

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

python

import sys
from heapq import heappop, heappush

INF = 1e9


# N: 도시 개수 / start: 시작 도시 번호 / end: 도착 도시 번호
# start -> end 까지의 최단 거리 구하기
def solution(N: int, start: int, end: int) -> int:
    # 시작 위치 기준 최소 거리
    distance = [INF] * (N + 1)
    distance[start] = 0

    queue = []
    for node, value in graph[start]:
        heappush(queue, (value, node))

    while queue:
        value, node = heappop(queue)

        if value < distance[node]:
            distance[node] = value

            for next_node, next_value in graph[node]:
                if value + next_value < distance[next_node]:
                    heappush(queue, (value + next_value, next_node))

    return distance[end]


if __name__ == "__main__":
    # 도시 개수
    N = int(input())

    # 버스 개수
    M = int(input())

    graph = [[] for _ in range(N + 1)]

    for _ in range(M):
        start, end, value = map(int, sys.stdin.readline().split())
        graph[start].append((end, value))

    start, end = map(int, sys.stdin.readline().split())

    print(solution(N, start, end))

# 입력값

5
8
1 2 2
1 3 3
1 4 1
1 5 10
2 4 2
3 4 1
3 5 1
4 5 3
1 5

# 출력값

4

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

회고:

다익스트라로 해결

• 안전지역, 위험지역, 죽음지역에 대한 정보를 나타내는 graph 생성:

  • (0, 0) ~ (500, 500) 까지 행/렬 각각 501칸으로 이뤄진 2차원 리스트
  • 안전지역의 값: 0 / 위험지역의 값: 1 / 죽음지역의 값: 2
  • 죽음지역의 값은 지나다니지 못하도록 해야 함 안전지역, 위험지역은 지나가게 될 경우 해당 value 만큼 최소거리가 추가됨

• 최소 거리를 나타내는 distance 생성:

  • graph 변수와 동일한 크기
  • 시작 위치는 (0, 0)이고, 시작 위치까지의 최단거리는 항상 0이다.
  • ex) distance[x][y]: 시작 위치 (0, 0)으로부터 (x, y)까지의 최단 거리

• graph 밖으로 벗어나지 않고 죽음 지역이 아닌 경우에 한하여, 동서남북으로 그 다음 최단 거리를 찾아서 heap에 추가. 추가할 때는 (최단 거리 정보, x좌표, y좌표) 정보를 넣어준다. 힙큐를 사용하기 때문에 최단 거리가 짧을 수록 heap의 앞부분으로 정렬되는 점 참고

• heap에서 최단 거리가 가장 짧은 것을 꺼내어, 최단 거리 정보를 업데이트 해준다.

python

import sys
from heapq import heappush, heappop

INF = 1e9


def update_graph(danger_value, *args):
    global graph

    x1, y1, x2, y2 = args

    for i in range(min(x1, x2), max(x1, x2) + 1):
        for j in range(min(y1, y2), max(y1, y2) + 1):
            graph[i][j] = danger_value


def solution():
    # 최단 거리 정보
    distance = [[INF] * 501 for _ in range(501)]

    # 시작 위치 거리 설정
    distance[0][0] = 0

    # 방향: 왼쪽, 오른쪽, 아래, 위
    dxs = (0, 0, 1, -1)
    dys = (-1, 1, 0, 0)

    # 시작 위치에 대한 다음 최단 거리 구하기 / heap: (거리, x좌표, y좌표) 들의 리스트
    heap = []
    for x, y in [(0, 1), (1, 0)]:
        if graph[x][y] != 2:
            heappush(heap, (graph[x][y], x, y))

    while heap:
        value, x, y = heappop(heap)

        # 최단 거리 구하기
        if value < distance[x][y]:
            distance[x][y] = value

            if x == 500 and y == 500:
                break

            for dx, dy in zip(dxs, dys):
                nx = x + dx
                ny = y + dy

                if nx < 0 or nx > 500 or ny < 0 or ny > 500:
                    continue

                if graph[nx][ny] != 2 and value + graph[nx][ny] < distance[nx][ny]:
                    heappush(heap, (value + graph[nx][ny], nx, ny))

    return -1 if distance[500][500] == INF else distance[500][500]


if __name__ == "__main__":
    # 0: 자유 롭게 다닐수 있는 곳, 1: 위험 지역, 2: 죽음 지역
    graph = [[0] * 501 for _ in range(501)]

    # 위험 구역 정보
    for _ in range(int(input())):
        update_graph(1, *map(int, sys.stdin.readline().split()))

    # 죽음 구역 정보
    for _ in range(int(input())):
        update_graph(2, *map(int, sys.stdin.readline().split()))

    print(solution())

# 입력값 

1
0 0 499 500
0

# 출력값

499

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

회고:

• 다익스트라 알고리즘 문제

python

import sys
from heapq import heappop, heappush

INF = 1e6


def solution(N: int, M: int, K: int, X: int, graph: list):
    # 최단 거리 테이블 (출발 노드는 거리 0으로 설정, 그 외에는 무한대로 설정)
    distance = [INF] * (N + 1)
    distance[X] = 0

    # 출발 노드와 연결된 최단 노드 확인
    queue = []
    for node in graph[X]:
        heappush(queue, (1, node))

    # 최단 거리 테이블 계산
    while queue:
        value, node = heappop(queue)
        next_value = value + 1

        if value < distance[node]:
            distance[node] = value

            for next_node in graph[node]:
                if next_value < distance[next_node]:
                    heappush(queue, (next_value, next_node))

    # 최단 거리가 K인 도시 개수 구하기
    is_exist = False
    for i in range(1, N + 1):
        if distance[i] == K:
            is_exist = True
            print(i)

    if not is_exist:
        print(-1)


if __name__ == "__main__":
    # N: 도시 개수, M: 도로 개수, K: 거리, X: 출발 도시 번호
    N, M, K, X = map(int, sys.stdin.readline().split())

    # 도로 정보
    graph = [[] for _ in range(N + 1)]
    for _ in range(M):
        start, end = map(int, sys.stdin.readline().split())
        graph[start].append(end)

    solution(N, M, K, X, graph)

# 입력값

4 4 1 1
1 2
1 3
2 3
2 4

# 출력값

2
3

views.py > hello_world 원래 함수

로그인하지 않은 사용자가 접근할 때, 로그인 페이지로 리다이렉트함

# views.py

def hello_world(request):
    if request.user.is_authenticated:
        if request.method == "POST":
            text = request.POST.get("hello_world_input")

            # DB 저장
            new_hello_world = HelloWorld()
            new_hello_world.text = text
            new_hello_world.save()

            return HttpResponseRedirect(reverse('accountapp:hello_world'))
        else:
            hello_world_list = HelloWorld.objects.all()
            return render(request, 'accountapp/hello_world.html', context={'hello_world_list': hello_world_list})
    else:
        return HttpResponseRedirect(reverse('accountapp:login'))

@login_required 데코레이터 사용

login_required 데코레이터 특징

• 로그인한 사용자만 접근할 수 있게 함
• 로그인하지 않은 사용자가 접근하면 자동으로 로그인 페이지로 리다이렉션됨

  from django.contrib.auth.decorators import login_required
  
  

@login_required def hello_world(request): # request.user.is_authenticated 비교 로직 제거함 if request.method == "POST": text = request.POST.get("hello_world_input")

    # DB 저장
    new_hello_world = HelloWorld()
    new_hello_world.text = text
    new_hello_world.save()

    return HttpResponseRedirect(reverse('accountapp:hello_world'))
else:
    hello_world_list = HelloWorld.objects.all()
    return render(request, 'accountapp/hello_world.html', context={'hello_world_list': hello_world_list})

<br>

#### 로그인하지 않은 사용자가 접근했을 때, 로그인 페이지가 아닌 "다른 페이지"로 리다이렉션 하고 싶다면?

1) 간단한 테스트 페이지 만들기
```python
# view.py

def test(request):
    return render(request, 'accountapp/test.html')

<!-- template -->

{% extends "base.html" %}

{% block content %}
    <div style="text-align: center;">
        <h1>TEST PAGE</h1>
    </div>
{% endblock %}

# urls.py

from django.urls import path

from accountapp.views import hello_world, test

app_name = "accountapp"

urlpatterns = [
    path('hello_world/', hello_world, name='hello_world'),
    path('test/', test, name='test'),
]

2) 로그인페이지가 아닌 다른 페이지(위의 테스트 페이지)로 리다이렉트 시키기

• views.py > @login_required 데코레이터 사용
• settigns.py > login_url 설정

  # views.py
  

from django.contrib.auth.decorators import login_required

@login_required def hello_world(request): if request.method == "POST": text = request.POST.get("hello_world_input")

    # DB 저장
    new_hello_world = HelloWorld()
    new_hello_world.text = text
    new_hello_world.save()

    return HttpResponseRedirect(reverse('accountapp:hello_world'))
else:
    hello_world_list = HelloWorld.objects.all()
    return render(request, 'accountapp/hello_world.html', context={'hello_world_list': hello_world_list})

```python
# settings.py

LOGIN_URL = reverse_lazy('accountapp:test')

3) 테스트 로그인 되지 않은 상태에서 /accounts/hello_world url로 접근하면 /accounts/test url로 리다이렉트 됨

⎷ 참고 (reverse, reverse_lazy 함수)

어째서 settigns.py 에서는 장고의 reverse를 사용하지 않고 reverse_lazy를 사용해야 하는가?

reverse, reverse_lazy 공통점 장고의 reverse, reverse_lazy 함수는 URL 이름을 바탕으로 URL을 동적으로 생성해주는 역할을 한다.
reverse, reverse_lazy 차이점 (호출시점 반환방식에 차이 O) (1) reverse: 호출 시 바로 URL을 반환해야 한다. 따라서 reverse를 사용하기 위해서는 호출 시점에 URLConf가 완전히 로드되어 있어야 한다. (2) reverse_lazy: URL을 즉시 생성하지 않고, 필요할 때까지 생성을 지연한다.

settings.py에서 reverse_lazy를 사용하는 이유는 django의 로딩순서 때문이다. settigns.py는 프로젝트의 구성 설정을 포함하며, 프로젝트가 실행될 때 가장 먼저 로드된다. 때문에 설정파일이 완전히 로드되기 전까지는 URLConf가 완전히 로드되지 않을 수 있다. reverse함수의 경우 URLConf가 완전히 로드가 되어야만 정상적으로 사용할 수 있기 때문에 settigns.py에서는 사용하지 않는다.

⎷ 클래스에 데코레이터 적용하기

각 클래스뷰 기능

• AccountUpdateView: 회원 정보 계정 수정
• AccountDeleteView: 회원 계정 삭제

상황

• 회원 정보 계정을 수정하고, 계정을 삭제할 때 로그인한 상태로 접근을 했는지 여부와 로그인한 유저와 접근하려는 대상의 정보가 일치하는지 여부를 확인한다. (나는 내 정보만 수정하거나 삭제가 가능해야 한다. 남의 정보를 조회할 수 없도록 해야 함)
• 따라서 각 클래스뷰에 대해서 get, post 함수가 아래와 같이 확장되어 있는 상태
• 코드 중복이 발생하여 이를 데코레이터로 수정할 예정

# views.py

class AccountUpdateView(UpdateView):
    model = User
    context_object_name = 'target_user'
    form_class = AccountUpdateForm
    success_url = reverse_lazy('accountapp:hello_world')
    template_name = 'accountapp/update.html'

    def get(self, *args, **kwargs):
        if self.request.user.is_authenticated and self.get_object() == self.request.user:
            return super().get(*args, **kwargs)
        else:
            return HttpResponseForbidden("허용되지 않는 접근입니다.")

    def post(self, *args, **kwargs):
        if self.request.user.is_authenticated and self.get_object() == self.request.user:
            return super().post(*args, **kwargs)
        else:
            return HttpResponseForbidden("허용되지 않는 접근입니다.")


class AccountDeleteView(DeleteView):
    model = User
    context_object_name = 'target_user'
    success_url = reverse_lazy('accountapp:login')
    template_name = 'accountapp/delete.html'

    def get(self, *args, **kwargs):
        if self.request.user.is_authenticated and self.get_object() == self.request.user:
            return super().get(*args, **kwargs)
        else:
            return HttpResponseForbidden("허용되지 않는 접근입니다.")

    def post(self, *args, **kwargs):
        if self.request.user.is_authenticated and self.get_object() == self.request.user:
            return super().post(*args, **kwargs)
        else:
            return HttpResponseForbidden("허용되지 않는 접근입니다.")

클래스에 데코레이터 적용하기

• 데코레이터 함수 역할

  • login_required: 장고에서 지원하는 함수로, 로그인한 상태로 접근하고 있는지 확인함
  • account_ownership_required: 로그인한 유저와 접근하려는 대상이 동일한지 확인

• 클래스 메서드에는 직접적으로 데코레이터를 사용할 수가 없다. 대신 method_decorator를 이용하면 클래스 메서드에 데코레이터를 적용시킬 수 있다.

• @method_decorator(데코레이터함수, '클래스메서드')

# decorator.py

from django.contrib.auth.models import User
from django.http import HttpResponseForbidden


# 로그인한 유저와 접근하려는 대상의 정보가 일치하는지 여부 확인
def account_ownership_required(func):
    def wrapper(request, *args, **kwargs):
        user = User.objects.get(pk=kwargs["pk"])

        if request.user == user:
            return func(request,*args, **kwargs)
        else:
            return HttpResponseForbidden("허용되지 않는 접근입니다.")

    return wrapper

# views.py 

from django.contrib.auth.decorators import login_required


@method_decorator(login_required, 'get')
@method_decorator(login_required, 'post')
@method_decorator(account_ownership_required, 'get')
@method_decorator(account_ownership_required, 'post')
class AccountUpdateView(UpdateView):
    model = User
    context_object_name = 'target_user'
    form_class = AccountUpdateForm
    success_url = reverse_lazy('accountapp:hello_world')
    template_name = 'accountapp/update.html'


@method_decorator(login_required, 'get')
@method_decorator(login_required, 'post')
@method_decorator(account_ownership_required, 'get')
@method_decorator(account_ownership_required, 'post')
class AccountDeleteView(DeleteView):
    model = User
    context_object_name = 'target_user'
    success_url = reverse_lazy('accountapp:login')
    template_name = 'accountapp/delete.html'

좀 더 간결하게 만들기

• 두 클래스 뷰는 공통적으로 login_required, account_ownership_required 데코레이터를 사용한다.
• 아래 has_ownership 변수와 같이 데코레이터 함수를 리스트에 담아서 사용하면 보다 간결하게 사용할 수 있다.

# views.py 

from django.contrib.auth.decorators import login_required

# login_required 먼저 순차적으로 실행됨
has_ownership = [login_required, account_ownership_required]


@method_decorator(has_ownership, 'get')
@method_decorator(has_ownership, 'post')
class AccountUpdateView(UpdateView):
    model = User
    context_object_name = 'target_user'
    form_class = AccountUpdateForm
    success_url = reverse_lazy('accountapp:hello_world')
    template_name = 'accountapp/update.html'


@method_decorator(has_ownership, 'get')
@method_decorator(has_ownership, 'post')
class AccountDeleteView(DeleteView):
    model = User
    context_object_name = 'target_user'
    success_url = reverse_lazy('accountapp:login')
    template_name = 'accountapp/delete.html'

https://school.programmers.co.kr/learn/courses/30/lessons/150370

회고:

• (python) f-string 활용

  • 아래 소스코드의 f"{term_year}.{term_month:0>2}.{day:0>2}"
  • ex) term_year=2000, term_month=1, day=12 라고 한다면, "2000.01.12"라는 문자열을 만드는 역할을 한다.
  • {변수:0>길이값} : 변수에 대해서 중앙 정렬이 아닌 (>)오른쪽으로 정렬을 해주는데, 폭을 길이값으로 하고, 부족한 부분은 0으로 채워넣는다는 의미

python

# 개인정보 n개 (고객의 약관 동의를 얻어 수집됨)
# 약관 종류 다양, 각 약관별 보관 유효기간 따로따로 정해져 있음

def solution(today, terms, privacies):
    year, month, day = map(int, today.split("."))
    day += 1

    expiration_date = {}
    for term in terms:
        term_type, term_month = term.split()
        term_month = int(term_month)

        if day == 29:
            term_month += 1

        term_month = month - term_month
        term_year = year

        if term_month <= 0:
            term_year -= -term_month // 12 + 1
            term_month = 12 - (-term_month % 12)

        expiration_date[term_type] = f"{term_year}.{term_month:0>2}.{day:0>2}"

    # 파기해야 할 개인정보
    result = []
    for idx, privacy in enumerate(privacies):
        regist_date, regist_term = privacy.split()

        if regist_date < expiration_date[regist_term]:
            result.append(idx + 1)

    return result


if __name__ == "__main__":
    result = solution(
        today="2020.05.17",
        terms=["A 3", "B 12"],
        privacies=["2020.01.01 A", "2020.05.16 B"],
    )

    print(result)

[1]

https://school.programmers.co.kr/learn/courses/30/lessons/92334

python

def solution(id_list, report, k):
    # 유저: 해당 유저가 신고한 유저들
    reporter_dict = {name: set() for name in id_list}

    # 유저: 신고당한 횟수
    reportee_dict = {name: 0 for name in id_list}

    for report_content in report:
        reporter, reportee = report_content.split(" ")

        if reportee not in reporter_dict[reporter]:
            reporter_dict[reporter].add(reportee)
            reportee_dict[reportee] += 1

    # 각 유저별 처리 결과 메일 받은 횟수 확인
    result = []
    for id in id_list:
        count = 0
        for reportee in reporter_dict[id]:
            if reportee_dict[reportee] >= k:
                count += 1

        result.append(count)

    return result


if __name__ == "__main__":
    result = solution(
        id_list=["muzi", "frodo", "apeach", "neo"],
        report=["muzi frodo", "apeach frodo", "frodo neo", "muzi neo", "apeach muzi"],
        k=2,
    )

    print(result)

[2, 1, 1, 0]

https://school.programmers.co.kr/learn/courses/30/lessons/12935

python

def solution(arr):
    if len(arr) == 1:
        return [-1]
    else:
        idx = arr.index(min(arr))
        return arr[:idx] + arr[idx + 1:]


if __name__ == "__main__":
    result = solution([4, 3, 2, 1])
    print(result)

[4, 3, 2]

https://school.programmers.co.kr/learn/courses/30/lessons/12926

python

def solution(s, n):
    upper_case = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    upper_case_dict = {c: idx for idx, c in enumerate(upper_case)}

    lower_case = "abcdefghijklmnopqrstuvwxyz"
    lower_case_dict = {c: idx for idx, c in enumerate(lower_case)}

    result = []
    for c in s:
        if not c.isalpha():
            result.append(c)
        elif c.islower():
            result.append(lower_case[(lower_case_dict[c] + n) % 26])
        else:
            result.append(upper_case[(upper_case_dict[c] + n) % 26])

    return "".join(result)


if __name__ == "__main__":
    result = solution("AB", 1)
    print(result)

BC

< view.py >

class AccountUpdateView(UpdateView):
    model = User
    context_object_name = 'target_user'
    form_class = AccountUpdateForm
    success_url = reverse_lazy('accountapp:hello_world')
    template_name = 'accountapp/update.html'

    # GET Method
    def get(self, *args, **kwargs):
        # 로그인 상태 여부 확인 / 요청한 유저 객체와 로그인된 유저 객체가 동일한지 확인
        if self.request.user.is_authenticated and self.get_object() == self.request.user:
            # UpdateView의 Get 함수를 그대로 따름
            return super().get(*args, **kwargs)
        else:
            # 403 에러코드 리턴 (권한이 옳지 않은 경우)
            return HttpResponseForbidden("허용되지 않는 접근입니다.")

    # POST Method
    def post(self, *args, **kwargs):
        if self.request.user.is_authenticated and self.get_object() == self.request.user:
            return super().post(*args, **kwargs)
        else:
            return HttpResponseForbidden("허용되지 않는 접근입니다.")

참고) self.get_object() 메서드:

• Django의 클래스 기반 뷰(Class-Based View, CBV)에서 self.get_object() 메소드는 주로 상세 조회 페이지(DetailView)나 수정 페이지(UpdateView), 삭제 페이지(DeleteView)와 같이 특정 모델 인스턴스에 접근이 필요한 경우에 사용된다.
• 이 메소드는 현재 URL에서 캡처된 파라미터를 기반으로 데이터베이스에서 객체를 조회하고, 객체가 존재하지 않을 경우 404 에러를 자동으로 반환한다.

https://leetcode.com/problems/managers-with-at-least-5-direct-reports/description/?envType=study-plan-v2&envId=top-sql-50

회고 (문제를 풀면서 의식의 흐름):

• IN절로 비교할 때, 인덱스가 설정되어 있다면 비교가 빨라진다.

• 하지만 비교해야 하는 값이 많거나, 서브쿼리가 포함되어 있는 경우 성능이 저하될 수 있다.

• 아래 문제는 IN절을 사용할 때 서브쿼리가 포함되고, 데이터셋이 많아지면 비교 대상이 많아지기 때문에 성능이 저하될 것 같다고 생각했다. 이런 경우엔 EXISTS가 더 효율적이지 않을까?

• EXISTS 특징 정리

  • EXISTS는 하위 쿼리가 적어도 하나 이상의 결과를 반환하는지 확인하는 데 사용된다. 주로 조건의 충족 여부만 중요할 때 사용한다.
  • EXISTS는 하위 쿼리 결과의 양과 상관없이 최초의 일치에서 처리를 중단하기 때문에, 특히 하위 쿼리가 복잡하거나 많은 데이터를 스캔해야 하는 경우 더 효율적일 수 있다.
  • EXISTS는 일반적으로 해당 조건과 관련된 데이터의 존재 유무만을 확인하기 때문에 IN보다 빠를 수 있다.

• 그래서 IN과 EXISTS 각각 사용해서 문제를 풀어봤는데, 예상과 달리 IN조건으로 푼 풀이가 6배는 빠르네..

• 서브쿼리로 나온 비교대상이 내 예상보다 많지 않았고, IN 조건에 걸린 컬럼이 PK라서 IN이 훨씬 빨랐던 것일까?

MySQL - IN() 활용 (runtime: 605ms)

SELECT T101.NAME
FROM Employee T101
WHERE T101.id IN (
        SELECT DISTINCT (T102.managerId)
        FROM Employee T102
        GROUP BY T102.managerId
        HAVING COUNT(T102.id) > 4
        )

MySQL - EXISTS() 활용 (runtime: 3705ms)

SELECT T102.NAME
FROM Employee T102
WHERE EXISTS (
        SELECT 1
        FROM Employee T101
        WHERE T102.id = T101.managerId
        GROUP BY T101.managerId
        HAVING COUNT(T101.id) >= 5
        )

https://school.programmers.co.kr/learn/courses/30/lessons/77885

회고:

• 풀이 방법:

  • 10진수를 2진수로 바꾼다.
  • 맨 오른쪽 숫자가 0이라면 해당 숫자만 1로 변경한다.
  • 그렇지 않다면, 오른쪽부터 왼쪽으로 01이라는 숫자를 찾고 10 으로 바꾼다.
  • 다시 10진수로 바꾼다.

python

def solution(numbers):
    result = []
    for number in numbers:
        binary_numbers = ["0"] + list(bin(number)[2:])
        length = len(binary_numbers)

        for i in range(length - 1, -1, -1):
            if binary_numbers[i] == "0":
                binary_numbers[i] = "1"
                if i != length - 1 and binary_numbers[i + 1] == "1":
                    binary_numbers[i + 1] = "0"

                break

        result.append(int("0b" + "".join(binary_numbers), 2))

    return result


if __name__ == "__main__":
    result = solution([2, 7])
    print(result)

[3, 11]

https://school.programmers.co.kr/learn/courses/30/lessons/12951#

python

# s 구성 요소: 공백, 알파벳, 숫자
# 공백 문자가 연속해서 나올 수 있다.
def solution(s):
    words = []
    for idx, c in enumerate(s):
        if not c.isalpha():
            words.append(c)
        elif idx == 0 or (idx > 0 and s[idx - 1] == " "):
            words.append(c.upper())
        else:
            words.append(c.lower())

    return "".join(words)


if __name__ == "__main__":
    result = solution("3people unFollowed me")
    print(result)

3people Unfollowed Me

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

python

def solution(n):
    answer = 0
    while n != 0:
        answer += n % 10
        n //= 10

    return answer

6