Python Language
컬렉션 모듈
수색…
소개
내장 collections
패키지는 고성능이며 dict
, list
, tuple
및 set
의 일반 컬렉션 유형에 대한 대안을 제공하는 여러 특수화되고 유연한 컬렉션 유형을 제공 set
. 또한 모듈은 다양한 유형의 콜렉션 기능 (예 : MutableSet
및 ItemsView
)을 설명하는 추상 기본 클래스를 정의합니다.
비고
collections 모듈에는 세 가지 유형이 있습니다.
- UserDict
- 사용자 목록
- UserString
그것들은 묶인 객체를 감싸는 래퍼 (wrapper) 역할을합니다. 예를 들어, UserDict 는 dict 객체 주위의 래퍼처럼 작동합니다. 각각의 경우에 클래스는 명명 된 유형을 시뮬레이트합니다. 인스턴스의 내용은 랩퍼 인스턴스의 데이터 속성을 통해 액세스 할 수있는 일반 유형 오브젝트에 보존됩니다. 이 세 가지 경우 각각에서 이러한 유형의 필요성은 부분적으로 기본 유형에서 직접 하위 클래스 화하는 기능으로 대체되었습니다. 그러나 랩퍼 클래스는 기본 유형이 속성으로 액세스 가능하기 때.에 더 쉽게 작업 할 수 있습니다.
컬렉션. 카운터
카운터 는 객체를 쉽게 카운트 할 수있게 해주는 dict 하위 클래스입니다. 그것은 세고있는 객체의 빈도로 작업하기위한 유틸리티 메소드를 가지고 있습니다.
import collections
counts = collections.Counter([1,2,3])
위의 코드는 생성자에 전달 된 모든 요소의 빈도가있는 counts라는 객체를 만듭니다. 이 예제에는 값 Counter({1: 1, 2: 1, 3: 1})
생성자 예제
편지 카운터
>>> collections.Counter('Happy Birthday')
Counter({'a': 2, 'p': 2, 'y': 2, 'i': 1, 'r': 1, 'B': 1, ' ': 1, 'H': 1, 'd': 1, 'h': 1, 't': 1})
단어 카운터
>>> collections.Counter('I am Sam Sam I am That Sam-I-am That Sam-I-am! I do not like that Sam-I-am'.split())
Counter({'I': 3, 'Sam': 2, 'Sam-I-am': 2, 'That': 2, 'am': 2, 'do': 1, 'Sam-I-am!': 1, 'that': 1, 'not': 1, 'like': 1})
조리법
>>> c = collections.Counter({'a': 4, 'b': 2, 'c': -2, 'd': 0})
개별 요소의 수를 가져옵니다.
>>> c['a']
4
개별 요소의 개수 설정
>>> c['c'] = -3
>>> c
Counter({'a': 4, 'b': 2, 'd': 0, 'c': -3})
카운터의 총 요소 수 가져 오기 (4 + 2 + 0-3)
>>> sum(c.itervalues()) # negative numbers are counted!
3
요소 가져 오기 (양수 카운터가있는 요소 만 유지)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
0 또는 음수 값의 키 제거
>>> c - collections.Counter()
Counter({'a': 4, 'b': 2})
모든 것을 제거하십시오.
>>> c.clear()
>>> c
Counter()
개별 요소 제거 추가
>>> c.update({'a': 3, 'b':3})
>>> c.update({'a': 2, 'c':2}) # adds to existing, sets if they don't exist
>>> c
Counter({'a': 5, 'b': 3, 'c': 2})
>>> c.subtract({'a': 3, 'b': 3, 'c': 3}) # subtracts (negative values are allowed)
>>> c
Counter({'a': 2, 'b': 0, 'c': -1})
collections.defaultdict
collections.defaultdict (default_factory)는 누락 된 키의 기본값이있는 dict
의 하위 클래스를 반환합니다. 인수는 인수없이 호출 될 때 기본값을 리턴하는 함수 여야합니다. 전달 된 항목이 없으면 기본값은 None
입니다.
>>> state_capitals = collections.defaultdict(str)
>>> state_capitals
defaultdict(<class 'str'>, {})
default_factory 메소드로 문자열 객체를 생성하는 defaultdict에 대한 참조를 반환합니다.
defaultdict
의 일반적인 사용법은 str
, int
, list
또는 dict
와 같은 내장 유형 중 하나를 default_factory로 사용하는 것입니다. 이는 인자없이 호출 할 때 빈 유형을 반환하기 때문입니다.
>>> str()
''
>>> int()
0
>>> list
[]
존재하지 않는 키로 defaultdict를 호출해도 일반 사전과 마찬가지로 오류가 발생하지 않습니다.
>>> state_capitals['Alaska']
''
>>> state_capitals
defaultdict(<class 'str'>, {'Alaska': ''})
int
를 사용한 또 다른 예 :
>>> fruit_counts = defaultdict(int)
>>> fruit_counts['apple'] += 2 # No errors should occur
>>> fruit_counts
default_dict(int, {'apple': 2})
>>> fruit_counts['banana'] # No errors should occur
0
>>> fruit_counts # A new key is created
default_dict(int, {'apple': 2, 'banana': 0})
기본 사전은 기본 사전과 함께 작동합니다.
>>> state_capitals['Alabama'] = 'Montgomery'
>>> state_capitals
defaultdict(<class 'str'>, {'Alabama': 'Montgomery', 'Alaska': ''})
list
를 default_factory로 사용하면 각각의 새 키에 대한 목록이 생성됩니다.
>>> s = [('NC', 'Raleigh'), ('VA', 'Richmond'), ('WA', 'Seattle'), ('NC', 'Asheville')]
>>> dd = collections.defaultdict(list)
>>> for k, v in s:
... dd[k].append(v)
>>> dd
defaultdict(<class 'list'>,
{'VA': ['Richmond'],
'NC': ['Raleigh', 'Asheville'],
'WA': ['Seattle']})
collections.OrderedDict
파이썬 사전의 키 순서는 임의적입니다. 즉, 키를 추가하는 순서에 의해 제어되지 않습니다.
예 :
>>> d = {'foo': 5, 'bar': 6}
>>> print(d)
{'foo': 5, 'bar': 6}
>>> d['baz'] = 7
>>> print(a)
{'baz': 7, 'foo': 5, 'bar': 6}
>>> d['foobar'] = 8
>>> print(a)
{'baz': 7, 'foo': 5, 'bar': 6, 'foobar': 8}
```
(위의 임의적 순서는이 코드를 사용하여 여기에 표시된 것과 다른 결과를 얻을 수 있음을 의미합니다.)
키가 나타나는 순서는 for
반복을 사용하여 반복되는 순서입니다.
collections.OrderedDict
클래스는 키 순서를 유지하는 사전 객체를 제공합니다. OrderedDict
는 일련의 정렬 된 항목 (여기서는 튜플 키 - 값 쌍 목록)과 함께 아래 표시된 것처럼 만들 수 있습니다.
>>> from collections import OrderedDict
>>> d = OrderedDict([('foo', 5), ('bar', 6)])
>>> print(d)
OrderedDict([('foo', 5), ('bar', 6)])
>>> d['baz'] = 7
>>> print(d)
OrderedDict([('foo', 5), ('bar', 6), ('baz', 7)])
>>> d['foobar'] = 8
>>> print(d)
OrderedDict([('foo', 5), ('bar', 6), ('baz', 7), ('foobar', 8)])
또는 빈 OrderedDict
를 만든 다음 항목을 추가 할 수 있습니다.
>>> o = OrderedDict()
>>> o['key1'] = "value1"
>>> o['key2'] = "value2"
>>> print(o)
OrderedDict([('key1', 'value1'), ('key2', 'value2')])
OrderedDict
반복하면 키가 추가 된 순서대로 액세스 할 수 있습니다.
기존 키에 새 값을 할당하면 어떻게됩니까?
>>> d['foo'] = 4
>>> print(d)
OrderedDict([('foo', 4), ('bar', 6), ('baz', 7), ('foobar', 8)])
키는 OrderedDict
에서 원래 위치를 유지합니다.
collections.namedtuple
다음과 같이 namedtuple
사용하여 새로운 유형 Person
을 정의하십시오 :
Person = namedtuple('Person', ['age', 'height', 'name'])
두 번째 인수는 튜플에 포함될 속성 목록입니다. 이러한 속성을 공백 또는 쉼표로 구분 된 문자열로 나열 할 수도 있습니다.
Person = namedtuple('Person', 'age, height, name')
또는
Person = namedtuple('Person', 'age height name')
일단 정의되면, 다음과 같이 필요한 매개 변수를 사용하여 객체를 호출하여 명명 된 튜플을 인스턴스화 할 수 있습니다.
dave = Person(30, 178, 'Dave')
명명 된 인수를 사용할 수도 있습니다.
jack = Person(age=30, height=178, name='Jack S.')
이제 명명 된 튜플의 속성에 액세스 할 수 있습니다.
print(jack.age) # 30
print(jack.name) # 'Jack S.'
namedtuple 생성자 (이 예에서는 'Person'
)의 첫 번째 인수는 typename
입니다. 일반적으로 생성자와 typename에 동일한 단어를 사용하지만 서로 다를 수 있습니다.
Human = namedtuple('Person', 'age, height, name')
dave = Human(30, 178, 'Dave')
print(dave) # yields: Person(age=30, height=178, name='Dave')
collections.deque
iterable의 데이터로 왼쪽에서 오른쪽으로 (append ()를 사용하여) 초기화 된 새로운 deque
객체를 리턴합니다. iterable이 지정되어 있지 않은 경우, 새로운 deque
는 하늘입니다.
Deques는 스택과 대기열을 일반화 한 것입니다 (이름은 "deck"으로 발음되며 "double-ended queue"의 약자입니다). Deques는 양쪽 방향에서 거의 같은 O (1) 성능으로 양면 deque
의 양쪽에서 thread 세이프, 메모리 효율적인 추가 및 팝을 지원합니다.
목록 객체는 유사한 연산을 지원하지만 빠른 고정 길이 연산에 최적화되어 있으며 기본 데이터 표현의 크기와 위치를 변경하는 pop (0) 및 insert (0, v) 연산에 대한 O (n) 메모리 이동 비용이 발생합니다 .
버전 2.4의 새로운 기능.
maxlen
이 지정되지 않았거나 None
경우 deques는 임의의 길이로 증가 할 수 있습니다. 그렇지 않은 경우, deque
는 지정된 최대 길이에 바인드됩니다. 제한된 길이의 deque
가 가득 차면 새 항목이 추가 될 때 해당 항목 수가 반대쪽 끝에서 무시됩니다. 묶여있는 길이 deques는 Unix의 tail 필터와 비슷한 기능을 제공합니다. 또한 가장 최근 활동 만 관심있는 트랜잭션 및 기타 데이터 풀을 추적하는 데 유용합니다.
버전 2.6에서 변경 : maxlen 매개 변수가 추가되었습니다.
>>> from collections import deque
>>> d = deque('ghi') # make a new deque with three items
>>> for elem in d: # iterate over the deque's elements
... print elem.upper()
G
H
I
>>> d.append('j') # add a new entry to the right side
>>> d.appendleft('f') # add a new entry to the left side
>>> d # show the representation of the deque
deque(['f', 'g', 'h', 'i', 'j'])
>>> d.pop() # return and remove the rightmost item
'j'
>>> d.popleft() # return and remove the leftmost item
'f'
>>> list(d) # list the contents of the deque
['g', 'h', 'i']
>>> d[0] # peek at leftmost item
'g'
>>> d[-1] # peek at rightmost item
'i'
>>> list(reversed(d)) # list the contents of a deque in reverse
['i', 'h', 'g']
>>> 'h' in d # search the deque
True
>>> d.extend('jkl') # add multiple elements at once
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])
>>> d.rotate(1) # right rotation
>>> d
deque(['l', 'g', 'h', 'i', 'j', 'k'])
>>> d.rotate(-1) # left rotation
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])
>>> deque(reversed(d)) # make a new deque in reverse order
deque(['l', 'k', 'j', 'i', 'h', 'g'])
>>> d.clear() # empty the deque
>>> d.pop() # cannot pop from an empty deque
Traceback (most recent call last):
File "<pyshell#6>", line 1, in -toplevel-
d.pop()
IndexError: pop from an empty deque
>>> d.extendleft('abc') # extendleft() reverses the input order
>>> d
deque(['c', 'b', 'a'])
출처 : https://docs.python.org/2/library/collections.html
컬렉션 .ChainMap
ChainMap
은 버전 3.3 에서 새로 추가되었습니다.
몇개의 maps
지정해, 새로운 ChainMap
오브젝트를 ChainMap
. 이 개체는 여러 dicts 또는 다른 매핑을 그룹화하여 업데이트 가능한 단일보기를 만듭니다.
ChainMap
은 중첩 된 컨텍스트와 오버레이를 관리하는 데 유용합니다. 파이썬 세계의 예제는 Django의 템플릿 엔진에서 Context
클래스를 구현할 때 발견됩니다. 결과를 단일 단위로 처리 할 수 있도록 여러 매핑을 빠르게 연결하는 데 유용합니다. 새 사전을 만들고 여러 update()
호출을 실행하는 것보다 훨씬 빠릅니다.
조회 값 체인이있을 때 ChainMap
대한 대소 문자가있을 수 있습니다. 예를 들어 사용자 지정 값과 기본값 사전을 모두 포함하는 경우를들 수 있습니다. 또 다른 예는 Django 나 Flask와 같이 웹에서 사용되는 POST
및 GET
매개 변수 맵입니다. ChainMap
사용하면 두 개의 서로 다른 사전을 조합하여 볼 수 있습니다.
maps
매개 변수 목록은 첫 번째 검색에서 마지막 검색까지 정렬됩니다. 조회는 키가 발견 될 때까지 기본 맵핑을 연속적으로 검색합니다. 반대로, 쓰기, 업데이트 및 삭제는 첫 번째 매핑에서만 작동합니다.
import collections
# define two dictionaries with at least some keys overlapping.
dict1 = {'apple': 1, 'banana': 2}
dict2 = {'coconut': 1, 'date': 1, 'apple': 3}
# create two ChainMaps with different ordering of those dicts.
combined_dict = collections.ChainMap(dict1, dict2)
reverse_ordered_dict = collections.ChainMap(dict2, dict1)
후속 조회에서 값이 먼저 발견되는 순서의 영향에 주목하십시오.
for k, v in combined_dict.items():
print(k, v)
date 1
apple 1
banana 2
coconut 1
for k, v in reverse_ordered_dict.items():
print(k, v)
date 1
apple 3
banana 2
coconut 1