So sánh List, Tuple, Dictionary, Set

▶ Xem trên YouTube

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": "alice@example.com"
}

# Đế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