# mvpa2.algorithms.group_clusterthr.Counter¶ class `mvpa2.algorithms.group_clusterthr.``Counter`(*args, **kwds)

Dict subclass for counting hashable items. Sometimes called a bag or multiset. Elements are stored as dictionary keys and their counts are stored as dictionary values.

```>>> c = Counter('abcdeabcdabcaba')  # count elements from a string
```
```>>> c.most_common(3)                # three most common elements
[('a', 5), ('b', 4), ('c', 3)]
>>> sorted(c)                       # list all unique elements
['a', 'b', 'c', 'd', 'e']
>>> ''.join(sorted(c.elements()))   # list elements with repetitions
'aaaaabbbbcccdde'
>>> sum(c.values())                 # total of all counts
15
```
```>>> c['a']                          # count of letter 'a'
5
>>> for elem in 'shazam':           # update counts from an iterable
...     c[elem] += 1                # by adding 1 to each element's count
>>> c['a']                          # now there are seven 'a'
7
>>> del c['b']                      # remove all 'b'
>>> c['b']                          # now there are zero 'b'
0
```
```>>> d = Counter('simsalabim')       # make another counter
>>> c.update(d)                     # add in the second counter
>>> c['a']                          # now there are nine 'a'
9
```
```>>> c.clear()                       # empty the counter
>>> c
Counter()
```

Note: If a count is set to zero or reduced to zero, it will remain in the counter until the entry is deleted or the counter is cleared:

```>>> c = Counter('aaabbc')
>>> c['b'] -= 2                     # reduce the count of 'b' by two
>>> c.most_common()                 # 'b' is still in, but its count is zero
[('a', 3), ('c', 1), ('b', 0)]
```

Methods

 `clear`(() -> None.  Remove all items from D.) `copy`() Return a shallow copy. `elements`() Iterator over elements repeating each as many times as its count. `fromkeys`(iterable[, v]) `get`((k[,d]) -> D[k] if k in D, ...) `has_key`((k) -> True if D has a key k, else False) `items`(() -> list of D’s (key, value) pairs, ...) `iteritems`(() -> an iterator over the (key, ...) `iterkeys`(() -> an iterator over the keys of D) `itervalues`(...) `keys`(() -> list of D’s keys) `most_common`([n]) List the n most common elements and their counts from the most common to the least. `pop`((k[,d]) -> v, ...) If key is not found, d is returned if given, otherwise KeyError is raised `popitem`(() -> (k, v), ...) 2-tuple; but raise KeyError if D is empty. `setdefault`((k[,d]) -> D.get(k,d), ...) `subtract`(\*args, \*\*kwds) Like dict.update() but subtracts counts instead of replacing them. `update`(\*args, \*\*kwds) Like dict.update() but add counts instead of replacing them. `values`(() -> list of D’s values) `viewitems`(...) `viewkeys`(...) `viewvalues`(...)

Create a new, empty Counter object. And if given, count elements from an input iterable. Or, initialize the count from another mapping of elements to their counts.

```>>> c = Counter()                           # a new, empty counter
>>> c = Counter('gallahad')                 # a new counter from an iterable
>>> c = Counter({'a': 4, 'b': 2})           # a new counter from a mapping
>>> c = Counter(a=4, b=2)                   # a new counter from keyword args
```

Methods

 `clear`(() -> None.  Remove all items from D.) `copy`() Return a shallow copy. `elements`() Iterator over elements repeating each as many times as its count. `fromkeys`(iterable[, v]) `get`((k[,d]) -> D[k] if k in D, ...) `has_key`((k) -> True if D has a key k, else False) `items`(() -> list of D’s (key, value) pairs, ...) `iteritems`(() -> an iterator over the (key, ...) `iterkeys`(() -> an iterator over the keys of D) `itervalues`(...) `keys`(() -> list of D’s keys) `most_common`([n]) List the n most common elements and their counts from the most common to the least. `pop`((k[,d]) -> v, ...) If key is not found, d is returned if given, otherwise KeyError is raised `popitem`(() -> (k, v), ...) 2-tuple; but raise KeyError if D is empty. `setdefault`((k[,d]) -> D.get(k,d), ...) `subtract`(\*args, \*\*kwds) Like dict.update() but subtracts counts instead of replacing them. `update`(\*args, \*\*kwds) Like dict.update() but add counts instead of replacing them. `values`(() -> list of D’s values) `viewitems`(...) `viewkeys`(...) `viewvalues`(...)
`copy`()

Return a shallow copy.

`elements`()

Iterator over elements repeating each as many times as its count.

```>>> c = Counter('ABCABC')
>>> sorted(c.elements())
['A', 'A', 'B', 'B', 'C', 'C']
```

# Knuth’s example for prime factors of 1836: 2**2 * 3**3 * 17**1 >>> prime_factors = Counter({2: 2, 3: 3, 17: 1}) >>> product = 1 >>> for factor in prime_factors.elements(): # loop over factors ... product *= factor # and multiply them >>> product 1836

Note, if an element’s count has been set to zero or is a negative number, elements() will ignore it.

classmethod `fromkeys`(iterable, v=None)
`most_common`(n=None)

List the n most common elements and their counts from the most common to the least. If n is None, then list all element counts.

```>>> Counter('abcdeabcdabcaba').most_common(3)
[('a', 5), ('b', 4), ('c', 3)]
```
`subtract`(*args, **kwds)

Like dict.update() but subtracts counts instead of replacing them. Counts can be reduced below zero. Both the inputs and outputs are allowed to contain zero and negative counts.

Source can be an iterable, a dictionary, or another Counter instance.

```>>> c = Counter('which')
>>> c.subtract('witch')             # subtract elements from another iterable
>>> c.subtract(Counter('watch'))    # subtract elements from another counter
>>> c['h']                          # 2 in which, minus 1 in witch, minus 1 in watch
0
>>> c['w']                          # 1 in which, minus 1 in witch, minus 1 in watch
-1
```
`update`(*args, **kwds)

```>>> c = Counter('which')