collections मॉड्यूल कोणते उपयुक्त प्रकार प्रदान करते?

Question

Accepted Answer

**`collections`** मॉड्यूल विशेष कंटेनर प्रकार प्रदान करते जो बनावट list/dict/tuple को सुविधाजनक, अनेकदा अधिक कार्यक्षम पर्यायांनी विस्तारित करते. त्यांना जाणून घेतल्याने तुम्ही स्वच्छ, वेगवान कोड लिहू शकता.

## defaultdict — स्वयंचलित डिफॉल्ट मूल्यांसह डिक्ट

```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 — दोन्ही टोकांवर वेगवान append/pop

```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) append/pop असते — रांगा, स्टॅक आणि स्लाइडिंग विंडोसाठी आदर्श (साधारण 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` वाचनीय हल्के रेकॉर्ड तयार करते.

साधारण dict/list सह समान नमुने हाताने तयार करण्याऐवजी यांचा वापर करणे हा मुहावरेदार, कार्यक्षम Python चा खुणा आहे — डेटा प्रक्रिया, अल्गोरिदम आणि स्वच्छ API साठी वास्तविक कोडमध्ये ते व्यापकपणे वापरले जातात.