fruits = ["táo", "cam", "chuối"]
mixed = [1, "hai", 3.0, True, [9, 9]]  # trộn nhiều kiểu, kể cả list lồng nhau
empty = []                              # list rỗng
also_empty = list()                     # cách khác

fruits = ["táo", "cam", "chuối", "xoài"]
print(fruits[0])    # táo  (phần tử đầu)
print(fruits[-1])   # xoài (phần tử cuối)
print(fruits[-2])   # chuối

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(nums[2:5])    # [2, 3, 4]      từ chỉ số 2 đến trước 5
print(nums[:3])     # [0, 1, 2]      từ đầu đến trước 3
print(nums[7:])     # [7, 8, 9]      từ 7 đến hết
print(nums[::2])    # [0, 2, 4, 6, 8] cách 1 phần tử
print(nums[::-1])   # [9, 8, ..., 0]  đảo ngược cả list
print(nums[-3:])    # [7, 8, 9]      ba phần tử cuối

fruits = ["táo", "cam"]

fruits.append("chuối")          # thêm 1 phần tử vào cuối -> ["táo", "cam", "chuối"]
fruits.insert(1, "xoài")        # chèn vào vị trí 1       -> ["táo", "xoài", "cam", "chuối"]
fruits.extend(["nho", "lê"])    # nối thêm nhiều phần tử
last = fruits.pop()             # lấy ra và xóa phần tử cuối ("lê")
fruits.remove("cam")            # xóa phần tử có giá trị "cam"
print(len(fruits))              # số phần tử
print("táo" in fruits)          # kiểm tra tồn tại -> True
fruits.reverse()                # đảo ngược tại chỗ

a = [1, 2]
a.append([3, 4])   # [1, 2, [3, 4]]  -> độ dài 3
b = [1, 2]
b.extend([3, 4])   # [1, 2, 3, 4]    -> độ dài 4

nums = [3, 1, 4, 1, 5, 9, 2]
nums.sort()                 # sắp xếp TẠI CHỖ, trả về None, đổi nums luôn
print(nums)                 # [1, 1, 2, 3, 4, 5, 9]

original = [3, 1, 4, 1, 5]
new = sorted(original)      # trả về list MỚI, không đổi original
print(original)             # [3, 1, 4, 1, 5]  (giữ nguyên)

# Sắp xếp giảm dần và theo khóa tùy chỉnh
words = ["banana", "kiwi", "apple"]
words.sort(key=len)               # theo độ dài: ['kiwi', 'apple', 'banana']
words.sort(key=len, reverse=True) # dài -> ngắn

a = [1, 2, 3]
b = a            # KHÔNG phải bản sao!
b.append(4)
print(a)         # [1, 2, 3, 4]  -> a cũng bị đổi!

import copy

original = [[1, 2], [3, 4]]

shallow = original.copy()       # hoặc list(original) hoặc original[:]
shallow[0].append(99)
print(original)                 # [[1, 2, 99], [3, 4]]  -> list con vẫn chung!

deep = copy.deepcopy(original)  # sao chép đệ quy toàn bộ
deep[0].append(77)
print(original)                 # không đổi -> deepcopy mới thực sự tách rời

squares = [x * x for x in range(6)]          # [0, 1, 4, 9, 16, 25]
evens = [x for x in range(20) if x % 2 == 0] # có điều kiện lọc
matrix = [[r * c for c in range(3)] for r in range(3)]  # lồng nhau

point = (3, 4)
rgb = 255, 128, 0          # ngoặc tròn là tùy chọn
single = (42,)             # CHÚ Ý: tuple một phần tử PHẢI có dấu phẩy
not_a_tuple = (42)         # cái này chỉ là số 42 trong ngoặc
empty = ()

point = (3, 4)
# point[0] = 9   -> TypeError: 'tuple' object does not support item assignment

point = (3, 4)
x, y = point        # x=3, y=4

# Hoán đổi biến không cần biến tạm
a, b = 1, 2
a, b = b, a         # a=2, b=1

# Giải nén với dấu sao (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

def min_max(numbers):
    return min(numbers), max(numbers)   # trả về tuple

low, high = min_max([5, 2, 9, 1])       # low=1, high=9

person = {
    "name": "An",
    "age": 25,
    "city": "Hà Nội",
}
print(person["name"])   # An
person["age"] = 26      # cập nhật
person["email"] = "[email protected]"  # thêm khóa mới
del person["city"]      # xóa khóa

person = {"name": "An"}
print(person["phone"])          # KeyError!
print(person.get("phone"))      # None (an toàn)
print(person.get("phone", "chưa có"))  # 'chưa có'

words = ["táo", "cam", "táo", "lê", "cam", "táo"]
count = {}
for w in words:
    count[w] = count.get(w, 0) + 1   # đếm tần suất
print(count)   # {'táo': 3, 'cam': 2, 'lê': 1}

# Gom phần tử vào danh sách theo nhóm
groups = {}
for name in ["An", "Bình", "Cường", "Anh"]:
    groups.setdefault(name[0], []).append(name)
print(groups)  # {'A': ['An', 'Anh'], 'B': ['Bình'], 'C': ['Cường']}

person = {"name": "An", "age": 25}

for key in person:                  # mặc định duyệt theo KHÓA
    print(key)

for value in person.values():       # chỉ giá trị
    print(value)

for key, value in person.items():   # cả cặp -> dùng phổ biến nhất
    print(f"{key} = {value}")

squares = {x: x * x for x in range(5)}    # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

prices = {"táo": 20, "cam": 30, "lê": 50}
expensive = {k: v for k, v in prices.items() if v > 25}  # {'cam': 30, 'lê': 50}

# Đảo ngược khóa <-> giá trị
inverted = {v: k for k, v in prices.items()}

s = {1, 2, 3, 2, 1}     # {1, 2, 3} -> tự loại trùng
empty = set()           # CHÚ Ý: {} là DICT rỗng, không phải set rỗng!

nums = [1, 1, 2, 3, 3, 3]
unique = set(nums)      # {1, 2, 3} -> cách loại trùng nhanh nhất

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

print(a | b)   # union (hợp):        {1, 2, 3, 4, 5, 6}
print(a & b)   # intersection (giao): {3, 4}
print(a - b)   # difference (hiệu):   {1, 2}
print(a ^ b)   # symmetric diff:      {1, 2, 5, 6} (có ở một bên, không cả hai)

# Cũng có dạng phương thức:
a.union(b); a.intersection(b); a.difference(b)

a.add(7)        # thêm
a.discard(99)   # xóa (không lỗi nếu không có)
print(3 in a)   # kiểm tra tồn tại -> RẤT nhanh

a = [1, 2, 3]
b = a           # b và a là CÙNG MỘT object
b.append(4)
print(a)        # [1, 2, 3, 4]  -> đổi qua b cũng thấy ở a
print(a is b)   # True -> kiểm tra "cùng object" bằng `is`

x = 5
y = x
y += 1          # tạo số mới, gán lại cho y
print(x)        # 5 -> x không đổi

def add_item(item, basket=[]):   # SAI: list mặc định bị chia sẻ
    basket.append(item)
    return basket

print(add_item("táo"))   # ['táo']
print(add_item("cam"))   # ['táo', 'cam']  -> ?! giỏ cũ chưa hết

def add_item(item, basket=None):
    if basket is None:
        basket = []          # tạo list mới mỗi lần gọi
    basket.append(item)
    return basket

# Tìm trong list: phải duyệt từng phần tử -> O(n)
big_list = list(range(1_000_000))
print(999_999 in big_list)   # phải quét gần như toàn bộ -> chậm

# Tìm trong set/dict: dùng hashing -> O(1), gần như tức thì
big_set = set(range(1_000_000))
print(999_999 in big_set)    # nhanh bất kể kích thước