bisect — 배열 이분(bisection) 알고리즘

bisect — 배열 이분(bisection) 알고리즘

(소스: Lib/bisect.py)

이 모듈은 매번 삽입 후 리스트를 정렬할 필요 없이 리스트를 정렬된 순서로 유지하는 것을 지원해요. 비교 연산이 비싼 긴 항목 리스트에서 선형 검색이나 잦은 재정렬보다 개선될 수 있어요.

모듈 이름이 bisect인 이유는 기본적인 이분(bisection) 알고리즘으로 작업하기 때문이에요. 특정 값을 찾는 다른 이분 도구들과 달리, 이 모듈의 함수는 삽입 지점(insertion point)을 찾도록 설계됐어요. 그래서 함수들은 값이 발견됐는지 결정하기 위해 __eq__() 메서드를 절대 호출하지 않아요. 대신 __lt__() 메서드만 호출하고 배열의 값들 사이에 삽입 지점을 반환해요.

참고: 이 모듈의 함수는 스레드 안전하지 않아요. 여러 스레드가 같은 시퀀스에 bisect 함수를 동시에 쓰면 정의되지 않은 동작이 나올 수 있어요. 예를 들어 여러 스레드에서 같은 리스트에 insort_left()를 쓰면 리스트가 정렬되지 않게 될 수 있어요.

출처: Python documentation

본문

함수

• bisect.bisect_left(a, x, lo=0, hi=len(a), *, key=None): 정렬 순서를 유지하기 위해 a에서 x의 삽입 지점을 찾아요. lo와 hi로 고려할 리스트 부분집합을 지정할 수 있고 기본은 전체 리스트. x가 이미 a에 있으면 삽입 지점은 기존 항목들 앞(왼쪽)이 돼요. 반환값은 a가 이미 정렬됐다면 list.insert()의 첫 매개변수로 쓰기 적합해요. 반환된 삽입 지점 ip는 a를 두 조각으로 나누는데, 왼쪽 조각은 all(elem < x for elem in a[lo : ip])이고 오른쪽 조각은 all(elem >= x for elem in a[ip : hi])예요. key는 각 요소에서 비교 키를 추출하는 단일 인자 키 함수. 복잡한 레코드 검색을 지원하려면 키 함수가 x 값에는 적용되지 않아요. key가 None이면 요소를 직접 비교하고 키 함수를 호출하지 않아요. (3.10에서 key 추가)
• bisect.bisect_right(a, x, lo=0, hi=len(a), *, key=None) / bisect.bisect(...): bisect_left()와 비슷하지만 x의 기존 항목 뒤(오른쪽)에 오는 삽입 지점을 반환. 왼쪽 조각은 all(elem <= x ...), 오른쪽 조각은 all(elem > x ...). (3.10에서 key 추가)
• bisect.insort_left(a, x, lo=0, hi=len(a), *, key=None): x를 a에 정렬 순서로 삽입. 먼저 bisect_left()로 삽입 지점을 찾고, a의 insert() 메서드로 x를 적절한 위치에 삽입해 정렬 순서를 유지해요. 키 함수(있다면)는 검색 단계에서 x에 적용되지만 삽입 단계에서는 적용되지 않아요. O(log n) 검색이 느린 O(n) 삽입 단계에 지배된다는 점을 명심하세요. (3.10에서 key 추가)
• bisect.insort_right(a, x, lo=0, hi=len(a), *, key=None) / bisect.insort(...): insort_left()와 비슷하지만 x를 기존 항목 뒤에 삽입. 먼저 bisect_right()로 삽입 지점을 찾아요. (3.10에서 key 추가)

성능 참고 (Performance Notes)

bisect()와 insort()로 시간에 민감한 코드를 쓸 때 기억할 점이에요.

• 이분은 값의 범위를 검색할 때 효과적이에요. 특정 값을 찾을 때는 dictionary가 더 성능이 좋아요.
• insort() 함수는 로그 검색 단계가 선형 시간 삽입 단계에 지배되므로 O(n) 이에요.
• 검색 함수는 무상태라 키 함수 결과를 사용 후 버려요. 그래서 루프에서 검색 함수를 쓰면 같은 배열 요소에 키 함수가 반복 호출될 수 있어요. 키 함수가 빠르지 않다면 @functools.cache로 감싸 중복 계산을 피하는 걸 고려하세요. 또는 아래 예제처럼 미리 계산한 키 배열을 검색해 삽입 지점을 찾는 것도 고려해요.

정렬된 리스트 검색

위의 bisect 함수들은 삽입 지점을 찾는 데 유용하지만, 일반적인 검색 작업에는 까다롭거나 어색할 수 있어요. 정렬된 리스트의 표준 조회로 바꾸는 다섯 함수를 보여줄게요.

def index(a, x):
    'Locate the leftmost value exactly equal to x'
    i = bisect_left(a, x)
    if i != len(a) and a[i] == x:
        return i
    raise ValueError
def find_lt(a, x):
    'Find rightmost value less than x'
    i = bisect_left(a, x)
    if i:
        return a[i-1]
    raise ValueError
def find_le(a, x):
    'Find rightmost value less than or equal to x'
    i = bisect_right(a, x)
    if i:
        return a[i-1]
    raise ValueError
def find_gt(a, x):
    'Find leftmost value greater than x'
    i = bisect_right(a, x)
    if i != len(a):
        return a[i]
    raise ValueError
def find_ge(a, x):
    'Find leftmost item greater than or equal to x'
    i = bisect_left(a, x)
    if i != len(a):
        return a[i]
    raise ValueError

예제

bisect() 함수는 숫자 테이블 조회에 유용해요. 이 예제는 시험 점수에 대한 학점을 정렬된 숫자 분기점 집합으로 조회해요. 90 이상은 'A', 80~89는 'B' 등이에요.

>>> def grade(score):
...     i = bisect([60, 70, 80, 90], score)
...     return "FDCBA"[i]
...
>>> [grade(score) for score in [33, 99, 77, 70, 89, 90, 100]]
['F', 'A', 'C', 'C', 'B', 'A', 'A']

bisect()와 insort() 함수는 튜플 리스트와도 동작해요. key 인자는 테이블의 레코드 순서를 정하는 필드를 추출하는 데 쓸 수 있어요.

>>> from collections import namedtuple
>>> from operator import attrgetter
>>> from bisect import bisect, insort
>>> from pprint import pprint
>>> Movie = namedtuple('Movie', ('name', 'released', 'director'))
>>> movies = [
...     Movie('Jaws', 1975, 'Spielberg'),
...     Movie('Titanic', 1997, 'Cameron'),
...     Movie('The Birds', 1963, 'Hitchcock'),
...     Movie('Aliens', 1986, 'Cameron')
... ]
>>> # Find the first movie released after 1960
>>> by_year = attrgetter('released')
>>> movies.sort(key=by_year)
>>> movies[bisect(movies, 1960, key=by_year)]
Movie(name='The Birds', released=1963, director='Hitchcock')
>>> # Insert a movie while maintaining sort order
>>> romance = Movie('Love Story', 1970, 'Hiller')
>>> insort(movies, romance, key=by_year)

키 함수가 비싸면 미리 계산한 키 리스트를 검색해 레코드의 인덱스를 찾는 방식으로 반복 호출을 피할 수 있어요.

>>> data = [('red', 5), ('blue', 1), ('yellow', 8), ('black', 0)]
>>> data.sort(key=lambda r: r[1])       # Or use operator.itemgetter(1).
>>> keys = [r[1] for r in data]         # Precompute a list of keys.
>>> data[bisect_left(keys, 0)]
('black', 0)
>>> data[bisect_left(keys, 1)]
('blue', 1)
>>> data[bisect_left(keys, 5)]
('red', 5)
>>> data[bisect_left(keys, 8)]
('yellow', 8)

더 알아보기 (Learn more)

• Python 공식 문서