List trong Python — Phan Nhật Chánh

List trong ngôn ngữ lập trình Python là một dạng dữ liệu cho phép lưu trữ nhiều kiểu dữ liệu khác nhau trong nó, và chũng ta có thể truy xuất đến các phần tử bên trong nó thông qua vị trí của phần tử đó trong list. Nó giống như một mảng tuần tự trong các ngôn ngữ lập trình khác.

Các tính chất của list

Thứ tự phần tử khác nhau thì list khác nhau

x = [1, 2]
y = [1, 2]
z = [2, 1]

print (x == y) # True
print (x == z) # False

Chúng ta có thể thay đổi các phần tử trong một list

Thay đổi một phần tử

x = [1, 2, 3]
x[1] = 5
print(x) #KQ: [1, 5, 3]

Thay đổi nhiều phần tử

y = [1, 2, 3, 4, 5]
y[1:3] = [20, 30]
print(y) #KQ: [1, 20, 30, 4, 5]

Tạo một list

Tạo một list trực tiếp

x = [1, "Python", 3] # list với kiểu dữ liệu hỗn hợp
y = [[1, 2, 3],
    [4, 5, 6]] # list lồng nhau
z = [] # list rỗng

print(x) #KQ: [1, 'Python', 3]
print(y) #KQ: [[1, 2, 3], [4, 5, 6]]
print(z) #KQ: []

Tạo list từ một tuple

a = (1, 2, 3) # tuple
x = list(a)

print(a) #KQ: (1, 2, 3)
print(x) #KQ: [1, 2, 3]

Tạo list với vòng lặp for

x = [i for i in range(5)]
print (x) #KQ: [0, 1, 2, 3, 4]

Tạo một list từ hàm range(start, stop[, step]) Hàm này được sử dụng để tạo một element bắt đầu từ 0 (theo mặc định), tăng thêm 1 (theo mặc định) và kết thúc tại một số được chỉ định.
- start số nguyên bắt đầu, chuỗi sẽ bắt đầu với tham số này. Giá trị mặc định là 0.
- stop số nguyên kết thúc, chuỗi sẽ kết thúc với tham số này.
- step số nguyên xác định khoảng cách giữa các số bên trong element. Giá trị mặc định là 1.
```
x = [*range(10, 21, 1)]
print (x) #KQ: [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

y = [*range(10, 21, 2)]
print (y) #KQ: [10, 12, 14, 16, 18, 20]
```

Sử dụng hàm random.sample() để tạo một list các số nguyên ngẫu nhiên

import random
x = random.sample(range(100), k=3)
print (x) #KQ: ra 1 list với 3 phần tử ngẫu nhiên

import random
x = random.sample(range(10, 30), 5)
print (x) #KQ: ra 1 list với 5 phần tử ngẫu nhiên

Sao chép List

x = [1, 2, 3]
y = x
z = x.copy ()
t = x [:]
u = list (x)

x [2] = 30 # x thay đổi.
print (x) # KQ: [1, 2, 30]
print (y) # y thay đổi với x. KQ: [1, 2, 30]
print (z) # z không thay đổi. KQ: [1, 2, 3]
print (t) # t không thay đổi. KQ: [1, 2, 3]
print (u) # u không thay đổi. KQ: [1, 2, 3]

Truy cập các phần tử của list

List thông thường (1 chiều)

x = [1, 2, 3, 4]

print (x [0]) # phần tử đơn lẻ. KQ: 1
print (x [: 2]) # cắt phần tử (1 đến 2). KQ: [1, 2]
print (x [-2]) # phần tử từ phải qua (chỉ số âm). KQ: 3

List lồng nhau

y = [
        [1, 2, 3],
        [4, 5, 6]
    ]

print (y [0] [1]) # phần tử đơn lẻ. KQ: 2
print (y [1]) # hàng 1. KQ: [4, 5, 6]
print([row[1] for row in y]) # cột 1. KQ: [2, 5]

Lấy chiều dài của list

Hàm len(<element>) trong Python trả về độ dài (số lượng ký tự) của chuỗi được chỉ định.

x = [1, 2, 3, 4, 5]
y = [
        [1, 2, 3],
        [4, 5, 6]
    ]

print (len(x)) # KQ: 5
print (len(y)) # số hàng. KQ: 2
print (len(y[0])) # số cột. KQ: 3

Thêm phần tử vào list

append và extend
- .append(<item>) đây là phương thức dùng để thêm một phần tử vào vị trí cuối cùng của List hiện tại.
- .extend(<list phần tử>) thêm các phần tử mới vào cuối list đã có (mang tính kế thừa list đã có).
```
x = [1, 2, 3]

x.append (4) # thêm từng phần tử
print (x) # [1, 2, 3, 4]

x.extend ([5, 6]) # mở rộng list
print (x) # [1, 2, 3, 4, 5, 6]
```

Thêm phần tử vào các vị trí mong muốn của list

x = [1, 2, 3, 4]
x.insert (9, 5) # ở vị trí thứ 9 (cuối danh sách)
print (x) # [1, 2, 3, 4, 5]

y = [1, 2]
y.insert(1, 3) # chèn giá trị 3 vào sau phần tử thứ 1
print(y) # [1, 3, 2]

Loại bỏ các phần tử trong list

Sử dụng từ khóa del (được dùng để xóa đối tượng)

x = [1, 2, 3, 4, 5]
print(x) # [1, 2, 3, 4, 5]

del x[1]
print(x) # [1, 3, 4, 5]

del x[:2]
print(x) # [4, 5]

del x  # xóa toàn bộ list
print(x) # NameError: name 'x' is not defined

Sử dụng .remove(<item>) để xóa một giá trị trong list (nó xóa giá trị được tìm thấy đầu tiên):

x = [1, 2, 3, 4, 3]
x.remove(3) # xóa giá trị tìm thấy đầu tiên "3"
print(x) # [1, 2, 4, 3]

Nếu bạn muốn xóa tất cả giá trị cụ thể khỏi list (sử dụng vòng lặp for:

x = [1, 2, 3, 4, 3]
x = [i for i in x if (i!=3 and i!= 1)]
print(x) # [1, 2, 4]

Sử dụng .pop(<item>) dùng để xóa một phần tử được chỉ định ra khỏi list và trả về phần tử vừa xóa.

x = [1, 2, 3, 4]
y = x.pop(2)  # xóa phần tử ở vị trí thứ 2
print(x) # KQ: [1, 2, 4]
print(y) # KQ: 3

z = x.pop()  # xóa phần tử cuối cùng
print(x) # KQ: [1, 2]
print(z) # KQ: 4

Sử dụng .clear() để làm rỗng một list (phương thức này dùng để xóa tất cả các item bên trong list)
```
x = [1, 2, 3]
x.clear()
print(x) # KQ: []
```
Trường hợp đặc biệt, sử dụng danh sách rỗng:
```
x = [1, 2, 3, 4]
x[1:3] = []
print(x) # KQ: [1, 4]
```

Thao tác với 2 list

Intersection (phép giao nhau)

Hàm list(iterable) và hàm set(iterable)

iterable có thể là string, tuple, set, list,...
Nếu không truyền tham số, set() sẽ tạo ra một tập hợp rỗng.
Nếu được truyền tham số, nó sẽ tạo một tập hợp các phần tử trong iterable.

A = [1, 2, 3, 4]
B = [2, 3, 4, 9]
C = [2, 4, 9, 10]

print (list(set(A) & set(B))) #KQ: [2, 3, 4]
print (list(set(A) & set(C))) #KQ: [2, 4]
print (list(set(B) & set(C))) #KQ: [9, 2, 4]
print (list(set(A) & set(B) & set(C))) #KQ: [2, 4]

D = [6, 7, 8, 9, 10]
print (list(set(A) & set(D))) #KQ: []

Để thiết lập 2 tập hợp giao nhau trong Python ta sử dụng cú pháp <A>.intersection(<B>) Trong đó A là tập hợp sẽ được giao với các tập hợp B khác (A∩B).

A = {1, 2, 3, 4}
B = {2, 3, 4, 9}
C = {2, 4, 9, 10}

print(A.intersection(B)) #KQ: {2, 3, 4}
print(A.intersection(C)) #KQ: {2, 4}
print(B.intersection(C)) #KQ: {9, 2, 4}
print(A.intersection(B, C)) #KQ: {2, 4}

Ghép nối 2 list

Sử dụng + và *

x = [1, 2, 3]
print(x + [4, 5, 6]) #KQ: [1, 2, 3, 4, 5, 6]
print(["re"] * 3) #KQ: ['re', 're', 're']

Sắp xếp list

Hàm sorted(element, key=None, reverse=False)) trong Python sắp xếp các phần tử của một đối tượng theo thứ tự nhất định (tăng dần hoặc giảm dần) và trả về đối tượng dưới dạng danh sách đã sắp xếp.
- element string, list, tuple,...
- key (nếu có) hàm sorted() so sánh giá trị với key sau đó sắp xếp. Giá trị mặc định là None.
- reverse Nếu giá trị là true, danh sách sẽ được sắp xếp theo kiểu đảo ngược (hoặc giảm dần). Nếu không được khai báo, giá trị mặc định là false.

Trả lại list đã sắp xếp nhưng không thay đổi list:

x = [1, 5, 3, 2, 4]
print(sorted(x)) # ASC. KQ: [1, 2, 3, 4, 5]
print(sorted(x, reverse=True)) # DESC. KQ: [5, 4, 3, 2, 1]
print (x) # x không thay đổi. KQ: [1, 5, 3, 2, 4]

Sắp xếp và thay đổi list:

x = [1, 5, 3, 2, 4]
x.sort() # return None, ASC
print(x) # x không thay đổi
x.sort(reverse=True) # DESC
print(x)

Đảo ngược list

Hàm reversed() được sử dụng để đảo ngược các element (string, list, tuple,...) ban đầu.

x = [1, 2, 3, 4]
y = x[::-1] # x không thay đổi
print(x) #KQ: [1, 2, 3, 4]
print(y) #KQ: [4, 3, 2, 1]
x.reverse() # x thay đổi.
print(x) #KQ: [4, 3, 2, 1]

Thao tác cho từng phần tử trong list

Hàm lambda có thể có nhiều tham số nhưng chỉ có 1 biểu thức.
Cú pháp: lambda <tham số>: <biểu thức>

square = lambda x: x ** 2
x = [1, 2, 3, 4]
y = map(square, x)
print(list(y)) #KQ: [1, 4, 9, 16]

Lập chỉ mục cho list

Sử dụng hàm enumerate()
Cú pháp: enumerate(element, start=0)
- element string, list, tuple,...
- start bắt đầu bộ đếm từ số này. Nếu tham số start bị bỏ qua thì 0 sẽ là giá trị mặc định được gán.
```
courses = ['a', 'b', 'c']
for idx, val in enumerate(courses, start=1):
    print(idx, val)
    # Kết quả:
    # 1 a
    # 2 b
    # 3 c
```

Lấy chỉ số của một số phần tử

Sử dụng hàm index()

Cú pháp: list**.index(element, start, end)**

element là string, list, tuple,...
start Xác định chỉ mục bắt đầu, mặc định là 0.

end xác định chỉ mục kết thúc, mặc định là bằng độ dài của element.

lst = ['a', 'e', 'i', 'o', 'i', 'u']

index = lst.index('e')
print('Chỉ mục của e:', index) # KQ: 1

index = lst.index('i')
print('Chỉ mục của i:', index) # KQ: 2

hoặc

lst = ['a', 'e', 'i', 'o', 'i', 'u']

# Lấy chỉ mục của giá trị tối đa trong list
print('Giá trị là:',lst.index(max(lst))) # KQ: 5

Tham khảo thêm

Thông tin thêm về Python List