So sánh List, Tuple, Dictionary, Set

1. Tổng quan về 4 kiểu dữ liệu

Python cung cấp 4 kiểu dữ liệu tập hợp (Collection) chính:

Kiểu dữ liệu	Ký hiệu	Có thứ tự	Có thể thay đổi	Cho phép trùng lặp
List	`[]`	✅ Có	✅ Có	✅ Có
Tuple	`()`	✅ Có	❌ Không	✅ Có
Dictionary	`{}`	✅ Có (3.7+)	✅ Có	Key: Không, Value: Có
Set	`{}`	❌ Không	✅ Có	❌ Không

# Ví dụ tạo 4 kiểu dữ liệu
my_list = [1, 2, 3, 2, 1]           # List - cho phép trùng lặp
my_tuple = (1, 2, 3, 2, 1)          # Tuple - cho phép trùng lặp
my_dict = {"a": 1, "b": 2, "c": 3}  # Dictionary - key-value pairs
my_set = {1, 2, 3}                   # Set - không trùng lặp

2. So sánh chi tiết

2.1. Cách tạo

# List - dùng ngoặc vuông []
fruits_list = ["apple", "banana", "orange"]
empty_list = []

# Tuple - dùng ngoặc tròn ()
fruits_tuple = ("apple", "banana", "orange")
single_tuple = (1,)  # Cần dấu phẩy cho tuple 1 phần tử
empty_tuple = ()

# Dictionary - dùng ngoặc nhọn {} với cặp key:value
person = {"name": "Alice", "age": 25}
empty_dict = {}

# Set - dùng ngoặc nhọn {} (không có key:value)
numbers_set = {1, 2, 3, 4, 5}
empty_set = set()  # KHÔNG dùng {} vì đó là dict rỗng!

2.2. Có thứ tự (Ordered)

# List - CÓ thứ tự, phần tử giữ nguyên vị trí
my_list = ["a", "b", "c"]
print(my_list[0])  # "a" - luôn là phần tử đầu tiên

# Tuple - CÓ thứ tự (giống List)
my_tuple = ("a", "b", "c")
print(my_tuple[1])  # "b" - luôn là phần tử thứ 2

# Dictionary - CÓ thứ tự (từ Python 3.7+)
my_dict = {"first": 1, "second": 2, "third": 3}
for key in my_dict:
    print(key)  # Luôn in: first, second, third

# Set - KHÔNG có thứ tự
my_set = {3, 1, 2}
print(my_set)  # Có thể in: {1, 2, 3} hoặc thứ tự khác
# KHÔNG thể truy cập bằng index: my_set[0] sẽ LỖI!

2.3. Có thể thay đổi (Mutable)

# List - CÓ THỂ thay đổi
my_list = [1, 2, 3]
my_list[0] = 10        # Sửa: [10, 2, 3]
my_list.append(4)      # Thêm: [10, 2, 3, 4]
my_list.remove(2)      # Xoá: [10, 3, 4]

# Tuple - KHÔNG THỂ thay đổi
my_tuple = (1, 2, 3)
# my_tuple[0] = 10     # LỖI: TypeError
# my_tuple.append(4)   # LỖI: AttributeError
# Muốn "thay đổi" phải tạo tuple mới
my_tuple = my_tuple + (4,)  # (1, 2, 3, 4)

# Dictionary - CÓ THỂ thay đổi
my_dict = {"a": 1}
my_dict["a"] = 10      # Sửa value: {"a": 10}
my_dict["b"] = 2       # Thêm: {"a": 10, "b": 2}
del my_dict["a"]       # Xoá: {"b": 2}

# Set - CÓ THỂ thay đổi (thêm/xoá, không sửa trực tiếp)
my_set = {1, 2, 3}
my_set.add(4)          # Thêm: {1, 2, 3, 4}
my_set.remove(1)       # Xoá: {2, 3, 4}
# KHÔNG thể sửa trực tiếp phần tử, phải xoá rồi thêm mới

2.4. Cho phép trùng lặp (Duplicates)

# List - CHO PHÉP trùng lặp
my_list = [1, 2, 2, 3, 3, 3]
print(my_list)  # [1, 2, 2, 3, 3, 3] - giữ nguyên

# Tuple - CHO PHÉP trùng lặp
my_tuple = (1, 2, 2, 3, 3, 3)
print(my_tuple)  # (1, 2, 2, 3, 3, 3) - giữ nguyên

# Dictionary - Key KHÔNG được trùng, Value có thể trùng
my_dict = {"a": 1, "b": 1, "a": 2}  # Key "a" bị trùng
print(my_dict)  # {"a": 2, "b": 1} - key sau ghi đè key trước

# Set - KHÔNG cho phép trùng lặp
my_set = {1, 2, 2, 3, 3, 3}
print(my_set)  # {1, 2, 3} - tự động loại bỏ trùng lặp

3. Hiệu suất (Performance)

Thao tác	List	Tuple	Dictionary	Set
Truy cập theo index	O(1)	O(1)	❌	❌
Truy cập theo key	❌	❌	O(1)	❌
Tìm kiếm (`in`)	O(n)	O(n)	O(1)	O(1)
Thêm cuối	O(1)	❌	O(1)	O(1)
Xoá phần tử	O(n)	❌	O(1)	O(1)
Bộ nhớ sử dụng	Trung bình	Ít nhất	Nhiều nhất	Trung bình

Kết luận:

Dictionary và Set rất nhanh khi tìm kiếm hoặc kiểm tra phần tử
Tuple tiết kiệm bộ nhớ nhất
List linh hoạt nhất khi cần thay đổi

4. Khi nào dùng kiểu dữ liệu nào?

Dùng List khi:

Cần lưu trữ các phần tử có thứ tự và có thể trùng lặp
Cần thay đổi (thêm, xoá, sửa) các phần tử thường xuyên
Cần truy cập theo index

# Danh sách học sinh (có thể thay đổi, có thứ tự)
students = ["Alice", "Bob", "Charlie"]
students.append("David")

# Lịch sử hoạt động (có thứ tự, có thể trùng lặp)
history = ["login", "view", "login", "logout"]

Dùng Tuple khi:

Dữ liệu không cần thay đổi (immutable)
Cần hiệu suất tốt hơn và tiết kiệm bộ nhớ
Cần dùng làm key trong Dictionary hoặc phần tử trong Set

# Toạ độ (không đổi)
point = (10, 20)

# Thông tin cố định
rgb_red = (255, 0, 0)
date = (2025, 1, 15)

# Làm key cho dictionary
locations = {
    (10, 20): "Point A",
    (30, 40): "Point B"
}

Dùng Dictionary khi:

Cần lưu trữ dữ liệu dạng key-value
Cần tra cứu nhanh theo key
Cần lưu trữ thông tin có cấu trúc

# Thông tin người dùng
user = {
    "name": "Alice",
    "age": 25,
    "email": "[email protected]"
}

# Đếm tần suất
word_count = {"hello": 5, "world": 3}

# Cấu hình ứng dụng
config = {
    "debug": True,
    "port": 8080,
    "database": "mysql"
}

Dùng Set khi:

Cần lưu trữ các phần tử duy nhất
Cần thực hiện các phép toán tập hợp (hợp, giao, hiệu)
Cần kiểm tra membership nhanh

# Loại bỏ trùng lặp
numbers = [1, 2, 3, 2, 1, 4, 3]
unique = set(numbers)  # {1, 2, 3, 4}

# Kiểm tra quyền truy cập
admin_users = {"alice", "bob", "admin"}
if username in admin_users:
    print("Granted")

# Tìm phần tử chung
class_a = {"Alice", "Bob", "Charlie"}
class_b = {"Bob", "David", "Eve"}
both = class_a & class_b  # {"Bob"}

5. Tóm tắt

Tiêu chí	List	Tuple	Dictionary	Set
Có thứ tự	✅	✅	✅ (3.7+)	❌
Có thể thay đổi	✅	❌	✅	✅
Cho phép trùng lặp	✅	✅	Key: ❌	❌
Truy cập index	✅	✅	❌	❌
Truy cập key	❌	❌	✅	❌
Tìm kiếm nhanh	❌	❌	✅	✅
Làm key Dict	❌	✅	❌	❌
Tiết kiệm bộ nhớ	🔸	✅	❌	🔸

Quy tắc đơn giản:

Cần thay đổi + có thứ tự → List
Không thay đổi + tiết kiệm bộ nhớ → Tuple
Tra cứu theo key → Dictionary
Loại bỏ trùng lặp + phép toán tập hợp → Set