collections మాడ్యూల్ ఏ ఉపయోగకరమైన రకాలను అందిస్తుంది?

Question

Accepted Answer

**`collections`** మాడ్యూల్ విशేషీకృత కంటైనర్ రకాలను అందిస్తుంది, అవి నిర్మిత list/dict/tuple లను సాధారణ నమూనాల కోసం సౌకర్యవంతమైన, తరచుగా మరింత సమర్థవంతమైన ప్రత్యామ్నాయాలతో విస్తరించాయి. వాటిని తెలుసుకోవడం మీరు శుభ్రమైన, వేగవంతమైన కోడ్ రాయడానికి అనుమతిస్తుంది.

## defaultdict — స్వయంచాలక డిఫాల్ట్ విలువలతో dict లు

```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
```

`defaultdict(list)` (లేదా `int`, `set`, మొదలైనవి) ఏదైనా తప్పిపోయిన కీ కోసం డిఫాల్ట్ సরఫరా చేస్తుంది — అలసట చెక్-అండ్-ఇనిషియలైజ్ నమూనాను తొలగిస్తుంది. గ్రూపింగ్ మరియు కౌంటింగ్ కోసం గొప్ప.

## Counter — సంభవనీయతలను లెక్కించండి

```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}
```

`Counter` ఫ్రీక్వెన్సీలను లెక్కించడం సులభతరం చేస్తుంది — పదాలు, ఓట్లు, సంభవనీయతలను లెక్కించడం — `most_common` వంటి సుందరమైన పద్ధతులతో.

## deque — రెండు చివరల వద్ద వేగవంతమైన appends/pops

```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)
```

`deque` రెండు-చివరల క్యూ, ఇది రెండు చివరలలో O(1) appends/pops కలిగి ఉంది — క్యూలు, స్టాక్‌లు మరియు స్లైడింగ్ విండోల కోసం ఆదర్శ (సాదా list ఫ్రంట్ ఆపరేషన్ల కోసం O(n)).

## namedtuple — తేలికపాటి, నామకరణ చేసిన రికార్డ్లు

```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
```

`namedtuple` tuple లకు నామకరణ చేసిన ఫీల్డ్‌లను ఇస్తుంది — ఇండెక్స్ ఆక్సెస్ కంటే మరింత చదవదగినది, మార్పులేనిది, మెమరీ-సమర్థవంతమైనది. (ఆధునిక కోడ్ తరచుగా మార్పుచెందే రికార్డ్‌ల కోసం బదులుగా `@dataclass` ఉపయోగిస్తుంది.)

## OrderedDict / ChainMap (ఇప్పుడు అరుదైనది)

```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)
```

## ఇది ఎందుకు ముఖ్యమైనది

`collections` మాడ్యూల్ సాధారణ నమూనాల కోసం సరైన సాధనను అందిస్తుంది, ఇది శుభ్రమైన మరియు తరచుగా మరింత సమర్థవంతమైన కోడ్‌కు దారితీస్తుంది. `defaultdict` మరియు `Counter` గ్రూపింగ్ మరియు కౌంటింగ్‌ను నాటకీయంగా సరళీకృతం చేస్తాయి (సంక్లిష్ట ručna తర్కాన్ని భర్తీ చేస్తాయి); `deque` ఇక్కడ list నెమ్మదిగా ఉండే ఇక్కడ O(1) రెండు-చివరల ఆపరేషన్లను ఇస్తుంది; `namedtuple` చదవదగిన తేలికపాటి రికార్డ్‌లను చేస్తుంది.

సాదా dict/list తో ఒకే నమూనాలను కైవాపు చేసే బదులుగా ఇవి వాటి కోసం చేరుకోవడం idiomatic, పనితీరు గల Python యొక్క గుర్తింపు — అవి డేటా ప్రాసెసింగ్, అల్గోరిథ్‌లు మరియు శుభ్ర API ల కోసం వాస్తవ కోడ్‌లో విస్తృతంగా ఉపయోగించబడుతున్నాయి.