Rate this post

List là một cấu trúc dữ liệu trong Python, là một danh sách các phần tử có thể thay đổi hoặc có thể thay thế được. Mỗi phần tử hoặc giá trị bên trong List được gọi là một item. Giống như các string được định nghĩa là các ký tự nằm giữa các dấu ngoặc kép, các List được xác định bằng cách có các giá trị nằm giữa các dấu ngoặc vuông [ ].

Các bài viết liên quan:

List rất phù hợp để sử dụng khi bạn muốn làm việc với nhiều giá trị liên quan. Chúng cho phép bạn giữ dữ liệu cùng nhau thuộc về nhau, cô đọng mã của bạn và thực hiện cùng một phương pháp và thao tác trên nhiều giá trị cùng một lúc.

Tóm tắt nội dung

Yêu cầu về môi trường

Bạn nên cài đặt Python 3 và thiết lập môi trường lập trình trên máy tính hoặc máy chủ của mình. Nếu bạn chưa thiết lập môi trường lập trình, bạn có thể tham khảo hướng dẫn cài đặt và thiết lập cho môi trường lập trình cục bộ hoặc môi trường lập trình trên máy chủ phù hợp với hệ điều hành của bạn (Ubuntu, CentOS, Debian, v.v.)

String Lists

Để bắt đầu, hãy tạo một List chứa các item thuộc kiểu dữ liệu string:

Để làm theo code ví dụ trong hướng dẫn này, hãy mở Python interactive shell trên hệ thống cục bộ của bạn bằng cách chạy lệnh python3. Sau đó, bạn có thể sao chép, dán hoặc chỉnh sửa các ví dụ bằng cách thêm chúng vào sau dấu nhắc >>>.

listString = ['item1', 'item2', 'item3', 'item4', 'item5']

Là một Danh sách các phần tử được sắp xếp theo thứ tự, mỗi item trong List có thể được gọi riêng lẻ thông qua lập chỉ item. List là một kiểu dữ liệu phức hợp được tạo thành từ các phần nhỏ hơn và rất linh hoạt vì chúng có thể có các giá trị được thêm, xóa và thay đổi. Khi bạn cần lưu trữ nhiều giá trị hoặc lặp lại các giá trị và bạn muốn có thể dễ dàng sửa đổi các giá trị đó, bạn có thể sẽ muốn làm việc với các kiểu dữ liệu List.

print(listString)

Trong hướng dẫn này, chúng ta sẽ tìm hiểu một số cách có thể làm việc với List trong Python.

Indexing Lists

Mỗi item trong List tương ứng với một số chỉ item, là một giá trị nguyên, bắt đầu bằng số chỉ item 0.

Đối với List listString, bảng phân tích chỉ item trông như sau:

item1	item2	item3	item4	item5
0	1	2	3	4

item đầu tiên, string ‘item1‘ bắt đầu ở chỉ item 0 và List kết thúc ở chỉ item 4 với item ‘item5‘.

Bởi vì mỗi item trong List Python có số chỉ item tương ứng, nên chúng ta có thể truy cập và thao tác với List theo cách giống như chúng tôi có thể làm với các loại dữ liệu tuần tự khác.

Bây giờ chúng ta có thể gọi một item rời rạc của List bằng cách tham chiếu đến số chỉ item của nó:

print(listString[1])

Các số chỉ item cho List này nằm trong khoảng từ 0-4, như trong bảng trên. Vì vậy, để gọi bất kỳ item nào riêng lẻ, chúng tôi sẽ đề cập đến các số chỉ item như sau:

sea_creatures[0] = 'shark'
sea_creatures[1] = 'cuttlefish'
sea_creatures[2] = 'squid'
sea_creatures[3] = 'mantis shrimp'
sea_creatures[4] = 'anemone'

Nếu chúng ta gọi List listString với số chỉ item bất kỳ lớn hơn 4, nó sẽ nằm ngoài phạm vi vì nó sẽ không hợp lệ:

print(sea_creatures[18])

Ngoài các số chỉ item dương, chúng ta cũng có thể truy cập các item từ List có số chỉ item âm, bằng cách đếm ngược từ cuối List, bắt đầu từ -1. Điều này đặc biệt hữu ích nếu chúng tôi có một List dài và chúng tôi muốn xác định chính xác một item ở cuối List.

Đối với cùng một List listString, bảng phân tích chỉ số phủ định trông giống như sau:

shark	cuttlefish	squid	mantis shrimp	anemone
-5	-4	-3	-2	-1

Vì vậy, nếu chúng ta muốn in item ‘item’ bằng cách sử dụng số chỉ item âm của nó, chúng ta có thể thực hiện như sau:

print(listString[-3])

Chúng ta có thể nối các item string trong List với các string khác bằng toán tử +:

print('Banny is a ' + listString[0])

Chúng tôi có thể nối item string ở chỉ item số 0 với string ‘Sammy is a’. Chúng ta cũng có thể sử dụng toán tử + để nối 2 hoặc nhiều List lại với nhau.

Với các số chỉ item tương ứng với các item trong List, chúng tôi có thể truy cập riêng từng item của List và làm việc với các item đó.

Sửa đổi các item trong List

Chúng ta có thể sử dụng lập chỉ item để thay đổi các item trong List, bằng cách đặt số chỉ item bằng một giá trị khác. Điều này cho phép chúng tôi kiểm soát tốt hơn các List vì chúng tôi có thể sửa đổi và cập nhật các item mà chúng chứa.

Nếu chúng ta muốn thay đổi giá trị string của item ở chỉ số 1 từ ‘cuttlefish’ thành ‘octopus’, chúng ta có thể làm như sau:

listString[1] = 'octopus'

Bây giờ khi chúng ta in sea_creatures, List sẽ khác:

print(sea_creatures)

Thay vào đó, chúng ta có thể thay đổi giá trị của một item bằng cách sử dụng số chỉ item âm:

listString[-3] = 'blobfish'
print(listString)

Bây giờ ‘blobfish’ đã thay thế ‘squid’ ở số chỉ số âm là -3 (tương ứng với số chỉ số dương là 2).

Khả năng sửa đổi các item trong List cho chúng ta khả năng thay đổi và cập nhật List một cách hiệu quả.

Slicing Lists

Chúng ta cũng có thể gọi ra một vài item từ List. Giả sử chúng ta chỉ muốn in các item ở giữa của listString, chúng ta có thể làm như vậy bằng cách tạo một slicing. Với các Slicibg, chúng ta có thể gọi nhiều giá trị bằng cách tạo một dãy số chỉ item được phân tách bằng dấu hai chấm [x:y]:

print(listString[1:4])

Khi tạo một Slicing , như trong [1:4], số chỉ item đầu tiên là nơi bắt đầu lát cắt (bao gồm) và số chỉ item thứ hai là nơi kết thúc Slicing – loại trừ, đó là lý do tại sao trong ví dụ của chúng tôi ở trên các item tại vị trí, 1, 2 và 3 là các item in ra.

Nếu chúng ta muốn bao gồm cả hai đầu List, chúng ta có thể bỏ qua một trong các số trong cú pháp list[x:y]. Ví dụ: nếu chúng tôi muốn in 3 item đầu tiên của List sea_creatures — đó sẽ là ‘shark’, ‘octopus’, ‘blobfish’ — chúng tôi có thể thực hiện việc này bằng cách nhập:

print(listString[:3])

Điều này đã in phần đầu của List, dừng ngay trước chỉ item 3.

Để bao gồm tất cả các item ở cuối List, chúng tôi sẽ đảo ngược cú pháp:

print(listString[2:])

Chúng ta cũng có thể sử dụng các số chỉ item âm khi cắt List, tương tự như các số chỉ item dương:

print(listString[-4:-2])
print(listString[-3:])

Một tham số cuối cùng mà chúng ta có thể sử dụng với việc cắt lát được gọi là step, tham số này đề cập đến số lượng item sẽ di chuyển về phía trước sau khi item đầu tiên được truy xuất từ List. Cho đến nay, chúng tôi đã bỏ qua tham số step và Python mặc định là step bằng 1, do đó mọi item nằm giữa hai số chỉ item đều được truy xuất.

Cú pháp cho cấu trúc này là list[x:y:z], với z ám chỉ step. Hãy tạo một List lớn hơn, sau đó chia nhỏ nó và đặt giá trị cho step là 2:

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
print(numbers[1:11:2])

[1:11:2] in các giá trị giữa các số chỉ item bao gồm 1 và không bao gồm 11, sau đó giá trị step của 2 báo cho chương trình chỉ in ra mọi item khác.

Chúng ta có thể bỏ qua hai tham số đầu tiên và sử dụng một mình sải chân làm tham số với cú pháp:

print(numbers[::3])

Bằng cách in ra các số List với step được đặt thành 3, chỉ mỗi item thứ ba được in:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

Việc cắt List có cả số chỉ item dương và âm và biểu thị bước tiến cung cấp cho chúng tôi quyền kiểm soát để thao tác với List và nhận đầu ra mà chúng tôi đang cố gắng đạt được.

Sửa đổi List với toán tử

Toán tử có thể được sử dụng để sửa đổi List. Chúng tôi sẽ xem xét cách sử dụng các toán tử + và * và các dạng phức hợp của chúng += và *=.

Toán tử + có thể được sử dụng để nối hai hoặc nhiều List lại với nhau:

test = ['test1', 'test2', 'test3', 'test4', 'test5']
example = ['example1', 'example2', 'example3', 'example4', 'example5']
print(sea_creatures + oceans)

Vì toán tử + có thể nối nên nó có thể được sử dụng để thêm một (hoặc một số) item ở dạng List vào cuối một List khác. Hãy nhớ đặt item trong ngoặc vuông:

test = test + ['test6']
print (test)

Toán tử * có thể được sử dụng để nhân List. Có lẽ bạn cần tạo bản sao của tất cả các tệp trong một thư item — trong những trường hợp này, bạn sẽ cần nhân các bộ sưu tập dữ liệu.

Hãy nhân List test với 2 và example với 3:

print(test * 2)
print(example * 3)

Bằng cách sử dụng toán tử *, chúng ta có thể sao chép List của mình theo số lần chúng ta chỉ định.

Chúng ta cũng có thể sử dụng các dạng phức hợp của toán tử + và * với toán tử gán =. Các toán tử ghép += và *= có thể được sử dụng để điền List một cách nhanh chóng và tự động. Ví dụ: bạn có thể sử dụng các toán tử này để điền vào List bằng giá trị thể sửa đổi sau đó bằng đầu vào do người dùng cung cấp.

Hãy

thêm một item ở dạng List vào List test. item này sẽ hoạt động như một biến và chúng tôi muốn thêm item giữ chỗ này nhiều lần. Để làm điều này, chúng ta sẽ sử dụng toán tử += với vòng lặp for.

for x in range(1,4):
    test += ['test7']
    print(test)

Đối với mỗi lần lặp của vòng lặp for, một item List bổ sung của ‘fish’ được thêm vào List gốc test.

shark = ['shark']

for x in range(1,4):
    sharks *= 2
    print(sharks)

Các toán tử + và * có thể được sử dụng để nối List và nhân List. Các toán tử ghép += và *= có thể nối các List và nhân các List và chuyển danh tính mới cho List ban đầu.

Xem thêm list trong c++

Xóa một item khỏi List

Các item có thể được xóa khỏi List bằng cách sử dụng câu lệnh del. Thao tác này sẽ xóa giá trị tại số chỉ item mà bạn chỉ định trong List.

Từ List sea_creatures, hãy xóa item ‘octopus’. item này nằm ở vị trí chỉ item là 1. Để xóa item này, chúng ta sẽ sử dụng câu lệnh del sau đó gọi biến List và số chỉ item của item đó:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1]
print(sea_creatures)

Bây giờ item ở vị trí chỉ item 1, string ‘octopus’, không còn trong List sea_creatures của chúng ta.

Chúng ta cũng có thể chỉ định một phạm vi với câu lệnh del. Giả sử chúng tôi muốn xóa không chỉ item ‘bạch tuộc’ mà còn cả ‘blobfish’ và ‘mantis tôm’. Chúng ta có thể gọi một phạm vi trong sea_creatures với câu lệnh del để thực hiện điều này:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1:4]
print(sea_creatures)

Bằng cách sử dụng một slice với câu lệnh del, chúng tôi có thể xóa các item nằm giữa số chỉ item là 1 (bao gồm) và số chỉ item là 4 (không bao gồm), để lại cho chúng tôi List 3 item sau khi xóa 3 item .

Câu lệnh del cho phép chúng ta xóa các item cụ thể khỏi kiểu dữ liệu List.

Xây dựng một List với các item List

List có thể được xác định với các item được tạo thành từ List, với mỗi List được đặt trong dấu ngoặc vuông được đặt bên trong dấu ngoặc lớn hơn của List cha:

sea_names = [['shark', 'octopus', 'squid', 'mantis shrimp'],['Sammy', 'Jesse', 'Drew', 'Jamie']]

Các List này trong List được gọi là List lồng nhau.

Để truy cập một item trong List này, chúng tôi sẽ phải sử dụng nhiều chỉ item:

print(sea_names[1][0])
print(sea_names[0][0])

List đầu tiên, vì nó bằng với một item, sẽ có số chỉ item là 0, đây sẽ là số đầu tiên trong cấu trúc và List thứ hai sẽ có số chỉ item là 1. Trong mỗi List lồng bên trong sẽ có số chỉ item riêng biệt, mà chúng ta sẽ gọi trong số chỉ item thứ hai:

sea_names[0][0] = 'shark'
sea_names[0][1] = 'octopus'
sea_names[0][2] = 'squid'
sea_names[0][3] = 'mantis shrimp'

sea_names[1][0] = 'Sammy'
sea_names[1][1] = 'Jesse'
sea_names[1][2] = 'Drew'
sea_names[1][3] = 'Jamie'

Khi làm việc với List của List, điều quan trọng cần lưu ý là bạn sẽ cần tham khảo nhiều hơn một số chỉ item để truy cập các item cụ thể trong List lồng nhau có liên quan.

Xem thêm List trong Java

Các phương pháp sắp xếp List

Trong Python, có nhiều phương pháp khác nhau để sắp xếp một list. Dưới đây là một số phương pháp phổ biến:

Sắp xếp list theo thứ tự tăng dần bằng phương thức sort():

my_list = [4, 2, 1, 3]
my_list.sort()
print(my_list)  # Output: [1, 2, 3, 4]

Sắp xếp list theo thứ tự giảm dần bằng phương thức sort() và tham số reverse=True:

my_list = [4, 2, 1, 3]
my_list.sort(reverse=True)
print(my_list)  # Output: [4, 3, 2, 1]

Sắp xếp list theo thứ tự tăng dần bằng hàm sorted():

my_list = [4, 2, 1, 3]
sorted_list = sorted(my_list)
print(sorted_list)  # Output: [1, 2, 3, 4]

Sắp xếp list theo thứ tự giảm dần bằng hàm sorted() và tham số reverse=True:

my_list = [4, 2, 1, 3]
sorted_list = sorted(my_list, reverse=True)
print(sorted_list)  # Output: [4, 3, 2, 1]

Sắp xếp list theo một tiêu chí cụ thể bằng hàm sorted() và tham số key:

my_list = ['banana', 'apple', 'cherry', 'date']
sorted_list = sorted(my_list, key=len)  # Sắp xếp theo độ dài các phần tử
print(sorted_list)  # Output: ['date', 'apple', 'cherry', 'banana']

Sắp xếp list theo một tiêu chí cụ thể bằng hàm sorted() và hàm lambda:

my_list = ['banana', 'apple', 'cherry', 'date']
sorted_list = sorted(my_list, key=lambda x: x[1])  # Sắp xếp theo ký tự thứ hai của mỗi phần tử
print(sorted_list)  # Output: ['banana', 'cherry', 'date', 'apple']

Lưu ý rằng cách sắp xếp list trong Python có thể được tùy chỉnh và mở rộng theo nhu cầu của bạn bằng cách sử dụng các hàm và phương pháp sắp xếp khác nhau.

Xem thêm Append() trong python thêm item vào list

Các phương pháp tìm kiếm trong List

Trong Python, có một số phương pháp tìm kiếm phổ biến để tìm kiếm một phần tử trong một list. Dưới đây là một số phương pháp tìm kiếm thông dụng:

Tìm kiếm phần tử trong list bằng phương thức index():

my_list = [4, 2, 1, 3]
index = my_list.index(2)
print(index)  # Output: 1

Lưu ý: Phương thức index() chỉ trả về chỉ số (index) đầu tiên của phần tử tìm thấy trong list. Nếu không tìm thấy phần tử, sẽ xảy ra lỗi ValueError.

Tìm kiếm phần tử trong list bằng phương thức count():

my_list = [4, 2, 1, 3, 2]
count = my_list.count(2)
print(count)  # Output: 2

Phương thức count() trả về số lần xuất hiện của phần tử trong list.

Tìm kiếm phần tử trong list bằng vòng lặp và cấu trúc điều kiện:

my_list = [4, 2, 1, 3]
target = 2
found = False

for item in my_list:
    if item == target:
        found = True
        break

if found:
    print("Phần tử được tìm thấy trong list")
else:
    print("Phần tử không được tìm thấy trong list")

Trong ví dụ trên, chúng ta sử dụng vòng lặp for để duyệt qua từng phần tử trong list và kiểm tra xem có phần tử nào bằng target hay không.

Sử dụng các phương pháp tìm kiếm từ thư viện numpy (đối với list chứa dữ liệu số học):

import numpy as np

my_list = [4, 2, 1, 3]
target = 2
index = np.where(np.array(my_list) == target)[0]

if len(index) > 0:
    print("Phần tử được tìm thấy tại vị trí:", index)
else:
    print("Phần tử không được tìm thấy trong list")

Trong trường hợp list chứa dữ liệu số học, bạn có thể sử dụng thư viện numpy để tìm kiếm và trả về vị trí của phần tử trong list.

Lưu ý rằng cách tìm kiếm trong list có thể khác nhau tùy thuộc vào yêu cầu cụ thể của bạn. Hãy chọn phương pháp phù hợp với tình huống và kiểu dữ liệu trong list của bạn.

Kết luận List trong Python

Kiểu dữ liệu List là kiểu dữ liệu linh hoạt có thể được sửa đổi trong suốt quá trình thực hiện chương trình của bạn. Hướng dẫn này bao gồm các tính năng cơ bản của List, bao gồm lập chỉ item, cắt, sửa đổi và nối List.

Từ đây, bạn có thể tìm hiểu thêm về cách làm việc với List trong Python bằng cách đọc “Cách sử dụng phương pháp List” và về cách hiểu List để tạo List dựa trên List hiện có. Để tìm hiểu thêm về các loại dữ liệu nói chung, bạn có thể đọc hướng dẫn “Tìm hiểu các loại dữ liệu” của chúng tôi.

Xem thêm linked list trong c++

Python

List trong Python