Cấu trúc động trong Python là gì?

>>> 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 "<stdin>", line 1, in <module> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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ú.

>>> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
KeyError: 'missing'

Trong khi các phiên bản ________ 40 tiêu chuẩn duy trì thứ tự chèn của các khóa trong Python 3. 6 trở lên, đây chỉ đơn giản là tác dụng phụ của việc triển khai CPython và không được xác định trong thông số ngôn ngữ cho đến Python 3. 7. Vì vậy, nếu thứ tự khóa là quan trọng để thuật toán của bạn hoạt động, thì tốt nhất bạn nên truyền đạt điều này một cách rõ ràng bằng cách sử dụng rõ ràng lớp

>>> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
KeyError: 'missing'

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

>>> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
KeyError: 'missing'

>>> 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 "<stdin>", line 1, in <module>
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 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
KeyError: 'missing'

>>> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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 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 "<stdin>", line 1, in <module> KeyError: 'missing' 63. 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 gõ và làm cho ý định của bạn rõ ràng hơn so với việc 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module> KeyError: 'missing' 67. 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module> KeyError: 'missing' 69. 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

Ví dụ:

>>> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
KeyError: 'missing'

>>>

>>> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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 ra ngoài 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module> 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

>>>

>>> 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 "<stdin>", line 1, in <module>
KeyError: 'missing'

>>> 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 "<stdin>", line 1, in <module> 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ư 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 "<stdin>", line 1, in <module>
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

>>>

>>> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module> KeyError: 'missing' 38. Mảng gõ cơ bản

Mô-đun

>>> 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 "<stdin>", line 1, in <module>
KeyError: 'missing'

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

>>> 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 "<stdin>", line 1, in <module>
KeyError: 'missing'

Do ràng buộc này, các đối tượ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 "<stdin>", line 1, in <module>
KeyError: 'missing'

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

>>>

>>> 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 "<stdin>", line 1, in <module>
KeyError: 'missing'

>>> 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 "<stdin>", line 1, in <module> 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}) 82. 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

>>> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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 đố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

>>>

>>> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module> 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}) 86. 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, _____ 486 đối tượng tương tự như đối tượng ________ 482 và bạn cũng có thể coi chúng là mảng byte bất biến

Giống như chuỗ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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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})

>>> 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}

>>>

>>> 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}

>>> 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} 72. 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

>>> 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}

>>> 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 "<stdin>", line 1, in <module>
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})

>>> 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}

>>> 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}

Một

>>> 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}

>>> 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 "<stdin>", line 1, in <module>
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 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 "<stdin>", line 1, in <module>
KeyError: 'missing'

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à pandas 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 "<stdin>", line 1, in <module>
  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 "<stdin>", line 1, in <module>
  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 phẩy động) và đóng gói chặt chẽ và hiệu suất là quan trọng, thì hãy dùng thử

  >>> 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 "<stdin>", line 1, in <module>
  KeyError: 'missing'
  

  38

• 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

  >>> 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 "<stdin>", line 1, in <module>
  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})
  

  82 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 "<stdin>", line 1, in <module>
  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

  >>> 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 "<stdin>", line 1, in <module>
  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})
  

  86 bất biến hoặc

  >>> 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}
  

  72 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module> 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

>>>

>>> 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 "<stdin>", line 1, in <module>
KeyError: 'missing'

>>> 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 "<stdin>", line 1, in <module> 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 hằng số bộ cần một mã lệnh

>>> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
KeyError: 'missing'

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

>>>

>>> 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 "<stdin>", line 1, in <module>
KeyError: 'missing'

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

>>> 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 "<stdin>", line 1, in <module>
KeyError: 'missing'

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.

>>>

>>> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module> KeyError: 'missing' 717. 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

  >>> 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 "<stdin>", line 1, in <module>
  KeyError: 'missing'
  

  718
• Các phiên bả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

  >>> 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 "<stdin>", line 1, in <module>
  KeyError: 'missing'
  

  719 đượ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 trình trang trí

>>> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
KeyError: 'missing'

Để 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

>>> 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 "<stdin>", line 1, in <module> KeyError: 'missing' 721. Đối tượng dữ liệu thuận tiện

Lớp

>>> 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 "<stdin>", line 1, in <module>
KeyError: 'missing'

>>> 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 "<stdin>", line 1, in <module>
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 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 "<stdin>", line 1, in <module>
KeyError: 'missing'

Các đối tượ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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
KeyError: 'missing'

Bên cạnh đó, các đối tượ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 "<stdin>", line 1, in <module>
KeyError: 'missing'

Các đối tượ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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
KeyError: 'missing'

Các đối tượ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 "<stdin>", line 1, in <module>
KeyError: 'missing'

Tôi 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

>>> 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 "<stdin>", line 1, in <module>
KeyError: 'missing'

Sử dụng các đối tượ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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module> KeyError: 'missing' 732. Bộ tên được cải thiện

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

>>> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
KeyError: 'missing'

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)

>>>

>>> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module> KeyError: 'missing' 737. 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

>>> 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 "<stdin>", line 1, in <module>
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 cấu trúc được xác định bằng một ngôn ngữ nhỏ dựa trên đó 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ư

>>> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
KeyError: 'missing'

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)

>>>

>>> 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module> KeyError: 'missing' 744. 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 phiên bả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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
KeyError: 'missing'

Đúng như tên gọi của 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
KeyError: 'missing'

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

  >>> 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 "<stdin>", line 1, in <module>
  KeyError: 'missing'
  

  751 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,

  >>> 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 "<stdin>", line 1, in <module>
  KeyError: 'missing'
  

  721 và

  >>> 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 "<stdin>", line 1, in <module>
  KeyError: 'missing'
  

  732 đề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ì

  >>> 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 "<stdin>", line 1, in <module>
  KeyError: 'missing'
  

  721 và

  >>> 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 "<stdin>", line 1, in <module>
  KeyError: 'missing'
  

  732 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í

  >>> 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 "<stdin>", line 1, in <module>
  KeyError: 'missing'
  

  757 hoặc bằng cách mở rộ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 "<stdin>", line 1, in <module>
  KeyError: 'missing'
  

  721 hoặc

  >>> 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 "<stdin>", line 1, in <module>
  KeyError: 'missing'
  

  732

• 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

  >>> 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 "<stdin>", line 1, in <module>
  KeyError: 'missing'
  

  737 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 là 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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
KeyError: 'missing'