Từ điển Python cho các biến

Những gì chúng tôi đã làm ở đây là tạo một từ điển trên dòng đầu tiên. Từ điển được tạo bằng cách sử dụng dấu ngoặc nhọn [_______133_______], giống như cách sử dụng dấu ngoặc vuông để tạo danh sách. Từ điển chúng tôi tạo ở đây có ba mục trong đó mỗi mục bao gồm một khóa và một giá trị. Giá trị là dữ liệu thực mà chúng tôi muốn giữ và điều quan trọng là cách chúng tôi có thể nhận được dữ liệu chúng tôi muốn. Khóa và giá trị được phân tách bằng dấu hai chấm và mỗi cặp khóa-giá trị được phân tách bằng dấu phẩy

Trên dòng tiếp theo, chúng tôi truy cập dữ liệu trong từ điển sounds. Một lần nữa, giống như danh sách, chúng tôi sử dụng dấu ngoặc vuông để đặt câu hỏi về dữ liệu của mình. Trong trường hợp này, chúng tôi đang yêu cầu từ điển cung cấp cho chúng tôi giá trị được liên kết với khóa "cat" và do đó, nó sẽ trả về cho chúng tôi "meow"

Vì từ điển có thể khá lớn và đôi khi khó có thể thấy phần nào là khóa và phần nào là giá trị, nên có thể viết từ điển trên nhiều dòng, một dòng cho mỗi mục khóa-giá trị

Phương pháp #2. Sử dụng iter[] + next[] Có thể sử dụng kết hợp các chức năng trên để thực hiện tác vụ cụ thể này. Nó sử dụng các trình vòng lặp để thực hiện tác vụ này. next[] được sử dụng để tìm nạp các cặp cho đến khi hết từ điển. Nó hoạt động với Python3.  

Từ điển là kho lưu trữ khóa-giá trị, nghĩa là chúng lưu trữ và cho phép truy xuất dữ liệu [hoặc giá trị] thông qua một khóa duy nhất. Điều này tương tự với một từ điển thực, nơi bạn tra cứu các định nghĩa [dữ liệu] bằng cách sử dụng một khóa nhất định - từ. Tuy nhiên, không giống như từ điển ngôn ngữ, các khóa trong từ điển Python không được sắp xếp theo thứ tự bảng chữ cái

Từ Python 3. 6 từ điển trở đi được sắp xếp theo thứ tự các phần tử được lưu trữ và truy xuất theo thứ tự chúng được thêm vào. Điều này thường chỉ có hậu quả đối với việc lặp lại [xem sau]

Mọi thứ có thể được lưu trữ trong biến Python đều có thể được lưu trữ trong giá trị từ điển. Điều đó bao gồm các loại có thể thay đổi bao gồm

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d['this'] = 'the other'
>>> d
{'this':'the other'}

6 và thậm chí

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d['this'] = 'the other'
>>> d
{'this':'the other'}

7 - nghĩa là bạn có thể lồng các từ điển vào bên trong một từ điển khác. Ngược lại, các khóa phải có thể băm và không thay đổi — đối tượng băm không được thay đổi sau khi tính toán. Điều này có nghĩa là không thể sử dụng các đối tượng

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d['this'] = 'the other'
>>> d
{'this':'the other'}

6 hoặc

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d['this'] = 'the other'
>>> d
{'this':'the other'}

7 cho các khóa từ điển, tuy nhiên, một

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d['key1']
'value1'

0 vẫn ổn

Băm là một đại diện có thể tái tạo, nhỏ gọn, của một giá trị ban đầu. Có thể lặp lại có nghĩa là việc băm cùng một đầu vào sẽ luôn tạo ra cùng một đầu ra. Điều này rất cần thiết cho các khóa từ điển nơi băm được sử dụng để lưu trữ và tra cứu giá trị. nếu hàm băm thay đổi mỗi khi chúng tôi băm khóa, chúng tôi sẽ không bao giờ tìm thấy bất kỳ thứ gì

Tạo

Từ điển có thể được định nghĩa bằng cả cú pháp nghĩa đen hoặc hàm tạo. Cú pháp theo nghĩa đen rõ ràng hơn một chút, nhưng có những tình huống mà

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d['key1']
'value1'

1 hữu ích

trăn

:::python
d = {}        # An empty dictionary, using literal syntax
d = dict[]    # An empty dictionary, using object syntax

Bạn có thể thêm các mục ban đầu vào từ điển bằng cách chuyển các cặp khóa-giá trị tại thời điểm tạo. Hai cú pháp sau đây là tương đương và sẽ tạo ra một từ điển giống hệt nhau

trăn

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

Tuy nhiên, hãy lưu ý rằng các khóa trong cú pháp

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d['this'] = 'the other'
>>> d
{'this':'the other'}

7 chỉ được giới hạn ở các tên tham số từ khóa hợp lệ — ví dụ: bạn không thể sử dụng bất kỳ thứ gì không phải là tên biến hợp lệ [bao gồm số, tên chữ và số viết tắt hoặc dấu chấm câu]

trăn

:::python
>>> dict[1='hello']
SyntaxError: invalid syntax

>>> dict[1a='hello']
SyntaxError: invalid syntax

Như mọi khi trong Python, các tham số từ khóa được hiểu là tên chuỗi, bỏ qua mọi biến được xác định có cùng tên

trăn

:::python
>>> a = 12345
>>> {a:'test'}
{12345: 'test'}

>>> dict[a='test']
{'a': 'test'}

Vì lý do này,

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d['key1']
'value1'

1 chỉ thực sự hữu ích khi bạn có tên khóa rất hạn chế. Trường hợp này thường xảy ra, nhưng bạn có thể tránh hoàn toàn những phiền toái này bằng cách sử dụng cú pháp

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d['key1']
'value1'

4 theo nghĩa đen

Thêm

Bạn có thể thêm các mục vào từ điển bằng cách gán giá trị cho một khóa, sử dụng cú pháp dấu ngoặc vuông

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d['key1']
'value1'

5

trăn

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d
{'this':'that'}

Gán cho các khóa đã tồn tại sẽ thay thế giá trị hiện có cho khóa đó

trăn

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d['this'] = 'the other'
>>> d
{'this':'the other'}

Truy xuất

Các giá trị cho một khóa nhất định có thể được truy xuất bằng khóa, sử dụng cú pháp dấu ngoặc vuông

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d['key1']
'value1'

5

trăn

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d['key1']
'value1'

Truy xuất một mục không xóa mục đó khỏi từ điển

trăn

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

Giá trị được trả về là cùng một đối tượng được lưu trữ trong từ điển, không phải là bản sao. Điều quan trọng cần ghi nhớ khi sử dụng các đối tượng có thể thay đổi, chẳng hạn như danh sách làm giá trị

trăn

:::python
>>> d = {'key1': [1,2,3,4]}
>>> l = d['key1']
>>> l
[1,2,3,4]

>>> l.pop[]
4

>>> d
d = {'key1': [1,2,3]}

Lưu ý rằng những thay đổi được thực hiện đối với

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d['this'] = 'the other'
>>> d
{'this':'the other'}

6 được trả lại tiếp tục được phản ánh trong từ điển. Danh sách đã truy xuất và giá trị trong từ điển là cùng một đối tượng

Loại bỏ

Để xóa một mục khỏi từ điển, bạn có thể sử dụng

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d['key1']
'value1'

8 sử dụng cú pháp dấu ngoặc vuông với phím để truy cập phần tử

trăn

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> del d['key1]
>>> d
{'key2':'value2', 'key3': 3}

Bạn cũng có thể xóa các mục khỏi từ điển bằng cách sử dụng

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d['key1']
'value1'

9. Thao tác này sẽ xóa khóa đã cho khỏi từ điển và trả về giá trị

trăn

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

0

Đếm

Số phần tử trong từ điển có thể được tìm thấy bằng cách sử dụng

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

0

trăn

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

1

Độ dài của một từ điển

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

1,

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

2 và

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

3 luôn bằng nhau

Xem đối tượng

Các khóa, giá trị và mục từ từ điển có thể được truy cập bằng các phương pháp

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

1,

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

2 và

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

3. Các phương thức này trả về các đối tượng dạng xem cung cấp dạng xem trên từ điển nguồn

Có các đối tượng xem riêng biệt cho từng khóa, giá trị và mục - lần lượt là

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

7,

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

8 và

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

9

trăn

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

2

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

9 cung cấp chế độ xem qua các bộ dữ liệu của

:::python
>>> d = {'key1': [1,2,3,4]}
>>> l = d['key1']
>>> l
[1,2,3,4]

>>> l.pop[]
4

>>> d
d = {'key1': [1,2,3]}

1 cặp

trăn

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

3

Các đối tượng xem này đều có thể lặp lại. Chúng cũng động — các thay đổi đối với từ điển gốc tiếp tục được phản ánh trong chế độ xem sau khi nó được tạo

trăn

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

4

Điều này khác với Python 2. 7, trong đó

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

1,

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

2 và

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

3 trả về một danh sách tĩnh

Tư cách thành viên

Để xác định xem một khóa nhất định có trong từ điển hay không, bạn có thể sử dụng từ khóa

:::python
>>> d = {'key1': [1,2,3,4]}
>>> l = d['key1']
>>> l
[1,2,3,4]

>>> l.pop[]
4

>>> d
d = {'key1': [1,2,3]}

5. Điều này sẽ trả về

:::python
>>> d = {'key1': [1,2,3,4]}
>>> l = d['key1']
>>> l
[1,2,3,4]

>>> l.pop[]
4

>>> d
d = {'key1': [1,2,3]}

6 nếu tìm thấy khóa đưa ra,

:::python
>>> d = {'key1': [1,2,3,4]}
>>> l = d['key1']
>>> l
[1,2,3,4]

>>> l.pop[]
4

>>> d
d = {'key1': [1,2,3]}

7 nếu không tìm thấy

trăn

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

5

Bạn cũng có thể kiểm tra xem một giá trị đã cho hoặc cặp khóa-giá trị có trong từ điển hay không bằng cách sử dụng chế độ xem

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

2 và

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

3

trăn

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

6

Những tra cứu này kém hiệu quả hơn so với tra cứu dựa trên khóa trên từ điển và việc cần tra cứu các giá trị hoặc mục thường là dấu hiệu cho thấy

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d['this'] = 'the other'
>>> d
{'this':'the other'}

7 không phải là nơi lưu trữ tốt cho dữ liệu của bạn

Danh sách từ từ điển

Để đưa

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d['this'] = 'the other'
>>> d
{'this':'the other'}

6 khóa, giá trị hoặc mục của từ điển vào danh sách, chúng ta có thể lấy các đối tượng xem

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

7,

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

8 hoặc

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

9 và chuyển chúng tới

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> del d['key1]
>>> d
{'key2':'value2', 'key3': 3}

5

trăn

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

7

Chuyển đổi các đối tượng dạng xem thành danh sách sẽ phá vỡ liên kết đến từ điển gốc, do đó, các cập nhật tiếp theo cho từ điển sẽ không được phản ánh trong danh sách

Từ điển từ danh sách

Các danh sách tương tự có thể được sử dụng để tạo từ điển. Cách tiếp cận đơn giản nhất là sử dụng

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d['this'] = 'the other'
>>> d
{'this':'the other'}

6 của

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> del d['key1]
>>> d
{'key2':'value2', 'key3': 3}

7 trong đó phần tử đầu tiên trong

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d['key1']
'value1'

0 được sử dụng cho khóa và phần tử thứ hai cho giá trị

trăn

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

8

Bạn có thể chuyển vào các trình vòng lặp khác, không chỉ danh sách. Hạn chế duy nhất là trình vòng lặp cần trả về 2 mục cho mỗi lần lặp

Nếu bạn có các thành phần khóa và giá trị trong các danh sách riêng biệt, bạn có thể sử dụng

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> del d['key1]
>>> d
{'key2':'value2', 'key3': 3}

9 để kết hợp chúng lại với nhau thành các bộ trước khi tạo từ điển

trăn

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

9

Nếu danh sách khóa và giá trị không có cùng độ dài, hành vi của

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> del d['key1]
>>> d
{'key2':'value2', 'key3': 3}

9 là âm thầm bỏ bất kỳ mục thừa nào khỏi danh sách dài hơn

trăn

:::python
>>> dict[1='hello']
SyntaxError: invalid syntax

>>> dict[1a='hello']
SyntaxError: invalid syntax

0

lặp đi lặp lại

Theo mặc định, lặp qua từ điển lặp qua các phím

trăn

:::python
>>> dict[1='hello']
SyntaxError: invalid syntax

>>> dict[1a='hello']
SyntaxError: invalid syntax

1

Điều này tương đương về mặt chức năng với việc lặp qua chế độ xem

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

1

trăn

:::python
>>> dict[1='hello']
SyntaxError: invalid syntax

>>> dict[1a='hello']
SyntaxError: invalid syntax

2

Từ điển không bị ảnh hưởng bởi việc lặp lại nó và bạn có thể sử dụng khóa trong vòng lặp của mình để truy cập giá trị từ từ điển

trăn ______9_______3

Nếu bạn muốn truy cập vào các giá trị từ điển trong vòng lặp của mình, bạn có thể lặp lại các mục để chúng được trả về trong vòng lặp

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

02. Các khóa và giá trị được trả về dưới dạng 2-tuple

trăn

:::python
>>> dict[1='hello']
SyntaxError: invalid syntax

>>> dict[1a='hello']
SyntaxError: invalid syntax

4

Bạn có thể giải nén khóa và giá trị thành các biến riêng biệt trong vòng lặp, làm cho chúng khả dụng mà không cần lập chỉ mục. Đây là cấu trúc vòng lặp phổ biến nhất được sử dụng với từ điển

trăn ______9_______5

Nếu bạn chỉ quan tâm đến các giá trị từ điển, bạn cũng có thể lặp lại trực tiếp các giá trị này

trăn ______9_______6

Nếu bạn muốn tính khi bạn lặp lại, bạn có thể sử dụng

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

03 như với bất kỳ trình lặp nào, nhưng bạn phải lồng quá trình giải nén

trăn ______9_______7

hiểu từ điển

Khả năng hiểu từ điển là các phép lặp tốc ký có thể được sử dụng để xây dựng từ điển, trong khi lọc hoặc thay đổi khóa hoặc giá trị

Lặp lại danh sách các bộ dữ liệu

:::python
>>> d = {'key1': [1,2,3,4]}
>>> l = d['key1']
>>> l
[1,2,3,4]

>>> l.pop[]
4

>>> d
d = {'key1': [1,2,3]}

1 và gán cho các khóa và giá trị sẽ tạo một từ điển mới

trăn

:::python
>>> dict[1='hello']
SyntaxError: invalid syntax

>>> dict[1a='hello']
SyntaxError: invalid syntax

8

Bạn có thể lọc các phần tử bằng cách sử dụng mệnh đề

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

05 ở cuối. Nếu biểu thức này có giá trị là

:::python
>>> d = {'key1': [1,2,3,4]}
>>> l = d['key1']
>>> l
[1,2,3,4]

>>> l.pop[]
4

>>> d
d = {'key1': [1,2,3]}

7 thì phần tử sẽ bị bỏ qua [nếu nó có giá trị là

:::python
>>> d = {'key1': [1,2,3,4]}
>>> l = d['key1']
>>> l
[1,2,3,4]

>>> l.pop[]
4

>>> d
d = {'key1': [1,2,3]}

6 thì nó sẽ được thêm vào]

trăn

:::python
>>> dict[1='hello']
SyntaxError: invalid syntax

>>> dict[1a='hello']
SyntaxError: invalid syntax

9

Bất kỳ biểu thức hợp lệ nào cũng có thể được sử dụng để so sánh, miễn là nó trả về giá trị trung thực hoặc sai

trăn

:::python
>>> a = 12345
>>> {a:'test'}
{12345: 'test'}

>>> dict[a='test']
{'a': 'test'}

0

So sánh có thể được thực hiện đối với các khóa, giá trị hoặc cả hai

trăn

:::python
>>> a = 12345
>>> {a:'test'}
{12345: 'test'}

>>> dict[a='test']
{'a': 'test'}

1

Vì chuỗi rỗng được đánh giá là

:::python
>>> d = {'key1': [1,2,3,4]}
>>> l = d['key1']
>>> l
[1,2,3,4]

>>> l.pop[]
4

>>> d
d = {'key1': [1,2,3]}

7 trong thử nghiệm Python nên chỉ riêng giá trị có thể được sử dụng để loại bỏ các giá trị chuỗi rỗng khỏi từ điển

trăn

:::python
>>> a = 12345
>>> {a:'test'}
{12345: 'test'}

>>> dict[a='test']
{'a': 'test'}

2

Các danh sách khóa và giá trị riêng biệt có thể được nén và lọc bằng cách sử dụng khả năng hiểu từ điển

trăn

:::python
>>> a = 12345
>>> {a:'test'}
{12345: 'test'}

>>> dict[a='test']
{'a': 'test'}

3

Các biểu thức cũng có thể được sử dụng trong cấu trúc

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

09 để thay đổi các khóa hoặc giá trị được tạo cho từ điển

trăn

:::python
>>> a = 12345
>>> {a:'test'}
{12345: 'test'}

>>> dict[a='test']
{'a': 'test'}

4

Mọi biểu thức đều hợp lệ, cho cả khóa và giá trị, bao gồm cả chức năng gọi

trăn

:::python
>>> a = 12345
>>> {a:'test'}
{12345: 'test'}

>>> dict[a='test']
{'a': 'test'}

5

Bạn có thể sử dụng một ternary

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

10 trong

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

09 để thay thế các phím một cách có chọn lọc. Trong các giá trị ví dụ sau được thay thế nếu chúng không khớp với

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

12

trăn

:::python
>>> a = 12345
>>> {a:'test'}
{12345: 'test'}

>>> dict[a='test']
{'a': 'test'}

6

Bạn cũng có thể sử dụng cú pháp bậc ba để xử lý khóa. Mọi biểu thức đều hợp lệ ở đây, trong ví dụ sau, chúng tôi thay thế các khóa bị thiếu bằng số lần lặp hiện tại [được lập chỉ mục 1]

trăn

:::python
>>> a = 12345
>>> {a:'test'}
{12345: 'test'}

>>> dict[a='test']
{'a': 'test'}

7

Nếu biểu thức của bạn tạo khóa trùng lặp, giá trị sau sẽ được ưu tiên cho khóa đó

trăn

:::python
>>> a = 12345
>>> {a:'test'}
{12345: 'test'}

>>> dict[a='test']
{'a': 'test'}

8

Bạn có thể sử dụng các vòng lặp lồng nhau trong phần hiểu từ điển mặc dù bạn thường không muốn vì nó có thể gây nhầm lẫn. Tuy nhiên, một ứng dụng hữu ích của điều này là để làm phẳng các từ điển lồng nhau. Ví dụ sau unnestes 2-deep dictionaries, loại bỏ các khóa bên ngoài

trăn

:::python
>>> a = 12345
>>> {a:'test'}
{12345: 'test'}

>>> dict[a='test']
{'a': 'test'}

9

Tay trái lặp vòng lặp bên ngoài, vòng lặp này lặp lại từ điển

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

13 tạo ra các giá trị trong

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

14. Vòng lặp bên trong bên phải lặp lại các khóa và giá trị từ điển này là

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

15 và

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

16, được sử dụng để tạo từ điển mới ở phía bên trái

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

09

sáp nhập

Có một số cách để hợp nhất từ ​​điển. Sự khác biệt chính giữa các phương pháp là cách thức [hoặc liệu] chúng xử lý các khóa trùng lặp

Cập nhật

Mỗi đối tượng từ điển có một phương thức

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

18, có thể được sử dụng để thêm một bộ khóa và giá trị vào một từ điển hiện có, sử dụng một từ điển khác làm nguồn

trăn

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d
{'this':'that'}

0

Điều này cập nhật từ điển gốc và không trả lại bản sao

Nếu có các khóa trùng lặp trong từ điển đang được cập nhật, các giá trị từ từ điển đó sẽ thay thế các giá trị trong từ điển đang được cập nhật

trăn

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d
{'this':'that'}

1

Nếu bạn không muốn thay thế các khóa đã có, bạn có thể sử dụng khả năng hiểu từ điển để lọc trước

trăn

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d
{'this':'that'}

2

giải nén

Từ điển có thể được giải nén thành

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

19 cặp từ khóa, được sử dụng để truyền tham số cho hàm hoặc hàm tạo. Điều này có thể được sử dụng để kết hợp nhiều từ điển bằng cách giải nén chúng liên tiếp

Điều này yêu cầu Python 3. 6 trở lên

trăn

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d
{'this':'that'}

3

Giải nén bằng cú pháp này xử lý các khóa trùng lặp, với từ điển sau được ưu tiên từ trước đó

trăn

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d
{'this':'that'}

4

Bạn có thể sử dụng cùng cú pháp này để hợp nhất nhiều từ điển lại với nhau

trăn

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d
{'this':'that'}

5

Bạn cũng có thể giải nén thành một

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d['key1']
'value1'

1

trăn

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d
{'this':'that'}

6

Tuy nhiên, trong trường hợp này, các khóa trùng lặp không được hỗ trợ và bạn bị giới hạn bởi các hạn chế đặt tên từ khóa được mô tả trước đó

trăn

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d
{'this':'that'}

7

Không có hạn chế như vậy đối với việc giải nén

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d['key1']
'value1'

4

trăn

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d
{'this':'that'}

8

Ngoài ra [Python 2. 7 chỉ]

Trong Python 2. 7

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

22 trả về một danh sách gồm các bộ dữ liệu

:::python
>>> d = {'key1': [1,2,3,4]}
>>> l = d['key1']
>>> l
[1,2,3,4]

>>> l.pop[]
4

>>> d
d = {'key1': [1,2,3]}

1. Các danh sách có thể được nối bằng cách sử dụng toán tử

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

24 và danh sách kết quả có thể được chuyển đổi trở lại một từ điển mới bằng cách chuyển đến hàm tạo

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d['this'] = 'the other'
>>> d
{'this':'the other'}

7

trăn

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d
{'this':'that'}

9

Bạn có thể thêm nhiều từ điển bằng phương pháp này. Các khóa từ điển sau được ưu tiên hơn trước

Liên minh [đặt hợp nhất]

Nếu cả khóa và giá trị của từ điển đều có thể băm được, thì chế độ xem

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

9 hỗ trợ các thao tác giống như

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

27

trăn

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d['this'] = 'the other'
>>> d
{'this':'the other'}

0

Việc hợp nhất diễn ra từ phải sang trái

Nếu các giá trị không thể băm được, điều này sẽ tăng

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

28

trăn

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d['this'] = 'the other'
>>> d
{'this':'the other'}

1

Tất cả các hoạt động tiêu chuẩn của

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

27 đều có thể thực hiện được trên

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

7 và

:::python
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

9

Sao chép

Để tạo một bản sao của từ điển hiện có, bạn có thể sử dụng

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

32. Điều này dẫn đến một từ điển giống hệt nhau là một đối tượng riêng biệt

trăn

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d['this'] = 'the other'
>>> d
{'this':'the other'}

2

Bạn cũng có thể tạo một bản sao của từ điển bằng cách chuyển từ điển hiện có tới phương thức khởi tạo

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d['this'] = 'the other'
>>> d
{'this':'the other'}

7. Điều này có chức năng tương đương với

:::python
>>> d = {'key1': 'value1', 'key2': 'value2', 'key3': 3}
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

>>> d = dict[key1='value1', key2='value2', key3=3]
>>> d
{'key1': 'value1', 'key2': 'value2', 'key3': 3}

32

trăn

:::python
>>> d = {}
>>> d['this'] = 'that'
>>> d['this'] = 'the other'
>>> d
{'this':'the other'}

3

Trong cả hai trường hợp, đây là những bản sao nông nghĩa là các đối tượng lồng nhau trong từ điển cũng không được sao chép. Các thay đổi đối với các đối tượng lồng nhau này cũng sẽ được phản ánh trong từ điển gốc

Giá trị từ điển Python có thể là biến không?

Làm cách nào để lấy các giá trị từ từ điển trong Python?

Làm thế nào chúng ta có thể nhận được các giá trị từ từ điển?

Làm cách nào để chuyển đổi biến thành từ điển trong Python?