멤버연산
1. 멤버연산자
멤버 연산은 어떤 값이 목록 안에 있는지 확인해주는 기능입니다. in과 not in 두 가지 방법으로 확인할 수 있습니다.
| 연산자 | 설명 |
|---|---|
in | 값이 목록 안에 있으면 True |
not in | 값이 목록 안에 없으면 True |
부정형을 만들 때 not이 붙는 위치가 다릅니다. is는 뒤에 붙여 is not, in은 앞에 붙여 not in으로 씁니다.
장바구니에 물건이 있는지 없는지 살펴본다고 생각해보세요. 다음과 같은 예시가 있을 수 있습니다.
fruits = ["사과", "바나나", "포도"]
print("사과" in fruits) # True, 사과가 목록에 있기 때문이에요.
print("오렌지" not in fruits) # True, 오렌지는 목록에 없기 때문이에요.
아래와 같은 예시도 가능합니다.
a = [1, 2, 3, 4]
b = [1, 2, 3, 4]
c = 'hello world'
print(1 in a) # 출력: True
print(0 not in a) # 출력: True
print([2] in b) # 출력: False
print([1, 2] in b) # 출력: False
print('h' in c) # 출력: True
print('hello ' in c) # 출력: True
이번에는 dict와 set에 대해서도 살펴보도록 하겠습니다.
a = {'key1': 'value1', 'key2': 'value2'} #딕셔너리
b = {10, 10, 20}
print(10 in b) # 출력: True
print({10} in b) # 출력: False, 주의
print({10, 20} in b) # 출력: False, 주의
print('key1' in a) # 출력: True
print('value1' in a) # 출력: False
print(('key1', 'key2') in a) # 출력: False
# {'key1':'value1'} in a # error
이처럼 set에서는 요소만, dict에서는 key값만 확인할 수 있습니다. 다만 일부 메서드를 사용하여 요소의 존재 여부를 파악할 수 있습니다.
'value1' in a.values()
in 연산자는 집합이나 dict에서 좀 더 높은 속도를 발휘합니다. 어떤 것이 얼마만큼의 시간이 걸리는지 측정하는 가장 보편적인 방법이 시간복잡도 측정인데요. in은 set, dict에서는 O(1)이고 list와 tuple에서는 O(n)입니다. 여기서 더 자세한 시간 복잡도에 대한 설명을 이어가진 않지만 시간이 빠른 순으로 아래와 같습니다.
O(1) < O(log n) < O(n) < O(n^2) < O(2^n)
2. 나아가기: 직접 재 본 멤버 연산의 속도
O(1)과 O(n)이 실제로 얼마나 다른지 측정해 보았습니다. 같은 정수를 list, tuple, set, dict에 담고, 들어 있지 않은 값 하나를 in으로 찾는 시간을 담긴 개수를 바꿔 가며 잰 결과입니다. 없는 값을 찾게 한 것은 list와 tuple이 끝까지 훑어야 하는 가장 나쁜 경우를 보기 위해서입니다.

가로축은 담긴 값의 개수, 세로축은 값 하나를 찾는 시간이며 둘 다 칸마다 10배씩 커지는 로그 눈금입니다. list와 tuple의 선은 개수가 10배가 될 때마다 시간도 거의 10배씩 오르는 오른쪽 위로 곧은 선입니다. 이것이 O(n)의 모양입니다. 반면 set과 dict는 값이 10개일 때나 100만 개일 때나 13~15나노초(1나노초는 10억분의 1초)로 수평입니다. 이것이 O(1)입니다. 값이 100만 개일 때 list는 약 4.4밀리초가 걸려 set보다 30만 배 넘게 느립니다. 반대로 값이 10개뿐이면 list도 50나노초 정도라 차이가 거의 없습니다. 값이 많고 여러 번 찾을 때 set과 dict가 빛을 발한다는 뜻입니다.
그렇다고 언제나 set으로 바꾸는 것이 답은 아닙니다. 리스트를 set으로 바꾸는 일 자체가 모든 값을 한 번씩 훑어 해시 테이블을 만드는 O(n) 작업이기 때문입니다.

값 1만 개가 든 리스트에서 값을 여러 번 찾을 때, 리스트에서 그대로 찾는 경우(주황)와 set(리스트)로 바꾼 뒤 찾는 경우(파랑)의 전체 시간입니다. 가로축은 찾는 횟수입니다. 파랑은 처음에 set을 만드는 시간(약 0.15밀리초)이 깔려 있어 한두 번 찾을 때는 오히려 손해지만, 그 뒤로는 찾을 때마다 거의 시간이 들지 않아 수평에 가깝습니다. 이 측정에서는 약 5번 이상 찾을 때부터 set으로 바꾸는 쪽이 이득이었습니다. 한두 번만 확인한다면 in 리스트로 충분하고, 반복문 안에서 계속 찾는다면 반복문 밖에서 set을 한 번 만들어 두는 것이 좋습니다.
위 순서를 실제 연산으로 재 보면 아래와 같습니다. O(1)은 dict에서 키로 찾기, O(log n)은 정렬된 리스트에서 이진 탐색(bisect), O(n)은 리스트에서 없는 값 찾기, O(n log n)은 정렬(sorted), O(n²)은 이중 for문으로 골랐습니다.

두 축 모두 로그 눈금이라 선의 기울기가 곧 복잡도입니다. O(1)인 초록 선은 수평이고, O(log n)인 파랑 선은 아주 완만하게 오릅니다. O(n)인 회색 선은 n이 10배가 될 때 시간도 10배가 되고, O(n²)인 보라 선은 그보다 두 배 가파르게, n이 10배가 될 때 시간이 100배씩 오릅니다. n이 3,000일 때 이중 for문은 이미 0.1초가 넘게 걸렸습니다. 같은 n에서 dict로 찾기는 수십 나노초(1나노초는 0.000000001초)입니다. 알고리즘 문제에서 '입력이 10만 개'라는 조건을 보면 O(n²) 풀이를 먼저 의심해야 하는 이유가 이 기울기에 있습니다.
측정에 쓴 코드는 아래와 같은 모양입니다. 직접 숫자를 바꿔 실행해 보세요. 실행하는 컴퓨터와 환경에 따라 시간 자체는 위 그래프와 다르게 나오지만, 크기에 따라 늘어나는 모양은 같습니다.
import timeit
for n in [1_000, 10_000, 100_000]:
data = list(range(n))
s = set(data)
t_list = timeit.timeit('-1 in data', globals=globals(), number=100) / 100
t_set = timeit.timeit('-1 in s', globals=globals(), number=100) / 100
print(f'n={n:>7,} list {t_list * 1e6:8.2f}µs set {t_set * 1e6:6.3f}µs')
마지막 수정