Cấu trúc dữ liệu trong Python có dễ không?

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

0. Từ điển Go-To của bạn

Vì từ điển rất quan trọng nên Python có tính năng triển khai từ điển mạnh mẽ được tích hợp trực tiếp vào ngôn ngữ cốt lõi. kiểu dữ liệu

Python cũng cung cấp một số đường cú pháp hữu ích để làm việc với từ điển trong chương trình của bạn. Ví dụ: cú pháp biểu thức từ điển dấu ngoặc nhọn [{ }] và cho phép bạn xác định các đối tượng từ điển mới một cách thuận tiện

>>>

>>> phonebook = {
..     "bob": 7387,
..     "alice": 3719,
..     "jack": 7052,
.. }

>>> squares = {x: x * x for x in range[6]}

>>> phonebook["alice"]
3719

>>> squares
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Có một số hạn chế về đối tượng nào có thể được sử dụng làm khóa hợp lệ

Từ điển của Python được lập chỉ mục bởi các khóa có thể thuộc bất kỳ loại nào. Đối tượng có thể băm có giá trị băm không bao giờ thay đổi trong suốt thời gian tồn tại của nó [xem

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

Các loại bất biến như chuỗi và số có thể băm được và hoạt động tốt như các khóa từ điển. Bạn cũng có thể sử dụng làm khóa từ điển miễn là chúng chỉ chứa các loại có thể băm

Đối với hầu hết các trường hợp sử dụng, việc triển khai từ điển tích hợp sẵn của Python sẽ làm mọi thứ bạn cần. Từ điển được tối ưu hóa cao và làm nền tảng cho nhiều phần của ngôn ngữ. Ví dụ: và các biến trong a đều được lưu trữ nội bộ trong từ điển

Từ điển Python dựa trên triển khai bảng băm đã được kiểm tra kỹ lưỡng và tinh chỉnh, cung cấp các đặc tính hiệu suất mà bạn mong đợi. Độ phức tạp thời gian O[1] đối với các thao tác tra cứu, chèn, cập nhật và xóa trong trường hợp trung bình

Có rất ít lý do để không sử dụng triển khai

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

Bên cạnh các đối tượng

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

Hãy cùng xem qua chúng

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

7. Ghi nhớ thứ tự chèn phím

Python bao gồm một lớp con

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

Ghi chú.

>>> arr = ["one", "two", "three"]
>>> arr[0]
'one'

>>> # Lists have a nice repr:
>>> arr
['one', 'two', 'three']

>>> # Lists are mutable:
>>> arr[1] = "hello"
>>> arr
['one', 'hello', 'three']

>>> del arr[1]
>>> arr
['one', 'three']

>>> # Lists can hold arbitrary data types:
>>> arr.append[23]
>>> arr
['one', 'three', 23]

>>> arr = ["one", "two", "three"]
>>> arr[0]
'one'

>>> # Lists have a nice repr:
>>> arr
['one', 'two', 'three']

>>> # Lists are mutable:
>>> arr[1] = "hello"
>>> arr
['one', 'hello', 'three']

>>> del arr[1]
>>> arr
['one', 'three']

>>> # Lists can hold arbitrary data types:
>>> arr.append[23]
>>> arr
['one', 'three', 23]

Trong khi các phiên bản

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

>>> arr = ["one", "two", "three"]
>>> arr[0]
'one'

>>> # Lists have a nice repr:
>>> arr
['one', 'two', 'three']

>>> # Lists are mutable:
>>> arr[1] = "hello"
>>> arr
['one', 'hello', 'three']

>>> del arr[1]
>>> arr
['one', 'three']

>>> # Lists can hold arbitrary data types:
>>> arr.append[23]
>>> arr
['one', 'three', 23]

>>>

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

Cho đến Python 3. 8, bạn không thể lặp lại các mục từ điển theo thứ tự ngược lại bằng cách sử dụng

>>> arr = ["one", "two", "three"]
>>> arr[0]
'one'

>>> # Lists have a nice repr:
>>> arr
['one', 'two', 'three']

>>> # Lists are mutable:
>>> arr[1] = "hello"
>>> arr
['one', 'hello', 'three']

>>> del arr[1]
>>> arr
['one', 'three']

>>> # Lists can hold arbitrary data types:
>>> arr.append[23]
>>> arr
['one', 'three', 23]

>>> arr = ["one", "two", "three"]
>>> arr[0]
'one'

>>> # Lists have a nice repr:
>>> arr
['one', 'two', 'three']

>>> # Lists are mutable:
>>> arr[1] = "hello"
>>> arr
['one', 'hello', 'three']

>>> del arr[1]
>>> arr
['one', 'three']

>>> # Lists can hold arbitrary data types:
>>> arr.append[23]
>>> arr
['one', 'three', 23]

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

>>> arr = ["one", "two", "three"]
>>> arr[0]
'one'

>>> # Lists have a nice repr:
>>> arr
['one', 'two', 'three']

>>> # Lists are mutable:
>>> arr[1] = "hello"
>>> arr
['one', 'hello', 'three']

>>> del arr[1]
>>> arr
['one', 'three']

>>> # Lists can hold arbitrary data types:
>>> arr.append[23]
>>> arr
['one', 'three', 23]

>>> arr = ["one", "two", "three"]
>>> arr[0]
'one'

>>> # Lists have a nice repr:
>>> arr
['one', 'two', 'three']

>>> # Lists are mutable:
>>> arr[1] = "hello"
>>> arr
['one', 'hello', 'three']

>>> del arr[1]
>>> arr
['one', 'three']

>>> # Lists can hold arbitrary data types:
>>> arr.append[23]
>>> arr
['one', 'three', 23]

>>> arr = ["one", "two", "three"]
>>> arr[0]
'one'

>>> # Lists have a nice repr:
>>> arr
['one', 'two', 'three']

>>> # Lists are mutable:
>>> arr[1] = "hello"
>>> arr
['one', 'hello', 'three']

>>> del arr[1]
>>> arr
['one', 'three']

>>> # Lists can hold arbitrary data types:
>>> arr.append[23]
>>> arr
['one', 'three', 23]

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

>>> arr = ["one", "two", "three"]
>>> arr[0]
'one'

>>> # Tuples have a nice repr:
>>> arr
['one', 'two', 'three']

>>> # Tuples are immutable:
>>> arr[1] = "hello"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object doesn't support item deletion

>>> # Tuples can hold arbitrary data types:
>>> # [Adding elements creates a copy of the tuple]
>>> arr + [23,]
['one', 'two', 'three', 23]

3. Trả lại giá trị mặc định cho các phím bị thiếu

Lớp này là một lớp con từ điển khác chấp nhận một hàm có thể gọi được trong hàm tạo của nó có giá trị trả về sẽ được sử dụng nếu không tìm thấy khóa được yêu cầu

Điều này có thể giúp bạn tiết kiệm một số thao tác nhập và làm cho ý định của bạn rõ ràng hơn so với việc sử dụng

>>> arr = ["one", "two", "three"]
>>> arr[0]
'one'

>>> # Tuples have a nice repr:
>>> arr
['one', 'two', 'three']

>>> # Tuples are immutable:
>>> arr[1] = "hello"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object doesn't support item deletion

>>> # Tuples can hold arbitrary data types:
>>> # [Adding elements creates a copy of the tuple]
>>> arr + [23,]
['one', 'two', 'three', 23]

>>> arr = ["one", "two", "three"]
>>> arr[0]
'one'

>>> # Tuples have a nice repr:
>>> arr
['one', 'two', 'three']

>>> # Tuples are immutable:
>>> arr[1] = "hello"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object doesn't support item deletion

>>> # Tuples can hold arbitrary data types:
>>> # [Adding elements creates a copy of the tuple]
>>> arr + [23,]
['one', 'two', 'three', 23]

>>>

>>> from collections import defaultdict
>>> dd = defaultdict[list]

>>> # Accessing a missing key creates it and
>>> # initializes it using the default factory,
>>> # i.e. list[] in this example:
>>> dd["dogs"].append["Rufus"]
>>> dd["dogs"].append["Kathrin"]
>>> dd["dogs"].append["Mr Sniffles"]

>>> dd["dogs"]
['Rufus', 'Kathrin', 'Mr Sniffles']

>>> arr = ["one", "two", "three"]
>>> arr[0]
'one'

>>> # Tuples have a nice repr:
>>> arr
['one', 'two', 'three']

>>> # Tuples are immutable:
>>> arr[1] = "hello"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object doesn't support item deletion

>>> # Tuples can hold arbitrary data types:
>>> # [Adding elements creates a copy of the tuple]
>>> arr + [23,]
['one', 'two', 'three', 23]

7. Tìm kiếm nhiều từ điển dưới dạng ánh xạ đơn

Cấu trúc dữ liệu nhóm nhiều từ điển thành một ánh xạ duy nhất. Tra cứu tìm kiếm từng ánh xạ cơ bản cho đến khi tìm thấy khóa. Chèn, cập nhật và xóa chỉ ảnh hưởng đến ánh xạ đầu tiên được thêm vào chuỗi

>>>

>>> from collections import ChainMap
>>> dict1 = {"one": 1, "two": 2}
>>> dict2 = {"three": 3, "four": 4}
>>> chain = ChainMap[dict1, dict2]

>>> chain
ChainMap[{'one': 1, 'two': 2}, {'three': 3, 'four': 4}]

>>> # ChainMap searches each collection in the chain
>>> # from left to right until it finds the key [or fails]:
>>> chain["three"]
3
>>> chain["one"]
1
>>> chain["missing"]
Traceback [most recent call last]:
  File "", line 1, in 
KeyError: 'missing'

>>> arr = ["one", "two", "three"]
>>> arr[0]
'one'

>>> # Tuples have a nice repr:
>>> arr
['one', 'two', 'three']

>>> # Tuples are immutable:
>>> arr[1] = "hello"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object doesn't support item deletion

>>> # Tuples can hold arbitrary data types:
>>> # [Adding elements creates a copy of the tuple]
>>> arr + [23,]
['one', 'two', 'three', 23]

9. Trình bao bọc để tạo từ điển chỉ đọc

là trình bao bọc xung quanh từ điển tiêu chuẩn cung cấp chế độ xem chỉ đọc đối với dữ liệu của từ điển được bao bọc. Lớp này đã được thêm vào Python 3. 3 và có thể được sử dụng để tạo các phiên bản proxy bất biến của từ điển

>>> import array
>>> arr = array.array["f", [1.0, 1.5, 2.0, 2.5]]
>>> arr[1]
1.5

>>> # Arrays have a nice repr:
>>> arr
array['f', [1.0, 1.5, 2.0, 2.5]]

>>> # Arrays are mutable:
>>> arr[1] = 23.0
>>> arr
array['f', [1.0, 23.0, 2.0, 2.5]]

>>> del arr[1]
>>> arr
array['f', [1.0, 2.0, 2.5]]

>>> arr.append[42.0]
>>> arr
array['f', [1.0, 2.0, 2.5, 42.0]]

>>> # Arrays are "typed":
>>> arr[1] = "hello"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: must be real number, not str

>>> import array
>>> arr = array.array["f", [1.0, 1.5, 2.0, 2.5]]
>>> arr[1]
1.5

>>> # Arrays have a nice repr:
>>> arr
array['f', [1.0, 1.5, 2.0, 2.5]]

>>> # Arrays are mutable:
>>> arr[1] = 23.0
>>> arr
array['f', [1.0, 23.0, 2.0, 2.5]]

>>> del arr[1]
>>> arr
array['f', [1.0, 2.0, 2.5]]

>>> arr.append[42.0]
>>> arr
array['f', [1.0, 2.0, 2.5, 42.0]]

>>> # Arrays are "typed":
>>> arr[1] = "hello"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: must be real number, not str

>>>

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

Từ điển trong Python. Tóm lược

Tất cả các triển khai từ điển Python được liệt kê trong hướng dẫn này là các triển khai hợp lệ được tích hợp trong thư viện chuẩn Python

Nếu bạn đang tìm kiếm một đề xuất chung về loại ánh xạ nào sẽ được sử dụng trong các chương trình của mình, thì tôi sẽ chỉ cho bạn loại dữ liệu

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

Tôi khuyên bạn chỉ nên sử dụng một trong các loại dữ liệu khác được liệt kê ở đây nếu bạn có các yêu cầu đặc biệt vượt quá những gì được cung cấp bởi

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

Tất cả các triển khai đều là các tùy chọn hợp lệ, nhưng mã của bạn sẽ rõ ràng hơn và dễ bảo trì hơn nếu nó luôn dựa vào các từ điển Python tiêu chuẩn

>>> from collections import ChainMap
>>> dict1 = {"one": 1, "two": 2}
>>> dict2 = {"three": 3, "four": 4}
>>> chain = ChainMap[dict1, dict2]

>>> chain
ChainMap[{'one': 1, 'two': 2}, {'three': 3, 'four': 4}]

>>> # ChainMap searches each collection in the chain
>>> # from left to right until it finds the key [or fails]:
>>> chain["three"]
3
>>> chain["one"]
1
>>> chain["missing"]
Traceback [most recent call last]:
  File "", line 1, in 
KeyError: 'missing'

6. Mảng động có thể thay đổi

là một phần của ngôn ngữ Python cốt lõi. Bất chấp tên của chúng, các danh sách của Python được triển khai dưới dạng các mảng động đằng sau hậu trường

Điều này có nghĩa là danh sách cho phép thêm hoặc xóa các phần tử và danh sách sẽ tự động điều chỉnh kho lưu trữ sao lưu chứa các phần tử này bằng cách cấp phát hoặc giải phóng bộ nhớ

Danh sách Python có thể chứa các phần tử tùy ý—mọi thứ đều là một đối tượng trong Python, kể cả các hàm. Do đó, bạn có thể kết hợp và kết hợp các loại dữ liệu khác nhau và lưu trữ tất cả chúng trong một danh sách duy nhất

Đây có thể là một tính năng mạnh mẽ, nhưng nhược điểm là việc hỗ trợ nhiều loại dữ liệu cùng lúc có nghĩa là dữ liệu thường ít được đóng gói chặt chẽ hơn. Kết quả là, toàn bộ cấu trúc chiếm nhiều không gian hơn

>>>

>>> arr = ["one", "two", "three"]
>>> arr[0]
'one'

>>> # Lists have a nice repr:
>>> arr
['one', 'two', 'three']

>>> # Lists are mutable:
>>> arr[1] = "hello"
>>> arr
['one', 'hello', 'three']

>>> del arr[1]
>>> arr
['one', 'three']

>>> # Lists can hold arbitrary data types:
>>> arr.append[23]
>>> arr
['one', 'three', 23]

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

4. Container bất biến

Giống như danh sách, là một phần của ngôn ngữ cốt lõi Python. Tuy nhiên, không giống như các danh sách, các đối tượng

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

Bộ dữ liệu là một cấu trúc dữ liệu khác có thể chứa các phần tử của các kiểu dữ liệu tùy ý. Tính linh hoạt này rất mạnh mẽ, nhưng một lần nữa, điều đó cũng có nghĩa là dữ liệu được đóng gói ít chặt chẽ hơn so với trong một mảng đã nhập

>>>

>>> arr = ["one", "two", "three"]
>>> arr[0]
'one'

>>> # Tuples have a nice repr:
>>> arr
['one', 'two', 'three']

>>> # Tuples are immutable:
>>> arr[1] = "hello"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object doesn't support item deletion

>>> # Tuples can hold arbitrary data types:
>>> # [Adding elements creates a copy of the tuple]
>>> arr + [23,]
['one', 'two', 'three', 23]

>>> import array
>>> arr = array.array["f", [1.0, 1.5, 2.0, 2.5]]
>>> arr[1]
1.5

>>> # Arrays have a nice repr:
>>> arr
array['f', [1.0, 1.5, 2.0, 2.5]]

>>> # Arrays are mutable:
>>> arr[1] = 23.0
>>> arr
array['f', [1.0, 23.0, 2.0, 2.5]]

>>> del arr[1]
>>> arr
array['f', [1.0, 2.0, 2.5]]

>>> arr.append[42.0]
>>> arr
array['f', [1.0, 2.0, 2.5, 42.0]]

>>> # Arrays are "typed":
>>> arr[1] = "hello"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: must be real number, not str

8. Mảng gõ cơ bản

Mô-đun

>>> import array
>>> arr = array.array["f", [1.0, 1.5, 2.0, 2.5]]
>>> arr[1]
1.5

>>> # Arrays have a nice repr:
>>> arr
array['f', [1.0, 1.5, 2.0, 2.5]]

>>> # Arrays are mutable:
>>> arr[1] = 23.0
>>> arr
array['f', [1.0, 23.0, 2.0, 2.5]]

>>> del arr[1]
>>> arr
array['f', [1.0, 2.0, 2.5]]

>>> arr.append[42.0]
>>> arr
array['f', [1.0, 2.0, 2.5, 42.0]]

>>> # Arrays are "typed":
>>> arr[1] = "hello"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: must be real number, not str

Mảng được tạo bằng lớp

>>> import array
>>> arr = array.array["f", [1.0, 1.5, 2.0, 2.5]]
>>> arr[1]
1.5

>>> # Arrays have a nice repr:
>>> arr
array['f', [1.0, 1.5, 2.0, 2.5]]

>>> # Arrays are mutable:
>>> arr[1] = 23.0
>>> arr
array['f', [1.0, 23.0, 2.0, 2.5]]

>>> del arr[1]
>>> arr
array['f', [1.0, 2.0, 2.5]]

>>> arr.append[42.0]
>>> arr
array['f', [1.0, 2.0, 2.5, 42.0]]

>>> # Arrays are "typed":
>>> arr[1] = "hello"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: must be real number, not str

Do ràng buộc này, các đối tượng

>>> import array
>>> arr = array.array["f", [1.0, 1.5, 2.0, 2.5]]
>>> arr[1]
1.5

>>> # Arrays have a nice repr:
>>> arr
array['f', [1.0, 1.5, 2.0, 2.5]]

>>> # Arrays are mutable:
>>> arr[1] = 23.0
>>> arr
array['f', [1.0, 23.0, 2.0, 2.5]]

>>> del arr[1]
>>> arr
array['f', [1.0, 2.0, 2.5]]

>>> arr.append[42.0]
>>> arr
array['f', [1.0, 2.0, 2.5, 42.0]]

>>> # Arrays are "typed":
>>> arr[1] = "hello"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: must be real number, not str

Ngoài ra, mảng hỗ trợ nhiều phương thức giống như danh sách thông thường và bạn có thể sử dụng chúng như một phương thức thay thế thả xuống mà không yêu cầu các thay đổi khác đối với mã ứng dụng của mình

>>>

>>> import array
>>> arr = array.array["f", [1.0, 1.5, 2.0, 2.5]]
>>> arr[1]
1.5

>>> # Arrays have a nice repr:
>>> arr
array['f', [1.0, 1.5, 2.0, 2.5]]

>>> # Arrays are mutable:
>>> arr[1] = 23.0
>>> arr
array['f', [1.0, 23.0, 2.0, 2.5]]

>>> del arr[1]
>>> arr
array['f', [1.0, 2.0, 2.5]]

>>> arr.append[42.0]
>>> arr
array['f', [1.0, 2.0, 2.5, 42.0]]

>>> # Arrays are "typed":
>>> arr[1] = "hello"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: must be real number, not str

>>> arr = "abcd"
>>> arr[1]
'b'

>>> arr
'abcd'

>>> # Strings are immutable:
>>> arr[1] = "e"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object doesn't support item deletion

>>> # Strings can be unpacked into a list to
>>> # get a mutable representation:
>>> list["abcd"]
['a', 'b', 'c', 'd']
>>> "".join[list["abcd"]]
'abcd'

>>> # Strings are recursive data structures:
>>> type["abc"]
""
>>> type["abc"[0]]
""

2. Mảng ký tự Unicode bất biến

Trăn 3. x sử dụng các đối tượng để lưu trữ dữ liệu văn bản dưới dạng các chuỗi ký tự Unicode bất biến. Nói một cách thực tế, điều đó có nghĩa là một

>>> arr = "abcd"
>>> arr[1]
'b'

>>> arr
'abcd'

>>> # Strings are immutable:
>>> arr[1] = "e"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object doesn't support item deletion

>>> # Strings can be unpacked into a list to
>>> # get a mutable representation:
>>> list["abcd"]
['a', 'b', 'c', 'd']
>>> "".join[list["abcd"]]
'abcd'

>>> # Strings are recursive data structures:
>>> type["abc"]
""
>>> type["abc"[0]]
""

>>> arr = "abcd"
>>> arr[1]
'b'

>>> arr
'abcd'

>>> # Strings are immutable:
>>> arr[1] = "e"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object doesn't support item deletion

>>> # Strings can be unpacked into a list to
>>> # get a mutable representation:
>>> list["abcd"]
['a', 'b', 'c', 'd']
>>> "".join[list["abcd"]]
'abcd'

>>> # Strings are recursive data structures:
>>> type["abc"]
""
>>> type["abc"[0]]
""

Các đối tượng chuỗi tiết kiệm không gian hiệu quả vì chúng được đóng gói chặt chẽ và chúng chuyên về một kiểu dữ liệu duy nhất. Nếu bạn đang lưu trữ văn bản Unicode, thì bạn nên sử dụng một chuỗi

Vì các chuỗi là bất biến trong Python, nên việc sửa đổi một chuỗi yêu cầu tạo một bản sao đã sửa đổi. Tương đương gần nhất với chuỗi có thể thay đổi là lưu trữ các ký tự riêng lẻ trong danh sách

>>>

>>> arr = "abcd"
>>> arr[1]
'b'

>>> arr
'abcd'

>>> # Strings are immutable:
>>> arr[1] = "e"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object doesn't support item deletion

>>> # Strings can be unpacked into a list to
>>> # get a mutable representation:
>>> list["abcd"]
['a', 'b', 'c', 'd']
>>> "".join[list["abcd"]]
'abcd'

>>> # Strings are recursive data structures:
>>> type["abc"]
""
>>> type["abc"[0]]
""

>>> arr = "abcd"
>>> arr[1]
'b'

>>> arr
'abcd'

>>> # Strings are immutable:
>>> arr[1] = "e"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object doesn't support item deletion

>>> # Strings can be unpacked into a list to
>>> # get a mutable representation:
>>> list["abcd"]
['a', 'b', 'c', 'd']
>>> "".join[list["abcd"]]
'abcd'

>>> # Strings are recursive data structures:
>>> type["abc"]
""
>>> type["abc"[0]]
""

6. Mảng bất biến của byte đơn

các đối tượng là các chuỗi bất biến của các byte đơn hoặc số nguyên trong phạm vi 0 ≤ x ≤ 255. Về mặt khái niệm, đối tượng

>>> arr = "abcd"
>>> arr[1]
'b'

>>> arr
'abcd'

>>> # Strings are immutable:
>>> arr[1] = "e"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object doesn't support item deletion

>>> # Strings can be unpacked into a list to
>>> # get a mutable representation:
>>> list["abcd"]
['a', 'b', 'c', 'd']
>>> "".join[list["abcd"]]
'abcd'

>>> # Strings are recursive data structures:
>>> type["abc"]
""
>>> type["abc"[0]]
""

>>> arr = "abcd"
>>> arr[1]
'b'

>>> arr
'abcd'

>>> # Strings are immutable:
>>> arr[1] = "e"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object doesn't support item deletion

>>> # Strings can be unpacked into a list to
>>> # get a mutable representation:
>>> list["abcd"]
['a', 'b', 'c', 'd']
>>> "".join[list["abcd"]]
'abcd'

>>> # Strings are recursive data structures:
>>> type["abc"]
""
>>> type["abc"[0]]
""

Giống như chuỗi,

>>> arr = "abcd"
>>> arr[1]
'b'

>>> arr
'abcd'

>>> # Strings are immutable:
>>> arr[1] = "e"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object doesn't support item deletion

>>> # Strings can be unpacked into a list to
>>> # get a mutable representation:
>>> list["abcd"]
['a', 'b', 'c', 'd']
>>> "".join[list["abcd"]]
'abcd'

>>> # Strings are recursive data structures:
>>> type["abc"]
""
>>> type["abc"[0]]
""

>>> arr = "abcd"
>>> arr[1]
'b'

>>> arr
'abcd'

>>> # Strings are immutable:
>>> arr[1] = "e"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object doesn't support item deletion

>>> # Strings can be unpacked into a list to
>>> # get a mutable representation:
>>> list["abcd"]
['a', 'b', 'c', 'd']
>>> "".join[list["abcd"]]
'abcd'

>>> # Strings are recursive data structures:
>>> type["abc"]
""
>>> type["abc"[0]]
""

>>> arr = bytes[[0, 1, 2, 3]]
>>> arr[1]
1

>>> # Bytes literals have their own syntax:
>>> arr
b'\x00\x01\x02\x03'
>>> arr = b"\x00\x01\x02\x03"

>>> # Only valid `bytes` are allowed:
>>> bytes[[0, 300]]
Traceback [most recent call last]:
  File "", line 1, in 
ValueError: bytes must be in range[0, 256]

>>> # Bytes are immutable:
>>> arr[1] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'bytes' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'bytes' object doesn't support item deletion

>>>

>>> arr = bytes[[0, 1, 2, 3]]
>>> arr[1]
1

>>> # Bytes literals have their own syntax:
>>> arr
b'\x00\x01\x02\x03'
>>> arr = b"\x00\x01\x02\x03"

>>> # Only valid `bytes` are allowed:
>>> bytes[[0, 300]]
Traceback [most recent call last]:
  File "", line 1, in 
ValueError: bytes must be in range[0, 256]

>>> # Bytes are immutable:
>>> arr[1] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'bytes' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'bytes' object doesn't support item deletion

>>> arr = bytes[[0, 1, 2, 3]]
>>> arr[1]
1

>>> # Bytes literals have their own syntax:
>>> arr
b'\x00\x01\x02\x03'
>>> arr = b"\x00\x01\x02\x03"

>>> # Only valid `bytes` are allowed:
>>> bytes[[0, 300]]
Traceback [most recent call last]:
  File "", line 1, in 
ValueError: bytes must be in range[0, 256]

>>> # Bytes are immutable:
>>> arr[1] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'bytes' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'bytes' object doesn't support item deletion

2. Mảng có thể thay đổi của byte đơn

Loại là một chuỗi các số nguyên có thể thay đổi trong phạm vi 0 ≤ x ≤ 255. Đối tượng

>>> arr = bytes[[0, 1, 2, 3]]
>>> arr[1]
1

>>> # Bytes literals have their own syntax:
>>> arr
b'\x00\x01\x02\x03'
>>> arr = b"\x00\x01\x02\x03"

>>> # Only valid `bytes` are allowed:
>>> bytes[[0, 300]]
Traceback [most recent call last]:
  File "", line 1, in 
ValueError: bytes must be in range[0, 256]

>>> # Bytes are immutable:
>>> arr[1] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'bytes' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'bytes' object doesn't support item deletion

>>> arr = "abcd"
>>> arr[1]
'b'

>>> arr
'abcd'

>>> # Strings are immutable:
>>> arr[1] = "e"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object doesn't support item deletion

>>> # Strings can be unpacked into a list to
>>> # get a mutable representation:
>>> list["abcd"]
['a', 'b', 'c', 'd']
>>> "".join[list["abcd"]]
'abcd'

>>> # Strings are recursive data structures:
>>> type["abc"]
""
>>> type["abc"[0]]
""

>>> arr = bytes[[0, 1, 2, 3]]
>>> arr[1]
1

>>> # Bytes literals have their own syntax:
>>> arr
b'\x00\x01\x02\x03'
>>> arr = b"\x00\x01\x02\x03"

>>> # Only valid `bytes` are allowed:
>>> bytes[[0, 300]]
Traceback [most recent call last]:
  File "", line 1, in 
ValueError: bytes must be in range[0, 256]

>>> # Bytes are immutable:
>>> arr[1] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'bytes' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'bytes' object doesn't support item deletion

>>> arr = bytes[[0, 1, 2, 3]]
>>> arr[1]
1

>>> # Bytes literals have their own syntax:
>>> arr
b'\x00\x01\x02\x03'
>>> arr = b"\x00\x01\x02\x03"

>>> # Only valid `bytes` are allowed:
>>> bytes[[0, 300]]
Traceback [most recent call last]:
  File "", line 1, in 
ValueError: bytes must be in range[0, 256]

>>> # Bytes are immutable:
>>> arr[1] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'bytes' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'bytes' object doesn't support item deletion

Một

>>> arr = bytes[[0, 1, 2, 3]]
>>> arr[1]
1

>>> # Bytes literals have their own syntax:
>>> arr
b'\x00\x01\x02\x03'
>>> arr = b"\x00\x01\x02\x03"

>>> # Only valid `bytes` are allowed:
>>> bytes[[0, 300]]
Traceback [most recent call last]:
  File "", line 1, in 
ValueError: bytes must be in range[0, 256]

>>> # Bytes are immutable:
>>> arr[1] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'bytes' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'bytes' object doesn't support item deletion

>>> arr = "abcd"
>>> arr[1]
'b'

>>> arr
'abcd'

>>> # Strings are immutable:
>>> arr[1] = "e"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object doesn't support item deletion

>>> # Strings can be unpacked into a list to
>>> # get a mutable representation:
>>> list["abcd"]
['a', 'b', 'c', 'd']
>>> "".join[list["abcd"]]
'abcd'

>>> # Strings are recursive data structures:
>>> type["abc"]
""
>>> type["abc"[0]]
""

>>>

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

Mảng trong Python. Tóm lược

Có một số cấu trúc dữ liệu tích hợp sẵn mà bạn có thể chọn khi triển khai mảng trong Python. Trong phần này, bạn đã tập trung vào các tính năng cốt lõi của ngôn ngữ và cấu trúc dữ liệu có trong thư viện chuẩn

Nếu bạn sẵn sàng vượt ra ngoài thư viện tiêu chuẩn của Python, thì các gói của bên thứ ba như NumPy và gấu trúc sẽ cung cấp nhiều cách triển khai mảng nhanh cho khoa học dữ liệu và điện toán khoa học

Nếu bạn muốn giới hạn bản thân trong các cấu trúc dữ liệu mảng có trong Python, thì đây là một số hướng dẫn

• Nếu bạn cần lưu trữ các đối tượng tùy ý, có khả năng chứa các loại dữ liệu hỗn hợp, thì hãy sử dụng

  >>> from collections import ChainMap
  >>> dict1 = {"one": 1, "two": 2}
  >>> dict2 = {"three": 3, "four": 4}
  >>> chain = ChainMap[dict1, dict2]
  
  >>> chain
  ChainMap[{'one': 1, 'two': 2}, {'three': 3, 'four': 4}]
  
  >>> # ChainMap searches each collection in the chain
  >>> # from left to right until it finds the key [or fails]:
  >>> chain["three"]
  3
  >>> chain["one"]
  1
  >>> chain["missing"]
  Traceback [most recent call last]:
    File "", line 1, in 
  KeyError: 'missing'
  

  6 hoặc

  >>> from types import MappingProxyType
  >>> writable = {"one": 1, "two": 2}
  >>> read_only = MappingProxyType[writable]
  
  >>> # The proxy is read-only:
  >>> read_only["one"]
  1
  >>> read_only["one"] = 23
  Traceback [most recent call last]:
    File "", line 1, in 
  TypeError: 'mappingproxy' object does not support item assignment
  
  >>> # Updates to the original are reflected in the proxy:
  >>> writable["one"] = 42
  >>> read_only
  mappingproxy[{'one': 42, 'two': 2}]
  

  4, tùy thuộc vào việc bạn có muốn cấu trúc dữ liệu bất biến hay không

• Nếu bạn có dữ liệu số [số nguyên hoặc dấu chấm động] và đóng gói chặt chẽ và hiệu suất là quan trọng, thì hãy dùng thử

  >>> import array
  >>> arr = array.array["f", [1.0, 1.5, 2.0, 2.5]]
  >>> arr[1]
  1.5
  
  >>> # Arrays have a nice repr:
  >>> arr
  array['f', [1.0, 1.5, 2.0, 2.5]]
  
  >>> # Arrays are mutable:
  >>> arr[1] = 23.0
  >>> arr
  array['f', [1.0, 23.0, 2.0, 2.5]]
  
  >>> del arr[1]
  >>> arr
  array['f', [1.0, 2.0, 2.5]]
  
  >>> arr.append[42.0]
  >>> arr
  array['f', [1.0, 2.0, 2.5, 42.0]]
  
  >>> # Arrays are "typed":
  >>> arr[1] = "hello"
  Traceback [most recent call last]:
    File "", line 1, in 
  TypeError: must be real number, not str
  

  8

• Nếu bạn có dữ liệu văn bản được biểu thị dưới dạng ký tự Unicode, thì hãy sử dụng

  >>> arr = "abcd"
  >>> arr[1]
  'b'
  
  >>> arr
  'abcd'
  
  >>> # Strings are immutable:
  >>> arr[1] = "e"
  Traceback [most recent call last]:
    File "", line 1, in 
  TypeError: 'str' object does not support item assignment
  
  >>> del arr[1]
  Traceback [most recent call last]:
    File "", line 1, in 
  TypeError: 'str' object doesn't support item deletion
  
  >>> # Strings can be unpacked into a list to
  >>> # get a mutable representation:
  >>> list["abcd"]
  ['a', 'b', 'c', 'd']
  >>> "".join[list["abcd"]]
  'abcd'
  
  >>> # Strings are recursive data structures:
  >>> type["abc"]
  ""
  >>> type["abc"[0]]
  ""
  

  2 tích hợp sẵn của Python. Nếu bạn cần cấu trúc dữ liệu dạng chuỗi có thể thay đổi, thì hãy sử dụng

  >>> from collections import ChainMap
  >>> dict1 = {"one": 1, "two": 2}
  >>> dict2 = {"three": 3, "four": 4}
  >>> chain = ChainMap[dict1, dict2]
  
  >>> chain
  ChainMap[{'one': 1, 'two': 2}, {'three': 3, 'four': 4}]
  
  >>> # ChainMap searches each collection in the chain
  >>> # from left to right until it finds the key [or fails]:
  >>> chain["three"]
  3
  >>> chain["one"]
  1
  >>> chain["missing"]
  Traceback [most recent call last]:
    File "", line 1, in 
  KeyError: 'missing'
  

  6 ký tự

• Nếu bạn muốn lưu trữ một khối byte liền kề, thì hãy sử dụng loại

  >>> arr = "abcd"
  >>> arr[1]
  'b'
  
  >>> arr
  'abcd'
  
  >>> # Strings are immutable:
  >>> arr[1] = "e"
  Traceback [most recent call last]:
    File "", line 1, in 
  TypeError: 'str' object does not support item assignment
  
  >>> del arr[1]
  Traceback [most recent call last]:
    File "", line 1, in 
  TypeError: 'str' object doesn't support item deletion
  
  >>> # Strings can be unpacked into a list to
  >>> # get a mutable representation:
  >>> list["abcd"]
  ['a', 'b', 'c', 'd']
  >>> "".join[list["abcd"]]
  'abcd'
  
  >>> # Strings are recursive data structures:
  >>> type["abc"]
  ""
  >>> type["abc"[0]]
  ""
  

  6 bất biến hoặc

  >>> arr = bytes[[0, 1, 2, 3]]
  >>> arr[1]
  1
  
  >>> # Bytes literals have their own syntax:
  >>> arr
  b'\x00\x01\x02\x03'
  >>> arr = b"\x00\x01\x02\x03"
  
  >>> # Only valid `bytes` are allowed:
  >>> bytes[[0, 300]]
  Traceback [most recent call last]:
    File "", line 1, in 
  ValueError: bytes must be in range[0, 256]
  
  >>> # Bytes are immutable:
  >>> arr[1] = 23
  Traceback [most recent call last]:
    File "", line 1, in 
  TypeError: 'bytes' object does not support item assignment
  
  >>> del arr[1]
  Traceback [most recent call last]:
    File "", line 1, in 
  TypeError: 'bytes' object doesn't support item deletion
  

  2 nếu bạn cần cấu trúc dữ liệu có thể thay đổi

Trong hầu hết các trường hợp, tôi muốn bắt đầu với một

>>> from collections import ChainMap
>>> dict1 = {"one": 1, "two": 2}
>>> dict2 = {"three": 3, "four": 4}
>>> chain = ChainMap[dict1, dict2]

>>> chain
ChainMap[{'one': 1, 'two': 2}, {'three': 3, 'four': 4}]

>>> # ChainMap searches each collection in the chain
>>> # from left to right until it finds the key [or fails]:
>>> chain["three"]
3
>>> chain["one"]
1
>>> chain["missing"]
Traceback [most recent call last]:
  File "", line 1, in 
KeyError: 'missing'

>>> from collections import ChainMap
>>> dict1 = {"one": 1, "two": 2}
>>> dict2 = {"three": 3, "four": 4}
>>> chain = ChainMap[dict1, dict2]

>>> chain
ChainMap[{'one': 1, 'two': 2}, {'three': 3, 'four': 4}]

>>> # ChainMap searches each collection in the chain
>>> # from left to right until it finds the key [or fails]:
>>> chain["three"]
3
>>> chain["one"]
1
>>> chain["missing"]
Traceback [most recent call last]:
  File "", line 1, in 
KeyError: 'missing'

Tôi nhận thấy rằng điều này ngay từ đầu thường quan trọng hơn nhiều so với việc cố gắng vắt kiệt từng giọt hiệu suất cuối cùng ngay từ đầu

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

0. Đối tượng dữ liệu đơn giản

Như đã đề cập, từ điển Python lưu trữ một số đối tượng tùy ý, mỗi đối tượng được xác định bằng một khóa duy nhất. Từ điển cũng thường được gọi là bản đồ hoặc mảng kết hợp và cho phép tra cứu, chèn và xóa hiệu quả bất kỳ đối tượng nào được liên kết với một khóa đã cho

Có thể sử dụng từ điển làm kiểu dữ liệu bản ghi hoặc đối tượng dữ liệu trong Python. Từ điển rất dễ tạo bằng Python vì chúng có đường cú pháp riêng được tích hợp vào ngôn ngữ dưới dạng chữ từ điển. Cú pháp từ điển ngắn gọn và khá thuận tiện để gõ

Các đối tượng dữ liệu được tạo bằng từ điển có thể thay đổi được và có rất ít sự bảo vệ đối với tên trường sai chính tả vì các trường có thể được thêm và xóa tự do bất kỳ lúc nào. Cả hai thuộc tính này đều có thể gây ra các lỗi đáng ngạc nhiên và luôn có sự đánh đổi giữa sự thuận tiện và khả năng phục hồi lỗi

>>>

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

4. Nhóm đối tượng bất biến

Bộ dữ liệu Python là một cấu trúc dữ liệu đơn giản để nhóm các đối tượng tùy ý. Các bộ dữ liệu là bất biến—chúng không thể được sửa đổi sau khi chúng được tạo

Về mặt hiệu suất, các bộ dữ liệu chiếm hơn , và chúng cũng nhanh hơn để xây dựng

Như bạn có thể thấy trong phần phân tách mã byte bên dưới, việc xây dựng một hằng số bộ cần một mã lệnh

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>>

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

Tuy nhiên, bạn không nên quá chú trọng vào những điểm khác biệt này. Trong thực tế, sự khác biệt về hiệu suất thường sẽ không đáng kể và việc cố gắng loại bỏ hiệu suất bổ sung ra khỏi chương trình bằng cách chuyển từ danh sách sang bộ dữ liệu có thể sẽ là cách tiếp cận sai lầm.

Một nhược điểm tiềm năng của các bộ dữ liệu đơn giản là dữ liệu bạn lưu trữ trong chúng chỉ có thể được lấy ra bằng cách truy cập nó thông qua các chỉ mục số nguyên. Bạn không thể đặt tên cho các thuộc tính riêng lẻ được lưu trữ trong một bộ. Điều này có thể ảnh hưởng đến khả năng đọc mã

Ngoài ra, một tuple luôn là một cấu trúc đặc biệt. rất khó để đảm bảo rằng hai bộ dữ liệu có cùng số lượng trường và cùng thuộc tính được lưu trữ trong chúng

Điều này giúp dễ dàng đưa ra các lỗi sơ ý, chẳng hạn như trộn lẫn thứ tự trường. Do đó, tôi khuyên bạn nên giữ số lượng trường được lưu trữ trong một bộ dữ liệu càng thấp càng tốt

>>>

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

Viết một lớp tùy chỉnh. Làm việc nhiều hơn, kiểm soát nhiều hơn

Các lớp cho phép bạn xác định các bản thiết kế có thể tái sử dụng cho các đối tượng dữ liệu để đảm bảo mỗi đối tượng cung cấp cùng một tập hợp các trường

Sử dụng các lớp Python thông thường làm kiểu dữ liệu bản ghi là khả thi, nhưng cũng cần thực hiện thủ công để có được các tính năng tiện lợi của các triển khai khác. Ví dụ: việc thêm các trường mới vào hàm tạo

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

Ngoài ra, biểu diễn chuỗi mặc định cho các đối tượng được khởi tạo từ các lớp tùy chỉnh không hữu ích lắm. Để khắc phục điều đó, bạn có thể phải thêm phương thức của riêng mình, phương thức này lại thường khá dài dòng và phải được cập nhật mỗi khi bạn thêm trường mới

Các trường được lưu trữ trên các lớp có thể thay đổi và các trường mới có thể được thêm tự do, bạn có thể thích hoặc không thích. Có thể cung cấp nhiều quyền kiểm soát truy cập hơn và tạo các trường chỉ đọc bằng trình trang trí, nhưng một lần nữa, điều này yêu cầu viết nhiều mã keo hơn

Viết một lớp tùy chỉnh là một tùy chọn tuyệt vời bất cứ khi nào bạn muốn thêm hành vi và logic nghiệp vụ vào các đối tượng bản ghi của mình bằng các phương thức. Tuy nhiên, điều này có nghĩa là các đối tượng này về mặt kỹ thuật không còn là đối tượng dữ liệu thuần túy nữa.

>>>

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

17. Trăn 3. Hơn 7 lớp dữ liệu

Các lớp dữ liệu có sẵn trong Python 3. 7 trở lên. Chúng cung cấp một giải pháp thay thế tuyệt vời để xác định các lớp lưu trữ dữ liệu của riêng bạn từ đầu

Bằng cách viết một lớp dữ liệu thay vì một lớp Python thuần túy, các thể hiện đối tượng của bạn sẽ nhận được một vài tính năng hữu ích giúp bạn tiết kiệm một số công việc đánh máy và triển khai thủ công

• Cú pháp để xác định các biến thể hiện ngắn hơn, vì bạn không cần triển khai phương thức

  >>> import collections
  >>> d = collections.OrderedDict[one=1, two=2, three=3]
  
  >>> d
  OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]
  
  >>> d["four"] = 4
  >>> d
  OrderedDict[[['one', 1], ['two', 2],
               ['three', 3], ['four', 4]]]
  
  >>> d.keys[]
  odict_keys[['one', 'two', 'three', 'four']]
  

  18
• Các thể hiện của lớp dữ liệu của bạn sẽ tự động nhận được biểu diễn chuỗi đẹp mắt thông qua phương thức

  >>> import collections
  >>> d = collections.OrderedDict[one=1, two=2, three=3]
  
  >>> d
  OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]
  
  >>> d["four"] = 4
  >>> d
  OrderedDict[[['one', 1], ['two', 2],
               ['three', 3], ['four', 4]]]
  
  >>> d.keys[]
  odict_keys[['one', 'two', 'three', 'four']]
  

  19 được tạo tự động
• Các biến thể hiện chấp nhận các chú thích kiểu, làm cho lớp dữ liệu của bạn tự ghi lại ở một mức độ nào đó. Hãy nhớ rằng chú thích loại chỉ là gợi ý không được thực thi nếu không có công cụ kiểm tra loại riêng

Các lớp dữ liệu thường được tạo bằng cách sử dụng trình trang trí

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>>

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

Để tìm hiểu thêm về các lớp dữ liệu Python, hãy xem Hướng dẫn cơ bản về các lớp dữ liệu trong Python 3. 7

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

21. Đối tượng dữ liệu thuận tiện

Lớp

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>> from types import MappingProxyType
>>> writable = {"one": 1, "two": 2}
>>> read_only = MappingProxyType[writable]

>>> # The proxy is read-only:
>>> read_only["one"]
1
>>> read_only["one"] = 23
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'mappingproxy' object does not support item assignment

>>> # Updates to the original are reflected in the proxy:
>>> writable["one"] = 42
>>> read_only
mappingproxy[{'one': 42, 'two': 2}]

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

Bên cạnh đó, các đối tượng

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

Các đối tượng

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>>

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

Tôi nhận thấy rằng việc chuyển từ các loại dữ liệu đặc biệt như từ điển có định dạng cố định sang các đối tượng

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

Sử dụng các đối tượng

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>>

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

32. Bộ tên được cải tiến

Đã thêm vào Python 3. 6, là em của lớp

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>> arr = ["one", "two", "three"]
>>> arr[0]
'one'

>>> # Lists have a nice repr:
>>> arr
['one', 'two', 'three']

>>> # Lists are mutable:
>>> arr[1] = "hello"
>>> arr
['one', 'hello', 'three']

>>> del arr[1]
>>> arr
['one', 'three']

>>> # Lists can hold arbitrary data types:
>>> arr.append[23]
>>> arr
['one', 'three', 23]

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

Xin lưu ý rằng chú thích loại không được thực thi nếu không có công cụ kiểm tra loại riêng biệt như mypy. Nhưng ngay cả khi không có công cụ hỗ trợ, chúng vẫn có thể cung cấp các gợi ý hữu ích cho các lập trình viên khác [hoặc cực kỳ khó hiểu nếu các gợi ý kiểu đã lỗi thời]

>>>

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

37. Cấu trúc C nối tiếp

Lớp chuyển đổi giữa các giá trị Python và cấu trúc C được tuần tự hóa thành các đối tượng Python

>>> arr = "abcd"
>>> arr[1]
'b'

>>> arr
'abcd'

>>> # Strings are immutable:
>>> arr[1] = "e"
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object does not support item assignment

>>> del arr[1]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'str' object doesn't support item deletion

>>> # Strings can be unpacked into a list to
>>> # get a mutable representation:
>>> list["abcd"]
['a', 'b', 'c', 'd']
>>> "".join[list["abcd"]]
'abcd'

>>> # Strings are recursive data structures:
>>> type["abc"]
""
>>> type["abc"[0]]
""

Các cấu trúc được xác định bằng một ngôn ngữ nhỏ dựa trên ngôn ngữ đó cho phép bạn xác định cách sắp xếp của các loại dữ liệu C khác nhau như

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

Các cấu trúc nối tiếp hiếm khi được sử dụng để biểu diễn các đối tượng dữ liệu được xử lý hoàn toàn bên trong mã Python. Chúng được dự định chủ yếu dưới dạng định dạng trao đổi dữ liệu chứ không phải là cách lưu trữ dữ liệu trong bộ nhớ chỉ được sử dụng bởi mã Python

Trong một số trường hợp, việc đóng gói dữ liệu nguyên thủy vào các cấu trúc có thể sử dụng ít bộ nhớ hơn so với việc giữ nó trong các kiểu dữ liệu khác. Tuy nhiên, trong hầu hết các trường hợp, đó sẽ là một tối ưu hóa khá nâng cao [và có lẽ không cần thiết]

>>>

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

44. Quyền truy cập thuộc tính ưa thích

Đây là một lựa chọn hơi khó hiểu hơn để triển khai các đối tượng dữ liệu trong Python. . Lớp này đã được thêm vào Python 3. 3 và cung cấp quyền truy cập thuộc tính vào không gian tên của nó

Điều này có nghĩa là các trường hợp

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

Đúng như tên gọi của nó,

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>>

>>> from collections import defaultdict
>>> dd = defaultdict[list]

>>> # Accessing a missing key creates it and
>>> # initializes it using the default factory,
>>> # i.e. list[] in this example:
>>> dd["dogs"].append["Rufus"]
>>> dd["dogs"].append["Kathrin"]
>>> dd["dogs"].append["Mr Sniffles"]

>>> dd["dogs"]
['Rufus', 'Kathrin', 'Mr Sniffles']

Bản ghi, cấu trúc và đối tượng dữ liệu trong Python. Tóm lược

Như bạn đã thấy, có khá nhiều tùy chọn khác nhau để triển khai các bản ghi hoặc đối tượng dữ liệu. Bạn nên sử dụng loại nào cho các đối tượng dữ liệu trong Python?

• Nếu bạn chỉ có một vài trường, thì việc sử dụng một đối tượng tuple đơn giản có thể ổn nếu thứ tự trường dễ nhớ hoặc tên trường không cần thiết. Ví dụ, nghĩ về một điểm

  >>> import collections
  >>> d = collections.OrderedDict[one=1, two=2, three=3]
  
  >>> d
  OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]
  
  >>> d["four"] = 4
  >>> d
  OrderedDict[[['one', 1], ['two', 2],
               ['three', 3], ['four', 4]]]
  
  >>> d.keys[]
  odict_keys[['one', 'two', 'three', 'four']]
  

  51 trong không gian ba chiều

• Nếu bạn cần các trường bất biến, thì các bộ dữ liệu đơn giản,

  >>> import collections
  >>> d = collections.OrderedDict[one=1, two=2, three=3]
  
  >>> d
  OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]
  
  >>> d["four"] = 4
  >>> d
  OrderedDict[[['one', 1], ['two', 2],
               ['three', 3], ['four', 4]]]
  
  >>> d.keys[]
  odict_keys[['one', 'two', 'three', 'four']]
  

  21 và

  >>> import collections
  >>> d = collections.OrderedDict[one=1, two=2, three=3]
  
  >>> d
  OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]
  
  >>> d["four"] = 4
  >>> d
  OrderedDict[[['one', 1], ['two', 2],
               ['three', 3], ['four', 4]]]
  
  >>> d.keys[]
  odict_keys[['one', 'two', 'three', 'four']]
  

  32 đều là những lựa chọn tốt

• Nếu bạn cần khóa tên trường để tránh lỗi chính tả, thì

  >>> import collections
  >>> d = collections.OrderedDict[one=1, two=2, three=3]
  
  >>> d
  OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]
  
  >>> d["four"] = 4
  >>> d
  OrderedDict[[['one', 1], ['two', 2],
               ['three', 3], ['four', 4]]]
  
  >>> d.keys[]
  odict_keys[['one', 'two', 'three', 'four']]
  

  21 và

  >>> import collections
  >>> d = collections.OrderedDict[one=1, two=2, three=3]
  
  >>> d
  OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]
  
  >>> d["four"] = 4
  >>> d
  OrderedDict[[['one', 1], ['two', 2],
               ['three', 3], ['four', 4]]]
  
  >>> d.keys[]
  odict_keys[['one', 'two', 'three', 'four']]
  

  32 là bạn của bạn

• Nếu bạn muốn giữ mọi thứ đơn giản, thì một đối tượng từ điển đơn giản có thể là một lựa chọn tốt do cú pháp thuận tiện gần giống với JSON

• Nếu bạn cần toàn quyền kiểm soát cấu trúc dữ liệu của mình, thì đã đến lúc viết một lớp tùy chỉnh với setters và getters

• Nếu bạn cần thêm hành vi [phương thức] vào đối tượng, thì bạn nên viết một lớp tùy chỉnh, từ đầu hoặc sử dụng trình trang trí

  >>> import collections
  >>> d = collections.OrderedDict[one=1, two=2, three=3]
  
  >>> d
  OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]
  
  >>> d["four"] = 4
  >>> d
  OrderedDict[[['one', 1], ['two', 2],
               ['three', 3], ['four', 4]]]
  
  >>> d.keys[]
  odict_keys[['one', 'two', 'three', 'four']]
  

  57 hoặc bằng cách mở rộng

  >>> import collections
  >>> d = collections.OrderedDict[one=1, two=2, three=3]
  
  >>> d
  OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]
  
  >>> d["four"] = 4
  >>> d
  OrderedDict[[['one', 1], ['two', 2],
               ['three', 3], ['four', 4]]]
  
  >>> d.keys[]
  odict_keys[['one', 'two', 'three', 'four']]
  

  21 hoặc

  >>> import collections
  >>> d = collections.OrderedDict[one=1, two=2, three=3]
  
  >>> d
  OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]
  
  >>> d["four"] = 4
  >>> d
  OrderedDict[[['one', 1], ['two', 2],
               ['three', 3], ['four', 4]]]
  
  >>> d.keys[]
  odict_keys[['one', 'two', 'three', 'four']]
  

  32

• Nếu bạn cần đóng gói dữ liệu chặt chẽ để đánh số thứ tự vào đĩa hoặc gửi qua mạng, thì đã đến lúc đọc trên

  >>> import collections
  >>> d = collections.OrderedDict[one=1, two=2, three=3]
  
  >>> d
  OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]
  
  >>> d["four"] = 4
  >>> d
  OrderedDict[[['one', 1], ['two', 2],
               ['three', 3], ['four', 4]]]
  
  >>> d.keys[]
  odict_keys[['one', 'two', 'three', 'four']]
  

  37 vì đây là một trường hợp sử dụng tuyệt vời cho nó

Nếu bạn đang tìm kiếm một lựa chọn mặc định an toàn, thì đề xuất chung của tôi để triển khai một bản ghi, cấu trúc hoặc đối tượng dữ liệu đơn giản trong Python sẽ là sử dụng

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]

>>> import collections
>>> d = collections.OrderedDict[one=1, two=2, three=3]

>>> d
OrderedDict[[['one', 1], ['two', 2], ['three', 3]]]

>>> d["four"] = 4
>>> d
OrderedDict[[['one', 1], ['two', 2],
             ['three', 3], ['four', 4]]]

>>> d.keys[]
odict_keys[['one', 'two', 'three', 'four']]