Khóa học Python từ Cơ bản đến Nâng cao

Bài 3.1. Thao tác chuỗi trong Python: slicing

Chào mừng các bạn đến với bài học về slicing trong Python! Chuỗi (string) là một trong những kiểu dữ liệu cơ bản và cực kỳ quan trọng mà bạn sẽ gặp thường xuyên khi lập trình. Việc thao tác hiệu quả với chuỗi, như trích xuất một phần, đảo ngược, hay lấy các ký tự theo một quy luật nào đó, là kỹ năng không thể thiếu. Và slicing chính là công cụ mạnh mẽ và linh hoạt mà Python cung cấp để giúp bạn thực hiện những điều đó một cách dễ dàng.

Hãy cùng khám phá cách "cắt lát" chuỗi trong Python nhé!

Cú pháp Slicing cơ bản

Slicing trong Python sử dụng dấu ngoặc vuông [] với tối đa ba tham số, được phân tách bằng dấu hai chấm :, theo cấu trúc:

ten_chuoi[start:stop:step]

Trong đó:

1. start: Chỉ số (index) của ký tự bắt đầu lấy chuỗi con. Nếu bỏ qua, mặc định là 0 (ký tự đầu tiên).
2. stop: Chỉ số của ký tự kết thúc chuỗi con. Quan trọng: Python sẽ lấy đến ký tự có chỉ số stop - 1. Nghĩa là, ký tự tại chỉ số stop sẽ không được bao gồm trong kết quả. Nếu bỏ qua, mặc định là đến hết chuỗi.
3. step: Bước nhảy. Xác định khoảng cách giữa các ký tự được chọn. Nếu bỏ qua, mặc định là 1 (lấy tất cả các ký tự liên tiếp).

Hãy xem xét chuỗi ví dụ sau để minh họa:

my_string = "Học lập trình Python thật thú vị!"
# Chỉ số:   01234567890123456789012345678901
#           Học lập trình Python thật thú vị!
# Chỉ số âm:-23...        ...-3-2-1

Lưu ý:

• Chỉ số trong Python bắt đầu từ 0.
• Bạn cũng có thể sử dụng chỉ số âm, với -1 là ký tự cuối cùng, -2 là ký tự kế cuối, và cứ thế tiếp tục.

Các ví dụ về Slicing

1. Lấy chuỗi con từ đầu đến một vị trí cụ thể

Để lấy phần đầu của chuỗi, bạn chỉ cần chỉ định stop. start sẽ mặc định là 0.

my_string = "Học lập trình Python thật thú vị!"

# Lấy 3 ký tự đầu tiên ("Học")
substring1 = my_string[:3]
print(f"Kết quả 1: '{substring1}'")

# Lấy từ đầu đến hết chữ "Python" (chỉ số của khoảng trắng sau 'n' là 18)
substring2 = my_string[:18]
print(f"Kết quả 2: '{substring2}'")

Giải thích:

• my_string[:3] lấy từ chỉ số 0 (mặc định) đến trước chỉ số 3. Kết quả là các ký tự tại chỉ số 0, 1, 2, tức là "Học".
• my_string[:18] lấy từ chỉ số 0 đến trước chỉ số 18. Kết quả là "Học lập trình Python".

2. Lấy chuỗi con từ một vị trí cụ thể đến hết chuỗi

Để lấy phần cuối của chuỗi, bạn chỉ cần chỉ định start. stop sẽ mặc định là đến hết chuỗi.

my_string = "Học lập trình Python thật thú vị!"

# Lấy từ "Python" (chỉ số 'P' là 12) đến hết chuỗi
substring3 = my_string[12:]
print(f"Kết quả 3: '{substring3}'")

# Lấy từ "thú vị!" (chỉ số 't' là 24) đến hết chuỗi
substring4 = my_string[24:]
print(f"Kết quả 4: '{substring4}'")

Giải thích:

• my_string[12:] lấy từ chỉ số 12 (ký tự 'P') cho đến hết chuỗi.
• my_string[24:] lấy từ chỉ số 24 (ký tự 't' trong "thú") cho đến hết chuỗi.

3. Lấy chuỗi con trong một khoảng xác định

Đây là trường hợp bạn cung cấp cả start và stop.

my_string = "Học lập trình Python thật thú vị!"

# Lấy chữ "lập trình" (từ chỉ số 4 đến trước chỉ số 11)
substring5 = my_string[4:11]
print(f"Kết quả 5: '{substring5}'")

# Lấy chữ "Python" (từ chỉ số 12 đến trước chỉ số 18)
substring6 = my_string[12:18]
print(f"Kết quả 6: '{substring6}'")

Giải thích:

• my_string[4:11] lấy từ chỉ số 4 ('l') đến chỉ số 10 ('h').
• my_string[12:18] lấy từ chỉ số 12 ('P') đến chỉ số 17 ('n').

4. Sử dụng chỉ số âm (Negative Indexing)

Chỉ số âm rất hữu ích khi bạn muốn làm việc với phần cuối của chuỗi mà không cần biết độ dài chính xác của nó.

my_string = "Học lập trình Python thật thú vị!"

# Lấy 3 ký tự cuối cùng ("vị!")
# -1 là '!', -2 là 'ị', -3 là 'v'
substring7 = my_string[-3:]
print(f"Kết quả 7: '{substring7}'")

# Lấy từ ký tự thứ 5 từ cuối ('ú') đến ký tự thứ 2 từ cuối ('ị')
# Chỉ số 'ú' là -5, chỉ số '!' là -1. Cần lấy đến trước '!', tức là stop=-1
substring8 = my_string[-5:-1]
print(f"Kết quả 8: '{substring8}'")

# Lấy toàn bộ chuỗi ngoại trừ ký tự đầu tiên và cuối cùng
substring9 = my_string[1:-1]
print(f"Kết quả 9: '{substring9}'")

Giải thích:

• my_string[-3:] lấy từ chỉ số -3 ('v') đến hết chuỗi.
• my_string[-5:-1] lấy từ chỉ số -5 ('ú') đến trước chỉ số -1 ('!'). Kết quả là "ú vị".
• my_string[1:-1] lấy từ chỉ số 1 ('ọ') đến trước chỉ số -1 ('!').

5. Sử dụng bước nhảy step

Tham số step cho phép bạn lấy các ký tự không liên tục.

my_string = "0123456789"

# Lấy các ký tự ở chỉ số chẵn (0, 2, 4, ...)
substring10 = my_string[::2]
print(f"Kết quả 10: '{substring10}'")

# Lấy các ký tự ở chỉ số lẻ (1, 3, 5, ...)
substring11 = my_string[1::2]
print(f"Kết quả 11: '{substring11}'")

# Lấy các ký tự từ chỉ số 1 đến 7 với bước nhảy là 3 (1, 4, 7)
substring12 = my_string[1:8:3] # stop là 8 để bao gồm chỉ số 7
print(f"Kết quả 12: '{substring12}'")

Giải thích:

• my_string[::2] bắt đầu từ 0 (mặc định), kết thúc ở cuối chuỗi (mặc định), và lấy mỗi 2 ký tự.
• my_string[1::2] bắt đầu từ 1, kết thúc ở cuối chuỗi, và lấy mỗi 2 ký tự.
• my_string[1:8:3] bắt đầu từ 1, dừng trước 8, và lấy mỗi 3 ký tự (tại chỉ số 1, 1+3=4, 4+3=7).

6. Đảo ngược chuỗi – Một ứng dụng kinh điển của Slicing!

Đây là một mẹo cực kỳ phổ biến và thanh lịch trong Python để đảo ngược một chuỗi: sử dụng step = -1.

my_string = "FullhouseDev"
reversed_string = my_string[::-1]
print(f"Chuỗi gốc: '{my_string}'")
print(f"Chuỗi đảo ngược: '{reversed_string}'")

my_string2 = "Python"
reversed_string2 = my_string2[::-1]
print(f"Chuỗi gốc: '{my_string2}'")
print(f"Chuỗi đảo ngược: '{reversed_string2}'")

Giải thích:

• my_string[::-1] không chỉ định start và stop (nghĩa là áp dụng cho toàn bộ chuỗi), nhưng có step = -1. Điều này yêu cầu Python duyệt chuỗi từ cuối về đầu, dẫn đến kết quả là chuỗi đảo ngược. Đây là một cách rất Pythonic!

Lưu ý quan trọng: Tính bất biến của chuỗi

Một điều rất quan trọng cần nhớ là chuỗi trong Python là bất biến (immutable). Điều này có nghĩa là bạn không thể thay đổi nội dung của một chuỗi đã tồn tại.

Khi bạn thực hiện slicing, Python không sửa đổi chuỗi gốc. Thay vào đó, nó tạo ra một chuỗi mới chứa kết quả của phép slicing.

original = "Xin chào"
sliced = original[0:3] # Tạo chuỗi mới "Xin"

print(f"Chuỗi gốc: {original}, ID: {id(original)}")
print(f"Chuỗi slice: {sliced}, ID: {id(sliced)}")

# original[0] = 'x' # Dòng này sẽ gây lỗi TypeError!

Việc hiểu rõ tính bất biến và cách slicing tạo chuỗi mới là rất quan trọng để tránh các lỗi logic không mong muốn.

Slicing là một kỹ thuật vô cùng mạnh mẽ và tiện lợi trong Python. Nắm vững nó sẽ giúp bạn xử lý chuỗi một cách hiệu quả hơn rất nhiều trong các dự án của mình. Hãy thực hành với nhiều chuỗi và các giá trị start, stop, step khác nhau để cảm nhận sự linh hoạt của nó!