lists, tuples आणि dictionaries मध्ये काय फरक आहे?

Question

Accepted Answer

हे तीनही Python के सबसे अधिक उपयोग होणारे collections आहेत, प्रत्येक वेगवेगळ्या गरजांसाठी उपयुक्त आहे. मुख्य फरक **mutability**, **ordering**, आणि **elements मध्ये कसे प्रवेश करता** यांमध्ये आहे.

## List — ordered, mutable sequence

```python
fruits = ["apple", "banana", "cherry"]
fruits[0]            # "apple" — index access
fruits.append("date") # ✅ mutable — can add/remove/change
fruits[1] = "berry"   # change in place
len(fruits)          # 4
```

अनुक्रमित संग्रहासाठी **list** वापरा जो बदलतो — items जोडणे, काढणे, पुनर्व्यवस्थित करणे.

## Tuple — ordered, immutable sequence

```python
point = (3, 4)
point[0]             # 3 — index access (like a list)
point[0] = 5         # ❌ TypeError — tuples are IMMUTABLE
x, y = point         # unpacking — common use
```

मूल्यांच्या निश्चित गटासाठी **tuple** वापरा जो बदलायला नको — coordinates, records, अनेक मूल्यांचे function returns. immutable असल्याने, tuples **dict keys** देखील असू शकतात आणि थोडेसे अधिक memory-efficient आहेत.

## Dict — key-value mapping

```python
user = {"name": "Ann", "age": 30}
user["name"]              # "Ann" — access by KEY, not index
user["email"] = "a@x.com" # mutable — add/update
user.get("phone", "N/A")  # safe access with a default
for k, v in user.items(): ...  # iterate key-value pairs
```

नावाने fast lookup (O(1)) साठी keys ला values शी map करण्यासाठी **dict** वापरा. Python 3.7 पासून, dicts insertion order संरक्षित करतात.

## Comparison

```text
              List          Tuple         Dict
Mutable?      yes           no            yes
Ordered?      yes           yes           yes (insertion, 3.7+)
Access by     index         index         key
Syntax        [1, 2]        (1, 2)        {"k": v}
Use for       changing seq  fixed record  key→value lookup
Dict key?     no            yes           no
```

## हे का महत्वाचे आहे

योग्य collection निवडणे ही मूलभूत, दैनंदिन Python निर्णय आहे जी correctness, performance आणि intent यांना प्रभावित करते.

Mutable ordered data साठी lists, fixed/immutable records साठी tuples (आणि dict keys), fast key-based lookup साठी dicts — योग्य वापरणे intent ला संप्रेषित करते (एक tuple "हे बदलणार नाही" हे सूचित करते) आणि योग्य performance characteristics देते (dict O(1) lookups vs list O(n) search).

त्यांचा गैरवापर करणे (उदा. list scan करणे जेव्हा dict lookup फिट होते) हे हळू किंवा स्पष्ट नसलेल्या code चा सामान्य स्रोत आहे.