Python Slice: Các phương pháp hữu ích cho lập trình hằng ngày

Nếu bạn đã chán việc loay hoay với các chỉ số cắt khó hiểu hoặc thắc mắc vì sao các danh sách sau khi cắt không hoạt động như mong đợi, bạn đang ở đúng nơi. Trong hướng dẫn này, chúng ta sẽ chia nhỏ thao tác cắt (slicing) trong Python thành những phần dễ tiêu hóa. Chúng ta sẽ đi từ cú pháp cơ bản đến các kỹ thuật nâng cao với mảng nhiều chiều. Thêm vào đó, tôi sẽ chia sẻ các ví dụ gắn với ứng dụng thực tế mà bạn có thể áp dụng ngay.

Nếu bạn muốn xây nền tảng Python vững chắc, hãy xem thêm khóa học Python Fundamentals của chúng tôi, được thiết kế để giúp bạn nắm vững các kỹ năng cốt lõi như slicing, cấu trúc dữ liệu và nhiều hơn nữa.

Tìm hiểu về Python Slicing

Hãy dành chút thời gian để nói về slicing trong Python là gì và vì sao nó hữu ích.

Slicing trong Python là gì?

Slicing trong Python là phương pháp trích xuất các phần cụ thể của các dãy như chuỗi (string), danh sách (list), bộ (tuple) và range. Slicing có thể là dùng hàm dựng sẵn slice() hoặc phổ biến hơn là ký pháp ngoặc vuông dạng: [start:end:step]. Tính năng này là một phần cốt lõi của ngôn ngữ, nên bạn có thể thực hiện slicing mà không cần nhập thêm gói nào. Slicing trong các thư viện ngoài như NumPy hoặc pandas có một số khác biệt thú vị, tôi sẽ trình bày chi tiết bên dưới.

Vì sao dùng slicing trong Python?

Slicing là một trong những công cụ trực quan và hiệu quả nhất để thao tác dữ liệu. Dù bạn đang phân tích dữ liệu, xử lý chuỗi hay thao tác mảng, slicing cho phép truy cập và xử lý các tập con dữ liệu.

Vì sao mọi lập trình viên nên thành thạo nó:

Mã gọn gàng, súc tích: Slicing loại bỏ nhu cầu dùng vòng lặp lặp lại hoặc điều kiện phức tạp, giúp mã ngắn hơn, sạch hơn và dễ gỡ lỗi.
Xử lý dữ liệu hiệu quả: Khác với truy cập thủ công theo chỉ số, slicing được tối ưu hiệu năng. Cơ chế nội bộ của Python đảm bảo các thao tác slicing nhanh và tiết kiệm bộ nhớ.
Đa dụng trên nhiều cấu trúc dữ liệu: Slicing hoạt động trơn tru trong hệ sinh thái Python, từ chuỗi và danh sách đến các cấu trúc nâng cao như mảng NumPy và khung dữ liệu pandas.
Ứng dụng thực tế: Slicing đơn giản hóa các tác vụ hàng ngày. Cần xử lý chỉ một phần của tập dữ liệu? Trích xuất một số cột cụ thể từ bảng? Hoặc đảo ngược chuỗi cho dự án phân tích văn bản? Slicing là lựa chọn hàng đầu.

Phương pháp cơ bản để slicing trong Python

Như đã nói, slicing là tính năng cốt lõi trong Python, cho phép trích xuất một phần các dãy như list, string và tuple. Python cung cấp hai cách chính để slicing mà không cần nhập gì thêm: cú pháp : và hàm slice(). Hiểu cả hai rất hữu ích vì bạn sẽ thường xuyên gặp cả hai.

Dùng cú pháp : để slicing trong Python

Cú pháp slicing sequence[start:stop:step] là cách phổ biến nhất để truy cập một phần của dãy. Mỗi tham số—start, stop và step—điều khiển cách thực hiện slicing:

start: Chỉ số nơi bắt đầu cắt (bao gồm). Mặc định là 0 nếu bỏ qua.
stop: Chỉ số nơi kết thúc cắt (không bao gồm). Mặc định là độ dài của dãy nếu bỏ qua.
step: Khoảng cách giữa các phần tử. Mặc định là 1 nếu bỏ qua.

Hãy thử một ví dụ:

numbers = [10, 20, 30, 40, 50, 60]  

print(numbers[1:4])  
# Output: [20, 30, 40]  

print(numbers[:3])   
# Output: [10, 20, 30]  

print(numbers[::2])  
# Output: [10, 30, 50]  Được hỗ trợ bởi

Bạn cũng có thể áp dụng cách này cho chuỗi:

text = "Python Slicing"  

print(text[7:])   
# Output: "Slicing"  

print(text[::-1]) 
# Output: "gnicilS nohtyP" (reverses the string)  Được hỗ trợ bởi

Bạn thậm chí có thể trích xuất các phần tử xen kẽ từ một danh sách bằng slicing:

data = [100, 200, 300, 400, 500]  

alternate = data[::2]  

print(alternate)  
# Output: [100, 300, 500]  Được hỗ trợ bởi

Trong thực tế, slicing đặc biệt hữu ích khi làm việc với tập dữ liệu lớn. Giả sử bạn đang xử lý tệp log có hàng triệu bản ghi và cần trích xuất 1.000 dòng cuối để phân tích:

logs = load_large_dataset()  
recent_logs = logs[-1000:]  Được hỗ trợ bởi

Cách này giúp tránh tải toàn bộ dữ liệu vào bộ nhớ, đảm bảo ứng dụng chạy hiệu quả.

Dùng hàm slice() trong Python

Hàm slice() của Python cung cấp cách định nghĩa các tham số cắt dưới dạng đối tượng slice có thể tái sử dụng. Những đối tượng này đóng gói logic slicing và có thể áp dụng trên nhiều dãy khác nhau.

Cú pháp và cách dùng

Hàm slice() có dạng:

slice(start, stop, step)  Được hỗ trợ bởi

Ví dụ:

# Create a slice object
slice_obj = slice(1, 4)

# Apply to a list
numbers = [10, 20, 30, 40, 50]
print(numbers[slice_obj])  # Output: [20, 30, 40]

# Apply to a string
text = "Python"
print(text[slice_obj])  # Output: "yth"  Được hỗ trợ bởi

Ưu điểm của Python slice()

Cá nhân tôi thích dùng hàm slice() vì nó cho phép tái sử dụng cùng một đối tượng slice trên nhiều dãy, tránh lặp lại logic slicing. Nó cũng giúp mã dễ đọc và dễ bảo trì hơn.

Như bạn thấy trong ví dụ sau, chúng ta định nghĩa một đối tượng slice một lần và tái sử dụng trên nhiều dãy. Điều này loại bỏ việc lặp lại các giá trị start, end và step. Nó cũng cải thiện khả năng tái sử dụng vì thay đổi ranh giới cắt ở một nơi sẽ tự động cập nhật mọi chỗ sử dụng.

# Define a reusable slice
my_slice = slice(2, 5)

# Apply to multiple sequences
data_list = [100, 200, 300, 400, 500]
data_string = "SlicingExample"

print(data_list[my_slice])  # Output: [300, 400, 500]
print(data_string[my_slice])  # Output: "ici"  Được hỗ trợ bởi

So sánh hai phương pháp

Cả hai phương pháp slicing đều có chỗ đứng trong Python. Cú pháp phù hợp với các thao tác ngắn gọn, trong khi slice() cực kỳ hữu ích cho logic slicing có thể tái sử dụng và linh hoạt.

Tính năng	Cú pháp `slice()`	Hàm
Dễ sử dụng	Đơn giản cho tác vụ cắt nhanh	Tốt hơn cho logic có thể tái sử dụng
Dễ đọc	Lý tưởng cho các lát cắt đơn giản	Tăng rõ ràng cho slicing phức tạp
Tính linh hoạt	Giới hạn ở dùng một lần trong mã	Tái sử dụng trên nhiều dãy

Python Slice trong các thư viện

Slicing không chỉ giới hạn ở cấu trúc dữ liệu dựng sẵn của Python—nó còn mở rộng sang các thư viện mạnh như NumPy và pandas, vốn không thể thiếu cho thao tác dữ liệu. Dù nguyên tắc cơ bản giữ nguyên, các thư viện này bổ sung khả năng slicing phù hợp với cấu trúc dữ liệu của chúng.

Slicing trong NumPy

Mảng NumPy đưa slicing lên tầm cao mới, cung cấp công cụ mạnh để thao tác các tập dữ liệu lớn, nhiều chiều. Khác biệt quan trọng trong slicing của NumPy là view so với copy: cắt một mảng NumPy thường trả về view (tham chiếu đến dữ liệu gốc), không phải bản sao. Hành vi này đảm bảo hiệu quả với dữ liệu lớn nhưng cần cẩn trọng để tránh thay đổi ngoài ý muốn.

Cắt mảng 1 chiều

import numpy as np  

# Create a 1D array
array = np.array([10, 20, 30, 40, 50])

# Slice elements from index 1 to 3
print(array[1:4])  
# Output: [20 30 40]  

# Apply step
print(array[::2])  
# Output: [10 30 50]  Được hỗ trợ bởi

Cắt mảng nhiều chiều

Với mảng nhiều chiều, slicing áp dụng độc lập trên từng trục.

# Create a 2D array
array_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Slice the first two rows and first two columns
print(array_2d[:2, :2])  
# Output:
# [[1 2]
#  [4 5]]  

# Slice the last column
print(array_2d[:, -1])  
# Output: [3 6 9]  Được hỗ trợ bởi

Lợi ích của slicing trong NumPy

Hiệu quả bộ nhớ: Thao tác trên lát cắt tránh sao chép dữ liệu, tăng tốc tính toán.
Linh hoạt: Cắt nhiều chiều cho phép kiểm soát chính xác tập con dữ liệu.

Khám phá sâu hơn NumPy trong khóa học Introduction to Data Science with Python của chúng tôi.

Slicing trong pandas

pandas mở rộng slicing để hoạt động mượt mà với DataFrame và Series, mang đến cách trực quan hơn để truy cập và thao tác dữ liệu có cấu trúc. Dù dựa trên slicing cơ bản của Python, slicing trong pandas có những hành vi riêng phù hợp dữ liệu dạng bảng.

Cắt hàng và cột trong DataFrame

import pandas as pd  

# Create a sample DataFrame
student_data = {'Name': ['Alice', 'Bob', 'Charlie'], 
                'Age': [25, 30, 35], 
                'Score': [85, 90, 95]}

students = pd.DataFrame(student_data

# Slice the first two rows
print(students[:2])  
# Output:
#      Name  Age  Score
# 0   Alice   25     85
# 1     Bob   30     90  

# Slice specific columns by name
print(students[['Name', 'Score']])  
# Output:
#       Name  Score
# 0    Alice     85
# 1      Bob     90
# 2  Charlie     95  Được hỗ trợ bởi

Sử dụng .loc[] và .iloc[]

pandas cung cấp .loc[] (theo nhãn) và .iloc[] (theo chỉ số) để kiểm soát chính xác hơn.

# Slice using .iloc (index-based)
print(df.iloc[1:, 1:])  
# Output:
#    Age  Score
# 1   30     90
# 2   35     95  Được hỗ trợ bởi

# Slice using .loc (label-based)
print(df.loc[:1, ['Name', 'Age']])  
# Output:
#    Name  Age
# 0  Alice   25
# 1    Bob   30  Được hỗ trợ bởi

Khác biệt chính trong slicing của pandas

Khoảng bao gồm: Khác với slicing của Python, .loc[] bao gồm chỉ số dừng cho cả hàng và cột.
Kết hợp chỉ số: pandas cho phép cắt theo cả nhãn và vị trí, mang lại sự linh hoạt cao hơn.

Với các kỹ thuật nâng cao, hãy khám phá khóa Manipulating DataFrames with pandas.

Python Slicing với các kiểu dữ liệu khác nhau

Giờ hãy xem các ví dụ slicing trong Python với những kiểu dữ liệu khác nhau để thấy slicing hoạt động ra sao trên những cấu trúc dữ liệu như chuỗi, danh sách, bộ (tuple), hoặc các kiểu phức tạp hơn.

Slicing chuỗi

Chuỗi trong Python là dãy ký tự, nghĩa là bạn có thể cắt chúng như list hoặc tuple. Điều này hữu ích để trích xuất chuỗi con, đảo ngược văn bản hoặc định dạng dữ liệu. Ở đây tôi dùng :.

Basic string slicing# Extract a substring
text = "Python Slicing"
print(text[7:14])  # Output: Slicing  

# Reverse a string
print(text[::-1])  # Output: gnicilS nohtyP  Được hỗ trợ bởi

Hàm slice() cho phép bạn tạo đối tượng slice có thể tái sử dụng để thao tác nhất quán.

# Create a slice object
slicer = slice(7, 14)

# Apply the slice object
print(text[slicer])  # Output: Slicing  Được hỗ trợ bởi

Tình huống sử dụng thực tế

Phân tích dữ liệu văn bản: Trích xuất trường cụ thể từ văn bản có cấu trúc như dòng CSV hoặc tệp log.
Xử lý chuỗi: Định dạng chuỗi bằng cách loại bỏ tiền tố, hậu tố hoặc ký tự không mong muốn.

Slicing danh sách và bộ (tuple)

List và tuple là các cấu trúc dữ liệu nền tảng của Python, và slicing chúng có thể đơn giản hóa công việc của bạn.

Slicing list cơ bản

# Extract elements from a list
numbers = [10, 20, 30, 40, 50]

print(numbers[1:4])  
# Output: [20, 30, 40]  

# Skip elements using steps
print(numbers[::2])  
# Output: [10, 30, 50]  Được hỗ trợ bởi

Slicing tuple

Tuple là bất biến, nhưng slicing vẫn hoạt động để trích xuất một phần của chúng.

# Slice a tuple
colors = ("red", "green", "blue", "yellow")

print(colors[:2])  
# Output: ('red', 'green')  Được hỗ trợ bởi

Lọc và sắp xếp lại

Slicing là cách tiện lợi để lọc hoặc sắp xếp lại phần tử.

# Filter odd-indexed elements
data = [5, 10, 15, 20, 25]

filtered = data[1::2]  
# Output: [10, 20]  Được hỗ trợ bởi

Slicing trong phân tích dữ liệu

Trong phân tích dữ liệu, slicing giúp trích xuất và tổ chức lại các tập con dữ liệu để xem xét sâu hơn. Các trường hợp bao gồm chọn tập con, nơi bạn trích xuất hàng hoặc cột liên quan để phân tích trọng tâm, và biến đổi dữ liệu, nơi bạn tổ chức lại tập dữ liệu để trực quan hóa hoặc báo cáo tốt hơn.

Slicing với NumPy

import numpy as np  

# Create a 2D array
data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Extract the first two rows
print(data[:2, :])  
# Output:
# [[1 2 3]
#  [4 5 6]]  Được hỗ trợ bởi

Còn rất nhiều điều để nói về NumPy, nhưng bạn có thể khám phá slicing trong NumPy sâu hơn với khóa học Data Structures and Algorithms in Python của chúng tôi.

Slicing với pandas

Một lựa chọn là pandas, cung cấp khả năng cắt giúp bạn truy cập và thao tác hàng, cột. Dưới đây là minh họa nhanh cách cắt cả hàng và cột trong DataFrame:

import pandas as pd  

# Create a DataFrame
df = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Score': [85, 90, 95]
})

# Slice rows and columns
print(df.loc[:1, ['Name', 'Score']])  
# Output:
#      Name  Score
# 0   Alice     85
# 1     Bob     90  Được hỗ trợ bởi

Kỹ thuật Python Slicing nâng cao

Khi nắm các kỹ thuật nâng cao, bạn có thể thao tác cấu trúc dữ liệu với độ chính xác và hiệu quả ấn tượng. Những kỹ thuật sau sẽ giúp bạn viết mã Python gọn và nhanh hơn.

Chỉnh sửa list bằng slicing

Một sức mạnh ít được biết đến của slicing là khả năng chỉnh sửa list trực tiếp. Bạn có thể thay thế, chèn hoặc xóa nhiều phần tử trong một dòng lệnh.

Thay thế phần tử:

numbers = [1, 2, 3, 4, 5]
numbers[1:4] = [20, 30, 40]

print(numbers)
# Output: [1, 20, 30, 40, 5]Được hỗ trợ bởi

Chèn phần tử:

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

print(numbers)
# Output: [1, 2, 3, 4, 5]
Được hỗ trợ bởi

Xóa phần tử:

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

print(numbers)
# Output: [1, 5]Được hỗ trợ bởi

Hiệu quả bộ nhớ

Hiểu liệu Python tạo bản sao hay view là điều thiết yếu để quản lý bộ nhớ khi cắt cấu trúc dữ liệu, nhất là với tập dữ liệu lớn. Với list và string dựng sẵn, slicing luôn tạo bản sao của dãy gốc, còn với mảng NumPy, slicing tạo view, nghĩa là cả mảng gốc và lát cắt đều trỏ đến cùng dữ liệu trong bộ nhớ.

Trong đoạn mã sau, thao tác slicing tạo view của mảng NumPy gốc thay vì bản sao. Điều này có nghĩa arr và sliced cùng tham chiếu dữ liệu nền trong bộ nhớ. Kết quả là chỉnh sửa sliced sẽ ảnh hưởng trực tiếp đến arr.

import numpy as np

arr = np.array([1, 2, 3, 4, 5])
sliced = arr[1:4]
sliced[0] = 99

print(arr)
# Output: [1, 99, 3, 4, 5]Được hỗ trợ bởi

Luôn thận trọng khi chỉnh sửa các lát cắt trong thư viện ngoài để tránh tác dụng phụ ngoài ý muốn.

Cân nhắc các trường hợp đặc biệt

Slicing rất mạnh, nhưng không phải không có bẫy. Dưới đây là những lỗi thường gặp:

Cắt vượt phạm vi

numbers = [1, 2, 3]

print(numbers[5:10])
# Output: []Được hỗ trợ bởi

Cắt vượt phạm vi không gây lỗi—nó chỉ trả về danh sách rỗng.

Lát cắt rỗng

numbers = [1, 2, 3]

print(numbers[1:1])
# Output: []
Được hỗ trợ bởi

Khi chỉ số bắt đầu và kết thúc giống nhau, kết quả là lát cắt rỗng.

Hành vi bước gây nhầm lẫn

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

print(numbers[::-2])
# Output: [5, 3, 1]Được hỗ trợ bởi

Giá trị bước -2 cắt danh sách theo chiều ngược, bỏ qua mỗi phần tử thứ hai.

Đánh chỉ số âm

Chỉ số âm cho phép bạn cắt các dãy bắt đầu từ cuối thay vì từ đầu.

Truy cập phần tử cuối

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

print(numbers[-1])  # Last element
# Output: 5Được hỗ trợ bởi

Đảo ngược danh sách

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

print(numbers[::-1])  # Reverse the list
# Output: [5, 4, 3, 2, 1]Được hỗ trợ bởi

Chỉ số âm đặc biệt hữu ích khi làm việc với độ dài dãy không biết trước hoặc khi xử lý dữ liệu theo chiều ngược.

Slicing nhiều chiều

Slicing không giới hạn ở cấu trúc một chiều. Trong các thư viện như NumPy, bạn có thể cắt mảng nhiều chiều với độ chính xác cao.

import numpy as np

matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Extract a sub-matrix
sub_matrix = matrix[:2, 1:]

print(sub_matrix)
# Output:
# [[2, 3],
#  [5, 6]]Được hỗ trợ bởi

Mẹo cho slicing nhiều chiều:

Dùng dấu phẩy để tách slicing cho từng chiều.
Tránh kết hợp chỉ số âm và cắt mặc định : theo cách gây mơ hồ.

Mẹo gỡ lỗi: Luôn in ra các lát cắt trung gian khi gỡ lỗi slicing nhiều chiều để đảm bảo bạn đang nhắm đúng tập con.

Những lỗi thường gặp với Python Slice

Slicing trong Python rất mạnh, nhưng không tránh khỏi sai sót. Một số bẫy thường gặp có thể khiến cả lập trình viên giàu kinh nghiệm cũng vấp phải. Hiểu các vấn đề này và cách khắc phục là chìa khóa để viết mã sạch và chính xác.

Phạm lỗi lệch một đơn vị (off-by-one)

Lỗi off-by-one xảy ra khi chỉ số bắt đầu hoặc kết thúc trong thao tác cắt vô tình bao gồm hoặc loại trừ phần tử không mong muốn. Đây là một trong những vấn đề phổ biến nhất và có thể dẫn đến kết quả sai hoặc lỗi trong mã.

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

# Intending to extract [2, 3, 4]
slice_result = numbers[1:3]

print(slice_result)
# Output: [2, 3]Được hỗ trợ bởi

Ở đây, chỉ số kết thúc loại trừ phần tử tại chỉ số 3, dẫn đến thiếu sót ngoài ý muốn. Cách tránh lỗi này:

Hiểu quy tắc chỉ số kết thúc: Chỉ số kết thúc trong slicing là loại trừ, nghĩa là không được bao gồm trong kết quả. Luôn cộng 1 vào chỉ số kết thúc nếu bạn muốn bao gồm phần tử đó.
Dùng độ dài tường minh: Nếu lát cắt cần bao gồm một phạm vi chỉ số cụ thể, hãy kiểm tra phép tính từ start đến stop khớp với ý định của bạn.

Ví dụ sửa đúng:

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

print(slice_result)
# Output: [2, 3, 4]Được hỗ trợ bởi

Hiểu sai giá trị bước (step)

Giá trị step xác định số phần tử bỏ qua giữa các chỉ số khi cắt. Hiểu sai cách hoạt động của step có thể dẫn đến kết quả bất ngờ, đặc biệt với step âm.

Bỏ qua quá ít hoặc quá nhiều phần tử

numbers = [1, 2, 3, 4, 5]
# Expecting every second element

step_result = numbers[::3]

print(step_result)
# Output: [1, 4]Được hỗ trợ bởi

Ở đây, step 3 bỏ qua quá nhiều phần tử, dẫn đến ít giá trị hơn mong đợi. Đoạn mã sau là ví dụ về step âm gây nhầm lẫn.

numbers = [1, 2, 3, 4, 5]
step_result = numbers[::-2]

print(step_result)
# Output: [5, 3, 1]Được hỗ trợ bởi

Step âm đảo ngược danh sách đồng thời bỏ qua phần tử, nhưng nếu hiểu sai hành vi, sẽ khó dự đoán kết quả. Đây là những điều tôi cân nhắc để dùng step đúng cách:

Lên kế hoạch cho khoảng lấy: Đảm bảo step khớp với khoảng bạn cần. Với mỗi phần tử thứ hai, dùng step là 2.
Thử nghiệm step âm riêng lẻ: Thử với ví dụ nhỏ để xác nhận bạn hiểu cách các lát đảo ngược hoạt động.
Kết hợp step với chỉ số start/stop: Dùng start và stop để giới hạn phạm vi lát cắt khi áp dụng step.

Ví dụ sửa đúng cách dùng step:

Every second element:
numbers = [1, 2, 3, 4, 5]

print(numbers[::2])
# Output: [1, 3, 5]

Reverse with a step:
numbers = [1, 2, 3, 4, 5]

print(numbers[4::-2])
# Output: [5, 3, 1]Được hỗ trợ bởi

Không tuân theo thực hành tốt

Đây là một số gợi ý hay để bạn tránh mắc lỗi:

Hình dung lát cắt của bạn: Dùng chú thích hoặc lệnh in để xác thực logic slicing.
Luyện tập với ví dụ: Bắt đầu với các list nhỏ, đơn giản để kiểm tra hiểu biết về tham số start, stop và step.
Dùng hàm dựng sẵn để rõ ràng hơn: Khi phân vân, hãy tạo lát cắt bằng hàm slice() để logic tường minh hơn.

Kết luận

Xuyên suốt hướng dẫn này, chúng ta đã khám phá các khái niệm như:

Cú pháp và tham số slicing cơ bản, bao gồm start, stop và step.
Các kỹ thuật thú vị như chỉnh sửa list bằng slicing, cân nhắc thực hành tiết kiệm bộ nhớ và xử lý dữ liệu nhiều chiều.
Những lỗi hay gặp như lệch một đơn vị và hiểu sai step, cùng cách tránh chúng.

Cách tốt nhất để củng cố hiểu biết là thực hành trực tiếp. Hãy thử với dữ liệu thực tế, kiểm tra các trường hợp biên và thử thách bản thân vượt qua những điều cơ bản.

DataCamp luôn sẵn sàng hỗ trợ. Hãy thử khóa học Data Manipulation with Python và các khóa khác như Developing Python Packages để có trải nghiệm học tương tác. Dù bạn là người mới hay muốn trau dồi kỹ thuật, những tài nguyên này có thể giúp bạn thành thạo slicing và nhiều kỹ năng khác.

Tác giả

Oluseye Jeremiah

Nhà viết nội dung về công nghệ, chuyên về AI, ML và khoa học dữ liệu, giúp làm rõ và phổ biến những ý tưởng phức tạp.

Chủ đề

Python Phân tích dữ liệu