Python cung cấp nhiều bộ sưu tập cấu trúc dữ liệu như danh sách, bộ dữ liệu, bộ và từ điển. Tuy nhiên, những bộ dữ liệu này rất giống với danh sách. Bởi vì danh sách là một cấu trúc dữ liệu thường được sử dụng, các nhà phát triển thường nhầm lẫn bộ dữ liệu khác với danh sách như thế nào
Bộ dữ liệu trong Python, giống như danh sách, là một tập hợp các mục thuộc bất kỳ loại dữ liệu nào, nhưng bộ dữ liệu là bất biến, có nghĩa là một khi đã được gán, chúng ta không thể thay đổi các phần tử của bộ hoặc chính bộ dữ liệu đó, trong khi các phần tử danh sách có thể thay đổi
Trong bài viết này, chúng tôi sẽ giải thích cho bạn Tuple trong python là gì và các thao tác khác nhau trên nó
Tạo Tuple
Các bộ chỉ có thể được tạo khi chúng được chỉ định, do đó, việc chèn tất cả các mục bên trong dấu ngoặc đơn, được phân tách bằng dấu phẩy, sẽ dẫn đến việc tạo một bộ
ví dụ 1
đầu ra
Khi thực thi, chương trình trên sẽ tạo đầu ra sau -
demoTuple_1: ['TutorialsPoint', 'python', 'codes']
ví dụ 2
đầu ra
Khi thực thi, chương trình trên sẽ tạo đầu ra sau -
demoTuple_2: [25, 6.8, 'TutorialsPoint']
ví dụ 3
đầu ra
demoTuple_3: ['Welcome', [5, 8, 11]]
Ví dụ 4
đầu ra
demoTuple_4: [[100, 80, 60], [2, 'TutorialsPoint']]
Truy cập các phần tử Tuple
Để truy cập các phần tử trong một tuple, chúng ta cần các chỉ mục
Chúng ta cũng có thể có các chỉ số âm trong bộ dữ liệu. Vì các chỉ mục bắt đầu bằng 0, nên chúng ta sử dụng 0 để truy cập phần tử đầu tiên của bộ, 1 để truy cập phần tử thứ hai, v.v.
Thuật toán [Các bước]
Sau đây là Thuật toán/các bước cần tuân thủ để thực hiện tác vụ mong muốn -
Tạo một biến để lưu trữ bộ dữ liệu đầu vào
In bộ dữ liệu đầu vào
Sử dụng chỉ mục tích cực, để truy cập phần tử đầu tiên của bộ dữ liệu đầu vào [chỉ mục bộ dữ liệu luôn bắt đầu từ 0]
Sử dụng chỉ mục tích cực, để truy cập phần tử thứ tư của bộ dữ liệu đầu vào [inputTuple [3]]
Mã số
đầu ra
Input Tuple: ['TutorialsPoint', 'python', 'sample', 'codes'] first element of tuple: TutorialsPoint fourth element of tuple: codes
Truy cập các phần tử Tuple bằng lập chỉ mục phủ định
Các chỉ mục phủ định, như chỉ mục danh sách và chuỗi, có thể được sử dụng để truy cập các phần tử bộ từ cuối
-1 để truy cập phần tử cuối cùng, -2 để truy cập phần tử cuối cùng thứ hai, v.v.
Thuật toán [Các bước]
Sau đây là Thuật toán/các bước cần tuân thủ để thực hiện tác vụ mong muốn -
Tạo một biến để lưu trữ bộ dữ liệu đầu vào
In bộ dữ liệu đầu vào
Sử dụng chỉ mục phủ định, để truy cập phần tử cuối cùng của bộ dữ liệu đầu vào [chỉ mục bộ dữ liệu phủ định luôn bắt đầu từ -1]
Sử dụng lập chỉ mục phủ định, để truy cập phần tử thứ hai cuối cùng của bộ dữ liệu đầu vào[inputTuple[-1]]
Mã số
đầu ra
Input Tuple: ['TutorialsPoint', 'python', 'sample', 'codes'] last element of tuple: codes last second element of tuple: sample
Cập nhật/Xóa phần tử Tuple
Một tuple là bất biến tôi. e, các mục của một tuple không thể thay đổi. Kết quả là, khi một bộ được tạo, bất kỳ thao tác nào cố gắng thay đổi các mục của nó đều bị hạn chế.
Chương trình sau cố gắng cập nhật/sửa đổi các thành phần của một bộ dữ liệu đầu vào, nhưng gây ra lỗi do bộ dữ liệu này là bất biến -
đầu ra
TypeError Traceback [most recent call last] in 4 # changing the 1st index element of the input tuple[python] to 'Java' 5 # It raises a TypeError since the tuple is immutable[tuple items cannot be changed] ----> 6 inputTuple[1] = 'Java' TypeError: 'tuple' object does not support item assignment
Chương trình sau cố gắng xóa các phần tử của bộ dữ liệu đầu vào, nhưng gây ra lỗi do bộ dữ liệu này là bất biến -
đầu ra
TypeError Traceback [most recent call last]
in
4 # deleting the 1st index element of the input tuple[python]
5 # It raises a TypeError since the tuple is immutable[tuple items cannot be changed]
----> 6 del inputTuple[1]
TypeError: 'tuple' object doesn't support item deletion
Phần kết luận
Bài viết này trình bày cách tạo bộ dữ liệu bằng bốn ví dụ khác nhau. Chúng tôi cũng đã học cách sử dụng lập chỉ mục để truy cập các phần tử tuple. Chúng tôi đã học cách sử dụng lập chỉ mục phủ định để truy cập các phần tử của bộ dữ liệu từ cuối. Chúng tôi đã trình bày cách bộ phát sinh lỗi khi cập nhật hoặc xóa phần tử
Bộ dữ liệu Python là một cấu trúc dữ liệu vùng chứa bất biến, có thứ tự và có thể lặp lại, có thể chứa các phần tử dữ liệu bất biến tùy ý và không đồng nhất
Tuple Motivation Ví dụ
Đây là một ví dụ cơ bản về việc tạo và sử dụng tuple
________số 8_______Bạn đã bao giờ có một hàm mà bạn muốn trả về một số giá trị chưa?
Giả sử, bạn có một hàm
t2 = 1, 2, 3, 'Python'1 có hai đối số. Cái đầu tiên là
t2 = 1, 2, 3, 'Python'2 được dịch thành một giá trị chuỗi và cái thứ hai là mã
t2 = 1, 2, 3, 'Python'3 thành một chuỗi mà đầu vào sẽ được dịch sang
Giả sử rằng đầu vào luôn bằng tiếng Anh. Đầu ra cũng phải có hai giá trị
- văn bản được dịch và
- một giá trị độ tin cậy cho thấy chất lượng ước tính của kết quả
Bây giờ, làm thế nào chúng ta có thể trả về cả hai giá trị cùng một lúc?
Một giải pháp rất phổ biến là lấy một đối tượng kết quả với một thuộc tính cho mỗi giá trị. Bạn phải xác định đối tượng này trước. Tùy thuộc vào bối cảnh chương trình của bạn, đây có thể là một ý tưởng hay. Tuy nhiên, trong Python, có một tùy chọn đơn giản hơn nhiều – bộ dữ liệu
Băng hình
Không có thời gian để đọc?
Hướng dẫn cơ bản về Python Tuples. Giới thiệu và cơ sở lý thuyết. Phần 1/7
Xem video này trên YouTubeĐây là video đầu tiên của một loạt các video bao gồm toàn bộ bài viết. Danh sách phát trên YouTube. https. //www. youtube. com/watch?v=D2i-SmUELJI&list=PLbo6ydLr984ZVxb8LemGocj44zfmsfnRY
Đặc điểm của Tuples
Cấu trúc dữ liệu tuple là cấu trúc dữ liệu có sẵn của ngôn ngữ Python với các đặc điểm sau
- Bộ dữ liệu là các thùng chứa, bạn có thể lưu trữ dữ liệu trong đó. Tài liệu Python định nghĩa một vùng chứa là một đối tượng thực hiện phương thức
t2 = 1, 2, 3, 'Python'
4. Nói cách khác, vùng chứa là thứ bạn có thể sử dụng toán tửt2 = 1, 2, 3, 'Python'
5 trên. Các ví dụ khác về vùng chứa trong Python là list, dict, set hoặc freezeset. Bộ sưu tập mô-đun chứa nhiều loại vùng chứa hơn - Các bộ dữ liệu được sắp xếp theo thứ tự, mỗi phần tử có vị trí của nó hoặc ngược lại, vị trí có ý nghĩa
- Các bộ dữ liệu có thể lặp lại, vì vậy bạn có thể sử dụng chúng, chẳng hạn như trong vòng lặp for
- Các bộ dữ liệu là bất biến, điều đó có nghĩa là bạn không thể thay đổi một bộ dữ liệu sau khi nó được tạo. Khi một tuple đã được tạo, bạn không thể sửa đổi nó nữa. Một ví dụ khác về kiểu dữ liệu bất biến trong Python là chuỗi. Bạn không thể sửa đổi các bộ dữ liệu hoặc chuỗi trong Python, thay vào đó, Python tạo một phiên bản mới với các giá trị đã sửa đổi. Tuy nhiên, nếu một bộ chứa các kiểu dữ liệu có thể thay đổi, chẳng hạn như danh sách, thì các phần tử của các danh sách đó có thể thay đổi. Tuy nhiên, các tham chiếu trong bộ dữ liệu đến các danh sách đó không thể
- Các bộ dữ liệu không đồng nhất vì chúng có thể chứa các phần tử của một số loại dữ liệu khác nhau cùng một lúc. Một ví dụ về kiểu dữ liệu đồng nhất là các chuỗi vì chúng chỉ có thể chứa các ký tự
cú pháp
Để tạo một bộ dữ liệu, chúng tôi đặt một số giá trị được phân tách bằng dấu phẩy trong dấu ngoặc đơn
t1 = [1, 2, 3, 'Python']
Và chúng ta có thể làm cho nó đơn giản hơn nữa, không cần dấu ngoặc đơn
t2 = 1, 2, 3, 'Python'
Cả hai cách đều hoàn toàn hợp lệ và tạo một bộ chứa bốn giá trị, ba số nguyên và một chuỗi. Tạo một tuple còn được gọi là đóng gói. Hãy xem một số bộ dữ liệu đặc biệt tiếp theo
empty_tuple = [] one_element_tuple = 1,
Bộ dữ liệu trống yêu cầu dấu ngoặc đơn, bởi vì đó là tất cả. Nếu bạn muốn tạo một bộ chỉ chứa một phần tử, bạn không cần dấu ngoặc đơn mặc dù trong trường hợp này, tôi khuyên bạn nên sử dụng dấu ngoặc đơn để cải thiện khả năng đọc. Có thể dễ dàng bỏ qua một dấu phẩy ở cuối dòng
hoạt động
Đối với các ví dụ sau, chúng tôi giả sử rằng s và t là các bộ, x, i, j, k, n là các số nguyên
Cú phápGiải thícht2 = 1, 2, 3, 'Python'6Kiểm tra xem bộ t có chứa giá trị trong biến x_______9_______7Kiểm tra xem bộ t có chứa giá trị trong biến x không.
t2 = 1, 2, 3, 'Python'8Nối các bộ t và s. Điều này tạo ra một bộ dữ liệu mới chứa các giá trị từ t và s.
t2 = 1, 2, 3, 'Python'9Lặp lại tuple t n lần. Điều này tạo ra một bộ dữ liệu mới chứa n lần tất cả các giá trị của t.
empty_tuple = [] one_element_tuple = 1,0Lấy phần tử tại chỉ mục i
empty_tuple = [] one_element_tuple = 1,1Lấy các phần tử từ chỉ mục i đến chỉ mục j [không bao gồm j] làm bộ dữ liệu
empty_tuple = [] one_element_tuple = 1,2Lấy phần tử từ chỉ mục i đến chỉ mục j [không bao gồm j] lấy mọi phần tử thứ k làm bộ dữ liệu
empty_tuple = [] one_element_tuple = 1,3Trả về độ dài của bộ dữ liệu
empty_tuple = [] one_element_tuple = 1,4Trả về phần tử nhỏ nhất
Hãy tự mình thử
bài tập thực hành. Điều gì xảy ra nếu bạn cố gán một giá trị trong một bộ? . g.
empty_tuple = [] one_element_tuple = 1,7]
Giải nén Tuples
Chúng ta đã thấy cách truy xuất một phần tử từ một bộ bằng cách sử dụng chỉ mục. Nhưng làm cách nào bạn có thể truy xuất tất cả các phần tử từ một bộ dữ liệu?
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]
Mặc dù mã được hiển thị ở trên hoạt động nhưng nó hoàn toàn không phải là Pythonic - đó không phải là cách bạn thực hiện trong Python. Trong Python, bạn có thể chỉ cần gán một bộ cho một số biến. Vì vậy, đối với ví dụ trên, chúng tôi sẽ viết đoạn mã sau
my_tuple = [1, 2, 3, 4, 5] one, two, three, four, five = my_tuple
Và đó là tất cả những gì chúng ta cần để có kết quả giống như trong đoạn trích đầu tiên. Điều quan trọng cần đề cập là chúng ta cần càng nhiều biến ở phía bên trái thì càng có nhiều giá trị trong bộ dữ liệu.
Đôi khi chúng ta không cần tất cả các giá trị từ một tuple. Ví dụ: giả sử chúng ta chỉ cần hai giá trị đầu tiên và giá trị cuối cùng từ bộ dữ liệu của mình. Một lần nữa, chúng ta có thể làm điều đó bằng cách sử dụng các chỉ số, tuy nhiên, có một cách Pythonic hơn. Nó được gọi là giải nén mở rộng, hãy để tôi chỉ cho bạn cách nó hoạt động
my_tuple = [1, 2, 3, 4, 5] one, *_, four, five = my_tuple
Như bạn có thể thấy, chúng tôi đã đánh dấu biến có tên là
empty_tuple = [] one_element_tuple = 1,8 [gạch dưới] bằng dấu hoa thị. Đầu tiên, điều này có nghĩa là 'tất cả phần còn lại' sẽ thuộc về biến này
Vì vậy, sau khi ánh xạ vị trí của các phần tử vào các biến, tất cả các giá trị còn lại sẽ chuyển đến biến được đánh dấu hoa thị. Biến này chứa danh sách các phần tử sau phép gán
Điều thú vị khác ở đây là tên biến _ [gạch dưới]. Mặc dù nó không liên quan gì đặc biệt đến các bộ dữ liệu, nhưng quy ước chung trong Python là gọi một biến giả hoặc biến bỏ đi như thế này. Vì trong ví dụ chúng ta chỉ muốn lấy giá trị đầu và hai giá trị cuối nên gọi biến chứa các giá trị còn lại _. Vì vậy, khi các lập trình viên khác đọc mã, họ hiểu rằng chúng tôi không quan tâm đến những giá trị còn lại đó
Khi bạn sử dụng giải nén mở rộng, bạn phải cẩn thận vì nó phải rõ ràng. Bạn không thể có hai biến có dấu hoa thị vì nó sẽ làm cho phép gán không rõ ràng
Làm việc với Tuples
Chúng tôi đã thấy một trường hợp sử dụng cho bộ dữ liệu. Trả về một số giá trị thuộc về nhau. Nếu bạn muốn xử lý đầu ra của một hàm như vậy, bạn cần một hàm chấp nhận một bộ hoặc bạn phải xóa cấu trúc dữ liệu kèm theo bằng toán tử dấu hoa thị. Khi bạn chuyển một bộ vào một lệnh gọi hàm, bạn phải sử dụng dấu ngoặc đơn, nếu không, Python sẽ không hiểu rằng đó là một bộ và sẽ diễn giải các giá trị thành các đối số riêng biệt
Truyền Tuples cho Hàm
Nếu bạn muốn chuyển một bộ trong một lệnh gọi hàm, bạn phải sử dụng dấu ngoặc đơn
def func[tup]:
for element in tup:
print[element]
# call function func
func[[1, 2, 3]]Nếu chúng ta muốn truyền một bộ dữ liệu cho một hàm mà chúng ta muốn sử dụng từng phần tử của bộ dữ liệu làm tham số riêng biệt, thì chúng ta phải xóa bộ dữ liệu đó bằng toán tử dấu hoa thị
empty_tuple = [] one_element_tuple = 1,9
from math import sqrt
def distance[a, b]:
return sqrt[a**2 + b**2]
point2D = [5, 3]
# call function distance
distance[*point2D]Hãy dùng thử, điều gì sẽ xảy ra nếu bạn gọi hàm
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]0 mà không sử dụng dấu hoa thị phía trước bộ dữ liệu
Bộ dữ liệu được đặt tên
Cho đến bây giờ chúng ta phải biết vị trí nào trong một bộ dữ liệu mà một giá trị nhất định được lưu trữ. Ví dụ: nếu chúng ta có một bộ dữ liệu
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]1, chúng ta phải biết mỗi số đại diện cho điều gì. Nếu bạn không biết rằng phần tử ở chỉ số 0 được coi là bán kính, ở chỉ số 1 là giá trị màu đỏ, ở chỉ số 2 là giá trị màu xanh lục, v.v., bạn sẽ không thể làm việc với bộ dữ liệu. Và khi bạn tạo một bộ dữ liệu mới, bạn phải cẩn thận với thứ tự của các giá trị vì vị trí của chúng mang lại ý nghĩa cho chúng. Đây là nơi
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]2 phát huy tác dụng. Nếu bạn muốn sử dụng
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]2, bạn phải
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]4. Mô-đun
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]5 là một phần của thư viện chuẩn Python
Cách sử dụng Namedtuple
from collections import namedtuple Person = namedtuple['Person', 'name age country'] bob = Person['Bob', 31, 'UK']
Trước hết, điều quan trọng cần lưu ý là
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]6 đã nhập là một hàm, không phải kiểu dữ liệu. Chính xác hơn
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]6là một nhà máy sản xuất lớp vì nó là một hàm tạo ra các lớp. Trong ví dụ của chúng tôi ở trên, chúng tôi đã tạo một lớp có tên là Người có ba phần tử. tên, tuổi và quốc gia. Đối số đầu tiên chúng tôi chuyển đến
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]6là tên lớp của chúng tôi, đối số thứ hai là một chuỗi tên phần tử. Thay vì chuỗi, chúng ta cũng có thể sử dụng một bộ hoặc danh sách các tên phần tử. Sau khi tạo lớp
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]9, chúng ta sử dụng nó để tạo một thể hiện của Person. Nếu từ vựng ở đây nghe rất giống với bạn, thì bạn đang đi đúng hướng. Mặc dù
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]6 thực sự là các bộ dữ liệu, nhưng ẩn sâu bên trong Python tạo ra một lớp
Với
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]6, chúng ta không cần phải biết giá trị nào ở vị trí nào nữa, thay vào đó chúng ta có thể truy cập đơn giản các giá trị theo tên của chúng, e. g
t1 = [1, 2, 3, 'Python']0
Sửa đổi Namedtuples
Như chúng ta đã thấy trước đây, các bộ dữ liệu không thể thay đổi trong Python. Vì
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]6 kế thừa từ
my_tuple = [1, 2, 3, 4, 5] one, two, three, four, five = my_tuple3, nên chúng cũng không thể thay đổi. Nếu chúng tôi muốn sửa đổi một bộ dữ liệu, chúng tôi phải sao chép tất cả các giá trị vào một bộ dữ liệu mới và thay thế các giá trị mà chúng tôi muốn cập nhật. Để làm như vậy, chúng tôi có một số tùy chọn
cắt lát
Giả sử hôm nay là sinh nhật của Bob, vậy làm cách nào để cập nhật bản ghi dữ liệu của anh ấy?
t1 = [1, 2, 3, 'Python']1
Vì
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]6 Person của chúng tôi chỉ chứa ba giá trị, nên việc cắt lát có vẻ hơi quá khổ nhưng nó cho thấy ý tưởng
Khi chúng tôi tạo
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]6 mới, chúng tôi phải xóa bộ dữ liệu kèm theo bằng toán tử dấu hoa thị vì hàm tạo của Person mong đợi ba đối số riêng biệt, không phải bộ dữ liệu. Nếu bạn không thích toán tử dấu hoa thị, bạn cũng có thể sử dụng
my_tuple = [1, 2, 3, 4, 5] one, two, three, four, five = my_tuple6 để tạo một phiên bản mới của
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]6 của chúng tôi
Sau đó, mã trông như thế này
t1 = [1, 2, 3, 'Python']2
Cập nhật giá trị sử dụng _replace[]
Một cách khác để sửa đổi các giá trị trong
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]6 là sử dụng phương thức
my_tuple = [1, 2, 3, 4, 5] one, two, three, four, five = my_tuple9. Tuy nhiên, hãy nhớ rằng, tuple là bất biến, sửa đổi luôn có nghĩa là tạo ra một tuple mới. Nếu bạn thử cách sau, bạn sẽ gặp lỗi
t1 = [1, 2, 3, 'Python']3
Vì vậy, một năm sau, vào ngày sinh nhật tiếp theo của anh ấy, Bob chuyển đến Hoa Kỳ. S. Làm cách nào để chúng tôi cập nhật bộ dữ liệu của mình bằng cách sử dụng phương thức
my_tuple = [1, 2, 3, 4, 5] one, two, three, four, five = my_tuple9 bây giờ?
t1 = [1, 2, 3, 'Python']4
Đó là nó. Và đừng quên việc gán lại – các bộ dữ liệu là bất biến, thực ra chúng ta đang tạo một bộ dữ liệu mới
Mở rộng Namedtuple
Bây giờ, chúng tôi muốn làm cho dữ liệu của chúng tôi về những người chính xác hơn. Do đó, chúng tôi muốn thêm một yếu tố khác gọi là thành phố. Làm cách nào chúng ta có thể mở rộng bộ Person của mình để giữ phần tử thứ tư?
t1 = [1, 2, 3, 'Python']5
Vì chúng tôi không muốn nhập lại tên trường của bộ Person ban đầu của chúng tôi, chúng tôi chỉ sử dụng thuộc tính
my_tuple = [1, 2, 3, 4, 5] one, *_, four, five = my_tuple1 để lấy một bộ gồm tất cả các tên trường. Sau đó, chúng tôi thêm một bộ dữ liệu với tên của các trường chúng tôi muốn thêm. Tiếp theo, chúng tôi tạo một
my_tuple = [1, 2, 3, 4, 5] one = my_tuple[0] two = my_tuple[1] three = my_tuple[2] four = my_tuple[3] five = my_tuple[4]6 mới với một trường bổ sung và tạo một phiên bản mới của bob sống ở Washington
Các ứng dụng của Namedtuple
Trong một số trường hợp, các bộ dữ liệu được đặt tên có thể được sử dụng độc đáo thay vì từ điển vì chúng không chỉ nhẹ hơn từ điển mà còn có thể truy cập các giá trị bằng ký hiệu dấu chấm thay vì từ điển [‘tên_trường’] hoặc từ điển. được[]. Rất đơn giản để chuyển đổi từ điển thành bộ dữ liệu được đặt tên và bộ dữ liệu được đặt tên thành từ điển
Chuyển đổi Namedtuple thành Dictionary
Điều này rất dễ dàng vì các bộ tên có một phương thức để
my_tuple = [1, 2, 3, 4, 5] one, *_, four, five = my_tuple3 thực hiện công việc cho bạn. Vì vậy, hãy xem cách chúng ta có thể chuyển đổi dữ liệu cũ của Bob thành từ điển
t1 = [1, 2, 3, 'Python']6
Chuyển đổi từ điển thành Namedtuple
Việc chuyển đổi từ dictionary sang namedtuple cũng rất đơn giản. Tất cả những gì chúng ta cần là toán tử dấu hoa thị kép
my_tuple = [1, 2, 3, 4, 5] one, *_, four, five = my_tuple4 để giải nén từ điển. Điều này để lại cho chúng tôi các mục từ điển được sử dụng làm tham số từ khóa
t1 = [1, 2, 3, 'Python']7
Chuyển đổi Danh sách Từ điển thành Danh sách Namedtuple
Thông thường lấy dữ liệu từ cơ sở dữ liệu dưới dạng danh sách từ điển. Mỗi từ điển chứa các cặp khóa-giá trị trong đó các khóa là tên cột từ cơ sở dữ liệu. Giả sử rằng truy vấn cơ sở dữ liệu của chúng tôi trả về kết quả này
t1 = [1, 2, 3, 'Python']8
Như bạn có thể thấy, một số giá trị là null trong cơ sở dữ liệu. Do đó, một số bộ dữ liệu chứa ít mục nhập hơn những bộ dữ liệu khác. Tuy nhiên, một chức năng khá ngắn là đủ để đạt được đầu ra mong muốn
t1 = [1, 2, 3, 'Python']9
Bây giờ, chúng tôi có thể làm việc rất tốt với dữ liệu mà không gặp bất kỳ sự cố nào với các mục nhập không tồn tại và ít mã hơn nhiều so với mức chúng tôi cần nếu chúng tôi lấy danh sách từ điển
Tóm lược
Tuples là một cấu trúc dữ liệu tích hợp sẵn của ngôn ngữ Python. Chúng là bất biến, vì vậy bạn không thể sửa đổi các giá trị bên trong. Thay vào đó, một bộ dữ liệu mới phải được tạo
Bộ dữ liệu là nơi chứa dữ liệu thuộc về nhau, chẳng hạn như tọa độ x và y của một điểm trong không gian 2D
Bộ dữ liệu được đặt tên cũng là bộ dữ liệu nhưng chúng có lợi thế quyết định. Bạn có thể truy cập các phần tử trong tuple theo tên, không chỉ theo chỉ mục. Điều này cho phép chuyển đổi dễ dàng giữa các bộ được đặt tên và từ điển
Bất kỳ nhà phát triển Python nâng cao nào cũng phải biết các bộ dữ liệu vì chúng phổ biến trong Python. Sau khi hoàn thành bài viết này, bạn sẽ không gặp vấn đề gì khi giải câu đố mã sau