Python Language
컬렉션 모듈

소개

비고

컬렉션. 카운터

카운터 는 객체를 쉽게 카운트 할 수있게 해주는 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