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` ટ્યુપલ્સને નામવાળા ક્ષેત્રો આપે છે — ઇન્ડેક્સ ોક્સેસ કરતાં વધુ વાંચણીય, અપરિવર્તનીય, મેમોરી-કાર્યક્ષમ. (આધુનિક કોડ ઘણીવાર મ્યુટેબલ રેકોર્ડ માટે તેના બદલે `@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 સાથે સમાન પેટર્નને હાથથી રોલ કરવાની જગ્યાએ આ તરફ આગળ વધવું એ અનુમાણિક, કાર્યક્ષમ Python નું ચિહ્ન છે — તેનો વ્યાપક વપરાશ બાજારમાં, ડેટા પ્રક્રિયા, અલ્ગોરિધમ્સ અને સ્વચ્છ APIs માટે થાય છે.