[파이썬 / 기본] collections

1. collections 모듈 소개 및 개요

collections 모듈?

• 파이썬의 collections 모듈은 특수 컨테이너 데이터 타입을 구현하며, 일반적인 내장 컨테이너(딕셔너리, 리스트, 튜플 등)에 비해 추가적인 기능을 제공하는 대안을 제시
• 코드를 더 효율적으로 만들거나 특정 데이터 처리 작업을 간소화하는 데 유용

이번 글에서 다룰 collections 모듈의 다섯 가지 주요 타입

• 1. Counter
• 2. Named Tuple (namedtuple)
• 3. Ordered Dict (OrderedDict)
• 4. Default Dict (defaultdict)
• 5. deque

from collections import Counter, namedtuple, OrderedDict, defaultdict, deque

print("collections 임포트 완료")
## 출력: collections 임포트 완료

--------------------------------------------------------------------------------

2. Counter - 요소 카운팅을 위한 컨테이너

• Counter는 요소를 딕셔너리 키로 저장
• 해당 요소의 **개수(count)**를 딕셔너리 값으로 저장하는 컨테이너

Counter 생성 및 기본 사용법

• 문자열과 같은 이터러블 객체를 Counter에 전달하여 쉽게 생성 가능
• 예를 들어, 'a'가 5번, 'b'가 4번, 'c'가 3번 포함된 문자열을 Counter로 만들면, 각 문자와 그 개수를 담은 딕셔너리 형태로 확인 가능

• 일반 딕셔너리처럼 항목(items), 키(keys), 값(values)을 조회
• 유용한 메서드: most_common()
  
  • 인수로 숫자를 지정하여 가장 많이 등장한 요소와 그 개수를 튜플이 담긴 리스트 형태로 반환
  • 예를 들어, my_counter.most_common(1)은 가장 흔한 요소인 ('a', 5) 튜플을 반환합니다.
  • 만약 요소 자체만 원한다면, 반환된 리스트의 첫 번째 튜플()에 접근하고, 다시 그 튜플의 첫 번째 요소()에 접근하여 얻을 수 있습니다 (이 경우 'a'를 얻게 됩니다).
• 유용한 메서드: elements()
  • elements() 메서드는 카운트된 각 요소를 그 개수만큼 반복하는 이터러블을 제공
  • 이 결과를 보기 좋게 출력하려면 리스트로 변환(list(my_counter.elements())).
  • 이 이터러블을 사용하여 각 요소를 순회(iterate) 가능

from collections import Counter

# 문자열로부터 Counter 생성
s = "aaabbbcccddeaaaa"
c = Counter(s)
print("Counter:", c)
## 출력: Counter: Counter({'a': 7, 'b': 3, 'c': 3, 'd': 2})

# most_common: 상위 2개
print("most_common(2):", c.most_common(2))
## 출력: most_common(2): [('a', 7), ('b', 3)]

# elements: 각 요소를 카운트 수만큼 반복하는 이터러블
print("elements -> list:", list(c.elements())[:10])
## 출력 예시 (부분): elements -> list: ['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd']

# Counter끼리 연산 (덧셈/뺄셈) 예시
c1 = Counter("aab")
c2 = Counter("abb")
print("c1 + c2:", c1 + c2)   # 합(카운트 합산)
## 출력: c1 + c2: Counter({'a': 3, 'b': 3})
print("c1 - c2:", c1 - c2)   # 차 (음수는 제거)
## 출력: c1 - c2: Counter({'a': 1})

 

--------------------------------------------------------------------------------

3단계: Named Tuple (namedtuple) - 경량 객체 타입

• namedtuple은 구조체(struct)와 유사한 경량 객체 타입을 쉽게 생성할 수 있도록 해주는 데이터 타입
• 이는 순서가 있고 불변(immutable)인 튜플과 유사하지만, 인덱스뿐만 아니라 이름으로도 요소에 접근 가능

Named Tuple 정의 및 생성

• 1. 클래스 이름 (예: 'Point')
• 2. 필드 이름 문자열 (쉼표나 공백으로 구분된 문자열, 예: 'x, y').

요소 접근 방법

• 생성된 객체의 필드 값은 다음과 같이 **점 표기법(dot notation)**을 사용하여 접근 가능

from collections import namedtuple

Point = namedtuple('Point', 'x y')
p = Point(10, 20)
print("Point:", p)
## 출력: Point: Point(x=10, y=20)

# 점 표기법으로 접근
print("x:", p.x, "y:", p.y)
## 출력: x: 10 y: 20

# _asdict()로 딕셔너리 변환, _replace()로 값 교체(새 객체 반환)
print("as dict:", p._asdict())
## 출력: as dict: {'x': 10, 'y': 20}
p2 = p._replace(x=99)
print("p2:", p2)
## 출력: p2: Point(x=99, y=20)

--------------------------------------------------------------------------------

4. Ordered Dictionary (OrderedDict) - 순서 기억 딕셔너리

• OrderedDict는 일반 딕셔너리와 유사하지만, 항목이 삽입된 순서를 기억한다는 특징이 있습니다.

삽입 순서 유지

• OrderedDict에 키-값 쌍을 삽입하면, 나중에 출력하거나 순회할 때 삽입한 순서대로 유지

OrderedDict는 파이썬의 내장 딕셔너리 클래스가 파이썬 3.7 버전부터 삽입 순서를 기억하는 기능이 보장되면서 그 중요성이 줄어들었음

 

from collections import OrderedDict

od = OrderedDict()
od['a'] = 1
od['b'] = 2
od['c'] = 3
print("OrderedDict 순회:", list(od.items()))
## 출력: OrderedDict 순회: [('a', 1), ('b', 2), ('c', 3)]

# move_to_end: 특정 키를 끝이나 앞으로 이동 가능
od.move_to_end('b')          # 기본은 끝으로 이동
print("move_to_end('b'):", list(od.items()))
## 출력: move_to_end('b'): [('a', 1), ('c', 3), ('b', 2)]

od.move_to_end('a', last=False)  # 'a'를 앞으로 이동
print("move_to_end('a', last=False):", list(od.items()))
## 출력: move_to_end('a', last=False): [('a', 1), ('c', 3), ('b', 2)]

 

--------------------------------------------------------------------------------

5. Default Dictionary (defaultdict) - 기본값 설정 딕셔너리

• defaultdict는 일반 딕셔너리 컨테이너와 유사
• 아직 설정되지 않은 키에 접근할 경우 기본값을 가지도록 설정할 수 있는 차이점 존재
• KeyError 방지
  • 일반 딕셔너리에서 존재하지 않는 키에 접근하면 KeyError 예외가 발생 ( defaultdict는 이를 방지 )

Default Dictionary 생성 및 사용

• defaultdict를 생성할 때, 기본값으로 사용할 타입을 인수로 지정
  • 기본 타입으로 int를 지정하면, 존재하지 않는 키에 접근할 경우 정수의 기본값인 0이 반환
  • float를 지정하면 0.0이 반환될 수 있습니다.
  • list를 지정하면 비어있는 리스트([])가 기본값으로 사용 가능

이 기능을 통해, **** 키가 존재하는지 여부를 미리 확인할 필요 없이 값에 안전하게 접근 가능 ****

 

from collections import defaultdict

# int를 기본값으로 지정하면 없는 키는 0으로 시작
dd_int = defaultdict(int)
dd_int['count'] += 1
print("defaultdict(int):", dd_int)
## 출력: defaultdict(int): defaultdict(<class 'int'>, {'count': 1})

# list를 기본값으로 지정하면 그룹핑에 편리
names = [("fruit", "apple"), ("fruit", "banana"), ("veg", "carrot")]
groups = defaultdict(list)
for k, v in names:
    groups[k].append(v)
print("그룹핑 결과:", dict(groups))
## 출력: 그룹핑 결과: {'fruit': ['apple', 'banana'], 'veg': ['carrot']}

# 키가 없을 때 자동 생성되므로 KeyError 방지
print("nonexistent key 접근:", groups['meat'])
## 출력: nonexistent key 접근: []

--------------------------------------------------------------------------------

6. deque - 양방향 큐

• deque는 **양방향 큐(Double Ended Queue)**
• 이는 양쪽 끝에서 요소를 추가하거나 제거하는 작업이 매우 효율적으로 구현되어 있어, 리스트보다 빠름

요소 추가 및 제거

• deque는 리스트와 유사하게 append()를 사용하여 오른쪽에 요소를 추가 가능
• 그러나 양방향 큐이기 때문에, 왼쪽에도 요소를 추가할 수 있는 appendleft() 메서드를 제공

다중 요소 확장 및 회전

• extend(): 오른쪽(마지막)에 여러 요소를 한 번에 추가
• extendleft(): 왼쪽(앞쪽)에 여러 요소를 한 번에 추가
  • 이때, 추가되는 리스트의 요소 순서가 반대로 적용되어 왼쪽에 추가
• rotate(n): 요소를 회전
  • 양수 n은 요소를 오른쪽으로 회전시키고, 음수 n은 요소를 왼쪽으로 회전
• clear() : 모든 요소 제거

 

from collections import deque

dq = deque([1, 2, 3])
dq.append(4)           # 오른쪽 추가
dq.appendleft(0)       # 왼쪽 추가
print("append/appendleft:", dq)
## 출력: append/appendleft: deque([0, 1, 2, 3, 4])

print("pop():", dq.pop())         # 오른쪽 제거
## 출력: pop(): 4
print("popleft():", dq.popleft()) # 왼쪽 제거
## 출력: popleft(): 0

# extend / extendleft
dq.extend([10, 11])
print("extend:", dq)
## 출력: extend: deque([1, 2, 3, 10, 11])

dq.extendleft([ -1, -2 ])  # 주의: 왼쪽에 여러 개 추가하면 입력 순서가 반대로 들어감
print("extendleft:", dq)
## 출력 예시: extendleft: deque([-2, -1, 1, 2, 3, 10, 11])

# rotate: 양수는 오른쪽으로, 음수는 왼쪽으로 회전
dq.rotate(2)
print("rotate(2):", dq)
## 출력 예시: rotate(2): deque([10, 11, -2, -1, 1, 2, 3])

dq.clear()
print("clear ->", dq)
## 출력: clear -> deque([])