Bài 07 – Cấu Trúc Dữ Liệu List Trong Python

Giới thiệu: List (danh sách) là một trong những cấu trúc dữ liệu quan trọng và linh hoạt nhất trong Python, cho phép lưu trữ và quản lý tập hợp các phần tử một cách hiệu quả.

Mục tiêu bài học:
– Hiểu khái niệm và cách tạo list trong Python
– Thành thạo các thao tác truy cập, thêm, sửa, xóa phần tử
– Sử dụng các phương thức và hàm built-in với list
– Áp dụng list comprehension để tạo list hiệu quả
– Giải quyết bài toán thực tế sử dụng list


1. Khái Niệm

Khái niệm: List là một cấu trúc dữ liệu có các đặc điểm:

  • Có thứ tự: Các phần tử được lưu trữ theo một trình tự xác định
  • Có thể thay đổi (mutable): Có thể thêm, xóa, sửa phần tử sau khi tạo
  • Cho phép trùng lặp: Có thể chứa nhiều phần tử có cùng giá trị
  • Hỗ trợ nhiều kiểu dữ liệu: Có thể chứa số, chuỗi, boolean, thậm chí các List khác

Ví dụ

# List chứa số nguyên
so_nguyen = [1, 2, 3, 4, 5]

# List chứa chuỗi
hoa_qua = ["táo", "chuối", "cam"]

# List hỗn hợp
hoan_hop = [1, "hello", 3.14, True]

# List rỗng
rong = []

Cú pháp tạo list:

# Tạo list rỗng
danh_sach_rong = []

# Tạo list với các phần tử trực tiếp
so_nguyen = [1, 2, 3, 4, 5]
chuoi_ky_tu = ["apple", "banana", "cherry"]
hoan_hop = [1, "hello", 3.14, True]

# Sử dụng hàm tạo: list()
tu_list = list(("a", "b", "c"))

# Tạo từ range()
list4 = list(range(5))   # [0, 1, 2, 3, 4]

# Tạo với giá trị mặc định
list5 = [0] * 5          # [0, 0, 0, 0, 0]

2. Truy Cập Phần Tử Trong List

Truy cập theo chỉ số: Trong Python,

  • Tính từ TRÁI->PHẢI: vị trí của phần tử đầu tiên là 0
    • [a, b, c, d, e], vị trí tương ứng
    • 0 1 2 3 4
  • Tính từ PHẢI<–TRÁI: vị trí của phần tử đầu tiên là -1
    • [a, b, c, d, e], vị trí tương ứng
    • -5 -4 -3 -2 -1
danh_sach = ["a", "b", "c", "d", "e"]
print(danh_sach[0])    # "a" - phần tử đầu
print(danh_sach[-1])   # "e" - phần tử cuối
print(danh_sach[1:4])  # ["b", "c", "d"] - cắt list

Duyệt qua list:

fruits = ["táo", "chuối", "cam"]

# Duyệt theo giá trị
for qua in fruits:
    print(qua)

# Duyệt theo chỉ số
for i in range(len(fruits)):
    print(f"Vị trí {i}: {fruits[i]}")

# Duyệt với enumerate
for index, value in enumerate(fruits):
    print(f"fruits[{index}] = {value}")

Cắt List (Slicing): Cú pháp: list[start : stop : step]

Trích lấy các phần tử trong danh sách, tính từ vị trí start , trong khoảng [stop đến stop), cách nhau step vị trí

  • Nếu start rỗng: –> start =0
  • Nếp stop rỗng: –> stop là cuối danh sách
  • Step rỗng (mạc địch): –> step=1
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Cú pháp: list[start:stop:step]
print(numbers[2:5])     # [2, 3, 4] - từ vị trí 2 đến 4
print(numbers[:4])      # [0, 1, 2, 3] - từ đầu đến 3
print(numbers[6:])      # [6, 7, 8, 9] - từ 6 đến cuối
print(numbers[::2])     # [0, 2, 4, 6, 8] - cách 2 phần tử
print(numbers[::-1])    # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] - đảo ngược

3. Các Thao Tác Cơ Bản Với List

A. Thêm phần tử:

ds = [1, 2, 3]
ds.append(4)           # [1, 2, 3, 4]
ds.insert(1, 1.5)      # [1, 1.5, 2, 3, 4]
ds.extend([5, 6])      # [1, 1.5, 2, 3, 4, 5, 6]

B. Sửa phần tử:

ds = ["a", "b", "c"]
ds[1] = "B"            # ["a", "B", "c"]
ds[0:2] = ["A", "B"]   # ["A", "B", "c"]

C. Xóa phần tử:

ds = [1, 2, 3, 4, 5]
ds.remove(3)           # Xóa phần tử có giá trị 3
del ds[0]              # Xóa phần tử tại vị trí 0
popped = ds.pop()      # Xóa và trả về phần tử cuối
ds.clear()             # Xóa toàn bộ list

D. Tìm kiếm và đếm:

letters = ["a", "b", "c", "a", "d", "b"]

# index(): tìm vị trí đầu tiên
vi_tri = letters.index("c")      # 2
# letters.index("x")             # ValueError: 'x' is not in list

# count(): đếm số lần xuất hiện
dem_a = letters.count("a")       # 2
dem_x = letters.count("x")       # 0

# Kiểm tra tồn tại
co_b = "b" in letters            # True
khong_co_z = "z" not in letters  # True

E. Sắp xếp, đảo ngược, tạo bản sao mới:

numbers = [3, 1, 4, 1, 5, 9, 2]

# Sắp xếp
numbers.sort()                    # [1, 1, 2, 3, 4, 5, 9]
numbers.sort(reverse=True)        # [9, 5, 4, 3, 2, 1, 1]

# Đảo ngược
numbers.reverse()                 # [1, 1, 2, 3, 4, 5, 9] → [9, 5, 4, 3, 2, 1, 1]

# Sao chép
copy_list = numbers.copy()        # Tạo bản sao độc lập

4. Các Thao Tác Khác

A. Độ dài và kiểm tra rỗng:

my_list = [1, 2, 3]

# len(): độ dài list
do_dai = len(my_list)    # 3

# Kiểm tra rỗng
if not my_list:
    print("List rỗng")
else:
    print(f"List có {len(my_list)} phần tử")

B. Nối và lặp List:

list1 = [1, 2, 3]
list2 = [4, 5, 6]

# Nối list
combined = list1 + list2      # [1, 2, 3, 4, 5, 6]

# Lặp list
repeated = list1 * 3          # [1, 2, 3, 1, 2, 3, 1, 2, 3]

# So sánh list
print([1, 2, 3] == [1, 2, 3]) # True
print([1, 2, 3] == [3, 2, 1]) # False

5. List Comprehension

Cú pháp: [biểu_thức for phần_tử in iterable if điều_kiện]

tạo danh sách các phần tử, với giá trị mỗi phần tử = giá trị biểu thức

Ví dụ:

# Tạo list bình phương
binh_phuong = [x**2 for x in range(1, 6)]    # [1, 4, 9, 16, 25]

# Lọc số chẵn
so_chan = [x for x in range(10) if x % 2 == 0]  # [0, 2, 4, 6, 8]

# Biến đổi chuỗi
chuoi = ["hello", "world", "python"]
chu_hoa = [s.upper() for s in chuoi]          # ["HELLO", "WORLD", "PYTHON"]

6. Các Hàm Built-in Với List

numbers = [1, 2, 3, 4, 5]

print(len(numbers))        # 5 - độ dài list
print(min(numbers))        # 1 - giá trị nhỏ nhất
print(max(numbers))        # 5 - giá trị lớn nhất
print(sum(numbers))        # 15 - tổng các phần tử

# Kiểm tra tồn tại
print(3 in numbers)        # True
print(6 not in numbers)    # True

Bài Tập Trắc nghiệm:

https://tiilaz.com/lap-trinh-python/lap-trinh-python-co-ban/20-cau-hoi-trac-nghiem-tren-list-cua-python/

Bài Tập Thực Hành Cơ Bản

Bài 1: Nhập 5 số từ bàn phím vào List và tính tổng

Bài 2: Tạo List có 10 số, tìm số lớn nhất và nhỏ nhất

Bài 3: Nhập List số nguyên, đếm số chẵn và số lẻ

Bài 4: Tạo bản sao đảo ngược của một List (không dùng reverse())

Bài 5: Kiểm tra số x có trong List không, nếu có thì ở vị trí nào

Bài 6: Nhập List số, sắp xếp theo thứ tự tăng dần

Bài 7: Tính điểm trung bình của List điểm số

Bài 8: Xóa tất cả phần tử có giá trị x trong List

Bài 9: Gộp hai List số nguyên thành một List mới

Bài 10: Nhập một câu, tách thành List các từ, tìm từ dài nhất

Bài tập khác:

Bài 11: Đếm số lần xuất hiện của từng phần tử trong list

Bài 12: Tìm phần tử xuất hiện nhiều nhất trong list

Bài 13: Xóa tất cả phần tử trùng lặp, giữ thứ tự ban đầu

Bài 13: Tạo ma trận 3×3 sử dụng list lồng nhau

Lưu Ý Quan Trọng

  1. Mutable: List có thể thay đổi sau khi tạo
  2. Tham chiếu: Gán trực tiếp tạo tham chiếu, dùng copy() để tạo bản sao
  3. Hiệu năng: append() nhanh hơn insert(0) với list lớn
  4. List comprehension: Hiệu quả và ngắn gọn hơn vòng lặp thông thường

Tóm Tắt

  • List linh hoạt cho lưu trữ tập hợp phần tử có thứ tự
  • Truy cập bằng chỉ số, cắt list, duyệt bằng vòng lặp
  • Thao tác thêm, sửa, xóa với các phương thức đa dạng
  • List comprehension công cụ mạnh để tạo và biến đổi list
  • Ứng dụng rộng rãi trong xử lý dữ liệu, algorithm

Comments are closed.