Dictionary trong Python (dict): tạo, phương thức, duyệt, sắp xếp và frozendict

Dictionary trong Python (dict) là tập hợp các cặp «khóa — giá trị», trong đó giá trị được tìm theo khóa gần như tức thì, dù có bao nhiêu bản ghi. Khi cần tính chi tiêu theo danh mục, lưu cấu hình hay tìm người dùng theo id, bạn sẽ dùng dict. Dưới đây là tất cả những gì cần biết để làm việc với python dict: cách tạo, các phương thức, duyệt, sắp xếp, gộp và frozendict — tính năng mới trong 3.15.

Dictionary trong Python là gì

Dict lưu các cặp, trong đó mỗi khóa là duy nhất: nếu ghi giá trị vào một khóa đã tồn tại, giá trị cũ sẽ bị thay thế. Bên trong, dict là một bảng băm, nên tìm kiếm, thêm và xóa theo khóa đều hoạt động trung bình trong thời gian hằng số, không cần duyệt từng phần tử.

Khóa phải là một đối tượng băm được: chuỗi, số, tuple gồm các giá trị bất biến. List không thể làm khóa — sẽ gặp TypeError: unhashable type: 'list'. Còn giá trị thì có thể là bất kỳ thứ gì, kể cả dict hay list khác.

Từ Python 3.7, dict đảm bảo nhớ thứ tự thêm vào: khi duyệt, bạn sẽ nhận các khóa theo đúng thứ tự đã thêm.

Cách tạo dictionary

Có nhiều cách tạo dict, và tất cả đều xuất hiện trong code thực tế.

spent = {"Ăn uống": 1200, "Taxi": 450}     # literal
empty = {}                                 # dict rỗng
also_empty = dict()                        # cũng vậy, qua hàm dict
user = dict(name="Lan", age=30)            # tham số có tên
pairs = dict([("a", 1), ("b", 2)])         # từ danh sách các cặp
keys = dict.fromkeys(["x", "y"], 0)        # {'x': 0, 'y': 0}

Lưu ý: cặp dấu ngoặc nhọn rỗng {} tạo ra một dict rỗng, không phải set. Set rỗng chỉ tạo được bằng set().

Cách tiện để tạo dict từ hai danh sách là zip:

names = ["Ăn uống", "Taxi", "Xem phim"]
sums = [1200, 450, 600]
spent = dict(zip(names, sums))
print(spent)   # {'Ăn uống': 1200, 'Taxi': 450, 'Xem phim': 600}

Truy cập theo khóa: d[k] và get

Giá trị được đọc bằng dấu ngoặc vuông. Nếu khóa không tồn tại, Python sẽ báo KeyError. Để tránh lỗi, dùng phương thức get: nó trả về None hoặc một giá trị mặc định.

spent = {"Ăn uống": 1200}
print(spent["Ăn uống"])        # 1200
print(spent.get("Xem phim"))   # None
print(spent.get("Xem phim", 0))  # 0
spent["Xem phim"]              # KeyError: 'Xem phim'

Kiểm tra khóa có trong dict hay không bằng toán tử in: "Ăn uống" in spent trả về True. Toán tử này chỉ xét khóa, không xét giá trị. Để tìm theo giá trị, viết 1200 in spent.values().

Thêm, sửa và xóa

Thêm hoặc cập nhật một bản ghi chỉ cần một câu gán. Kết hợp với get rất tiện cho việc đếm:

spent = {}
for category, amount in [("Ăn uống", 250), ("Taxi", 300), ("Ăn uống", 400)]:
    spent[category] = spent.get(category, 0) + amount
print(spent)   # {'Ăn uống': 650, 'Taxi': 300}

Xóa khóa bằng del d[k] (gây KeyError nếu khóa không có) hoặc d.pop(k, default) — cách này còn trả về giá trị đã xóa. Xóa toàn bộ dict bằng d.clear(). Độ dài của dict, tức số cặp, là len(d).

Bảng phương thức của dict

setdefault: điền dict bằng danh sách

Phương thức setdefault rất hữu ích khi giá trị là danh sách và bạn cần nhóm dữ liệu:

groups = {}
for item, cat in [("cà phê", "Ăn uống"), ("tàu điện", "Đi lại"), ("pizza", "Ăn uống")]:
    groups.setdefault(cat, []).append(item)
print(groups)   # {'Ăn uống': ['cà phê', 'pizza'], 'Đi lại': ['tàu điện']}

update: cập nhật dict

update thay đổi dict tại chỗ: khóa mới được thêm vào, khóa trùng sẽ bị ghi đè.

cfg = {"debug": False, "lang": "vi"}
cfg.update({"debug": True, "theme": "dark"})
print(cfg)   # {'debug': True, 'lang': 'vi', 'theme': 'dark'}

defaultdict: dict với giá trị mặc định

collections.defaultdict là lớp con của dict, khi truy cập một khóa chưa có, nó tự tạo giá trị bằng một hàm factory. Code đếm và nhóm nhờ đó ngắn hơn.

from collections import defaultdict

spent = defaultdict(int)
for cat, amount in [("Ăn uống", 250), ("Taxi", 300), ("Ăn uống", 400)]:
    spent[cat] += amount
print(dict(spent))   # {'Ăn uống': 650, 'Taxi': 300}

groups = defaultdict(list)
groups["Ăn uống"].append("cà phê")

Để đếm số lần xuất hiện đơn giản, còn có collections.Counter: Counter(["a", "b", "a"]) cho Counter({'a': 2, 'b': 1}).

Duyệt dictionary: vòng lặp for

Duyệt dict bằng vòng lặp for mặc định là duyệt theo khóa. Để nhận cả khóa và giá trị, hãy duyệt items() — đây là cách phổ biến nhất.

spent = {"Ăn uống": 650, "Taxi": 300}

for cat in spent:                    # các khóa
    print(cat)

for amount in spent.values():        # các giá trị
    print(amount)

for cat, amount in spent.items():    # các cặp
    print(f"{cat}: {amount} ₫")

Không được thay đổi kích thước dict ngay trong lúc duyệt — sẽ có RuntimeError: dictionary changed size during iteration. Nếu cần xóa một số khóa, hãy duyệt trên bản sao: for k in list(d):.

In dictionary ra màn hình

print(d) in dict trên một dòng. Với dict lớn hoặc lồng nhau, tiện hơn là module pprint hoặc json.dumps(d, ensure_ascii=False, indent=2) — kết quả có thụt đầu dòng và tiếng Việt không bị mã hóa thành ký tự escape.

Sắp xếp dictionary

Bản thân dict không được sắp xếp tại chỗ, nó không có phương thức sort. Sắp xếp dict nghĩa là tạo một dict mới từ các cặp đã sắp xếp bằng sorted.

spent = {"Taxi": 300, "Ăn uống": 650, "Xem phim": 120}

by_key = dict(sorted(spent.items()))
print(by_key)    # {'Ăn uống': 650, 'Taxi': 300, 'Xem phim': 120}

by_value = dict(sorted(spent.items(), key=lambda p: p[1], reverse=True))
print(by_value)  # {'Ăn uống': 650, 'Taxi': 300, 'Xem phim': 120}

Nếu chỉ cần top N danh mục, đừng chuyển kết quả trở lại thành dict: sorted(spent.items(), key=lambda p: p[1], reverse=True)[:2] trả về một danh sách các cặp.

Để sắp xếp một danh sách dict theo một trường: sorted(users, key=lambda u: u["age"]).

Gộp và cộng dictionary

Từ Python 3.9, dict có thể gộp bằng toán tử |, còn |= cập nhật dict tại chỗ. Khi trùng khóa, toán hạng bên phải thắng.

a = {"x": 1, "y": 2}
b = {"y": 20, "z": 3}
print(a | b)          # {'x': 1, 'y': 20, 'z': 3}
print({**a, **b})     # cùng kết quả, qua giải nén
a |= b                # tương đương a.update(b)

Lưu ý: a + b với dict không hoạt động, sẽ gây TypeError. Nếu muốn cộng giá trị theo các khóa trùng nhau, dùng Counter: Counter(a) + Counter(b).

Giải nén dictionary

Hai dấu sao ** giải nén dict thành các tham số có tên của hàm hoặc thành một dict khác:

def greet(name, city):
    return f"{name} đến từ {city}"

data = {"name": "Lan", "city": "Hà Nội"}
print(greet(**data))   # Lan đến từ Hà Nội

Dict comprehension

Dict comprehension tạo một dict từ bất kỳ dãy nào chỉ trong một dòng:

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

big = {k: v for k, v in spent.items() if v > 200}

inverted = {v: k for k, v in {"a": 1, "b": 2}.items()}
print(inverted)  # {1: 'a', 2: 'b'}

Ví dụ cuối là cách đảo dict, hoán đổi khóa và giá trị cho nhau. Cách này chỉ đúng khi các giá trị là duy nhất và băm được; nếu không, một số cặp sẽ bị mất.

Dictionary lồng nhau

Giá trị có thể là một dict khác — đây là cách mô tả các cấu trúc như phản hồi JSON của API hay dict của dict người dùng.

users = {
    101: {"name": "Lan", "skills": ["python", "sql"]},
    102: {"name": "Nam", "skills": ["go"]},
}
print(users[101]["skills"][0])            # python
print(users.get(103, {}).get("name"))     # None, không có KeyError

Sao chép dictionary: bản sao và tên thứ hai

Câu lệnh b = a không sao chép dict, nó chỉ gắn thêm một tên thứ hai vào cùng đối tượng. Thay đổi qua b sẽ thấy trong a. Điều tương tự xảy ra khi truyền dict vào hàm: hàm nhận tham chiếu tới đối tượng dùng chung và có thể làm hỏng nó mà không báo lỗi.

import copy

a = {"limits": [0, 500]}
b = a.copy()              # bản sao nông
b["limits"].append(1000)  # danh sách bên trong vẫn dùng chung!
print(a)                  # {'limits': [0, 500, 1000]}

c = copy.deepcopy(a)      # bản sao độc lập hoàn toàn

So sánh dictionary

Toán tử == so sánh dict theo nội dung: chúng bằng nhau khi mọi cặp trùng khớp. Thứ tự khóa không được xét: {"a": 1, "b": 2} == {"b": 2, "a": 1} cho True. Để tìm các khóa chung, dùng phép toán tập hợp trên các view: a.keys() & b.keys().

Dictionary có kiểu: chú thích

Chú thích kiểu cho dict viết như dict[str, int]. Nếu dict có một tập trường cố định với các kiểu khác nhau, tiện hơn là TypedDict từ module typing:

from typing import TypedDict

class User(TypedDict):
    name: str
    age: int

u: User = {"name": "Lan", "age": 30}

Chú thích kiểu không được kiểm tra khi chạy chương trình; chúng được IDE và các công cụ phân tích như mypy đọc.

Dictionary bất biến: frozendict trong Python 3.15

Python 3.15 bổ sung kiểu tích hợp frozendict (PEP 814): không cần import, và cố gắng sửa nó sẽ gây TypeError ngay lập tức. Trước đây, dict bất biến phải làm bằng một lớp bọc từ module types hoặc gói bên thứ ba. Đây chính xác là thứ cần cho các cấu hình dùng chung mà không hàm nào được âm thầm thay đổi.

config = frozendict(min_amount=0, max_amount=500)
config["max_amount"] = 1000
# TypeError: 'frozendict' object does not support item assignment

strict = config | {"max_amount": 300}   # frozendict mới, bản gốc vẫn nguyên
cache = {config: "báo cáo tháng 5"}     # băm được — dùng làm khóa được

Những điều cần biết, theo tài liệu của khóa học:

• frozendict kế thừa từ object, không kế thừa từ dict, nên isinstance(cfg, dict) sẽ trả về False. Để kiểm tra «bất kỳ dict nào», dùng collections.abc.Mapping hoặc isinstance(x, (dict, frozendict)).
• Nó chỉ băm được khi các khóa và giá trị đều băm được: frozendict(a=[1]) vẫn tạo được, nhưng hash() sẽ lỗi. Tính bất biến là nông, giống như tuple.
• Thứ tự được giữ, nhưng == không xét đến nó.
• json.dumps, pickle và copy đều hỗ trợ frozendict.

Lỗi thường gặp

• KeyError khi đọc — dùng get hoặc kiểm tra bằng in.
• List làm khóa — đổi thành tuple: d[tuple(lst)].
• Thay đổi dict trong vòng lặp — duyệt trên list(d).
• Kỳ vọng phép gán tạo bản sao — hãy dùng copy() hoặc deepcopy.
• {} thay cho set rỗng — đó là dict rỗng.

Tổng kết

Dict trong Python là cấu trúc dữ liệu chủ đạo của ngôn ngữ: tìm kiếm nhanh theo khóa, giữ thứ tự thêm vào, các phương thức tiện dụng như get, setdefault, update, duyệt qua items(), sắp xếp bằng sorted và gộp bằng toán tử |. Hãy nhớ về việc sao chép và khóa phải băm được; với cấu hình trong Python 3.15, dùng frozendict. Dict, list, tuple và set được thực hành trong khóa học «Python 3.15: từ người mới đến chuyên nghiệp» qua ví dụ trình theo dõi chi tiêu.