Hướng dẫn dùng slicing python python

Tiếp tục với chủ đề các hàm tích hợp sẵn trong Python, bài viết sẽ giới thiệu cho các bạn về hàm slice() với cú pháp, cách sử dụng cũng như các ví dụ cụ thể. Mời bạn đọc theo dõi.

Hàm slice() trong Python trả về một slice object. Đối tượng này giúp bạn xác định cách cắt một chuỗi có sẵn (có thể là string, bytes, tuple, list, range) hoặc các đối tượng hỗ trợ giao thức chuỗi (như _getitem__(), __len__()).

Cú pháp hàm slice() trong Python:

slice(stop)   slice(start, stop, step)

Các tham số của hàm slice()

Hàm slice() có thể có tới 3 tham số:

Nếu chỉ truyền một tham số vào slice() thì start và step không có giá trị.

Giá trị trả về từ slice()

Hàm slice() trả về một slice object sử dụng để cắt một chuỗi theo các chỉ mục tương ứng truyền trong hàm.

1. Khởi tạo list

Để khởi tạo một list, cách nhanh nhất là dùng cặp [] đại diện cho kiểu dữ liệu List.

# Create an empty list
empty_list = []

# Create a list of numbers
integer_list = [2, 3, 5]

# Create a list of string
string_list = ['code', 'learn', 'lap-trinh']

# create a list of some type
mixed_list = ['code', 'learn', 'lap-trinh', 'so', 0, True, ['hoc', 'lap', 'trinh']]

print(f"empty_list: {empty_list}")
print(f"integer_list: {integer_list}")
print(f"string_list: {string_list}")
print(f"mixed_list: {mixed_list}")

empty_list: []
integer_list: [2, 3, 5]
string_list: ['code', 'learn', 'lap-trinh']
mixed_list: ['code', 'learn', 'lap-trinh', 'so', 0, True, ['hoc', 'lap', 'trinh']]

Python cung cấp built-in function list() để thực hiện khởi tạo một List với đầu vào là một kiểu dữ liệu khác. Cách dùng này giống như là đang convert kiểu dữ liệu vậy.

# Create a list from a tuple
my_tuple = (1, 1, 2, 3, 5, 8)
tuple_list = list(my_tuple)


# Create a list from the range()
integer_range_list = list(range(10))

# Create a list from a string
letter_list = list('codelearn')

print(f"tuple_list: {tuple_list}")
print(f"integer_range_list: {integer_range_list}")
print(f"letter_list: {letter_list}")
tuple_list: [1, 1, 2, 3, 5, 8]
integer_range_list: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
letter_list: ['c', 'o', 'd', 'e', 'l', 'e', 'a', 'r', 'n']

Như ví dụ trên, ta thấy List có thể chứa được các kiểu dữ liệu khác nhau: number, string, list,…

2. Các toán tử với List

Kiểu dữ liệu List hỗ trợ toán tử +, tương đương với việc cộng hai List vào nhau.

operator_1 = [1, 2, 3]
operator_2 = [3, 4, 5]
result = operator_1 + operator_2
print(f"{operator_1} + {operator_2} = {result}")

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

Với phép toán số học, List hỗ trợ phép toán * với một số, tương đương với việc “gấp thếp” thêm số phần tử vào List

number_list = [1, 2, 3]
print(number_list * 2)
print(number_list * 3)

[1, 2, 3, 1, 2, 3]
[1, 2, 3, 1, 2, 3, 1, 2, 3]

3. Kiểm tra số lượng phần tử/rỗng

Để kiểm tra số lượng phần tử trong List, chúng ta sẽ dùng built-in function len()

number_list = [1, 2, 3, 3, 4, 5]
len_of_list = len(number_list)
print(f'{number_list} have {len_of_list} item')

[1, 2, 3, 3, 4, 5] have 6 item

Nếu một List rỗng (số lượng phần tử = 0), tương đương với giá trị Faulty

empty_list = []
print(bool(empty_list))

if not empty_list:
    print("Empty list")

False
Empty list

4. Index

Để lấy ra một phần tử trong List chúng ta truy xuất vào List theo index (số thứ tự của phần tử trong List).
Như phần lớn các ngôn ngữ lập trình, index trong List của Python được đánh số thứ tự từ 0.
Do đánh số thứ tự từ 0 nên phần tử cuối cùng của List sẽ là len(List) – 1.

# a list has value equal index.
number_list = [0, 1, 2, 3, 4, 5, 6]

print("First index: ", number_list[0])
print("Second index: ", number_list[1])
print("Third index: ", number_list[2])
print("Last index:", number_list[len(number_list) - 1])

First index: 0
Second index: 1
Third index: 2
Last index: 6

Câu lệnh lấy ra giá trị cuối cùng của List ở trên là thường dùng cho các ngôn ngữ lập trình C-Style, ở Python, các Pythonista không làm như vậy.
Python cung cấp một loại index có giá trị “âm”, ví dụ: -1 tương đương với len(number_list) – 1,  -2 tương đương với len(number_list) – 2

print("Last index by len:", number_list[len(number_list) - 1])
print("Last index by negative index:", number_list[-1])

print("Downward index by len:", number_list[len(number_list) - 2])
print("Downward index by negative index:", number_list[-2])

Last index by len: 6
Last index by negative index: 6
Downward index by len: 5
Downward index by negative index: 5

5. Slice & Slicing

Trong quá trình sử dụng, có lúc chúng ta sẽ phải thực hiện xử lý dữ liệu trong một tập con của List (lấy các giá trị từ phần tử thứ x đến y).
Với các ngôn ngữ lập trình khác, có lẽ phải dùng vòng lặp để thực hiện lấy ra các giá trị và đưa vào một biến dữ liệu mới. Ở Python, chúng ta được cung cấp một khái niệm là Slice (lát cắt), thực hiện “cắt” (Slicing) List ban đầu thành các List con theo điều kiện được đưa vào.

Cách dùng slice như ví dụ dưới đây:

number_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Lẩy 5 phần tử đầu tiên (từ index 0 đến index 4)
sub_list_5 = number_list[:5]

# Lấy dữ liệu từ phần tử thứ 6 (từ index 5 đến cuối)
sub_list_from_6 = number_list[5:]

# Lấy ra dữ liệu từ phần tử thứ 3 đến thứ 6 (index 2 --> 5)
sub_list_3_to_6 = number_list[2:6]

# Lấy các phần tử với bước nhảy 3
sub_list_step_3 = number_list[::3]

print("Number list", number_list)
for index, value in enumerate(number_list):
    print("Số thứ tự:", index, "Giá trị: ", value)
print("Lấy 5 phần tử đầu tiên", sub_list_5)
print("Lấy dữ liệu từ phần tử thứ 6", sub_list_from_6)
print("Lấy dữ liệu từ phần tử thứ 3 đến 6", sub_list_3_to_6)
print("Lấy các phần tử với bước nhảy 3", sub_list_step_3)

Number list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Số thứ tự: 0 Giá trị: 1
Số thứ tự: 1 Giá trị: 2
Số thứ tự: 2 Giá trị: 3
Số thứ tự: 3 Giá trị: 4
Số thứ tự: 4 Giá trị: 5
Số thứ tự: 5 Giá trị: 6
Số thứ tự: 6 Giá trị: 7
Số thứ tự: 7 Giá trị: 8
Số thứ tự: 8 Giá trị: 9
Số thứ tự: 9 Giá trị: 10
Lấy 5 phần tử đầu tiên [1, 2, 3, 4, 5]
Lấy dữ liệu từ phần tử thứ 6 [6, 7, 8, 9, 10]
Lấy dữ liệu từ phần tử thứ 3 đến 6 [3, 4, 5, 6]
Lấy các phần tử với bước nhảy 3 [1, 4, 7, 10]

Công thức của slice: list[start:stop:step]

start: Vị trí bắt đầu muốn lấy dữ liệu. Mặc định start = 0

stop: Vị trí cuối muốn lấy dữ liệu. Mặc định stop = len(list).
Có thể xác định vị trí cuối muốn lấy ra dựa trên số lượng muốn lấy ra theo công thức: stop = start + count.
Ví dụ muốn lấy ra 5 phần tử thì stop = start + 5.

step: Bước nhảy khi thực hiện lấy ra dữ liệu. Mặc định step=1.
Các phần tử được lấy ra sẽ có index là start + step * number. number tăng dần 1 đơn vị từ 0 và thỏa mãn start + step * number < stop
Ví dụ: number_list[::3] tương đương với start = 0, stop = 10, step = 3
với number = 0 –> Ta lấy ra được phần tử có index = 0 + 3*0 = 0 –> Lấy ra giá trị 1 (1 < 10 nên tiếp tục tăng giá trị number = 1)
với number = 1 –> Ta lấy ra được phần tử có index = 0 + 3*1 = 3 –> Lấy ra giá trị 4 (4 < 10 nên tiếp tục tăng giá trị number = 2)
với number = 2 –> Ta lấy ra được phần tử có index = 0 + 3*2 = 6 –> Lấy ra giá trị 7 (7 < 10 nên tiếp tục tăng giá trị number = 3)
với number = 3 –> Ta lấy ra được phần tử có index = 0 + 3*3 = 9 –> Lấy ra giá trị 10 (10 = 10 nên ngừng việc tiếp tục tăng giá trị number)

Tương đương với việc ta lấy ra được một sub list có giá trị: [1, 4, 7, 10]

6. Thêm phần tử vào List

Thêm phần tử vào cuối List dùng function List.append(item)

empty_list: []
integer_list: [2, 3, 5]
string_list: ['code', 'learn', 'lap-trinh']
mixed_list: ['code', 'learn', 'lap-trinh', 'so', 0, True, ['hoc', 'lap', 'trinh']]

integer_list: [1, 2, 3, 4, 5]
integer_list after append: [1, 2, 3, 4, 5, 6]

Thêm phần tử vào một vị trí bất kỳ trong list, dùng List.insert(index, value)

empty_list: []
integer_list: [2, 3, 5]
string_list: ['code', 'learn', 'lap-trinh']
mixed_list: ['code', 'learn', 'lap-trinh', 'so', 0, True, ['hoc', 'lap', 'trinh']]

After insert [1, 2, 10, 3, 4, 5]

Thêm các phần tử của một list khác vào list, có 2 cách:
– Dùng toán tử +: Tạo ra một list thứ 3 chứa tất cả các phần tử của list_1 và list_2
– Dùng function List.extend(list_2): Đưa các phần tử ở list_2 vào list_1

Tùy vào nhu cầu sử dụng mà chúng ta dùng 1 trong 2 cách trên.

Ví dụ:

empty_list: []
integer_list: [2, 3, 5]
string_list: ['code', 'learn', 'lap-trinh']
mixed_list: ['code', 'learn', 'lap-trinh', 'so', 0, True, ['hoc', 'lap', 'trinh']]

after +: [1, 2, 3, 4, 5]
after extend: [1, 2, 3, 4, 5, 1.0, 2.1, 3.2, 4.3]

7. Tìm kiếm trong list

Để tìm kiếm trong List, Python cung cấp 1 function là list.index(x[, start[, end]])
Với x là giá trị cần tìm; start/end tương ứng với slice ở phía trên, nếu có giá trị start/end thì trước khi tìm kiếm sẽ thực hiện sinh ra một sublist với các giá trị trong khoảng start/end.

Giá trị trả về: Trả về index của giá trị cần tìm nếu như giá trị đang có trong index.
Thực hiện raise lên ValueError nếu không có giá trị trong List.

Ví dụ:

empty_list: []
integer_list: [2, 3, 5]
string_list: ['code', 'learn', 'lap-trinh']
mixed_list: ['code', 'learn', 'lap-trinh', 'so', 0, True, ['hoc', 'lap', 'trinh']]

index of 3 in [1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10]: 2
—————————————————————————
ValueError Traceback (most recent call last)
in
5
6 number = 11
—-> 7 index = integer_list.index(11)

ValueError: 11 is not in list

Nếu không quan tâm đến vị trí của dữ liệu trong list mà chỉ quan tâm đến có trong list hay không, thường dùng câu lệnh với từ khóa in.

empty_list: []
integer_list: [2, 3, 5]
string_list: ['code', 'learn', 'lap-trinh']
mixed_list: ['code', 'learn', 'lap-trinh', 'so', 0, True, ['hoc', 'lap', 'trinh']]

empty_list: []
integer_list: [2, 3, 5]
string_list: ['code', 'learn', 'lap-trinh']
mixed_list: ['code', 'learn', 'lap-trinh', 'so', 0, True, ['hoc', 'lap', 'trinh']]

6 is in [1, 2, 3, 4, 5]: False

8. Xóa phần tử khỏi list.

.remove(item): Xóa phần tử đầu tiên có giá trị bằng với giá trị yêu cầu xóa
.pop(index): Xóa phần tử tại vị trí index, trả về giá trị đã xóa trong kết quả.
.pop(): Xóa phần tử cuối cùng trong list, trả về giá trị đã xóa trong kết quả.
.clear(): Xóa toàn bộ các giá trị trong list.

Ngoài ra có một cách xóa khác
del list[index]: Xóa phần tử tại vị trí index.

empty_list: []
integer_list: [2, 3, 5]
string_list: ['code', 'learn', 'lap-trinh']
mixed_list: ['code', 'learn', 'lap-trinh', 'so', 0, True, ['hoc', 'lap', 'trinh']]

Trước khi xóa [1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10]
Sau khi xóa số 5 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Sau khi lấy ra giá trị 3 tại vị trí index=2: [1, 2, 4, 5, 6, 7, 8, 9, 10]
Sau khi lấy ra giá trị 10 tại vị trí cuối cùng: [1, 2, 4, 5, 6, 7, 8, 9]
Sau khi xóa tại vị trí index=0: [2, 4, 5, 6, 7, 8, 9]
Sau khi xóa toàn bộ các bản ghi: []

9. Sắp xếp trong list.

Để thực hiện sắp xếp các item trong list, Python cung cấp cho chúng ta một function là .sort(key=None, reverse=False), ngoài ra thì còn có built-in function sorted(list, key=None, reverse=False)
Điểm khác biệt của 2 cách dùng này là my_list.sort() sẽ thực hiện sắp xếp và thay đổi giá trị ngay trong my_list, sorted(my_list) trả về một list mới sau khi đã được sắp xếp.