Python
Data Structures · #6 / 11

Lists + Tuples

क्रमबद्ध collections और ज़रूरी methods

यह क्यों मायने रखता है

ज़्यादातर समस्याओं के लिए lists डिफ़ॉल्ट container हैं। Tuples डेटा को सुरक्षित ढंग से ताला लगा देते हैं।

मूल विचार

Lists लचीली अलमारियाँ हैं; tuples बंद डिब्बे हैं। Tuples hashable होते हैं (dict keys, set सदस्य बन सकते हैं), lists नहीं।

आज़माकर देखिए

List की बुनियादी बातें — append, extend, slice, comprehension:

xs = [1, 2, 3]
xs.append(4)          # in place
xs.extend([5, 6])     # in place
xs += [7]             # in place too
print(xs)

# Comprehension — the Pythonic loop
squares = [x*x for x in xs if x % 2 == 0]
print(squares)
not loaded

Tuples अपरिवर्तनीय होते हैं, unpacking का समर्थन करते हैं, और dict keys बन सकते हैं:

origin = (0, 0)
def move(point, dx, dy):
  x, y = point        # unpacking
  return (x + dx, y + dy)

print(move(origin, 3, 4))

routes = { (0, 0): "home", (3, 4): "park" }
print(routes[(3, 4)])
not loaded

Sorting — जगह पर बदलना बनाम नया लौटाना:

words = ["apple", "Banana", "cherry"]
print(sorted(words))                      # case-sensitive
print(sorted(words, key=str.lower))       # case-insensitive
print(sorted(words, key=len, reverse=True))

# In place — returns None! (common bug)
words.sort()
print(words)
not loaded

List methods (पूरी ज़रूरी सूची)

| Method | यह क्या करता है | उदाहरण | | --- | --- | --- | | append(x) | एक item जोड़ता है | nums.append(5) | | extend(iter) | कई जोड़ता है | nums.extend([6,7]) | | insert(i,x) | किसी index पर जोड़ता है | nums.insert(1, 42) | | remove(x) | पहला मिलान हटाता है | nums.remove(2) | | pop(i) | index से हटाता है | nums.pop() | | clear() | सब हटाता है | nums.clear() | | index(x) | स्थिति ढूँढता है | nums.index(3) | | count(x) | मान गिनता है | nums.count(3) | | sort() | जगह पर sort करता है | nums.sort() | | reverse() | जगह पर उलटता है | nums.reverse() | | copy() | shallow copy | nums.copy() |

List को stack / queue की तरह

एक list बढ़िया stack बनती है (अंत से append / pop)। तेज़ queue के लिए collections.deque की ओर बढ़िए — list के आगे से pop करना O(n) है:

from collections import deque
q = deque([1, 2, 3])
q.append(4)     # enqueue
q.popleft()     # dequeue — O(1)

Copy बनाम alias (महत्वपूर्ण)

a = [1, 2, 3]
b = a          # alias — same list, mutations are shared
c = a.copy()   # new list — independent

Nested list का जाल

[[0] * 3] * 3 उसी भीतरी row को तीन बार दोहराता है — एक को बदलने से सब बदल जाती हैं:

grid = [[0] * 3] * 3   # WRONG: shared rows
grid = [[0] * 3 for _ in range(3)]  # correct: independent rows

झटपट जाँच

छोटे अभ्यास

क्या करें और क्या न करें

और गहराई में — complexity की झलक
  • Index access: O(1)
  • Append: O(1) amortized
  • आगे insert/remove: O(n)
  • सदस्यता (x in lst): O(n)

आम ग़लतियाँ

मुख्य बातें