Xác định vị trí trong python

Nếu bạn muốn tìm trận đấu đầu tiên.

Python có một phương thức chuỗi được xây dựng sẵn để thực hiện công việc: index [] .

string.index[value, start, end]

Ở đâu:

• Giá trị: [Bắt buộc] Giá trị cần tìm.
• start: [Tùy chọn] Bắt đầu tìm kiếm ở đâu. Mặc định là 0.
• end: [Tùy chọn] Nơi kết thúc tìm kiếm. Mặc định là ở cuối chuỗi.

def character_index[]:
    string = "Hello World! This is an example sentence with no meaning."
    match = "i"
    return string.index[match]
        
print[character_index[]]
> 15

Nếu bạn muốn tìm tất cả các trận đấu.

Giả sử bạn cần tất cả các chỉ mục có ký tự matchchứ không chỉ chỉ mục đầu tiên.

Cách pythonic sẽ được sử dụng enumerate[].

def character_indexes[]:
    string = "Hello World! This is an example sentence with no meaning."
    match = "i"

    indexes_of_match = []

    for index, character in enumerate[string]:
        if character == match:
            indexes_of_match.append[index]
    return indexes_of_match

print[character_indexes[]]
# [15, 18, 42, 53]

Hoặc thậm chí tốt hơn với khả năng hiểu danh sách:

def character_indexes_comprehension[]:
    string = "Hello World! This is an example sentence with no meaning."
    match = "i"

    return [index for index, character in enumerate[string] if character == match]


print[character_indexes_comprehension[]]
# [15, 18, 42, 53]

1 hữu ích 0 bình luận chia sẻ

Nội dung chính

• 1. Khởi tạo list
• 2. Các toán tử với List
• 3. Kiểm tra số lượng phần tử/rỗng
• 4. Index
• 5. Slice & Slicing
• 6. Thêm phần tử vào List
• 7. Tìm kiếm trong list
• 8. Xóa phần tử khỏi list.
• 9. Sắp xếp trong list.
• 10. Lấy ra các phần tử với vòng lặp.

List là một kiểu dữ liệu thông dụng, thường được các lập trình viên dùng trong các ứng dụng cần có sự lưu trữ tạm thời. Python hỗ trợ cực nhiều các function, tiện ích để đẩy nhanh việc truy xuất dữ liệu vào/ra với List. Bài viết dưới đây sẽ giới thiệu với các bạn về kiểu dữ liệu thông dụng này, hãy cùng khám phá với Hybrid Technologies nhé!

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]

integer_list = [1, 2, 3, 4, 5]
print[f"integer_list: {integer_list}"]
integer_list.append[6]
print[f"integer_list after append: {integer_list}"]

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]

integer_list = [1, 2, 3, 4, 5]
integer_list.insert[2, 10]
print[f'After insert {integer_list}']

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ụ:

integer_list = [1, 2, 3, 4, 5]
float_list = [1.0, 2.1, 3.2, 4.3]

numbers = []
numbers = numbers + integer_list
print[f'after +: {numbers}']

numbers.extend[float_list]
print[f'after extend: {numbers}']

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ụ:

integer_list = [1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10]
number = 3
index = integer_list.index[3]
print[f"index of {number} in {integer_list}: {index}"]

number = 11
index = integer_list.index[11]

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.

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

number = 4 
print[f'{number} is in {integer_list}:', number in integer_list]

number = 6
print[f'{number} is in {integer_list}:', number in integer_list]

4 is in [1, 2, 3, 4, 5]: True

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.

integer_list = [1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10]
print["Trước khi xóa", integer_list]
integer_list.remove[5]
print["Sau khi xóa số 5", integer_list]
value = integer_list.pop[2]
print[f"Sau khi lấy ra giá trị {value} tại vị trí index=2: {integer_list}"]
value = integer_list.pop[]
print[f"Sau khi lấy ra giá trị {value} tại vị trí cuối cùng: {integer_list}"]

del integer_list[0]
print[f"Sau khi xóa tại vị trí index=0: {integer_list}"]

integer_list.clear[]
print[f"Sau khi xóa toàn bộ các bản ghi: {integer_list}"]

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.

10. Lấy ra các phần tử với vòng lặp.

Để lấy ra từng phần tử trong một List, thường các lập trình viên sẽ dùng vòng lặp for.

integer_list = [1, 2, 3, 4, 5]
for number in integer_list:
    print[number]

Kết quả:
1
2
3
4
5

Để lấy ra index và giá trị tại từng vị trí, sử dụng vòng lặp for với built-in function enumerate

for index, number in enumerate[integer_list]:
    print[f"index: {index}- value: {number}"]

index: 0- value: 1
index: 1- value: 2
index: 2- value: 3
index: 3- value: 4
index: 4- value: 5

Nguồn: Tổng Hợp.

KIỂU DỮ LIỆU LIST TRONG PYTHON

5 [100%] 1 vote