collections module என்ன பயனுள்ள types-ஐ வழங்குகிறது?

Question

Accepted Answer

**`collections`** module சிறப்பு container types-ஐ வழங்குகிறது, இவை built-in list/dict/tuple-ஐ பொதுவான patterns-க்கு வசதியான, பெரும்பாலும் மிகவும் திறமையான மாற்றுகளுடன் விரிவுபடுத்துகின்றன. அவற்றை அறிந்துகொள்வது தூய்மையான, வேகமான code எழுத உங்களை அனுமதிக்கிறது.

## defaultdict — தானியங்கி default மதிப்புகளுடன் 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`, முதலியன) எந்த missing key-க்கும் ஒரு default-ஐ வழங்குகிறது — சலிப்பான check-and-initialize pattern-ஐ நீக்குகிறது. grouping மற்றும் counting-க்கு சிறந்தது.

## 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` frequencies-ஐ tally செய்வதை அற்பமாக்குகிறது — words, votes, occurrences எண்ணுதல் — `most_common` போன்ற வசதியான methods-உடன்.

## 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 கொண்ட ஒரு double-ended queue — queues, stacks, மற்றும் sliding windows-க்கு ஏற்றது (ஒரு வெற்று list முன்-புற operations-க்கு O(n)).

## namedtuple — இலகுவான, பெயரிடப்பட்ட records

```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-க்கு பெயரிடப்பட்ட fields-ஐ அளிக்கிறது — index access-ஐ விட படிக்கக்கூடியது, immutable, memory-திறமையானது. (நவீன code பெரும்பாலும் mutable records-க்கு பதிலாக `@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` module பொதுவான patterns-க்கான சரியான கருவியை வழங்குகிறது, இது தூய்மையான மற்றும் பெரும்பாலும் மிகவும் திறமையான code-க்கு வழிவகுக்கிறது. `defaultdict` மற்றும் `Counter` grouping மற்றும் counting-ஐ வியத்தகு வகையில் எளிமைப்படுத்துகின்றன (சொற்பெருக்கான கைமுறை logic-ஐ மாற்றுகின்றன); `deque` ஒரு list மெதுவாக இருக்கும் இடத்தில் O(1) double-ended operations-ஐ அளிக்கிறது; `namedtuple` படிக்கக்கூடிய இலகுவான records-ஐ உருவாக்குகிறது.

அதே patterns-ஐ வெற்று dicts/lists-உடன் கைமுறையாக உருவாக்குவதற்குப் பதிலாக இவற்றை நாடுவது idiomatic, performant Python-இன் அடையாளம் — அவை data processing, algorithms, மற்றும் தூய்மையான APIs-க்கு உண்மையான code-இல் பரவலாகப் பயன்படுத்தப்படுகின்றன.

defaultdict — தானியங்கி default மதிப்புகளுடன் dicts

Counter — நிகழ்வுகளை எண்ணுதல்

deque — இரண்டு முனைகளிலும் வேகமான appends/pops

namedtuple — இலகுவான, பெயரிடப்பட்ட records

OrderedDict / ChainMap (இப்போது குறைவாகப் பொதுவானவை)

இது ஏன் முக்கியம்