Milyen hasznos típusokat nyújt a collections modul?

Question

Accepted Answer

A **`collections`** modul speciális tároló típusokat biztosít, amelyek kiterjesztik a beépített list/dict/tuple típusokat praktikus és gyakran hatékonyabb alternatívákkal a közös mintákhoz. Ezen típusok ismerete tisztább és gyorsabb kód írásához vezet.

## defaultdict — szótárak automatikus alapértelmezett értékekkel

```python
from collections import defaultdict

# ❌ without it — must check/initialize keys manually
groups = {}
for item in items:
    if item.category not in groups:
        groups[item.category] = []
    groups[item.category].append(item)

# ✅ defaultdict auto-creates the default for missing keys
groups = defaultdict(list)        # missing key → a new empty list
for item in items:
    groups[item.category].append(item)   # no existence check needed
```

A `defaultdict(list)` (vagy `int`, `set`, stb.) alapértelmezett értéket biztosít bármely hiányzó kulcshoz — kiküszöbölve a fárasztó ellenőrzés-és-inicializálás mintát. Kiváló csoportosításhoz és számláláshoz.

## Counter — előfordulások számlálása

```python
from collections import Counter

c = Counter("mississippi")         # Counter({'i': 4, 's': 4, 'p': 2, 'm': 1})
c.most_common(2)                    # [('i', 4), ('s', 4)] — top 2
c["x"]                              # 0 — missing keys return 0, no error

Counter(["a", "b", "a", "c", "a"])  # count list items → {'a': 3, 'b': 1, 'c': 1}
```

A `Counter` trivialissá teszi a frekvenciaszámlálást — szavak, szavazatok, előfordulások számlálása — hasznos módszerekkel, mint a `most_common`.

## deque — gyors append/pop mindkét végén

```python
from collections import deque

q = deque([1, 2, 3])
q.append(4)          # add to the right
q.appendleft(0)      # add to the LEFT — O(1) (a list's insert(0) is O(n)!)
q.popleft()          # remove from the left — O(1)
q = deque(maxlen=3)  # bounded — auto-drops old items (sliding window)
```

A `deque` egy kétirányú sor O(1) append/pop műveletekkel mindkét végén — ideális sorokhoz, stack-ekhez és csúszóablakok-hoz (egy sima lista O(n) az elöl végzett műveletekhez).

## namedtuple — könnyű, megnevezett rekordok

```python
from collections import namedtuple

Point = namedtuple("Point", ["x", "y"])
p = Point(3, 4)
p.x, p.y          # 3, 4 — access by NAME (clearer than p[0], p[1])
p                 # Point(x=3, y=4) — readable
```

A `namedtuple` megnevezett mezőket ad a tuple-öknek — olvashatóbb, mint az index alapú hozzáférés, változtathatatlan, memória-hatékony. (A modern kód gyakran a `@dataclass`-t használja helyette a változtatható rekordokhoz.)

## OrderedDict / ChainMap (mostanában kevésbé gyakori)

```text
OrderedDict → ordered dict (less needed since regular dicts keep order in 3.7+)
ChainMap    → search multiple dicts as one (e.g. layered config/defaults)
```

## Miért fontos

A `collections` modul az alkalmas eszközt biztosítja a közös mintákhoz, amely tisztább és gyakran hatékonyabb kódhoz vezet. A `defaultdict` és `Counter` drámailag egyszerűsítik a csoportosítást és számlálást (helyettesítve a nehézkes kézi logikát); a `deque` O(1) kétirányú műveleteket ad ott, ahol a lista lassú lenne; a `namedtuple` olvasható, könnyű rekordokat hoz létre.

Az egyszerű dicts/list-ekkel azonos mintákat kézzel kezelés helyett ezekhez fordulni az idiomatikus, hatékony Python jellegzetessége — széles körben használatosak a valódi kódban adatfeldolgozáshoz, algoritmusokhoz és tiszta API-khoz.