Các cấu trúc dữ liệu trong Python bạn cần học

Python đã được sử dụng trên toàn thế giới cho các lĩnh vực khác nhau như làm trang web, trí tuệ nhân tạo và nhiều hơn nữa. Nhưng để có thể làm được tất cả những điều này, dữ liệu đóng một vai trò rất quan trọng, điều đó có nghĩa là dữ liệu này cần được lưu trữ hiệu quả và việc truy cập nó phải kịp thời. Vậy làm thế nào để bạn đạt được điều này? Và đó chính là Cấu trúc dữ liệu. Chúng ta hãy tìm hiểu Cấu trúc dữ liệu trong Python thông qua các chủ đề sẽ được đề cập dưới đây.

Để tiện cho việc tìm hiểu ta sẽ đi qua các đề mục sau: 

• Cấu trúc dữ liệu là gì?
• Các kiểu cấu trúc dữ liệu trong Python
• Cấu trúc dữ liệu tích hợp
  • Danh sách (List)
  • Từ điển (Dictionary)
  • Tuple
  • Sets
• Cấu trúc dữ liệu do người dùng xác định
  • Arrays vs. List
  • Stack
  • Queue
  • Trees
  • Linked Lists
  • Graphs
  • HashMaps

Cấu trúc dữ liệu là gì?

Việc tổ chức, quản lý và lưu trữ dữ liệu rất quan trọng vì nó cho phép truy cập dễ dàng hơn và sửa đổi hiệu quả. Cấu trúc dữ liệu (Data Structure) cho phép bạn sắp xếp dữ liệu của mình theo cách cho phép bạn lưu trữ các bộ dữ liệu được thu thập, liên quan đến chúng và theo đó mà thực hiện các thao tác trên chúng.

Có thể bạn quan tâm: Top 10 tài liệu lập trình Python cơ bản và nâng cao

Các kiểu cấu trúc dữ liệu trong Python

Python có hỗ trợ ngầm cho Cấu trúc dữ liệu cho phép bạn lưu trữ và truy cập dữ liệu. Các cấu trúc này được gọi là List, Dictionary, Tuple và Set.

Python cho phép người dùng tạo Cấu trúc dữ liệu của riêng họ, cho phép toàn quyền kiểm soát chức năng. Các cấu trúc dữ liệu nổi bật nhất là Stack, Queue, Tree, Linked List, v.v. đồng thời cũng có sẵn trong các ngôn ngữ lập trình khác. Vì vậy, bây giờ bạn đã biết các loại có sẵn bao gồm những gì, vậy còn ngại gì việc dùng Cấu trúc dữ liệu và triển khai chúng bằng Python.

Cấu trúc dữ liệu tích hợp (Built-in Data Structures)

Về cấu trúc dữ liệu trong Python, các Cấu trúc dữ liệu này được tích hợp sẵn với Python giúp lập trình dễ dàng hơn và giúp các lập trình viên sử dụng chúng để có được các giải pháp nhanh hơn. Hãy cùng tìm hiểu chi tiết hơn từng phần trong cấu trúc dữ liệu.

Lists

Lists được sử dụng để lưu trữ dữ liệu của các loại dữ liệu khác nhau một cách tuần tự. Có các địa chỉ được gán cho mọi thành phần của danh sách, được gọi là Index. Giá trị chỉ mục bắt đầu từ 0 và tiếp tục cho đến khi phần tử cuối cùng được gọi là chỉ số dương. Ngoài ra còn có lập chỉ mục tiêu cực bắt đầu từ -1 cho phép bạn truy cập các phần tử từ cuối đến trước. Xem qua ví dụ bên dưới để hiểu rõ hơn
Tạo một Lists:
Để tạo danh sách, bạn sử dụng dấu ngoặc vuông và thêm các yếu tố vào đó. Nếu bạn không vượt qua bất kỳ yếu tố nào trong dấu ngoặc vuông, bạn sẽ nhận được một danh sách trống làm đầu ra.

1	my_list = [] #create empty list
2	print(my_list)
3	my_list = [1, 2, 3, 'example', 3.132] #creating list with data
4	print(my_list)

Output: 
[]
[1, 2, 3, ‘example’, 3.132]

Thêm các yếu tố:

Thêm các yếu tố trong danh sách có thể đạt được bằng cách sử dụng các hàm append (), extend () và insert ().

• Hàm append () thêm tất cả các phần tử được truyền vào nó dưới dạng một phần tử.
• Hàm extend () thêm từng phần tử vào danh sách.
• Hàm insert () thêm phần tử được truyền vào giá trị chỉ mục và tăng kích thước của danh sách.

1	my_list = [1, 2, 3]
2	print(my_list)
3	my_list.append([555, 12]) #add as a single element
4	print(my_list)
5	my_list.extend([234, 'more_example']) #add as different elements
6	print(my_list)
7	my_list.insert(1, 'insert_example') #add element i
8	print(my_list)

Output:
[1, 2, 3]
[1, 2, 3, [555, 12]]
[1, 2, 3, [555, 12], 234, ‘more_example’]
[1, ‘insert_example’, 2, 3, [555, 12], 234, ‘more_example’]
Xóa các yếu tố:

• Để xóa các thành phần, hãy sử dụng từ khóa del được tích hợp sẵn trong Python nhưng điều này không trả lại bất cứ điều gì cho chúng tôi.
• Nếu bạn muốn phần tử quay lại, bạn sử dụng hàm pop () lấy giá trị chỉ mục.
• Để loại bỏ một phần tử theo giá trị của nó, bạn sử dụng hàm remove ().

Ví dụ:

1	my_list = [1, 2, 3, 'example', 3.132, 10, 30]
2	del my_list[5] #delete element at index 5
3	print(my_list)
4	my_list.remove('example') #remove element with value
5	a = my_list.pop(1) #pop element from list
6	a = my_list.pop(1) #pop element from list
7	print('Popped Element: ', a, ' List remaining: ', my_list)
8	my_list.clear() #empty the list
9	print(my_list)

Output:
[1, 2, 3, ‘example’, 3.132, 30]
[1, 2, 3, 3.132, 30]
Popped Element: 2 List remaining: [1, 3, 3.132, 30]
[]
Yếu tố truy cập:
Truy cập các phần tử giống như truy cập Chuỗi (Strings) trong Python. Bạn vượt qua các giá trị index và do đó có thể có được các giá trị khi cần thiết.

1	my_list = [1, 2, 3, 'example', 3.132, 10, 30]
2	for element in my_list: #access elements one by one
3	print(element)
4	print(my_list) #access all elements
5	print(my_list[3]) #access index 3 element
6	print(my_list[0:2]) #access elements from 0 to 1 and exclude 2
7	print(my_list[::-1]) #access elements in reverse

Output:
1
2
3
example
3.132
10
30
[1, 2, 3, ‘example’, 3.132, 10, 30]
example
[1, 2]
[30, 10, 3.132, ‘example’, 3, 2, 1]
Các chức năng khác:
Bạn có một số chức năng khác có thể được sử dụng khi làm việc với cấu trúc dữ liệu trong Python này.

• Hàm len () trả về cho chúng ta độ dài của list.
• Hàm index () tìm giá trị chỉ mục của giá trị được truyền vào nơi nó đã gặp lần đầu tiên.
• Hàm Count () tìm số đếm của giá trị được truyền cho nó.
• Các hàm được sắp xếp () và sort () thực hiện cùng một việc, đó là sắp xếp các giá trị của danh sách. Sắp xếp () có kiểu trả về trong khi sort () sửa đổi list ban đầu.

1	my_list = [1, 2, 3, 10, 30, 10]
2	print(len(my_list)) #find length of list
3	print(my_list.index(10)) #find index of element that occurs first
4	print(my_list.count(10)) #find count of the element
5	print(sorted(my_list)) #print sorted list but not change original
6	my_list.sort(reverse=True) #sort original list
7	print(my_list)

Output:
6
3
2
[1, 2, 3, 10, 10, 30]
[30, 10, 10, 3, 2, 1]

Dictionary

Trong các cấu trúc dữ liệu trong Python, Dictionary được sử dụng để lưu trữ các cặp key-value. Để hiểu rõ hơn, hãy nghĩ đến một thư mục điện thoại nơi hàng trăm và hàng ngàn tên và số tương ứng của chúng đã được thêm vào. Bây giờ các giá trị không đổi ở đây là Tên và Số điện thoại được gọi là các phím. Và các tên và số điện thoại khác nhau là các giá trị đã được đưa vào các phím. Nếu bạn truy cập các giá trị của các phím, bạn sẽ nhận được tất cả tên và số điện thoại. Vì vậy, đó là những gì một cặp key-value. Và trong Python, cấu trúc này được lưu trữ bằng Dictionary. Để dễ hiểu hơn chúng ta cùng xét ví dụ.
Tạo một từ điển
Từ điển có thể được tạo bằng cách sử dụng dấu ngoặc hoa hoặc sử dụng hàm dict (). Bạn cần thêm các cặp khóa-giá trị bất cứ khi nào bạn làm việc với từ điển.

1	my_dict = {} #empty dictionary
2	print(my_dict)
3	my_dict = {1: 'Python', 2: 'Java'} #dictionary with elements
4	print(my_dict)

Output:
{}
{1: ‘Python’, 2: ‘Java’}
Thay đổi và thêm khóa, cặp giá trị
Để thay đổi các giá trị của từ điển, bạn cần phải làm điều đó bằng cách sử dụng các phím. Vì vậy, trước tiên bạn truy cập khóa và sau đó thay đổi giá trị cho phù hợp. Để thêm giá trị, bạn chỉ cần thêm một cặp key-value khác như hiển thị bên dưới:

1	my_dict = {'First': 'Python', 'Second': 'Java'}
2	print(my_dict)
3	my_dict['Second'] = 'C++' #changing element
4	print(my_dict)
5	my_dict['Third'] = 'Ruby' #adding key-value pair
6	print(my_dict)

Output:
{‘First’: ‘Python’, ‘Second’: ‘Java’}
{‘First’: ‘Python’, ‘Second’: ‘C++’}
{‘First’: ‘Python’, ‘Second’: ‘C++’, ‘Third’: ‘Ruby’}

Xóa khóa, cặp giá trị
Để xóa các giá trị, bạn sử dụng hàm pop () trả về giá trị đã bị xóa.
Để truy xuất cặp khóa-giá trị, bạn sử dụng hàm popitem () trả về một bộ khóa và giá trị.
Để xóa toàn bộ Dictionary, bạn sử dụng hàm clear ().
Output:
Value: Ruby
Dictionary: {‘First’: ‘Python’, ‘Second’: ‘Java’}

Key, value pair: (‘Second’, ‘Java’)
Dictionary {‘First’: ‘Python’}

{}
Yếu tố truy cập
Bạn chỉ có thể truy cập các yếu tố bằng cách sử dụng các phím. Bạn có thể sử dụng hàm get () hoặc chỉ truyền các giá trị chính và bạn sẽ truy xuất các giá trị.

1	my_dict = {'First': 'Python', 'Second': 'Java'}
2	print(my_dict['First']) #access elements using keys
3	print(my_dict.get('Second'))

Output:
Python
Java
Các chức năng khác
Trong chức năng của cấu trúc dữ liệu trong Python này, bạn có các hàm khác nhau trả về cho chúng ta các khóa hoặc các giá trị của cặp key-value tương ứng với các hàm khóa (), giá trị (), vật phẩm () tương ứng.

1	my_dict = {'First': 'Python', 'Second': 'Java', 'Third': 'Ruby'}
2	print(my_dict.keys()) #get keys
3	print(my_dict.values()) #get values
4	print(my_dict.items()) #get key-value pairs
5	print(my_dict.get('First'))

Output:
dict_keys([‘First’, ‘Second’, ‘Third’])
dict_values([‘Python’, ‘Java’, ‘Ruby’])
dict_items([(‘First’, ‘Python’), (‘Second’, ‘Java’), (‘Third’, ‘Ruby’)])
Python

Tuple (các bộ dữ liệu)

Dưới đây là so sánh 2 cấu trúc dữ liệu trong Python Tuple vs List
 

Tuples giống như các list với ngoại lệ là dữ liệu một khi được nhập vào bộ dữ liệu không thể thay đổi bất kể điều gì. Ngoại lệ duy nhất là khi dữ liệu bên trong Tuple có thể thay đổi, chỉ sau đó dữ liệu Tuple có thể được thay đổi. Xem ví dụ để hiểu rõ hơn:
Tạo một tuple
Bạn tạo một tuple bằng cách sử dụng dấu ngoặc đơn hoặc

1	my_tuple = (1, 2, 3) #create tuple
2	print(my_tuple)

Output:
(1, 2, 3)
Yếu tố truy cập
Truy cập các phần tử giống như để truy cập các giá trị trong lists.

1	my_tuple2 = (1, 2, 3, 'growupwork') #access elements
2	for x in my_tuple2:
3	print(x)
4	print(my_tuple2)
5	print(my_tuple2[0])
6	print(my_tuple2[:])
7	print(my_tuple2[3][4])

Output:
1
2
3
growupwork
(1, 2, 3, ‘growupwork’)
1
(1, 2, 3, ‘growupwork’)
e
Các yếu tố bổ sung
Để nối thêm các giá trị, bạn sử dụng toán tử ‘+, sẽ mất một tuple khác để được thêm vào nó.

1	my_tuple = (1, 2, 3)
2	my_tuple = my_tuple + (4, 5, 6) #add elements
3	print(my_tuple)

Output:
(1, 2, 3, 4, 5, 6)
Các chức năng khác
Các chức năng này giống như những chức năng của lists.

1	my_tuple = (1, 2, 3, ['hindi', 'python'])
2	my_tuple[3][0] = 'english'
3	print(my_tuple)
4	print(my_tuple.count(2))
5	print(my_tuple.index(['english', 'python']))

Output:
(1, 2, 3, [‘english’, ‘python’])
1
3

Sets

Sets là một tập hợp các yếu tố không có thứ tự là duy nhất. Có nghĩa là ngay cả khi dữ liệu được lặp lại nhiều lần, nó sẽ chỉ được nhập vào tập hợp một lần. Cấu trúc dữ liệu trong Python này giống với các Sets mà bạn đã học về số học. Các hoạt động cũng tương tự như với các Sets số học. Xem chương trình ví dụ dưới đây để hiểu rõ hơn.
Tạo một sets
Các sets được tạo bằng cách sử dụng các dấu ngoặc hoa nhưng thay vì thêm các cặp key-value, bạn chỉ cần truyền các giá trị cho nó.

1	my_set = {1, 2, 3, 4, 5, 5, 5} #create set
2	print(my_set)

Output:
{1, 2, 3, 4, 5}
Thêm các yếu tố
Để thêm các phần tử, bạn sử dụng hàm add () và truyền giá trị cho nó.

1	my_set = {1, 2, 3}
2	my_set.add(4) #add element to set
3	print(my_set)

Output:
{1, 2, 3, 4}
Hoạt động theo sets
Các hoạt động khác nhau trên tập hợp như thể thống nhất, giao nhau, vv được hiển thị dưới đây.

1	my_set = {1, 2, 3, 4}
2	my_set_2 = {3, 4, 5, 6}
3	print(my_set.union(my_set_2), '----------', my_set | my_set_2)
4	print(my_set.intersection(my_set_2), '----------', my_set & my_set_2)
5	print(my_set.difference(my_set_2), '----------', my_set - my_set_2)
6	print(my_set.symmetric_difference(my_set_2), '----------', my_set ^ my_set_2)
7	my_set.clear()
8	print(my_set)

• Hàm union () kết hợp dữ liệu có trong cả hai sets.
• Hàm giao nhau () chỉ tìm thấy dữ liệu trong cả hai sets.
• Hàm differ () xóa dữ liệu có trong cả hai và dữ liệu đầu ra chỉ có trong tập được truyền.
• Hàm symmetric_difference () thực hiện giống như hàm differ () nhưng xuất ra dữ liệu còn lại trong cả hai sets.

Output:
{1, 2, 3, 4, 5, 6} ———- {1, 2, 3, 4, 5, 6}
{3, 4} ———- {3, 4}
{1, 2} ———- {1, 2}
{1, 2, 5, 6} ———- {1, 2, 5, 6}
set()

Vậy giờ đây, bạn đã hiểu về tích hợp các Cấu trúc dữ liệu (built-in Data Structures), hãy để bắt đầu với Cấu trúc dữ liệu do người dùng xác định - loại lớn thứ hai của cấu trúc dữ liệu trong Python. Cấu trúc dữ liệu do người dùng định nghĩa, chính tên cho thấy người dùng xác định cách thức Cấu trúc dữ liệu sẽ hoạt động và xác định các chức năng trong đó. Điều này cung cấp cho người dùng toàn quyền kiểm soát cách dữ liệu cần được lưu, thao tác và vv.

Chúng ta hãy tiếp tục tìm hiểu và  nghiên cứu các Cấu trúc dữ liệu nổi bật nhất trong hầu hết các ngôn ngữ lập trình.

User-Defined Data Structures (Cấu trúc dữ liệu do người dùng xác định)

Arrays vs. Lists

Arrays vs. Lists cùng một cấu trúc với một sự khác biệt. Lists cho phép lưu trữ phần tử dữ liệu không đồng nhất trong khi Arrays chỉ cho phép các phần tử đồng nhất được lưu trữ bên trong chúng.
Trong đó. Một Arrays về cơ bản là một cấu trúc dữ liệu có thể chứa nhiều hơn một giá trị tại một thời điểm. Nó là một tập hợp hoặc loạt các yếu tố được đặt cùng loại.
Ví dụ:

1	a=arr.array('d',[1.2,1.3,2.3])

Stack

Stacks là các cấu trúc dữ liệu tuyến tính dựa trên nguyên tắc Last-In-First-Out (LIFO) trong đó dữ liệu được nhập sau cùng sẽ là dữ liệu đầu tiên được truy cập. cấu trúc dữ liệu trong Python này được xây dựng bằng cách sử dụng cấu trúc mảng (array)và có các hoạt động cụ thể là đẩy (thêm) các phần tử, popping (xóa) các phần tử và chỉ truy cập các phần tử từ một điểm trong Stacks được gọi là TOP. TOP này là con trỏ đến vị trí hiện tại của Stacks. Stacks được sử dụng nổi bật trong các ứng dụng như Recursive Programming, đảo ngược các từ, hoàn tác các cơ chế trong trình soạn thảo văn bản, v.v.

Queue

Queue cũng là một cấu trúc dữ liệu tuyến tính dựa trên nguyên tắc Nhập trước xuất trước (FIFO) trong đó dữ liệu được nhập trước sẽ được truy cập trước. Nó được xây dựng bằng cấu trúc array và có các thao tác có thể được thực hiện từ cả hai đầu của Queue, nghĩa là đầu-đuôi hoặc mặt trước. Các hoạt động như thêm và xóa các phần tử được gọi là En-Queue và De-Queue và truy cập các phần tử có thể được thực hiện. Queue được sử dụng làm Bộ đệm mạng (Network Buffers) để quản lý tắc nghẽn lưu lượng, được sử dụng trong Hệ điều hành để Lên lịch công việc và nhiều hơn nữa.

Tree

Tree là cấu trúc dữ liệu phi tuyến tính có gốc và nút. Root là nút từ nơi dữ liệu bắt nguồn và các nút là các điểm dữ liệu khác có sẵn cho chúng ta. Nút có trước là cha và nút sau được gọi là con. Có những cấp độ mà một Tree phải thể hiện độ sâu của thông tin. Các nút cuối cùng được gọi là leaf. Tree tạo ra một hệ thống phân cấp có thể được sử dụng trong rất nhiều ứng dụng trong thế giới thực như các trang HTML sử dụng Tree để phân biệt thẻ nào nằm dưới khối nào. cấu trúc dữ liệu trong Python này cũng hiệu quả trong mục đích tìm kiếm và nhiều hơn nữa.

Danh sách liên kết (Linked List)

Linked List là Cấu trúc dữ liệu tuyến tính không được lưu trữ do đó được liên kết với nhau bằng cách sử dụng con trỏ. Nút của danh sách được liên kết bao gồm dữ liệu và con trỏ được gọi là “Next”. Các cấu trúc này được sử dụng rộng rãi nhất trong các ứng dụng xem hình ảnh, ứng dụng nghe nhạc và vv.

Đồ thị (Graph)

Đồ thị được sử dụng để lưu trữ dữ liệu thu thập các điểm được gọi là đỉnh (nút) và cạnh (cạnh). Đồ thị có thể được gọi là đại diện chính xác nhất của bản đồ thế giới thực. Chúng được sử dụng để tìm khoảng cách cost-to-distance khác nhau giữa các điểm dữ liệu khác nhau được gọi là các nút và do đó tìm được đường dẫn ít nhất. Nhiều ứng dụng như Google Maps, Uber và nhiều ứng dụng khác sử dụng Biểu đồ để tìm khoảng cách ít nhất và tăng lợi nhuận theo những cách tốt nhất.

HashMaps

HashMaps giống như từ điển trong Python. Chúng có thể được sử dụng để thực hiện các ứng dụng như danh bạ, điền dữ liệu theo danh sách và nhiều hơn nữa

Gợi ý tìm việc:

Chúng ta vừa đi qua tất cả các Cấu trúc dữ liệu trong Python nổi bật nhất. GrowUpWork hy vọng bạn đã hiểu cấu trúc dữ liệu tích hợp cũng như Cấu trúc dữ liệu do người dùng định nghĩa mà chúng ta có trong Python và tại sao chúng quan trọng.