[Python] 코딩 테스트에 필요한 6가지 파이썬 표준 라이브러리

1. 내장 함수

내장 함수는 프로그램 작성에 있어 가장 기본적이면서도 필수적인 기능을 포함하고 있으며, 별도의 import 명령어 없이 바로 사용할 수 있다. 

input(), print(), sum(), min(), max(), eval(), sorted()

 

sum() : 리스트와 같은 iterable 객체가 입력으로 주어졌을 때, 모든 원소의 합을 반환한다. 

 - iterable 객체 : 반복 가능한 객체 (리스트, 사전, 튜플 등)

result = sum([1, 2, 3, 4, 5])

print(result) # 15

min() : 파라미터가 2개 이상 들어왔을 때 가장 작은 값을 반환한다. 

result = min(7, 3, 5, 2)

print(result) # 2

max() : 파라미터가 2개 이상 들어왔을 때 가상 큰 값을 반환한다. 

result = max(7, 3, 5, 2)

print(result) # 7

eval() : 수학 수식이 문자열 형식으로 들어오면 해당 수식을 계산한 결과를 반환한다. 

result = eval("(3 + 5) * 7")

print(result) # 56

sorted() : iterable 객체가 들어왔을 때, 정렬된 결과를 반환한다. 

 - key 속성 : 정렬 기준을 명시

 - reverse 속성 : 정렬된 결과 리스트를 뒤집을지 설정

# 오름차순 정렬
result = sorted([9, 1, 8, 5, 4])                 
print(result) # [1, 4, 5, 8, 9]

# 내림차순 정렬
result = sorted([9, 1, 8, 5, 4], reverse = True) 
print(result) # [9, 8, 5, 4, 1]

# 두번째 원소(수)를 기준으로 내림차순 정렬
result = sorted([('리오', 35), ('루카', 75), ('릴리', 50), ('루이', 43)], key = lambda x: x[1], reverse = True)
print(result) # [('루카', 75), ('릴리', 50), ('루이', 43), ('리오', 35)]

iterable 객체의 sort()

리스트와 같은 iterable 객체는 기본적으로 sort() 함수를 내장하고 있어서 굳이 sorted() 함수를 사용하지 않아도 된다. 

data = [9, 1, 8, 5, 4]
data.sort()

print(data) # [1, 4, 5, 8, 9]

 

2. itertools

itertools는 반복되는 데이터를 처리하는 기능을 포함하고 있는 라이브러리이다. 

permutations, combinations, product, combinations_with_replacement

 

permutations : 리스트와 같은 iterable 객체에서 r개의 데이터를 뽑아 일렬로 나열하는 모든 경우를 계산해준다. → 순열

permutations는 클래스이므로 객체 초기화 이후에는 리스트 자료형으로 변환하여 사용해야한다. 

 

예) 리스트 ['A', 'B', 'C']에서 3개(r = 3)를 뽑아 나열하는 모든 경우를 출력하시오.

from itertools import permutations

data = ['A', 'B', 'C']

result = list(permutations(data, 3))

print(result) # [('A', 'B', 'C'), ('A', 'C', 'B'), ('B', 'A', 'C'), ('B', 'C', 'A'), ('C', 'A', 'B'), ('C', 'B', 'A')]

combinations : 리스트와 같은 iterable 객체에서 r개의 데이터를 뽑아 순서를 고려하지 않고 나열하는 모든 경우를 계산해준다. → 조합

combinations는 클래스이므로 객체 초기화 이후에는 리스트 자료형으로 변환하여 사용한다. 

 

예) 리스트 ['A', 'B', 'C']에서 2개(r = 2)를 뽑아 순서에 상관없이 나열하는 모든 경우를 출력하시오.

from itertools import combinations

data = ['A', 'B', 'C']

result = list(combinations(data, 2))

print(result) # [('A', 'B'), ('A', 'C'), ('B', 'C')]

product : 리스트와 같은 iterable 객체에서 r개의 데이터를 뽑아 일렬로 나열하는 모든 경우를 계산한다. → 순열, permutation과 같지만 product는 원소를 중복하여 뽑는다. 

product 객체 초기화 시 뽑고자 하는 데이터의 수를 repeat 속성값으로 넣어준다. 

product는 클래스이므로 객체 초기화 이후에는 리스트 자료형으로 변환하여 사용한다. 

 

예) 리스트 ['A', 'B', 'C']에서 중복을 포함하여 2개(r = 2)를 뽑아 나열하는 모든 경우를 출력하시오.

 - 중복 포함 : ('A', 'A'), ('B', 'B') 등 가능

from itertools import product 

data = ['A', 'B', 'C']
result = list(product(data, repeat=2))

print(result) # [('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')]

combinations_with_replacement : 리스트와 같은 iterable 객체에서 r개의 데이터를 뽑아 순서를 고려하지 않고 나열하는 모든 경우를 계산해준다. → 조합, combinations와 같지만 원소를 중복해서 뽑는다. 

combinations_with_replacement는 클래스이므로 객체 초기화 이후에는 리스트 자료형으로 변환하여 사용한다.

 

예) 리스트 ['A', 'B', 'C']에서 중복을 포함하여 2개(r = 2)를 뽑아 순서에 상관없이 나열하는 모든 경우를 출력하시오.

from itertools import combinations_with_replacement

data = ['A', 'B', 'C']
result = list(combinations_with_replacement(data, 2))

print(result) # [('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]

 

3. heapq

힙(Heap) 기능을 제공하기 위한 라이브러리이다.

파이썬의 힙은 최소 힙(Min Heap)으로 구성되어 있으므로 단순히 원소를 힙에 전부 넣었다가 뺴는 것만으로도 시간 복잡도 O(NlogN)에 오름차순 정렬이 완료된다. (보통 최소 힙 자료구조의 최상단 원소 : 가장 작은 원소)

 

heapq.heappush( ) : 힙에서 원소를 삽입할 때

heapq.heappop( ) : 힙에서 원소를 꺼낼 때

 

예) 힙 정렬(Heap Sort)을 heapq로 구현하는 경우

import heapq

def heapsort(iterable):
    h = []
    result = []
    
    # 모든 원소를 차례대로 힙에 삽입
    for value in iterable:
        heapq.heappush(h, value)
        
    # 힙에 삽입된 모든 원소를 차례대로 꺼내어 담기
    for i in range(len(h)):
        result.append(heapq.heappop(h))
        
    return result
    
result = heapsort([1, 3, 5, 7, 9, 2, 4, 6, 8, 0])
print(result) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

파이썬에서는 최대 힙(Max Heap)을 제공하지 않는다. 따라서 heapq 라이브러리를 이용해 최대 힙을 구현해야하는 데, 이때는 원소의 부호를 임시로 변경하는 방식을 사용한다. → 힙에 원소를 삽입하기 전에 잠시 부호를 반대로 바꾸었다가, 힙에서 원소를 꺼낸 뒤에 다시 원소의 부호를 바꾼다. 

 

예) 최대 힙을 heapq로 구현하여 내림차순 힙 정렬을 구현하는 경우

import heapq

def heapsortDesc(iterable):
    h = []
    result = []
    
    # 모든 원소를 차례대로 힙에 삽입(부호를 변경하여)
    for value in iterable:
        heapq.heappush(h, -value)
        
    # 힙에 삽입된 모든 원소를 차례대로 꺼내어 담기
    for i in range(len(h)):
        result.append(-heapq.heappop(h))
        
    return result
    
result = heapsortDesc([1, 3, 5, 7, 9, 2, 4, 6, 8, 0])
print(result) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

코딩 테스트>> heapq는 다익스트라 최단 경로 알고리즘을 포함해 다양한 알고리즘에서 우선순위 큐 기능을 구현하고자 할 때 사용된다. heapq 외에도 priorityQueue 라이브러리를 사용할 수 있지만, 코딩 테스트 환경에서는 보통 heapq가 더 빠르게 동작한다. 

 

4. bisect

파이썬에서 이진 탐색을 쉽게 구현할 수 있도록 제공하는 라이브러리이다.

bisect 라이브러리는 '정렬된 배열'에서 특정한 원소를 찾아야 할 때 매우 효과적으로 사용된다. 

 

bisect_left(a, x) : 정렬된 순서를 유지하면서 리스트 a에 데이터 x를 삽입할 가장 왼쪽 인덱스를 찾는 메서드

bisect_right(a, x) : 정렬된 순서를 유지하면서 리스트 a에 데이터 x를 삽입할 가장 오른쪽 인덱스를 찾는 메서드

 

예) 정렬된 리스트 [1, 2, 4, 4, 8]이 있을 때, 새롭게 데이터 4개를 삽입하려는 경우

이때 bisect_left(a, 4)와 bisect_right(a, 4)는 각각 인덱스값으로 2와 4를 반환한다. 

from bisect import bisect_left, bisect_right

a = [1, 2, 4, 4, 8]
x = 4

print(bisect_left(a, x))  # 2
print(bisect_right(a, x)) # 4

 

정렬된 리스트에서 값이 특정 범위에 속하는 원소의 개수를 구하고자 할 때, 효과적으로 사용할 수 있다. 

 

예) count_by_range(a, left_value, right_value) 함수를 구현하는 경우

count_by_range(a, left_value, right_value) 함수는 [left_value, right_value]에 속하는 데이터의 개수를 반환한다. → 시간 복잡도 O(logN)로 빠르게  계산되는 편이다. 

from bisect import bisect_left, bisect_right

def count_by_range(a, left_value, right_value):
    right_index = bisect_right(a, right_value)
    left_index = bisect_left(a, left_value)
    return right_index - left_index
    
a = [1, 2, 3, 3, 3, 3, 4, 4, 8, 9]

# 값이 4인 데이터의 개수 출력
print(count_by_range(a, 4, 4))  # 2

# 값이 [-1, 3] 범위에 있는 데이터 개수 출력
print(count_by_range(a, -1, 3)) # 6

 

5. collections

cllections는 파이썬의 유용한 자료구조를 제공하는 표준 라이브러리이다. 

deque, Counter

 

deque

파이썬에서 큐를 구현할 때 사용한다. (스택을 구현할 때도 사용된다.)

리스트 자료형과 다르게 인덱싱, 슬라이싱 등의 기능은 사용할 수 없지만, 연속적으로 나열된 데이터의 시작 부분이나 끝부분에 데이터를 삽입하거나 삭제할 때 매우 효과적이다. 

 

popleft( ) : 첫 번째 원소 제거

pop( ) : 마지막 원소 제거

appendleft(x) : 첫 번째 인덱스에 원소 x를 삽입

append(x) : 마지막 인덱스에 원소 x를 삽입

 

→ 큐 자료구조로 이용할 때 : 삽입에는 append(x), 삭제에는 popleft()를 사용한다. 그러면 먼저 들어온 원소가 항상 먼저 나가게 된다. 

 

예) 리스트 [2, 3, 4]의 가장 앞쪽과 뒤쪽에 원소를 삽입하는 경우

from collections import deque

data = deque([2, 3, 4])
data.appendleft(1)
data.append(5)

print(data)       # deque([1, 2, 3, 4, 5])
# 리스트 자료형으로 변환
print(list(data)) # [1, 2, 3, 4, 5]

Counter : 등장 횟수를 세는 기능을 제공한다. 리스트와 같은 iterable 객체가 주어졌을 때, 해당 객체 내부의 원소가 몇 번씩 등장했는지 알려준다. → 원소별 등장 횟수를 세는 기능이 필요할 때 사용

 

예) 원소별 등장 횟수를 세야하는 경우

from collections import Counter

counter = Counter(['red', 'blue', 'red', 'green', 'blue', 'blue'])

# 'blue'가 등장한 횟수
print(counter['blue'])  # 3
# 'green'이 등장한 횟수
print(counter['green']) # 1
# 사전 자료형으로 변환
print(dict(counter))    # {'red': 2, 'blue': 3, 'green': 1}

 

6. math

자주 사용되는 수학정인 기능을 포함하고 있는 라이브러리이다. 

factorial(x), sqrt(x), gcd(a, b)

 

factorial(x) : x! 값을 반환한다. 

 

예) 5!을 출력하는 경우

import math

print(math.factorial(5)) # 120

sqrt(x) : x의 제곱근을 반환한다. 

 

예) 7의 제곱근을 출력하는 경우

import math

print(math.sqrt(7)) # 2.64575131106

gcd(a, b) : a와 b의 최대 공약수를 반환한다. 

 

예) 21과 14의 최대 공약수를 출력하는 경우

import math

print(math.gcd(21, 14)) # 7

수학 공식에서 자주 등장하는 상수가 필요할 때에도 math 라이브러리를 사용할 수 있다. 

파이(pi), 자연상수 e

import math

print(math.pi) # 3.141592653589793
print(math.e)  # 2.718281828459045