list, tuple, dict, set — bộ tứ cấu trúc dữ liệu cốt lõi

# 1. Literal — cách dùng 99% trường hợp
nums = [1, 2, 3, 4]
mixed = [1, "hai", 3.0, True, None]   # Python list cho phép mọi type, trộn lẫn được

# 2. Constructor list() từ iterable bất kỳ
chars = list("abc")            # ['a', 'b', 'c']
rng   = list(range(5))         # [0, 1, 2, 3, 4]

# 3. Repeat operator * — cẩn thận với mutable reference!
zeros = [0] * 5             # [0, 0, 0, 0, 0] — OK với int
grid  = [[0] * 3] * 3          # 🔥 3 reference TRỎ CÙNG 1 inner list!
grid[0][0] = 9
print(grid)                # [[9,0,0],[9,0,0],[9,0,0]] ← sai!

# Cách đúng tạo 2D list:
grid = [[0] * 3 for _ in range(3)]   # 3 inner list độc lập

# Truy cập (zero-indexed). Index âm đếm từ cuối
nums[0]      # 1   — phần tử đầu
nums[-1]     # 4   — phần tử cuối
len(nums)   # 4

lst = [3, 1, 4]

lst.append(5)              # [3, 1, 4, 5]
lst.extend([9, 2])         # [3, 1, 4, 5, 9, 2]
lst.insert(0, 0)            # [0, 3, 1, 4, 5, 9, 2]   (chèn đầu)
last = lst.pop()           # last = 2; lst = [0, 3, 1, 4, 5, 9]
lst.remove(1)              # xoá giá trị 1 đầu tiên

# sort() in-place vs sorted() trả mới
lst.sort()                  # mutate lst, return None
new = sorted(lst, reverse=True) # trả list mới, lst nguyên vẹn

# Sort theo key (giống ORDER BY trong SQL)
people = [("An", 25), ("Bình", 17), ("Cường", 30)]
people.sort(key=lambda p: p[1])   # sort theo tuổi

# index / count — KHÔNG mutate
lst = [1, 2, 3, 2, 1]
lst.index(2)                # 1 — lần xuất hiện đầu
lst.count(1)                # 2

# Có thể có hoặc không có dấu ngoặc
t1 = (1, 2, 3)
t2 = 1, 2, 3          # giống y hệt t1 — dấu phẩy mới tạo tuple, không phải ()

# 🔥 Gotcha: 1 phần tử BẮT BUỘC có dấu phẩy
a = (1)                # 🛑 đây là int 1, không phải tuple
b = (1,)               # ✅ tuple 1 phần tử
type(a), type(b)      # <class 'int'>, <class 'tuple'>

# Tuple rỗng
empty = ()                # hoặc tuple()

# Từ iterable
tuple([1, 2, 3])         # (1, 2, 3)
tuple("abc")             # ('a', 'b', 'c')

# Method ít — chỉ có count và index (không mutate được)
t = (1, 2, 3, 2, 1)
t.count(2)               # 2
t.index(3)               # 2

# Thử sửa → TypeError
t[0] = 99               # TypeError: 'tuple' object does not support item assignment

# 1. Cơ bản
x, y = 1, 2                  # x=1, y=2
a, b, c = [10, 20, 30]          # a=10, b=20, c=30 — unpack được mọi iterable

# 2. Swap không cần biến tạm — idiom Pythonic kinh điển
a, b = b, a

# 3. Return nhiều giá trị từ function (thực ra là return 1 tuple)
def divmod_simple(a, b):
    return a // b, a % b   # tuple ngầm

q, r = divmod_simple(17, 5)       # q=3, r=2

# 4. Star unpacking — gom phần còn lại
first, *rest = [1, 2, 3, 4]    # first=1, rest=[2,3,4]
*init, last = [1, 2, 3, 4]     # init=[1,2,3], last=4
head, *mid, tail = [1, 2, 3, 4, 5]   # head=1, mid=[2,3,4], tail=5

# 5. Bỏ qua giá trị bằng _ (convention)
_, year, _ = ("2026-05-20").split("-")   # lấy year, bỏ 2 phần

# 6. Nested unpacking
((a, b), c) = ((1, 2), 3)         # a=1, b=2, c=3

# 7. Unpacking trong vòng lặp — siêu phổ biến với dict.items()
pairs = [("a", 1), ("b", 2), ("c", 3)]
for key, value in pairs:
    print(f"{key}: {value}")

# 1. Literal
user = {"name": "An", "age": 25, "city": "Hà Nội"}

# 2. Constructor dict() — keyword form (key phải là valid identifier)
user2 = dict(name="Bình", age=22)

# 3. Từ iterable of pairs
user3 = dict([("name", "Cường"), ("age", 30)])

# 4. dict comprehension (xem mục 9)
sq = {x: x**2 for x in range(5)}    # {0:0, 1:1, 2:4, 3:9, 4:16}

# --- Truy cập ---
user["name"]                # 'An'
user["unknown"]             # KeyError: 'unknown' 🔥

user.get("name")            # 'An' — an toàn, không lỗi
user.get("unknown")         # None
user.get("unknown", 0)      # 0 — default tự chọn

# Check key tồn tại
"name" in user             # True   — O(1) hash lookup, nhanh!
"age" not in user         # False

# setdefault — pattern xây dict-of-list không cần check key
words = ["apple", "ant", "bat", "banana", "cat"]
groups = {}
for w in words:
    groups.setdefault(w[0], []).append(w)
# {'a': ['apple','ant'], 'b': ['bat','banana'], 'c': ['cat']}
# defaultdict (xem mục 11) thanh lịch hơn cho pattern này.

# items() — iterate cả key + value
for k, v in user.items():
    print(f"{k} = {v}")

# update — merge
defaults = {"theme": "light", "lang": "vi"}
prefs    = {"theme": "dark"}
defaults.update(prefs)        # defaults = {'theme': 'dark', 'lang': 'vi'}

# Python 3.9+ — merge operator | (giống Object spread của JS)
merged = defaults | prefs    # mới, không mutate

d = {}
d["c"] = 3
d["a"] = 1
d["b"] = 2

list(d)            # ['c', 'a', 'b']  — đúng thứ tự chèn, không sort
list(d.items())    # [('c', 3), ('a', 1), ('b', 2)]

# Update giá trị key đã có KHÔNG đổi vị trí
d["c"] = 99
list(d)            # ['c', 'a', 'b']  — 'c' vẫn ở đầu

# Xoá + chèn lại = đẩy 'c' về cuối
del d["c"]
d["c"] = 99
list(d)            # ['a', 'b', 'c']

# 1. Literal
s = {1, 2, 3}

# 🔥 Gotcha: {} là DICT rỗng, không phải set rỗng
empty_dict = {}              # dict, không phải set
empty_set  = set()           # cách duy nhất tạo set rỗng

type({})                    # <class 'dict'>
type(set())                 # <class 'set'>

# 2. Từ iterable — dedupe trick kinh điển
set([1, 2, 2, 3, 3, 3])     # {1, 2, 3}
set("mississippi")            # {'m', 'i', 's', 'p'}

# --- Thao tác cơ bản ---
s.add(4)                    # {1, 2, 3, 4}
s.add(2)                    # không thay đổi — đã có 2
s.discard(5)                # OK, không lỗi nếu không có
s.remove(5)                 # KeyError nếu không có
s.pop()                      # xoá & trả 1 phần tử bất kỳ

# Membership — siêu nhanh O(1)
2 in s                       # True

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

a | b                  # {1, 2, 3, 4, 5, 6}     hợp
a & b                  # {3, 4}                 giao
a - b                  # {1, 2}                 a trừ b
a ^ b                  # {1, 2, 5, 6}           hiệu đối xứng

{1, 2} <= a              # True — {1,2} là tập con của a
a.isdisjoint({7, 8})    # True — không có phần tử chung

# Use case thực tế: tìm common tags
post1_tags = {"python", "web", "flask"}
post2_tags = {"python", "data", "web"}
common = post1_tags & post2_tags    # {'python', 'web'}

fs = frozenset([1, 2, 3])
fs.add(4)                  # AttributeError — không có method add

# Vẫn dùng được mọi phép | & - ^
fs | {4}                    # frozenset({1, 2, 3, 4})

# Use case: set chứa các "tổ hợp" không thay đổi
combos = {
    frozenset(["red", "green"]),
    frozenset(["blue", "yellow"]),
}                              # OK — frozenset hashable

# dict key là một tổ hợp role chẳng hạn
permissions = {
    frozenset(["read"]): "viewer",
    frozenset(["read", "write"]): "editor",
    frozenset(["read", "write", "admin"]): "owner",
}

s = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Cú pháp: s[start:stop:step]
# - start mặc định 0 (hoặc len-1 nếu step âm)
# - stop mặc định len (hoặc -len-1 nếu step âm). KHÔNG bao gồm stop!
# - step mặc định 1

s[2:5]            # [2, 3, 4]       — từ index 2 đến 4 (5 không gồm)
s[:3]             # [0, 1, 2]       — 3 phần tử đầu
s[-3:]            # [7, 8, 9]       — 3 phần tử cuối
s[:]              # bản copy của toàn bộ s (shallow)
s[::2]            # [0, 2, 4, 6, 8] — mọi index chẵn
s[1::2]           # [1, 3, 5, 7, 9] — mọi index lẻ
s[::-1]           # [9, 8, 7, ... 0] ← REVERSE idiom kinh điển
s[8:2:-1]        # [8, 7, 6, 5, 4, 3] — từ 8 ngược về 3

# Out-of-range KHÔNG lỗi (khác với indexing!)
s[100:200]        # []  — slice rỗng, không IndexError
s[100]            # IndexError 🔥

# String là sequence của ký tự → slicing hoạt động như list
"Python"[::-1]     # 'nohtyP'
"Hello World"[6:]   # 'World'

# Slice assignment — chỉ với list (mutable sequence)
lst = [1, 2, 3, 4, 5]
lst[1:3] = [20, 30]  # [1, 20, 30, 4, 5]
lst[1:3] = []          # [1, 4, 5] — xoá range bằng gán list rỗng

# So sánh: loop truyền thống vs comprehension
# 1. Loop truyền thống — 4 dòng
squares = []
for x in range(10):
    squares.append(x ** 2)

# 2. List comprehension — 1 dòng
squares = [x ** 2 for x in range(10)]
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 3. Có filter (if)
evens = [x for x in range(10) if x % 2 == 0]
# [0, 2, 4, 6, 8]

# 4. Có if/else trong expression (chú ý vị trí trước for)
labels = ["chẵn" if x % 2 == 0 else "lẻ" for x in range(5)]
# ['chẵn', 'lẻ', 'chẵn', 'lẻ', 'chẵn']

# 5. Nested loop — đọc giống for/for lồng nhau
pairs = [(x, y) for x in [1, 2, 3] for y in ['a', 'b']]
# [(1,'a'),(1,'b'),(2,'a'),(2,'b'),(3,'a'),(3,'b')]

# 6. Flatten 2D list
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [x for row in matrix for x in row]
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 7. Transpose ma trận
T = [[row[i] for row in matrix] for i in range(3)]
# [[1,4,7], [2,5,8], [3,6,9]]

# Dict comprehension — key: value
sq_dict = {x: x ** 2 for x in range(5)}
# {0:0, 1:1, 2:4, 3:9, 4:16}

# Invert dict (swap key/value)
d = {"a": 1, "b": 2, "c": 3}
inv = {v: k for k, v in d.items()}
# {1: 'a', 2: 'b', 3: 'c'}

# Filter dict theo value
prices = {"a": 100, "b": 250, "c": 50}
expensive = {k: v for k, v in prices.items() if v > 100}
# {'b': 250}

# Set comprehension
mod5 = {x % 5 for x in range(20)}
# {0, 1, 2, 3, 4}  — tự dedupe

# Unique vowels từ string
vowels = {c for c in "hello world" if c in "aeiou"}
# {'e', 'o'}

# List comprehension — EAGER, tạo list ngay
lst = [x ** 2 for x in range(10_000_000)]
# Cấp phát ~80MB RAM ngay lập tức 🔥

# Generator expression — LAZY, chỉ tính khi cần
gen = (x ** 2 for x in range(10_000_000))
# Cấp phát ~200 byte — chỉ là object generator!

# Tính tổng — không cần lưu trung gian
total = sum(x ** 2 for x in range(10_000_000))
# Idiom: khi truyền vào sum/min/max/any/all/... có thể BỎ () thừa

# Iterate qua từng phần tử
for v in gen:
    if v > 1000:
        break

# 🔥 Generator dùng 1 lần — sau khi cạn không reset được
gen2 = (x * 2 for x in range(3))
list(gen2)              # [0, 2, 4]
list(gen2)              # []  — đã cạn!

from collections import Counter

# 1. Từ string — đếm ký tự
c = Counter("mississippi")
# Counter({'i': 4, 's': 4, 'p': 2, 'm': 1})
c["s"]                    # 4
c["z"]                    # 0 — Counter trả 0 cho key vắng (KHÔNG raise KeyError)

# 2. Từ list of words
words = "to be or not to be".split()
wc = Counter(words)
# Counter({'to': 2, 'be': 2, 'or': 1, 'not': 1})

# 3. most_common(n) — top n phổ biến nhất
wc.most_common(2)
# [('to', 2), ('be', 2)]

# 4. Update / subtract
c.update("missing")         # cộng dồn count
c.subtract("mi")            # trừ count

# 5. Math operations — cộng / trừ 2 Counter
a = Counter("abracadabra")
b = Counter("alacazam")
a + b                    # cộng count tương ứng
a - b                    # trừ (không cho âm)
a & b                    # min(a, b) — intersection
a | b                    # max(a, b) — union

# 6. Total + reset
c.total()                  # 3.10+ — tổng count
+c                       # bỏ count ≤ 0

from collections import defaultdict

# 1. dict-of-list — gom nhóm
words = ["apple", "ant", "bat", "banana", "cat"]
groups = defaultdict(list)
for w in words:
    groups[w[0]].append(w)
# defaultdict(list, {'a': ['apple','ant'], 'b': ['bat','banana'], 'c': ['cat']})

# So với dict thường — phải setdefault hoặc check:
# if w[0] not in groups: groups[w[0]] = []
# groups[w[0]].append(w)

# 2. dict-of-int — đếm (tương đương Counter)
counts = defaultdict(int)
for c in "mississippi":
    counts[c] += 1
# {'m': 1, 'i': 4, 's': 4, 'p': 2}

# 3. dict-of-set — gom unique
tags_by_user = defaultdict(set)
events = [("an", "login"), ("an", "login"), ("binh", "click")]
for user, tag in events:
    tags_by_user[user].add(tag)
# {'an': {'login'}, 'binh': {'click'}}

# 4. Nested defaultdict
tree = defaultdict(lambda: defaultdict(int))
tree["a"]["x"] = 1
tree["a"]["y"] = 2
tree["b"]["z"] = 3

from collections import deque

# Cơ bản
dq = deque([1, 2, 3])
dq.append(4)              # deque([1, 2, 3, 4])
dq.appendleft(0)          # deque([0, 1, 2, 3, 4])  — O(1)!
dq.pop()                  # 4 — từ phải
dq.popleft()              # 0 — từ trái, O(1)

# Queue FIFO
queue = deque()
queue.append("job1")
queue.append("job2")
queue.popleft()             # 'job1' — first in first out

# Bounded deque — như buffer cố định kích thước
recent = deque(maxlen=3)
for i in range(5):
    recent.append(i)
list(recent)              # [2, 3, 4] — chỉ giữ 3 cuối

# Rotate — xoay vòng
dq = deque([1, 2, 3, 4, 5])
dq.rotate(2)              # deque([4, 5, 1, 2, 3])
dq.rotate(-1)             # deque([5, 1, 2, 3, 4])

from collections import namedtuple

# 1. Tạo namedtuple class
Point = namedtuple("Point", ["x", "y"])
p = Point(3, 4)
p.x, p.y                  # 3, 4 — truy cập bằng tên
p[0], p[1]              # 3, 4 — vẫn truy cập bằng index được
x, y = p                  # unpacking như tuple thường
isinstance(p, tuple)      # True — là subclass của tuple

# Immutable
p.x = 99                  # AttributeError

# 2. Class-based syntax (typing.NamedTuple) — có type hints
from typing import NamedTuple
class User(NamedTuple):
    name: str
    age: int
    city: str = "Hà Nội"      # default value

u = User("An", 25)
u.name                    # 'An'

# 3. dataclass (chương 5 sẽ đào sâu) — mutable + nhiều tính năng hơn
from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: float
    stock: int = 0

prod = Product("Book", 19.99)
prod.price = 14.99         # OK — dataclass mặc định mutable