- 특정 프로그래밍 언어에서 미리 소스코드를 구현해 놓은 라이브러리
- 별도로 import가 필요없는 기본 내장 라이브러리의 함수
| 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
| |
| temp = [3, 7, 1, 2, 9] |
| result1 = sorted(temp) |
| result2 = sorted(temp, reverse = True) |
| print(result1, ' ', result2) |
| |
| |
| 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)] |
| |
| 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는 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는 우선순위큐를 구현할 때 사용
- 파이썬은 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) |
| |
| |
| 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) |
| |
| |
| 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_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)) |
> 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] |
| |
| |
| print(count_by_range(a, 4, 4)) |
| |
| |
| print(count_by_range(a, 2, 7)) |
- 유용한 자료구조를 제공하는 표준 라이브러리
- deque와 Counter 클래스가 가장 유용히 쓰이며, 보통 파이썬에서는 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']) |
| print(counter['B']) |
| print(counter['C']) |
| print(dict(counter)) |
| 1 |
| 3 |
| 2 |
| {'A': 1, 'B': 3, 'C': 2} |
- 수학 관련 라이브러리
- 팩토리얼, 제곱근, 최대공약수(GCD) 등 다양한 수학 기능을 제공
| |
| |
| import math |
| print(math.factorial(10)) |
3628800
| |
| |
| import math |
| print(math.sqrt(10)) |
3.1622776601683795
| |
| |
| import math |
| print(math.gcd(100, 60)) |
20
| import math |
| |
| print(math.pi) |
| print(math.e) |
| 3.141592653589793 |
| 2.718281828459045 |