[ Python ] 주요 라이브러리의 문법과 주의점

표준 라이브러리란,

특정한 프로그래밍 언어에서 자주 사용되는 표준 소스코드를 미리 구현해 놓은 라이브러리를 의미

1) 내장 함수 : print( ), input( )과 같은 기본 입출력 기능부터 sorted( )와 같은 정렬 기능을 포함하고 있는 기본 내장 라이브러리이다. 파이썬 프로그램을 작성할 때 없어서는 안되는 필수적인 기능을 포함하고 있다.
2) itertools : 파이썬에서 반복되는 형태의 데이터를 처리하는 기능을 제공하는 라이브러리이다. 순열과 조합 라이브러리를 사용한다.
3) heapq : 힙(heap) 기능을 제공하는 라이브러리이다. 우선순위 큐 기능을 구현하기 위해 사용한다.
4) bisect : 이진탐색(Binary Search) 기능을 제공하는 라이브러리이다.
5) collections : 덱(deque), 카운터(Counter) 등의 유용한 자료구조를 포함하고 있는 라이브러리이다.
6) math : 필수적인 수학적 기능을 제공하는 라이브러리이다. 펙토리얼, 제곱근, 최대공약수(GCD), 삼각함수 관련 함수부터 파이(pi)와 같은 상수를 포함하고 있다.

내장 함수 : 별도의 import 명령어 없이 바로 사용할 수 있는 내장함수

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

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

* iterable 객체 : 반복가능한 객체 리스트, 사전 자료형, 튜플 자료형 등

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]

파이썬에서는 리스트의 원소로 리스트나 튜플이 존재할 때 특정한 기준에 따라 정렬 수행 가능
정렬 기준 : key 속성

ex) 리스트 [('홍길동', 35), ('이순신', 75), ('아무개', 50)] : 원소를 튜플의 두 번째 원소(수)를 기준으로 내림차순 정렬

result = sorted([('홍길동', 35), ('이순신', 75), ('아무개', 50)], key=lambda x: x[1], reverse=True)
print(result) #[('이순신', 75), ('아무개', 50), ('홍길동', 35)]

sort( ) : 리스트 객체의 내부 값이 정렬된 값으로 바로 변경

data = [9, 1, 8, 5, 3]
data.sort()
print(data) # [1, 3, 5, 8, 9]

 

itertools : 반복되는 데이터를 처리하는 기능 포함

permutations, combinations, product, combinations_with_replacement

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

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

ex) 리스트 ['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개의 데이터를 뽑아 순서를 고려하지 않고 나열하는 모든 경우(조합)을 계산 class

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

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

from itertools import combinations

data = ['A', 'B', 'C'] #데이터 준비
result = list(combinations(data, 2)) # 2개를 뽑는 모든 조합 구하기 

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

product : permutations와 같이 리스트와 같은 iterable객체에서 r개의 데이터를 뽑아
일렬로 나열하는 모든 경우 (순열)을 계산 class ** 원소를 중복해서 뽑는다 **

product 객체 초기화 : 데이터의 수를 repeat 속성값으로 넣어준다.
객체 초기화 이후에는 리스트 자료형으로 변환하여 사용한다.

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

from itertools import product

data = ['A', 'B', 'C'] #데이터 준비
result = list(product(data, repeat=2)) # 2개를 뽑는 모든 순열 구하기 (중복허용)

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

combinations_with_replacement : combinations와 같이 리스트와 같은 iterable객체에서 r개의 데이터를 뽑아 순서를 고려하지 않고 일렬로 나열하는 모든 경우 (조합)을 계산 class ** 원소를 중복해서 뽑는다 **

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

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

from itertools import combinations_with_replacement

data = ['A', 'B', 'C'] #데이터 준비
result = list(combinations_with_replacement(data, 2)) # 2개를 뽑는 모든 조합 구하기 (중복허용)

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

heapq : 다익스트라 최단경로 알고리즘을 포함해 다양한 알고리즘에서 우선순위 큐 기능을 구현하고자 할 때 사용

 

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

힙에 원소를 삽입할 때 : heapq.heappush( )
힙에 원소를 꺼낼 때 : heapq.heappop( )

ex) 힙 정렬을 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]

파이썬에서는 최대 힙을 제공 X
heapq 라이브러리를 이용하여 최대힙 구현 시, 원소의 부호를 임시로 변경하는 방식을 사용

** 힙에 원소를 삽입하기 전에 잠시 부호를 반대로 바꾸었다가 힙에서 원소를 꺼낸 뒤에 다시 원소의 부호를 바꾸면 된다. **

ex) 최대힙을 구현하여 내림차순 힙 정렬을 구현

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) #[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

bisect : 이진 탐색을 쉽게 구현, '정렬된 배열'에서 특정한 원소를 찾아야할 때 매우 효과적으로 사용됨

 

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

ex) 정렬된 리스트 [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

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

from bisect import bisect_left, bisect_right

# 값이 [left_value, right_value]인 데이터의 개수를 반환하는 함수
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

collections : 유용한 자료구조를 제공하는 라이브러리 deque, Counter

 

- deque : 큐 구현용도, 리스트 자료형과 다르게 인덱싱, 슬라이싱 기능 사용 X. 다만 연속적으로 나열된 데이터의 시작부분이나 끝 부분에 데이터를 삽입하거나 삭제할 때는 매우 효과적으로 사용될 수 있다.
- Counter : 등장횟수를 세는 기능 제공. 리스트와 같은 iterable 객체가 주어졌을 때, 해당 객체 내부의 원소가 몇 번씩 등장했는지 알려준다. ** 원소별 등장 횟수를 세는 기능이 필요할 때 짧은 소스코드로 이를 구현할 수 있다. **

기본 리스트의 자료형

	리스트	deque
가장 앞쪽에 원소 추가	O(N)	O(1)
가장 뒤쪽에 원소 추가	O(1)	O(1)
가장 앞쪽에 있는 원소 제거	O(N)	O(1)
가장 뒤쪽에 있는 원소 제거	O(1)	O(1)

리스트 자료형은 append()메서드로 데이터를 추가하거나, pop() 메서드로 데이터를 삭제할 때 '가장 뒤쪽 원소'를 기준으로 수행된다. 따라서 앞 쪽에 있는 원소를 처리할 때에는 리스트에 포함된 데이터의 개수에 따라서 많은 시간이 소요될 수 있다. 시간 복잡도 O(N)

deque는 스택이나 큐의 기능을 모두 포함한다고 볼 수 있음. **자료구조의 대용으로 사용 가능**

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

먼저 들어온 원소가 항상 먼저 나가게 된다.

ex) 리스트 [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

from collections import Counter

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

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

 

math : 자주 사용되는 수학적인 기능을 포함하고 있는 라이브러리 팩토리얼, 제곱근, 최대공약수 등

factorial(x) x! 값 반환

import math

print(math.factorial(5)) # 팩토리얼 출력  120

sqrt(x) x의 제곱근을 반환

import math

print(math.sqrt(7)) # 7의 제곱근을 출력  2.6457513110645907

gcd(a, b) a와 b의 최대공약수

import math

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

import math

print(math.pi) # 3.141592653589793 파이 출력
print(math.e) # 2.718281828459045 자연상수 e 출력

 

 

본 게시물은  [ 이것이 취업을 위한 코딩테스트다 with 파이썬  - 나동빈 ] 을 참조하여 정리한 게시글입니다.