Hướng dẫn how is data structure implemented in python? - cấu trúc dữ liệu được thực hiện như thế nào trong python?

Python has been used worldwide for different fields such as making websites, artificial intelligence and much more. But to make all of this possible, data plays a very important role which means that this data should be stored efficiently and the access to it must be timely. So how do you achieve this? We use something called Data Structures. With that being said, let us go through the topics we will cover in Data Structures in Python. 

The article has been broken down into the following parts:

• What is a Data Structure?
• Types of Data Structures in Python
• Built-in Data Structures
  • List
  • Dictionary
  • Tuple
  • Sets
• User-Defined Data Structures
  • Arrays vs. List
  • Stack
  • Queue
  • Trees
  • Linked Lists
  • Graphs
  • HashMaps

So, let’s get started :]

What is a Data Structure? 

Organizing, managing and storing data is important as it enables easier access and efficient modifications. Data Structures allows you to organize your data in such a way that enables you to store collections of data, relate them and perform operations on them accordingly. 

Python has implicit support for Data Structures which enable you to store and access data. These structures are called List, Dictionary, Tuple and Set.

Python allows its users to create their own Data Structures enabling them to have full control over their functionality. The most prominent Data Structures are Stack, Queue, Tree, Linked List and so on which are also available to you in other programming languages. So now that you know what are the types available to you, why don’t we move ahead to the Data Structures and implement them using Python.

Built-in Data Structures

As the name suggests, these Data Structures are built-in with Python which makes programming easier and helps programmers use them to obtain solutions faster. Let’s discuss each of them in detail.

Lists

Lists are used to store data of different data types in a sequential manner. There are addresses assigned to every element of the list, which is called as Index. The index value starts from 0 and goes on until the last element called the positive index. There is also negative indexing which starts from -1 enabling you to access elements from the last to first. Let us now understand lists better with the help of an example program.

Find out our Python Training in Top Cities/Countries

Creating a list

To create a list, you use the square brackets and add elements into it accordingly. If you do not pass any elements inside the square brackets, you get an empty list as the output.

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

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

Adding Elements

Adding the elements in the list can be achieved using the append[], extend[] and insert[] functions.

• The append[] function adds all the elements passed to it as a single element.
• The extend[] function adds the elements one-by-one into the list.
• The insert[] function adds the element passed to the index value and increase the size of the list too.

my_list = [1, 2, 3]
print[my_list]
my_list.append[[555, 12]] #add as a single element
print[my_list]
my_list.extend[[234, 'more_example']] #add as different elements
print[my_list]
my_list.insert[1, 'insert_example'] #add element i
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’]

Deleting Elements

• To delete elements, use the del keyword which is built-in into Python but this does not return anything back to us.
• If you want the element back, you use the pop[] function which takes the index value.
• To remove an element by its value, you use the remove[] function.

Example:

my_list = [1, 2, 3, 'example', 3.132, 10, 30]
del my_list[5] #delete element at index 5
print[my_list]
my_list.remove['example'] #remove element with value
print[my_list]
a = my_list.pop[1] #pop element from list
print['Popped Element: ', a, ' List remaining: ', my_list]
my_list.clear[] #empty the list
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]
[]

Accessing Elements

Accessing elements is the same as accessing Strings in Python. You pass the index values and hence can obtain the values as needed.

my_list = [1, 2, 3, 'example', 3.132, 10, 30]
for element in my_list: #access elements one by one
    print[element]
print[my_list] #access all elements
print[my_list[3]] #access index 3 element
print[my_list[0:2]] #access elements from 0 to 1 and exclude 2
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]

Other Functions

You have several other functions that can be used when working with lists.

• The len[] function returns to us the length of the list.
• The index[] function finds the index value of value passed where it has been encountered the first time.
• The count[] function finds the count of the value passed to it.
• The sorted[] and sort[] functions do the same thing, that is to sort the values of the list. The sorted[] has a return type whereas the sort[] modifies the original list.

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

Output:

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

Dictionary

Dictionaries are used to store key-value pairs. To understand better, think of a phone directory where hundreds and thousands of names and their corresponding numbers have been added. Now the constant values here are Name and the Phone Numbers which are called as the keys. And the various names and phone numbers are the values that have been fed to the keys. If you access the values of the keys, you will obtain all the names and phone numbers. So that is what a key-value pair is. And in Python, this structure is stored using Dictionaries. Let us understand this better with an example program.

Tạo ra một từ điển

Từ điển có thể được tạo bằng cách sử dụng niềng hoa hoặc sử dụng hàm dict []. Bạn cần thêm các cặp giá trị khóa bất cứ khi nào bạn làm việc với từ điển.

my_dict = {} #empty dictionary
print[my_dict]
my_dict = {1: 'Python', 2: 'Java'} #dictionary with elements
print[my_dict]

Đầu ra: {} {1: ‘Python, 2:‘ Java,}
{}
{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ác khóa. 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 các giá trị, bạn chỉ cần thêm một cặp giá trị khóa khác như được hiển thị bên dưới.

my_dict = {'First': 'Python', 'Second': 'Java'}
print[my_dict]
my_dict['Second'] = 'C++' #changing element
print[my_dict]
my_dict['Third'] = 'Ruby' #adding key-value pair
print[my_dict]

Đầu ra: {'đầu tiên': 'python', 'thứ hai': 'java'} {'first': 'python', 'thứ hai': 'c ++'} {'first': 'python', 'thứ hai': ' C ++ ',' thứ ba ':' Ruby '}
{‘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 giá trị khóa, bạn sử dụng hàm popitem [] trả về một bộ khóa và giá trị.
• Để xóa toàn bộ từ điển, bạn sử dụng hàm Clear [].

my_dict = {'First': 'Python', 'Second': 'Java', 'Third': 'Ruby'}
a = my_dict.pop['Third'] #pop element
print['Value:', a]
print['Dictionary:', my_dict]
b = my_dict.popitem[] #pop the key-value pair
print['Key, value pair:', b]
print['Dictionary', my_dict]
my_dict.clear[] #empty dictionary
print['n', my_dict]

Output:

Giá trị: Từ điển Ruby: {{đầu tiên
Dictionary: {‘First’: ‘Python’, ‘Second’: ‘Java’}

Khóa, cặp giá trị: [’thứ hai,‘ java,] Từ điển {’đầu tiên
Dictionary {‘First’: ‘Python’}

{}

Truy cập các yếu tố

Bạn chỉ có thể truy cập các yếu tố bằ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ị.

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

Đầu ra: Python Java
Python
Java

Cac chưc năng khac

Bạn có các hàm khác nhau trả lại cho chúng tôi các khóa hoặc giá trị của cặp giá trị khóa tương ứng với các hàm khóa [], giá trị [], item [].

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

Đầu ra: Dict_Keys [['First', 'Second', 'thứ ba']] Dict_Values ​​[['Python', 'Java', 'Ruby']] Dict_Items [[['đầu tiên', 'Python'], ['thứ hai ',' Java '], [' thứ ba ',' ruby ​​']]]
dict_keys[[‘First’, ‘Second’, ‘Third’]]
dict_values[[‘Python’, ‘Java’, ‘Ruby’]]
dict_items[[[‘First’, ‘Python’], [‘Second’, ‘Java’], [‘Third’, ‘Ruby’]]]
Python

Tuple

Tuples giống như danh sách với ngoại lệ mà dữ liệu đã từng nhập vào bộ tuple 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 mới có thể được thay đổi. Chương trình ví dụ sẽ giúp bạn hiểu rõ hơn.

Tạo ra một tuple

Bạn tạo một tuple bằng cách sử dụng dấu ngoặc đơn hoặc sử dụng hàm tuple [].

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

Đầu ra: [1, 2, 3]
[1, 2, 3]

Truy cập các yếu tố

Bạn chỉ có thể truy cập các yếu tố bằ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ị.

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

Đầu ra: Python Java
1
2
3
edureka
[1, 2, 3, ‘edureka’]
1
[1, 2, 3, ‘edureka’]
e

Cac chưc năng khac

Bạn có các hàm khác nhau trả lại cho chúng tôi các khóa hoặc giá trị của cặp giá trị khóa tương ứng với các hàm khóa [], giá trị [], item [].

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

Đầu ra: Dict_Keys [['First', 'Second', 'thứ ba']] Dict_Values ​​[['Python', 'Java', 'Ruby']] Dict_Items [[['đầu tiên', 'Python'], ['thứ hai ',' Java '], [' thứ ba ',' ruby ​​']]]
[1, 2, 3, 4, 5, 6]

Cac chưc năng khac

Bạn có các hàm khác nhau trả lại cho chúng tôi các khóa hoặc giá trị của cặp giá trị khóa tương ứng với các hàm khóa [], giá trị [], item [].

Tuple
[1, 2, 3, [‘english’, ‘python’]]
1
3

Tuples giống như danh sách với ngoại lệ mà dữ liệu đã từng nhập vào bộ tuple 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 mới có thể được thay đổi. Chương trình ví dụ sẽ giúp bạn hiểu rõ hơn.

Tạo ra một tuple

Bạn tạo một tuple bằng cách sử dụng dấu ngoặc đơn hoặc sử dụng hàm tuple [].

Đầu ra: [1, 2, 3]

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

Truy cập các phần tử giống như để truy cập các giá trị trong danh sách.
{1, 2, 3, 4, 5}

Đầu ra: 1 2 3 Edureka [1, 2, 3, ‘Edureka,] 1 [1, 2, 3,‘ Edureka,] E

Các yếu tố nối tiếp

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

Để nối 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, 2, 3, 4}

Đầu ra: [1, 2, 3, 4, 5, 6]

Các chức năng này giống như chúng dành cho danh sách.

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

• my_list = [1, 2, 3]
  print[my_list]
  my_list.append[[555, 12]] #add as a single element
  print[my_list]
  my_list.extend[[234, 'more_example']] #add as different elements
  print[my_list]
  my_list.insert[1, 'insert_example'] #add element i
  print[my_list]
  

  4
• Đầu ra: [1, 2, 3, [‘Tiếng Anh,‘ Python,]] 1 3
• Bộ
• Bộ 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 hơn một lần, nó sẽ được nhập vào bộ chỉ một lần. Nó giống với các tập hợp mà bạn đã học bằng số học. Các hoạt động cũng giống như là với các bộ số học. Một chương trình ví dụ sẽ giúp bạn hiểu rõ hơn.

Tạo một bộ
{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[]

Các bộ được tạo bằng cách sử dụng niềng hoa nhưng thay vì thêm các cặp giá trị khóa, bạn chỉ cần truyền các giá trị cho nó.

Đầu ra: {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ó.

Đầu ra: {1, 2, 3, 4}

Hoạt động trong bộ

Các hoạt động khác nhau trên các tập hợp như liên minh, giao lộ và như vậy được hiển thị bên dưới.

Xếp hàng

Hàng đợi cũng là một cấu trúc dữ liệu tuyến tính dựa trên nguyên tắc đầu tiên đầu tiên [FIFO] trong đó dữ liệu được nhập đầu tiên sẽ được truy cập đầu tiên. Nó được xây dựng bằng cách sử dụng cấu trúc mảng và có các hoạt động có thể được thực hiện từ cả hai đầu của hàng đợi, nghĩa là đuôi hoặc lưng 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-cator và truy cập các yếu tố có thể được thực hiện. Hàng đợi được sử dụng làm bộ đệm mạng để quản lý tắc nghẽn giao thông, được sử dụng trong các hệ điều hành để lên lịch công việc và nhiều hơn nữa.

Cây

Cây là các 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 tôi. Nút đi trước là cha mẹ và nút sau được gọi là đứa trẻ. Có những cấp độ một cây phải hiển thị độ sâu của thông tin. Các nút cuối cùng được gọi là lá. Cây 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 cây để phân biệt thẻ nào có trong khối nào. Nó cũng hiệu quả trong việc tìm kiếm mục đích và nhiều hơn nữa.

Danh sách liên kết

Danh sách được liên kết là các cấu trúc dữ liệu tuyến tính không được lưu trữ do đó nhưng được liên kết với nhau bằng cách sử dụng con trỏ. Nút của một danh sách được liên kết bao gồm dữ liệu và một 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 trình phát nhạc, v.v.

Đồ thị

Biểu đồ được sử dụng để lưu trữ thu thập dữ liệu của các điểm gọi là các đỉnh [nút] và các cạnh [cạnh]. Đồ thị có thể được gọi là đại diện chính xác nhất của bản đồ trong thế giới thực. Chúng được sử dụng để tìm ra các khoảng cách chi phí 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 thấy đường dẫn ít nhất. Nhiều ứng dụng như Google Maps, Uber và nhiều biểu đồ sử dụng khác để 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. They are used to find the various cost-to-distance between the various data points called as the nodes and hence find the least path. Many applications such as Google Maps, Uber, and many more use Graphs to find the least distance and increase profits in the best ways.

Hashmaps

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

Điều đó kết thúc tất cả các cấu trúc dữ liệu nổi bật trong Python. Tôi hy vọng bạn đã hiểu được các cấu trúc dữ liệu do người dùng định nghĩa mà chúng tôi có trong Python và tại sao chúng lại quan trọng.

Bây giờ bạn đã hiểu các cấu trúc dữ liệu trong Python, hãy xem & nbsp; Chứng nhận Python & nbsp; bởi Edureka, & nbsp; một công ty học tập trực tuyến đáng tin cậy & nbsp; với mạng lưới nhiều hơn & NBSP; by Edureka, a trusted online learning company with a network of more than 250,000 satisfied learners spread across the globe.

Khóa đào tạo Chứng nhận lập trình Python của Edureka, được thiết kế cho các sinh viên và các chuyên gia muốn trở thành bậc thầy trong chương trình Python. Khóa học được thiết kế để cung cấp cho bạn một khởi đầu vào chương trình Python và đào tạo bạn cho cả các khái niệm cốt lõi và nâng cao.

Đi trước đường cong công nghệ với chương trình sau đại học này trong AI và học máy hợp tác với Học viện E & CNTT, Viện Công nghệ Quốc gia, Warangal. Khóa học trí tuệ nhân tạo này được quản lý để mang lại kết quả tốt nhất.

Có một câu hỏi cho chúng tôi? Vui lòng đề cập đến nó trong phần bình luận của các cấu trúc dữ liệu này mà bạn cần học với blog Python và chúng tôi sẽ liên hệ lại với bạn càng sớm càng tốt.

Cấu trúc dữ liệu được thực hiện như thế nào?

Chúng ta có thể thực hiện tất cả các cấu trúc dữ liệu trong Python không?

Các thuật toán được thực hiện như thế nào trong Python?

Cấu trúc dữ liệu nào được sử dụng để thực hiện?