COMMON Archives - 42 중 3 번째 페이지

[PYTHON/COMMON] schedule 패키지 설치하기

■ schedule 패키지를 설치하는 방법을 보여준다. 1. 명령 프롬프트를 실행한다. 2. 명령 프롬프트에서 아래 명령을 실행한다. ▶ 실행 명령


pip install schedule

pip install schedule

[PYTHON/COMMON] langchain-anthropic 패키지 설치하기

■ langchain-anthropic 패키지를 설치하는 방법을 보여준다. 1. 명령 프롬프트를 실행한다. 2. 명령 프롬프트에서 아래 명령을 실행한다. ▶ 실행 명령


pip install langchain-anthropic

pip install langchain-anthropic

[PYTHON/COMMON] system 함수 : 터미널 화면 지우기

■ system 함수를 사용해 터미널 화면을 지우는 방법을 보여준다. ▶ 예제 코드 (PY)


import os

def clearTerminal():
    if os.name == "nt": # 윈도우즈
        os.system("cls")
    else:  # 리눅스, OSX
        os.system("clear")

import os

def clearTerminal():

if os.name == "nt": # 윈도우즈

os.system("cls")

else: # 리눅스, OSX

os.system("clear")

[PYTHON/COMMON] pykrx 패키지 설치하기

■ pykrx 패키지를 설치하는 방법을 보여준다. 1. 명령 프롬프트를 실행한다. 2. 명령 프롬프트에서 아래 명령을 실행한다. ▶ 실행 명령


pip install pykrx

pip install pykrx

[PYTHON/COMMON] itemgetter 클래스 : 딕셔너리에서 특정 키 값 구하기

■ itemgetter 클래스를 사용해 딕셔너리에서 특정 키 값을 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


from operator import itemgetter

sourceDictionary = {
    "Alice"   : 85,
    "Bob"     : 92,
    "Charlie" : 78
}

itemgetter1 = itemgetter("Alice", "Charlie")

scoreTuple = itemgetter1(sourceDictionary)

print(scoreTuple)

"""
(85, 78)
"""

from operator import itemgetter

sourceDictionary = {

"Alice" : 85,

"Bob" : 92,

"Charlie" : 78

}

itemgetter1 = itemgetter("Alice", "Charlie")

scoreTuple = itemgetter1(sourceDictionary)

print(scoreTuple)

"""

(85, 78)

"""

[PYTHON/COMMON] itemgetter 클래스 : 특정 항목을 기준으로 리스트 정렬하기

■ itemgetter 클래스를 사용해 특정 항목을 기준으로 리스트를 정렬하는 방법을 보여준다. ▶ 예제 코드 1 (PY)


from operator import itemgetter

sourceList = [
    ("Alice"  , 25),
    ("Bob"    , 20),
    ("Charlie", 23)
]

ageItemgetter = itemgetter(1) # 두번째 항목

targetList = sorted(sourceList, key = ageItemgetter)

print(targetList)

"""
[('Bob', 20), ('Charlie', 23), ('Alice', 25)]
"""

from operator import itemgetter

sourceList = [

("Alice" , 25),

("Bob" , 20),

("Charlie", 23)

]

ageItemgetter = itemgetter(1) # 두번째 항목

targetList = sorted(sourceList, key = ageItemgetter)

print(targetList)

"""

[('Bob', 20), ('Charlie', 23), ('Alice', 25)]

"""

▶ 예제 코드 2 (PY)

[PYTHON/COMMON] hex 함수 : RGBA 색상값을 ARGB 색상 16진수 문자열 값 구하기

■ hex 함수를 사용해 RGBA 색상값을 ARGB 색상 16진수 문자열 값으로 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


red   = 166
green = 128
blue  = 255
alpha = 0.8

redHexadecimalString   = hex(red  ).replace("0x", "")
greenHexadecimalString = hex(green).replace("0x", "")
blueHexadecimalString  = hex(blue ).replace("0x", "")
alphaHexadecimalString = hex(int(round(alpha * 255, 0))).replace("0x", "")

print(redHexadecimalString  ) # a6
print(greenHexadecimalString) # 80
print(blueHexadecimalString ) # ff
print(alphaHexadecimalString) # cc

argbHexadecimalString = "#{alphaHexadecimalString}{redHexadecimalString}{greenHexadecimalString}{blueHexadecimalString}".format(
    alphaHexadecimalString = str(alphaHexadecimalString).ljust(2, "0"),
    redHexadecimalString   = str(redHexadecimalString  ).ljust(2, "0"),
    greenHexadecimalString = str(greenHexadecimalString).ljust(2, "0"),
    blueHexadecimalString  = str(blueHexadecimalString ).ljust(2, "0")
)

print(argbHexadecimalString) # #cca680ff

red = 166

green = 128

blue = 255

alpha = 0.8

redHexadecimalString = hex(red ).replace("0x", "")

greenHexadecimalString = hex(green).replace("0x", "")

blueHexadecimalString = hex(blue ).replace("0x", "")

alphaHexadecimalString = hex(int(round(alpha * 255, 0))).replace("0x", "")

print(redHexadecimalString ) # a6

print(greenHexadecimalString) # 80

print(blueHexadecimalString ) # ff

print(alphaHexadecimalString) # cc

argbHexadecimalString = "#{alphaHexadecimalString}{redHexadecimalString}{greenHexadecimalString}{blueHexadecimalString}".format(

alphaHexadecimalString = str(alphaHexadecimalString).ljust(2, "0"),

redHexadecimalString = str(redHexadecimalString ).ljust(2, "0"),

greenHexadecimalString = str(greenHexadecimalString).ljust(2, "0"),

blueHexadecimalString = str(blueHexadecimalString ).ljust(2, "0")

)

print(argbHexadecimalString) # #cca680ff

[PYTHON/COMMON] pip list 명령 : –format 옵션을 사용해 설치 패키지 리스트 조회하기

■ pip list 명령의 –format 옵션을 사용해 설치 패키지 리스트를 조회하는 방법을 보여준다. 1. [명령 프롬프트]를 실행한다. 2. [명령 프롬프트]에서 아래 명령을

[PYTHON/COMMON] nsmallest 함수 : 리스트 힙 정렬하기

■ nsmallest 함수를 사용해 리스트 힙을 정렬하는 방법을 보여준다. ▶ 예제 코드 (PY)


import heapq

sourceList = [14, 10, 6, 8, 12, 4]

targetList = heapq.nsmallest(len(sourceList), sourceList)

print(targetList) # [4, 6, 8, 10, 12, 14]

import heapq

sourceList = [14, 10, 6, 8, 12, 4]

targetList = heapq.nsmallest(len(sourceList), sourceList)

print(targetList) # [4, 6, 8, 10, 12, 14]

[PYTHON/COMMON] heapify/heappop 함수 : 리스트 힙 정렬하기

■ heapify/heappop 함수를 사용해 리스트를 힙 정렬하는 방법을 보여준다. ▶ 예제 코드 (PY)


import heapq

sourceList = [14, 10, 6, 8, 12, 4]

heapq.heapify(sourceList)

print(sourceList) # [4, 8, 6, 10, 12, 14]

targetLst = []

while sourceList:
    targetLst.append(heapq.heappop(sourceList))

print(targetLst) # [4, 6, 8, 10, 12, 14]

import heapq

sourceList = [14, 10, 6, 8, 12, 4]

heapq.heapify(sourceList)

print(sourceList) # [4, 8, 6, 10, 12, 14]

targetLst = []

while sourceList:

targetLst.append(heapq.heappop(sourceList))

print(targetLst) # [4, 6, 8, 10, 12, 14]

[PYTHON/COMMON] 최소 힙을 최대 힙으로 변환하기

■ 최소 힙을 최대 힙으로 변환하는 방법을 보여준다. ▶ 예제 코드 (PY)


import heapq

sourceList = [4, 8, 6, 10, 12, 14]

reverseSign = lambda x : x * -1

targetList = list(map(reverseSign, sourceList))

heapq.heapify(targetList)

targetList = list(map(reverseSign, targetList))

print(targetList) # [14, 12, 6, 10, 8, 4]

import heapq

sourceList = [4, 8, 6, 10, 12, 14]

reverseSign = lambda x : x * -1

targetList = list(map(reverseSign, sourceList))

heapq.heapify(targetList)

targetList = list(map(reverseSign, targetList))

print(targetList) # [14, 12, 6, 10, 8, 4]

[PYTHON/COMMON] heapify 함수 : 리스트를 최소 힙으로 변환하기

■ heapify 함수를 사용해 리스트를 최소 힙으로 변환하는 방법을 보여준다. ▶ 예제 코드 (PY)


import heapq

list1 = [14, 10, 6, 8, 12, 4]

heapq.heapify(list1)

print(list1) # [4, 8, 6, 10, 12, 14]

import heapq

list1 = [14, 10, 6, 8, 12, 4]

heapq.heapify(list1)

print(list1) # [4, 8, 6, 10, 12, 14]

[PYTHON/COMMON] heappop 함수 : 최소 힙에서 데이터 삭제하기

■ heappop 함수를 사용해 최소 힙에서 데이터를 삭제하는 방법을 보여준다. ▶ 예제 코드 (PY)


import heapq

list1 = []

heapq.heappush(list1, 14)
heapq.heappush(list1, 10)
heapq.heappush(list1, 6 )
heapq.heappush(list1, 8 )
heapq.heappush(list1, 12)
heapq.heappush(list1, 4 )

print(list1) # [4, 8, 6, 14, 12, 10]

heapq.heappop(list1) # 최소 힙에서 데이터 삭제는 루트 노드를 삭제하는 것이다.

print(list1) # [6, 8, 10, 14, 12]

import heapq

list1 = []

heapq.heappush(list1, 14)

heapq.heappush(list1, 10)

heapq.heappush(list1, 6 )

heapq.heappush(list1, 8 )

heapq.heappush(list1, 12)

heapq.heappush(list1, 4 )

print(list1) # [4, 8, 6, 14, 12, 10]

heapq.heappop(list1) # 최소 힙에서 데이터 삭제는 루트 노드를 삭제하는 것이다.

print(list1) # [6, 8, 10, 14, 12]

[PYTHON/COMMON] heappush 함수 : 최소 힙에서 데이터 추가하기

■ heappush 함수를 사용해 최소 힙에서 데이터를 추가하는 방법을 보여준다. ▶ main.py


import heapq

list1 = []

heapq.heappush(list1, 14)

print(list1) # [14]

heapq.heappush(list1, 10)

print(list1) # [10, 14]

heapq.heappush(list1, 6)

print(list1) # [6, 14, 10]

heapq.heappush(list1, 8)

print(list1) # [6, 8, 10, 14]

heapq.heappush(list1, 12)

print(list1) # [6, 8, 10, 14, 12]

heapq.heappush(list1, 4)

print(list1) # [4, 8, 6, 14, 12, 10]

import heapq

list1 = []

heapq.heappush(list1, 14)

print(list1) # [14]

heapq.heappush(list1, 10)

print(list1) # [10, 14]

heapq.heappush(list1, 6)

print(list1) # [6, 14, 10]

heapq.heappush(list1, 8)

print(list1) # [6, 8, 10, 14]

heapq.heappush(list1, 12)

print(list1) # [6, 8, 10, 14, 12]

heapq.heappush(list1, 4)

print(list1) # [4, 8, 6, 14, 12, 10]

[PYTHON/COMMON] 그래프에서 다익스트라 알고리즘(Dijkstra Algorithm) 최단 경로 구하기

■ 그래프에서 다익스트라 알고리즘(Dijkstra Algorithm)을 사용해 최단 경로를 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


import heapq
import sys

def getDijkstraShortestPathDictionary(graphDictionaryDictionary, startNode):
    distanceDictionary = {node : sys.maxsize for node in graphDictionaryDictionary}

    distanceDictionary[startNode] = 0

    queueList = []

    heapq.heappush(queueList, (distanceDictionary[startNode], startNode))

    while queueList:
        currentDistance, node = heapq.heappop(queueList)

        if distanceDictionary[node] < currentDistance:
            continue

        for adjacentNode, distance in graphDictionaryDictionary[node].items():
            weightedDistance = currentDistance + distance

            if weightedDistance < distanceDictionary[adjacentNode]:
                distanceDictionary[adjacentNode] = weightedDistance

                heapq.heappush(queueList, (weightedDistance, adjacentNode))

    return distanceDictionary

graphDictionaryDictionary = {
    "A" : {"B" : 10, "C" : 3         },
    "B" : {"C" :  1, "D" : 2         },
    "C" : {"B" :  4, "D" : 8, "E" : 2},
    "D" : {"E" :  7                  },
    "E" : {"D" :  9                  }
}

shortestPathDictionary = getDijkstraShortestPathDictionary(graphDictionaryDictionary, "B")

print(shortestPathDictionary)

"""
{'A': 9223372036854775807, 'B': 0, 'C': 1, 'D': 2, 'E': 3}
"""

import heapq

import sys

def getDijkstraShortestPathDictionary(graphDictionaryDictionary, startNode):

distanceDictionary = {node : sys.maxsize for node in graphDictionaryDictionary}

distanceDictionary[startNode] = 0

queueList = []

heapq.heappush(queueList, (distanceDictionary[startNode], startNode))

while queueList:

currentDistance, node = heapq.heappop(queueList)

if distanceDictionary[node] < currentDistance:

continue

for adjacentNode, distance in graphDictionaryDictionary[node].items():

weightedDistance = currentDistance + distance

if weightedDistance < distanceDictionary[adjacentNode]:

distanceDictionary[adjacentNode] = weightedDistance

heapq.heappush(queueList, (weightedDistance, adjacentNode))

return distanceDictionary

graphDictionaryDictionary = {

"A" : {"B" : 10, "C" : 3 },

"B" : {"C" : 1, "D" : 2 },

"C" : {"B" : 4, "D" : 8, "E" : 2},

"D" : {"E" : 7 },

"E" : {"D" : 9 }

}

shortestPathDictionary = getDijkstraShortestPathDictionary(graphDictionaryDictionary, "B")

print(shortestPathDictionary)

"""

{'A': 9223372036854775807, 'B': 0, 'C': 1, 'D': 2, 'E': 3}

"""

[PYTHON/COMMON] dict 클래스 : fromkeys 정적 메소드를 사용해 딕셔너리 만들기

■ dict 클래스의 fromkeys 정적 메소드를 사용해 딕셔너리를 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


sourceDictionary = {
    "서울" : 100,
    "인천" : 200,
    "수원" : 300,
    "대전" : 400,
    "광주" : 500,
    "대구" : 600,
    "부산" : 700
}

targetDictionary = dict.fromkeys(sourceDictionary.keys(), 0)

print(targetDictionary)

"""
{'서울': 0, '인천': 0, '수원': 0, '대전': 0, '광주': 0, '대구': 0, '부산': 0}
"""

sourceDictionary = {

"서울" : 100,

"인천" : 200,

"수원" : 300,

"대전" : 400,

"광주" : 500,

"대구" : 600,

"부산" : 700

}

targetDictionary = dict.fromkeys(sourceDictionary.keys(), 0)

print(targetDictionary)

"""

{'서울': 0, '인천': 0, '수원': 0, '대전': 0, '광주': 0, '대구': 0, '부산': 0}

"""

[PYTHON/COMMON] 그래프에서 너비 우선 탐색(Breadth-First Search) 최단 경로 구하기 (노드간 가중치 포함)

■ 그래프에서 너비 우선 탐색(Breadth-First Search)을 사용해 노드간 가중치 포함해 최단 경로를 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


from collections import deque

def getBreadthFirstSearchShortestPathTuple(graphDictionary, startNode, distanceDictionary):
    visitedNodeList   = [startNode]
    adjacentNodeDeque = deque([startNode])

    while adjacentNodeDeque:
        node = adjacentNodeDeque.popleft()
        for adjacentNode in graphDictionary[node]:
            if adjacentNode not in visitedNodeList:
                visitedNodeList.append(adjacentNode)
                adjacentNodeDeque.append(adjacentNode)
                distanceDictionary[adjacentNode] = distanceDictionary[node] + 1

    return visitedNodeList, distanceDictionary

graphDictionary = {
    "A" : ["B", "F", "I"], # A 노드에 인접한 노드들이 B, F, I 노드이다.
    "B" : ["A", "E", "C"],
    "C" : ["B", "E", "D"],
    "D" : ["C", "G", "H"],
    "E" : ["B", "C", "G"],
    "F" : ["A", "G"     ],
    "G" : ["E", "F", "D"],
    "H" : ["D"          ],
    "I" : ["A"          ]
}

distanceDictionary = dict.fromkeys(graphDictionary.keys(), 0)

shortestPathTuple = getBreadthFirstSearchShortestPathTuple(graphDictionary, "B", distanceDictionary)

print(shortestPathTuple)

"""
(
    ['B', 'A', 'E', 'C', 'F', 'I', 'G', 'D', 'H'],                                    # B 노드에서 제일 가까운 노드 순서로 나열된다.
    {'A' : 1, 'B' : 0, 'C' : 1, 'D' : 2, 'E' : 1, 'F' : 2, 'G' : 2, 'H' : 3, 'I' : 2} # B 노드에서 각 노드의 가중치를 나타낸다.
)
"""

from collections import deque

def getBreadthFirstSearchShortestPathTuple(graphDictionary, startNode, distanceDictionary):

visitedNodeList = [startNode]

adjacentNodeDeque = deque([startNode])

while adjacentNodeDeque:

node = adjacentNodeDeque.popleft()

for adjacentNode in graphDictionary[node]:

if adjacentNode not in visitedNodeList:

visitedNodeList.append(adjacentNode)

adjacentNodeDeque.append(adjacentNode)

distanceDictionary[adjacentNode] = distanceDictionary[node] + 1

return visitedNodeList, distanceDictionary

graphDictionary = {

"A" : ["B", "F", "I"], # A 노드에 인접한 노드들이 B, F, I 노드이다.

"B" : ["A", "E", "C"],

"C" : ["B", "E", "D"],

"D" : ["C", "G", "H"],

"E" : ["B", "C", "G"],

"F" : ["A", "G" ],

"G" : ["E", "F", "D"],

"H" : ["D" ],

"I" : ["A" ]

}

distanceDictionary = dict.fromkeys(graphDictionary.keys(), 0)

shortestPathTuple = getBreadthFirstSearchShortestPathTuple(graphDictionary, "B", distanceDictionary)

print(shortestPathTuple)

"""

(

['B', 'A', 'E', 'C', 'F', 'I', 'G', 'D', 'H'], # B 노드에서 제일 가까운 노드 순서로 나열된다.

{'A' : 1, 'B' : 0, 'C' : 1, 'D' : 2, 'E' : 1, 'F' : 2, 'G' : 2, 'H' : 3, 'I' : 2} # B 노드에서 각 노드의 가중치를 나타낸다.

)

"""

[PYTHON/COMMON] 그래프에서 너비 우선 탐색(Breadth-First Search) 최단 경로 구하기

■ 그래프에서 너비 우선 탐색(Breadth-First Search)을 사용해 최단 경로를 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


from collections import deque

def getBreadthFirstSearchShortestPathList(graphDictionary, startNode):
    visitedNodeList   = []
    adjacentNodeDeque = deque([startNode])

    while adjacentNodeDeque:
        node = adjacentNodeDeque.popleft()
        if node not in visitedNodeList:
            visitedNodeList.append(node)
            adjacentNodeDeque.extend(graphDictionary[node])

    return visitedNodeList

graphDictionary = {
    "A" : ["B", "F", "I"], # A 노드에 인접한 노드들이 B, F, I 노드이다.
    "B" : ["A", "E", "C"],
    "C" : ["B", "E", "D"],
    "D" : ["C", "G", "H"],
    "E" : ["B", "C", "G"],
    "F" : ["A", "G"     ],
    "G" : ["E", "F", "D"],
    "H" : ["D"          ],
    "I" : ["A"          ]
}

shortestPathList = getBreadthFirstSearchShortestPathList(graphDictionary, "B")

print(shortestPathList)

"""
['B', 'A', 'E', 'C', 'F', 'I', 'G', 'D', 'H'] # B 노드에서 제일 가까운 노드 순서로 나열된다.
"""

from collections import deque

def getBreadthFirstSearchShortestPathList(graphDictionary, startNode):

visitedNodeList = []

adjacentNodeDeque = deque([startNode])

while adjacentNodeDeque:

node = adjacentNodeDeque.popleft()

if node not in visitedNodeList:

visitedNodeList.append(node)

adjacentNodeDeque.extend(graphDictionary[node])

return visitedNodeList

graphDictionary = {

"A" : ["B", "F", "I"], # A 노드에 인접한 노드들이 B, F, I 노드이다.

"B" : ["A", "E", "C"],

"C" : ["B", "E", "D"],

"D" : ["C", "G", "H"],

"E" : ["B", "C", "G"],

"F" : ["A", "G" ],

"G" : ["E", "F", "D"],

"H" : ["D" ],

"I" : ["A" ]

}

shortestPathList = getBreadthFirstSearchShortestPathList(graphDictionary, "B")

print(shortestPathList)

"""

['B', 'A', 'E', 'C', 'F', 'I', 'G', 'D', 'H'] # B 노드에서 제일 가까운 노드 순서로 나열된다.

"""

[PYTHON/COMMON] 리스트에서 이진 탐색(Binary Search)을 사용해 특정 값 인덱스 구하기

■ 리스트에서 이진 탐색(Binary Search)을 사용해 특정 값의 인덱스를 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


def getBinarySearchValueIndex(sourceList, value):
    firstIndex, lastIndex = 0, len(sourceList)

    while firstIndex <= lastIndex:
        middleIndex = (firstIndex + lastIndex) // 2
        if sourceList[middleIndex] == value:
            return middleIndex
        if sourceList[middleIndex] > value:
            lastIndex = middleIndex - 1
        else:
            firstIndex = middleIndex + 1

sourceList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

valueIndex = getBinarySearchValueIndex(sourceList, 6)

print(valueIndex, sourceList[valueIndex]) # 5 6

def getBinarySearchValueIndex(sourceList, value):

firstIndex, lastIndex = 0, len(sourceList)

while firstIndex <= lastIndex:

middleIndex = (firstIndex + lastIndex) // 2

if sourceList[middleIndex] == value:

return middleIndex

if sourceList[middleIndex] > value:

lastIndex = middleIndex - 1

else:

firstIndex = middleIndex + 1

sourceList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

valueIndex = getBinarySearchValueIndex(sourceList, 6)

print(valueIndex, sourceList[valueIndex]) # 5 6

[PYTHON/COMMON] 그래프에서 깊이 우선 탐색(Depth-First Search) 최단 경로 구하기

■ 그래프에서 깊이 우선 탐색(Depth-First Search)을 사용해 최단 경로를 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


def getDepthFirstSearchShotestPathList(graphDictionary, startNode):
    visitedNodeList  = []
    adjacentNodeList = [startNode]

    while adjacentNodeList:
        node = adjacentNodeList.pop()
        if node not in visitedNodeList:
            visitedNodeList.append(node)
            adjacentNodeList.extend(graphDictionary[node])

    return visitedNodeList

graphDictionary = {
    "A" : ["B", "F", "I"], # A 노드에 인접한 노드들이 B, F, I 노드이다.
    "B" : ["A", "C", "E"],
    "C" : ["B", "D", "E"],
    "D" : ["C", "G", "H"],
    "E" : ["B", "C", "G"],
    "F" : ["A", "G"     ],
    "G" : ["D", "E", "F"],
    "H" : ["D"          ],
    "I" : ["A"          ]
}

shortestPathList = getDepthFirstSearchShotestPathList(graphDictionary, "B")

print(shortestPathList)

"""
['B', 'E', 'G', 'F', 'A', 'I', 'D', 'H', 'C'] # B 노드에서 제일 가까운 노드 순서로 나열된다.
"""

def getDepthFirstSearchShotestPathList(graphDictionary, startNode):

visitedNodeList = []

adjacentNodeList = [startNode]

while adjacentNodeList:

node = adjacentNodeList.pop()

if node not in visitedNodeList:

visitedNodeList.append(node)

adjacentNodeList.extend(graphDictionary[node])

return visitedNodeList

graphDictionary = {

"A" : ["B", "F", "I"], # A 노드에 인접한 노드들이 B, F, I 노드이다.

"B" : ["A", "C", "E"],

"C" : ["B", "D", "E"],

"D" : ["C", "G", "H"],

"E" : ["B", "C", "G"],

"F" : ["A", "G" ],

"G" : ["D", "E", "F"],

"H" : ["D" ],

"I" : ["A" ]

}

shortestPathList = getDepthFirstSearchShotestPathList(graphDictionary, "B")

print(shortestPathList)

"""

['B', 'E', 'G', 'F', 'A', 'I', 'D', 'H', 'C'] # B 노드에서 제일 가까운 노드 순서로 나열된다.

"""

[PYTHON/COMMON] 그래프에서 플로이드 워셜 알고리즘(Floyd-Warshall Algorithm) 최단 경로 구하기

■ 그래프에서 플로이드 워셜 알고리즘(Floyd-Warshall Algorithm)을 최단 경로를 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


import sys

def getFloydWarshallShortestPathListList(nodeCount, adjacentListList):
    distanceListList = [[sys.maxsize] * nodeCount for _ in range(nodeCount)]

    for y, x, edge in adjacentListList:
        distanceListList[y - 1][x - 1] = edge

    for k in range(nodeCount):
        distanceListList[k][k] = 0
        for y in range(nodeCount):
            for x in range(nodeCount):
                distanceListList[y][x] = min(distanceListList[y][x], distanceListList[y][k] + distanceListList[k][x])

    return distanceListList

nodeCount        = 4                                                         # 노드 수
adjacentListList = [[1, 3, -2], [2, 1, 4], [2, 3, 3], [3, 4, 2], [4, 2, -1]] # [1, 3, -2]는 node1에서 node3까지 edge가 -2이다.

shortestPathListList = getFloydWarshallShortestPathListList(nodeCount, adjacentListList)

print(shortestPathListList)

"""
[[0, -1, -2, 0], [4, 0, 2, 4], [5, 1, 0, 2], [3, -1, 1, 0]]

=================================
       node1  node2  node3  node4
=====  =====  =====  =====  =====
node1      0     -1     -2      0
node2      4      0      2      4
node3      5      1      0      2
node4      3     -1      1      0
=================================
"""

import sys

def getFloydWarshallShortestPathListList(nodeCount, adjacentListList):

distanceListList = [[sys.maxsize] * nodeCount for _ in range(nodeCount)]

for y, x, edge in adjacentListList:

distanceListList[y - 1][x - 1] = edge

for k in range(nodeCount):

distanceListList[k][k] = 0

for y in range(nodeCount):

for x in range(nodeCount):

distanceListList[y][x] = min(distanceListList[y][x], distanceListList[y][k] + distanceListList[k][x])

return distanceListList

nodeCount = 4 # 노드 수

adjacentListList = [[1, 3, -2], [2, 1, 4], [2, 3, 3], [3, 4, 2], [4, 2, -1]] # [1, 3, -2]는 node1에서 node3까지 edge가 -2이다.

shortestPathListList = getFloydWarshallShortestPathListList(nodeCount, adjacentListList)

print(shortestPathListList)

"""

[[0, -1, -2, 0], [4, 0, 2, 4], [5, 1, 0, 2], [3, -1, 1, 0]]

=================================

node1 node2 node3 node4

===== ===== ===== ===== =====

node1 0 -1 -2 0

node2 4 0 2 4

node3 5 1 0 2

node4 3 -1 1 0

=================================

"""

[PYTHON/COMMON] perf_counter 함수 : 경과 시간 구하기

■ perf_counter 함수를 사용해 경과 시간을 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


import time

startTimestamp = time.perf_counter()

for _ in range(100):
    print(time.time())
    time.sleep(0.01)

elapsedTime = time.perf_counter() - startTimestamp

print(f"{elapsedTime:0.2f} 초")

"""
1.01 초
"""

import time

startTimestamp = time.perf_counter()

for _ in range(100):

print(time.time())

time.sleep(0.01)

elapsedTime = time.perf_counter() - startTimestamp

print(f"{elapsedTime:0.2f} 초")

"""

1.01 초

"""

[PYTHON/COMMON] nest_asyncio 패키지 설치하기

■ nest_asyncio 패키지를 설치하는 방법을 보여준다. 1. 명령 프롬프트를 실행한다. 2. 명령 프롬프트에서 아래 명령을 실행한다. ▶ 실행 명령


pip install nest_asyncio

pip install nest_asyncio

※ 쥬피터

[PYTHON/COMMON] load_dotenv 함수 : .env 파일에서 환경 변수 로드하기

■ load_dotenv 함수를 사용해 .env 파일에서 환경 변수를 로드하는 방법을 보여준다. ▶ .env


KEY1=VALUE1
KEY2=VALUE2

KEY1=VALUE1

KEY2=VALUE2

▶ main.py


import os

from dotenv import load_dotenv

load_dotenv() # load_dotenv("./.env")

print(os.environ["KEY1"])
print(os.environ["KEY2"])

"""
VALUE1
VALUE2
"""

import os

from dotenv import load_dotenv

load_dotenv() # load_dotenv("./.env")

print(os.environ["KEY1"])

print(os.environ["KEY2"])

"""

VALUE1

VALUE2

"""

▶ requirements.txt


python-dotenv==1.0.1

python-dotenv==1.0.1

※ pip

[PYTHON/COMMON] python-dotenv 패키지 설치하기

■ python-dotenv 패키지를 설치하는 방법을 보여준다. 1. 명령 프롬프트를 실행한다. 2. 명령 프롬프트에서 아래 명령을 실행한다. ▶ 실행 명령


pip install python-dotenv

pip install python-dotenv