6. 표준 라이브러리

 표준 라이브러리 

• 특정 프로그래밍 언어에서 미리 소스코드를 구현해 놓은 라이브러리

 

내장함수

• 별도로 import가 필요없는 기본 내장 라이브러리의 함수

 

입출력

a = input() # 입력
print(a)    # 출력

Hello World
Hello World

 

더하기

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

15

 

최대값

# max() - 가장 큰 값을 반환

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

7

 

최소값

# min() - 파라미터 2개 이상이 주어질 때 가장 작은 값을 반환

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

2

 

문자열로 이루어진 수식 계산

result = eval("(2 + 8) * 10")
print(result)

100

 

정렬

# sorted() - 정렬을 하지만, 기본 데이터는 변경하지 않음
temp = [3, 7, 1, 2, 9]
result1 = sorted(temp) # 오름차순 정렬
result2 = sorted(temp, reverse = True) # 내림차순 정렬
print(result1, ' ', result2)

# key 기준 정렬 가능
temp = [('A', 70), ('B', 90), ('C', 80)]
result = sorted(temp, key = lambda x: x[1], reverse = True)
print(result)

[1, 2, 3, 7, 9]   [9, 7, 3, 2, 1]
[('B', 90), ('C', 80), ('A', 70)]

 

# sort() - 정렬 후, 기존 데이터의 값도 변경
data = [3, 7, 1, 2, 9]
data.sort() # 오름차순 정렬
print(data)
data.sort(reverse = True) # 내림차순 정렬
print(data)

[1, 2, 3, 7, 9]
[9, 7, 3, 2, 1]

 

itertools

• itertools는 iterable한 데이터를 처리하기에 좋은 메소드가 포함되어 있는 라이브러리이다.
• permutations(순열), combinations(조합) 클래스가 가장 유용히 사용됨.
• permutations : r개의 원소를 뽑아 순열 ▶ 순열을 시행한 후 리스트 변환 필요
• combinations : r개의 원소를 뽑아 조합 ▶ 조합을 시행한 후 리스트 변환 필요
• product: 순열과 같은 동작을 하지만, 중복을 허용 ▶ 시행 후 리스트 변환 필요
• combinations_with_replacement: 조합과 같은 동작을 하지만, 중복을 허용 ▶ 시행 후 리스트 변환 필요

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')]

 

from itertools import combinations

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

[('A', 'B'), ('A', 'C'), ('B', 'C')]

 

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')]

 

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')]

 

heapq

• heapq는 우선순위큐를 구현할 때 사용
• 파이썬은 default가 최소힙(Min Heap) ▶ 힙 정렬 시간 복잡도: O(NlogN)
• heapq.heappush() : 힙에 원소를 삽입하는 메서드
• heapq.heappop() : 힙에서 원소를 꺼내는 메서드

from heapq import heappush, heappop

def heapsort(iterable):
    heap = []
    result = []
    
    # 힙에 원소 삽입
    for num in iterable:
        heappush(heap, num)
    
    # 힙에서 원소를 빼어 result에 추가
    while heap:
        result.append(heappop(heap))
    return result

temp = [1, 9, 7, 5, 3, 4, 0, 2, 6, 8]
result = heapsort(temp)
print(result)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

 

• 최대힙(Max Heap) 구조로 바꾸고 싶다면, 역부호를 이용한다.

 

from heapq import heappush, heappop

def rheapsort(iterable):
    heap = []
    result = []
    
    # 힙에 원소 삽입
    for num in iterable:
        heappush(heap, -num)  # (-) 부호를 붙이면, 가장 큰 수가 상위 노드로 가게 됨
    
    # 힙에서 원소 꺼내어 result에 추가
    while heap:
        result.append(-heappop(heap)) # 원소를 꺼내고 (-) 부호 다시 붙여 원상복귀
    return result

temp = [1, 9, 7, 5, 3, 4, 0, 2, 6, 8]
result = rheapsort(temp)
print(result)

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

 

bisect

• bisect는 이진탐색 알고리즘을 구현하기 위해 사용되는 라이브러리이다.
• 정렬된 배열에서 특정한 원소를 찾을 때 효과적이다. ▶ 이진탐색의 전제가 정렬된 배열
• bisect_left(), bisect_right() 함수 ▶ 시간복잡도 O(logN)
• bisect_left(list, x): list에 x를 삽입할 가장 왼쪽 인덱스를 반환
• bisect_right(list, x): list에 x를 삽입할 가장 오른쪽 인덱스를 반환

from bisect import bisect_left, bisect_right

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

print(bisect_left(a, x))
print(bisect_right(a, x))

4
6

> bisect_left(a, x)에 의해서 4는 [1, 1, 2, 2, ↓ 4, 4, 8, 8]처럼 2 뒤를 찾게 된다. (삽입 위치: 인덱스 4)

> bisect_right(a, x)에 의해서 4는 [1, 1, 2, 2, 4, 4, ↓ 8, 8]처럼 8 앞을 찾게 된다. (삽입 위치: 인덱스 6)

 

• 원소의 개수를 구하는 함수 만들기 ▶ bisect를 이용한 이진탐색 알고리즘은 원소의 개수를 찾는데 효율적이다.
• count_by_range(a, left_value, right_value)
  • 정렬된 list a에서 [left_value, right_valut] 범위에 있는 값의 개수를 반환
  • 시간 복잡도 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, 1, 1, 2, 3, 3, 3, 4, 5, 5, 5, 7, 8, 8, 8, 9]

# 값이 4인 원소의 개수 출력
print(count_by_range(a, 4, 4))

# 값이 [2, 7] 범위에 있는 원소의 개수 출력
print(count_by_range(a, 2, 7))

1
9

 

collections

• 유용한 자료구조를 제공하는 표준 라이브러리
• deque와 Counter 클래스가 가장 유용히 쓰이며, 보통 파이썬에서는 deque를 사용해 큐를 구현

리스트와 deque 차이

• 리스트
  • append()와 pop() 메서드로 원소를 추가/삭제 할 때 가장 맨 뒤 원소를 기준으로 함
  • 앞쪽에 있는 원소를 제거할 때 리스트 원소의 개수가 많을수록 시간이 오래 걸림
• deque
  • 인덱싱, 슬라이싱 등의 기능은 사용 불가능
  • 다만, 연속적으로 나열된 데이터의 시작이나 끝부분에 데이터를 삽입/삭제할 때 효과적
• 시간 복잡도
  • 가장 앞쪽에 원소 추가: 리스트[O(N)], deque[O(1)]
  • 가장 뒤쪽에 원소 추가: 리스트[O(1)], deque[O(1)]
  • 가장 앞쪽의 원소 제거: 리스트[O(N)], deque[O(1)]
  • 가장 뒤쪽의 원소 제거: 리스트[O(1)], deque[O(1)]

• popleft() : 첫 번째 원소를 제거
• pop() : 마지막 원소 제거
• appendleft(x) : 첫 번째 인덱스에 원소 x 삽입
• append(x) : 마지막 인덱스에 원소 x 삽입

from collections import deque

data = deque([2, 3, 4, 5, 6, 7, 8, 9])
data.appendleft(1)
data.append(10)

print(data)
print(list(data))  # 리스트 자료형으로 변환

deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

 

• Counter는 리스트, 튜플과 같은 iterable 객체에서 특정 원소의 개수를 세는 기능을 제공함

from collections import Counter

counter = Counter(['A', 'B', 'C', 'B', 'B', 'C'])

print(counter['A']) # 'A'가 등장한 횟수
print(counter['B']) # 'B'가 등장한 횟수
print(counter['C']) # 'C'이 등장한 횟수
print(dict(counter)) # 사전 자료형으로 변환 ▶ 'name':개수

1
3
2
{'A': 1, 'B': 3, 'C': 2}

 

math

• 수학 관련 라이브러리
• 팩토리얼, 제곱근, 최대공약수(GCD) 등 다양한 수학 기능을 제공

Factorial

# factorial(x): 팩토리얼 x를 반환

import math
print(math.factorial(10))

3628800

 

Square Root

# sqrt(x): x의 제곱근 반환

import math
print(math.sqrt(10))

3.1622776601683795

 

Greatest Common Divisor

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

import math
print(math.gcd(100, 60))

20

 

Pi / Exponential

import math

print(math.pi)  # 파이 pi
print(math.e)   # 자연상수 e

3.141592653589793
2.718281828459045