collections मॉड्यूल कौन से उपयोगी प्रकार प्रदान करता है?

Question

Accepted Answer

**`collections`** मॉड्यूल विशेष कंटेनर प्रकार प्रदान करता है जो बिल्ट-इन list/dict/tuple को सुविधाजनक, अक्सर अधिक कुशल विकल्प के साथ बढ़ाते हैं जो सामान्य पैटर्न के लिए हैं। उन्हें जानने से आप स्वच्छ, तेजी से कोड लिख सकते हैं।

## defaultdict — स्वचालित डिफ़ॉल्ट मानों के साथ dicts

```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` tuples को नामित फ़ील्ड देता है — सूचकांक पहुंच की तुलना में अधिक पठनीय, अपरिवर्तनीय, मेमोरी-दक्ष। (आधुनिक कोड अक्सर परिवर्तनशील रिकॉर्ड के लिए इसके बजाय `@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` समूहीकरण और गिनती को नाटकीय रूप से सरल बनाते हैं (मैनुअल तर्क को प्रतिस्थापित करते हुए); `deque` O(1) दोहरी-छोर संचालन देता है जहां एक list धीमा होगा; `namedtuple` पठनीय हल्के रिकॉर्ड बनाता है।

सादे dicts/lists के साथ समान पैटर्न को हाथ से रोल करने के बजाय इन तक पहुंचना idiomatic, कुशल Python का एक संकेत है — वे डेटा प्रोसेसिंग, एल्गोरिदम और स्वच्छ API के लिए वास्तविक कोड में व्यापक रूप से उपयोग किए जाते हैं।