Hướng dẫn can i store a list a key in dictionary python? - tôi có thể lưu danh sách khóa trong từ điển python không?

Từ điển là gì

Từ điển - như danh sách - là bộ sưu tập của các đối tượng. Không giống như danh sách, từ điển là các bộ sưu tập không có thứ tự. Chúng không được lập chỉ mục bởi các số tuần tự, nhưng bằng các khóa:

Show
>>> mydict = {"apples": 42, "oranges": 999}
>>> mydict['oranges']
999

Syntax dictonary

Một từ điển - có tên loại

mydict = {"hello": "world", 
          0: "a", 
          1: "b", 
          "2": "not a number"
          (1, 2, 3): "a tuple!"}
9 - được biểu thị bằng niềng răng xoăn:
>>> mydict = {"message": {"hello": 123456}}
>>> print(mydict['message'])
{'hello': 123456}
>>> print(mydict['message']['hello'])
123456
0.type name of
mydict = {"hello": "world", 
          0: "a", 
          1: "b", 
          "2": "not a number"
          (1, 2, 3): "a tuple!"}
9 – is denoted by curly braces:
>>> mydict = {"message": {"hello": 123456}}
>>> print(mydict['message'])
{'hello': 123456}
>>> print(mydict['message']['hello'])
123456
0.

Một từ điển trống có thể được khởi tạo bằng cách sử dụng chức năng cấu trúc

>>> mydict = {"message": {"hello": 123456}}
>>> print(mydict['message'])
{'hello': 123456}
>>> print(mydict['message']['hello'])
123456
1 hoặc đơn giản là với một cặp niềng răng xoăn:

newdict = {}

Dấu phẩy được sử dụng để tách các thành viên trong một từ điển. Nhưng mỗi thành viên bao gồm một cặp giá trị khóa. Một dấu hai chấm được sử dụng như một dấu phân cách giữa một khóa và giá trị tương ứng của nó: are used to separate the members in a dictionary. But each member consists of a key-value pair. A colon is used as a delimiter between a key and its corresponding value:

{"a": 99, "hello": "world"}

Truy cập các giá trị của một từ điển theo chỉ mục (nghĩa là các khóa của nó) sử dụng cùng một ký hiệu khung vuông như các đối tượng loại chuỗi khác:

>>> mydict = {"z": 92, "world": "hello"}
>>> print(mydict['world'])
hello
>>> print(mydict["z"])

Khóa hợp lệ

Các khóa của từ điển có thể là bất kỳ loại bất biến, bao gồm: chuỗi, số và bộ dữ liệu:keys of a dictionary can be any kind of immutable type, which includes: strings, numbers, and tuples:

mydict = {"hello": "world", 
          0: "a", 
          1: "b", 
          "2": "not a number"
          (1, 2, 3): "a tuple!"}

Tuy nhiên, đối với hầu hết các phần, chúng ta sẽ thấy mình sử dụng các chuỗi làm khóa khi tạo các đối tượng từ điển theo cách thủ công và chuyển đổi dữ liệu trong thế giới thực thành các đối tượng từ điển.

Giống như đối tượng danh sách có thể chứa một chuỗi của bất kỳ loại đối tượng Python nào, các giá trị được lưu trữ trong từ điển - và chúng tôi sử dụng các khóa để truy cập - có thể là bất kỳ loại đối tượng Python nào, chẳng hạn như danh sách hoặc từ điển khác:list object can contain a sequence of any kind of Python object, the values stored in a dictionary – and with which we use keys to access – can be any kind of Python object, such as lists or other dictionaries:

>>> mydict = {"message": {"hello": 123456}}
>>> print(mydict['message'])
{'hello': 123456}
>>> print(mydict['message']['hello'])
123456

Trong thực tế, rất thích nghi với khái niệm từ điển trong các từ điển khác. Nếu bạn sử dụng API của Instagram để tìm nạp dữ liệu về tài khoản của Snoop Dogg, API sẽ trả về tệp văn bản (ở định dạng JSON) có thể biến thành từ điển Python:JSON format) that can be turned into a Python dictionary:

{
    "data": {
        "id": "1574083",
        "username": "snoopdogg",
        "full_name": "Snoop Dogg",
        "profile_picture": "http://distillery.s3.amazonaws.com/profiles/profile_1574083_75sq_1295469061.jpg",
        "bio": "This is my bio",
        "website": "http://snoopdogg.com",
        "counts": {
            "media": 1320,
            "follows": 420,
            "followed_by": 3410
        }
}

Lưu ý cách từ điển "bên ngoài" chứa một khóa duy nhất,

>>> mydict = {"message": {"hello": 123456}}
>>> print(mydict['message'])
{'hello': 123456}
>>> print(mydict['message']['hello'])
123456
2, chỉ vào một đối tượng từ điển với các cặp giá trị khóa tương ứng với thông tin về tài khoản của Snoop Dogg. Và từ điển đó chứa một từ điển khác thông qua khóa,
>>> mydict = {"message": {"hello": 123456}}
>>> print(mydict['message'])
{'hello': 123456}
>>> print(mydict['message']['hello'])
123456
3.

Lặp lại thông qua một từ điển

Lưu ý: Không giống như danh sách, lặp lại thông qua từ điển sẽ không xảy ra theo thứ tự dự đoán. Tôi đi sâu hơn vào chi tiết trong một phần sau.

Lặp qua các phím

Nếu chúng ta chuyển một đối tượng

mydict = {"hello": "world", 
          0: "a", 
          1: "b", 
          "2": "not a number"
          (1, 2, 3): "a tuple!"}
9 vào vòng lặp, theo mặc định, chỉ có khóa sẽ được mang lại:key will be yielded:

>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    print(x)
b
a

Đôi khi chúng ta chỉ cần chìa khóa. Tuy nhiên, việc có các khóa cũng cho phép chúng tôi truy cập từng giá trị bằng cách tham chiếu, bao gồm khả năng thay đổi các giá trị được đề cập đến:

>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    val = mydict[x]
...    mydict[x] = val.upper()
...    print('Changed what', x, 'points to: from', val, 'to', mydict[x])
Changed what b points to: from world to WORLD
Changed what a points to: from hello to HELLO

Sử dụng phương thức Keys () để có được một chuỗi các phím

Nếu bạn có ý định chỉ lặp qua khóa từ điển, tôi khuyên bạn nên làm rõ ràng bằng cách gọi phương thức

>>> mydict = {"message": {"hello": 123456}}
>>> print(mydict['message'])
{'hello': 123456}
>>> print(mydict['message']['hello'])
123456
5 của từ điển:

>>> for k in mydict.keys():
...     print(k)
b
a

Phương thức

>>> mydict = {"message": {"hello": 123456}}
>>> print(mydict['message'])
{'hello': 123456}
>>> print(mydict['message']['hello'])
123456
5 trả về một đối tượng
>>> mydict = {"message": {"hello": 123456}}
>>> print(mydict['message'])
{'hello': 123456}
>>> print(mydict['message']['hello'])
123456
7 mà tôi không thực sự sử dụng trực tiếp. Thay vào đó, tôi sẽ chuyển đổi nó thành một đối tượng danh sách với hàm tạo
>>> mydict = {"message": {"hello": 123456}}
>>> print(mydict['message'])
{'hello': 123456}
>>> print(mydict['message']['hello'])
123456
8:

newdict = {}
0

Lặp lại thông qua các giá trị

Nếu chúng ta chỉ muốn lặp lại thông qua các giá trị của một từ điển hoặc để có được danh sách các giá trị của nó, chúng ta có thể gọi phương thức

>>> mydict = {"message": {"hello": 123456}}
>>> print(mydict['message'])
{'hello': 123456}
>>> print(mydict['message']['hello'])
123456
9 của nó:

newdict = {}
1

Lưu ý rằng nếu chúng ta lặp qua các giá trị của một từ điển với một vòng lặp, thì bên trong vòng lặp, chúng ta không có cách nào để truy cập trực tiếp các phím của từ điển hoặc để có thể thay đổi những gì các phím đó chỉ ra. Đôi khi, điều đó thật tốt - vì các vòng lặp trở nên phức tạp, thật tốt khi biết chính xác loại quyền truy cập và chức năng nào mà các vòng lặp có.

Lặp lại thông qua các cặp giá trị khóa với các mục ()

Thông thường, chúng tôi muốn có quyền truy cập vào cả khóa và giá trị cho mọi cặp giá trị khóa trong một từ điển. Chúng ta có thể sử dụng phương thức

>>> mydict = {"message": {"hello": 123456}}
>>> print(mydict['message'])
{'hello': 123456}
>>> print(mydict['message']['hello'])
123456
5 và sau đó lấy giá trị của mỗi khóa bên trong vòng lặp:

newdict = {}
2

Hoặc, chúng tôi chỉ có thể sử dụng phương pháp

{
    "data": {
        "id": "1574083",
        "username": "snoopdogg",
        "full_name": "Snoop Dogg",
        "profile_picture": "http://distillery.s3.amazonaws.com/profiles/profile_1574083_75sq_1295469061.jpg",
        "bio": "This is my bio",
        "website": "http://snoopdogg.com",
        "counts": {
            "media": 1320,
            "follows": 420,
            "followed_by": 3410
        }
}
1. Đầu tiên, tôi sẽ hiển thị những gì
{
    "data": {
        "id": "1574083",
        "username": "snoopdogg",
        "full_name": "Snoop Dogg",
        "profile_picture": "http://distillery.s3.amazonaws.com/profiles/profile_1574083_75sq_1295469061.jpg",
        "bio": "This is my bio",
        "website": "http://snoopdogg.com",
        "counts": {
            "media": 1320,
            "follows": 420,
            "followed_by": 3410
        }
}
1 trả về, và sau đó chuyển đổi nó thành một danh sách với
>>> mydict = {"message": {"hello": 123456}}
>>> print(mydict['message'])
{'hello': 123456}
>>> print(mydict['message']['hello'])
123456
8

newdict = {}
3

Lưu ý rằng nội dung thực tế là như nhau, cho dù chúng ở trong bộ sưu tập

{
    "data": {
        "id": "1574083",
        "username": "snoopdogg",
        "full_name": "Snoop Dogg",
        "profile_picture": "http://distillery.s3.amazonaws.com/profiles/profile_1574083_75sq_1295469061.jpg",
        "bio": "This is my bio",
        "website": "http://snoopdogg.com",
        "counts": {
            "media": 1320,
            "follows": 420,
            "followed_by": 3410
        }
}
4 hay
{
    "data": {
        "id": "1574083",
        "username": "snoopdogg",
        "full_name": "Snoop Dogg",
        "profile_picture": "http://distillery.s3.amazonaws.com/profiles/profile_1574083_75sq_1295469061.jpg",
        "bio": "This is my bio",
        "website": "http://snoopdogg.com",
        "counts": {
            "media": 1320,
            "follows": 420,
            "followed_by": 3410
        }
}
5 - chỉ là đối tượng danh sách cho phép chúng tôi truy cập từng mục riêng lẻ theo chỉ mục số, trong số các chức năng khác:

newdict = {}
4

Về cơ bản,

{
    "data": {
        "id": "1574083",
        "username": "snoopdogg",
        "full_name": "Snoop Dogg",
        "profile_picture": "http://distillery.s3.amazonaws.com/profiles/profile_1574083_75sq_1295469061.jpg",
        "bio": "This is my bio",
        "website": "http://snoopdogg.com",
        "counts": {
            "media": 1320,
            "follows": 420,
            "followed_by": 3410
        }
}
1 trả về một chuỗi các bộ dữ liệu.tuples.

Vì vậy, khi chúng tôi lặp lại thông qua

{
    "data": {
        "id": "1574083",
        "username": "snoopdogg",
        "full_name": "Snoop Dogg",
        "profile_picture": "http://distillery.s3.amazonaws.com/profiles/profile_1574083_75sq_1295469061.jpg",
        "bio": "This is my bio",
        "website": "http://snoopdogg.com",
        "counts": {
            "media": 1320,
            "follows": 420,
            "followed_by": 3410
        }
}
7 với vòng lặp, chúng tôi có thể tận dụng một tính năng được gọi là giải nén. Lưu ý thay đổi trong câu lệnh for-loop:tuple unpacking. Notice the change in the for-loop statement:

newdict = {}
5

Chúng ta có thể tìm hiểu các chi tiết về việc giải nén một số thời điểm khác. Hiện tại, chúng ta có thể nghĩ về nó như là một cách thực sự thuận tiện để gán nhiều hơn một biến trong một dòng. Chúng tôi cũng có thể làm điều này:tuple unpacking some other time. For now, we can think of it as just a really convenient way to assign more than one variable in a single line. We could have also done this:

newdict = {}
6

Nhưng tại sao lại là một dòng chảy khi chúng ta không cần phải như vậy?

Các phương pháp từ điển khác

So với danh sách, đối tượng từ điển không thực sự có rất nhiều phương thức hoặc thuộc tính:

newdict = {}
7

Chúng tôi đã bảo hiểm

>>> mydict = {"message": {"hello": 123456}}
>>> print(mydict['message'])
{'hello': 123456}
>>> print(mydict['message']['hello'])
123456
9,
>>> mydict = {"message": {"hello": 123456}}
>>> print(mydict['message'])
{'hello': 123456}
>>> print(mydict['message']['hello'])
123456
5 và
{
    "data": {
        "id": "1574083",
        "username": "snoopdogg",
        "full_name": "Snoop Dogg",
        "profile_picture": "http://distillery.s3.amazonaws.com/profiles/profile_1574083_75sq_1295469061.jpg",
        "bio": "This is my bio",
        "website": "http://snoopdogg.com",
        "counts": {
            "media": 1320,
            "follows": 420,
            "followed_by": 3410
        }
}
1. Trong số một số còn lại, cá nhân tôi chỉ sử dụng
>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    print(x)
b
a
1 và
>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    print(x)
b
a
2 - và đôi khi,
>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    print(x)
b
a
3

get()

Tương tự như cố gắng truy cập một danh sách bằng giá trị chỉ mục quá lớn, việc truy cập khóa không tồn tại của từ điển sẽ tăng

>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    print(x)
b
a
4:

newdict = {}
8

Phương pháp

>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    print(x)
b
a
5 cung cấp một cách an toàn để kiểm tra khóa,
>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    print(x)
b
a
6. Nếu từ điển có khóa
>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    print(x)
b
a
6, phương thức
>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    print(x)
b
a
5 sẽ trả về giá trị. Nếu không, thì đối tượng
>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    print(x)
b
a
9 được trả về:

newdict = {}
9

Điều này đặc biệt hữu ích khi lặp qua danh sách các từ điển, trong đó không phải tất cả các từ điển đều có tất cả các khóa giống nhau:

{"a": 99, "hello": "world"}
0

Đầu ra:

{"a": 99, "hello": "world"}
1

OK, điều đó không tuyệt vời, nhưng ít nhất chương trình đã không gặp sự cố. Chúng ta có thể sửa đổi vòng lặp với một số nhánh có điều kiện để tránh các giá trị

>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    val = mydict[x]
...    mydict[x] = val.upper()
...    print('Changed what', x, 'points to: from', val, 'to', mydict[x])
Changed what b points to: from world to WORLD
Changed what a points to: from hello to HELLO
0 xấu xí đó, đó là những gì Python sẽ in lên màn hình cho các đối tượng
>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    print(x)
b
a
9:

{"a": 99, "hello": "world"}
2

Đầu ra:

{"a": 99, "hello": "world"}
3

OK, điều đó không tuyệt vời, nhưng ít nhất chương trình đã không gặp sự cố. Chúng ta có thể sửa đổi vòng lặp với một số nhánh có điều kiện để tránh các giá trị >>> mydict = {'a': 'hello', 'b': 'world'} >>> for x in mydict: ... val = mydict[x] ... mydict[x] = val.upper() ... print('Changed what', x, 'points to: from', val, 'to', mydict[x]) Changed what b points to: from world to WORLD Changed what a points to: from hello to HELLO 0 xấu xí đó, đó là những gì Python sẽ in lên màn hình cho các đối tượng >>> mydict = {'a': 'hello', 'b': 'world'} >>> for x in mydict: ... print(x) b a 9:

Sử dụng

>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    print(x)
b
a
3 để cung cấp giá trị thay vì giá trị không

{"a": 99, "hello": "world"}
4

Vì vậy, những chi nhánh có điều kiện đã làm việc. Nhưng hãy thành thật: Không ai thích viết loại rừng xấu xí xấu xí đó, đặc biệt là đối với a như vậy. Có nhiều cách để giảm thiểu điều này, bao gồm cả việc sử dụng phương thức

>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    print(x)
b
a
3 của đối tượng
mydict = {"hello": "world", 
          0: "a", 
          1: "b", 
          "2": "not a number"
          (1, 2, 3): "a tuple!"}
9, cho phép chúng tôi chỉ định giá trị dự phòng, ngoài
>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    print(x)
b
a
9, cho các khóa bị thiếu:

{"a": 99, "hello": "world"}
5

Đó là đẹp hơn nhiều. Đầu ra giống như trước đây:

Sử dụng Update () để đặt một số cặp giá trị khóa cùng một lúcin-place update of the calling dictionary.

Phương pháp

>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    val = mydict[x]
...    mydict[x] = val.upper()
...    print('Changed what', x, 'points to: from', val, 'to', mydict[x])
Changed what b points to: from world to WORLD
Changed what a points to: from hello to HELLO
6 lấy một từ điển,
>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    val = mydict[x]
...    mydict[x] = val.upper()
...    print('Changed what', x, 'points to: from', val, 'to', mydict[x])
Changed what b points to: from world to WORLD
Changed what a points to: from hello to HELLO
7, như một đối số (nó cũng có thể lấy các chuỗi khác, nhưng hãy giữ cho nó đơn giản ngay bây giờ) và thực hiện cập nhật tại chỗ của từ điển gọi.

{"a": 99, "hello": "world"}
6

Đối với các khóa trong >>> mydict = {'a': 'hello', 'b': 'world'} >>> for x in mydict: ... val = mydict[x] ... mydict[x] = val.upper() ... print('Changed what', x, 'points to: from', val, 'to', mydict[x]) Changed what b points to: from world to WORLD Changed what a points to: from hello to HELLO 7 cũng tồn tại trong từ điển gọi, các giá trị tương ứng trong từ điển gọi được thay thế. Đối với các khóa chưa có trong từ điển gọi, các cặp giá trị khóa mới được thêm vào:

Từ điển và danh sách, so sánh

Chèn các yếu tốlist, members are added into memory sequentially:

{"a": 99, "hello": "world"}
7

Trong danh sách, các thành viên được thêm vào bộ nhớ theo tuần tự:

{"a": 99, "hello": "world"}
8

Python chỉ cho phép chúng tôi đặt (tức là thay đổi) giá trị tại một chỉ mục hiện có:

{"a": 99, "hello": "world"}
9

Tuy nhiên, nó sẽ gây ra lỗi nếu chúng ta cố gắng đặt giá trị thành một chỉ mục mà danh sách chưa đạt được:dictionaries are unordered collections of objects, we're allowed to set values with any key we like:

>>> mydict = {"z": 92, "world": "hello"}
>>> print(mydict['world'])
hello
>>> print(mydict["z"])
0

Ngược lại, vì từ điển là các bộ sưu tập đối tượng không được đặt hàng, chúng tôi được phép đặt các giá trị với bất kỳ khóa nào chúng tôi thích:

Hậu quả của việc không được đặt hànglist is considered ordered because its members are arranged in the same order that they were inserted into the list. Every time we iterate through a list, sequentially, we can assume that its members will always be accessible in the same order that they were inserted.

>>> mydict = {"z": 92, "world": "hello"}
>>> print(mydict['world'])
hello
>>> print(mydict["z"])
1

Một danh sách được coi là đặt hàng vì các thành viên của nó được sắp xếp theo cùng một thứ tự mà họ được đưa vào danh sách. Mỗi khi chúng tôi lặp lại thông qua một danh sách, theo tuần tự, chúng tôi có thể cho rằng các thành viên của nó sẽ luôn có thể truy cập theo cùng một thứ tự mà họ đã được chèn vào.

>>> mydict = {"z": 92, "world": "hello"}
>>> print(mydict['world'])
hello
>>> print(mydict["z"])
2

Trong số các hoạt động khác, điều này cho phép chúng tôi cắt danh sách theo các khối tuần tự:dictionary are not stored in any particular order. No matter what order you add key-value pairs into a dictionary, we have no idea what order they'll come out as when we iterate through the dictionary:

>>> mydict = {"z": 92, "world": "hello"}
>>> print(mydict['world'])
hello
>>> print(mydict["z"])
3

Ngược lại, các thành viên của từ điển không được lưu trữ theo bất kỳ thứ tự cụ thể nào. Cho dù bạn có thể thêm các cặp giá trị khóa vào từ điển, chúng tôi không biết chúng sẽ xuất hiện thứ tự nào như khi chúng tôi lặp lại từ điển:

Đây thường không được coi là một nhược điểm lớn. Đối với hầu hết các trường hợp sử dụng từ điển, chúng tôi không thực sự quan tâm đến thứ tự các cặp giá trị khóa được lưu trữ là gì.collections module with allows us to create an OrderedDict. I cover that in a later section.

Tuy nhiên, đối với những lần chúng tôi yêu cầu đơn đặt hàng, Python có một mô -đun bộ sưu tập với cho phép chúng tôi tạo ra một đơn đặt hàng. Tôi bao gồm điều đó trong một phần sau.

Tính linh hoạt như một định dạng dữ liệu

Bất cứ điều gì có thể được thể hiện trong một danh sách có thể được biểu diễn dưới dạng từ điển và ngược lại. Tại sao chọn cái này hơn cái kia? Nó phụ thuộc vào những gì mà lập trình viên (hoặc nhà cung cấp dữ liệu) cảm thấy có ý nghĩa nhất để đại diện cho dữ liệu.list of the components of David Bowie's birth name, and how we would access each part of his name:

>>> mydict = {"z": 92, "world": "hello"}
>>> print(mydict['world'])
hello
>>> print(mydict["z"])
4

Ví dụ, đây là danh sách các thành phần của tên khai sinh của David Bowie và cách chúng tôi sẽ truy cập từng phần tên của anh ấy:

>>> mydict = {"z": 92, "world": "hello"}
>>> print(mydict['world'])
hello
>>> print(mydict["z"])
5

Đây là cách chúng ta có thể đại diện cho nó như một từ điển:

Từ điển có vẻ nhiều hơn nhiều, phải không? Tuy nhiên, độ verbosity của từ điển được đền đáp cho con người: dễ nhớ rằng

>>> mydict = {'a': 'hello', 'b': 'world'}
>>> for x in mydict:
...    val = mydict[x]
...    mydict[x] = val.upper()
...    print('Changed what', x, 'points to: from', val, 'to', mydict[x])
Changed what b points to: from world to WORLD
Changed what a points to: from hello to HELLO
9 trỏ đến thành phần họ, thay vì giá trị chỉ số của
>>> for k in mydict.keys():
...     print(k)
b
a
0, như trong trường hợp của danh sách.

Nhưng việc thực hiện danh sách, đơn giản như có vẻ như, bị giới hạn bởi sự đơn giản của chính nó, và khó khăn hơn nhiều để thích nghi với dữ liệu thực tế, phức tạp hơn.

>>> mydict = {"z": 92, "world": "hello"}
>>> print(mydict['world'])
hello
>>> print(mydict["z"])
6

Ví dụ, nếu chúng ta muốn thêm tiêu đề và hậu tố vào một cái tên?

Bây giờ, bất cứ ai cũng mong đợi rằng chỉ mục

>>> for k in mydict.keys():
...     print(k)
b
a
1 chỉ vào tên đầu tiên sẽ ngạc nhiên/bối rối.

>>> mydict = {"z": 92, "world": "hello"}
>>> print(mydict['world'])
hello
>>> print(mydict["z"])
7

Tuy nhiên, việc triển khai từ điển có thể xử lý các bổ sung cho định nghĩa dữ liệu một cách dễ dàng:

Bất cứ ai truy cập khóa

>>> for k in mydict.keys():
...     print(k)
b
a
2 đều có thể mong đợi nó sẽ trả về tên đầu tiên, việc bổ sung các khóa mới -
>>> for k in mydict.keys():
...     print(k)
b
a
3 và
>>> for k in mydict.keys():
...     print(k)
b
a
4 - không thay đổi cách chúng tôi làm việc với dữ liệu.

>>> mydict = {"z": 92, "world": "hello"}
>>> print(mydict['world'])
hello
>>> print(mydict["z"])
8

Vâng, trông khá phức tạp. Nhưng cuộc sống rất phức tạp.

(Ngoài ra, tên cực kỳ phức tạp, điều này nhấn mạnh lý do tại sao sử dụng một danh sách đơn giản không đủ để đại diện


Từ điển trong tự nhiên

Dưới đây là các ví dụ về cách các khái niệm và đối tượng trong thế giới thực khác nhau được mô hình hóa như từ điển.

JSON là dữ liệu

Tôi sẽ dành một hướng dẫn khác cho việc này, nhưng từ điển (và danh sách) có thể được biểu diễn dưới dạng tệp văn bản thông qua định dạng JSON. Hiện tại, giả vờ, chúng tôi đã thực hiện bước tuần tự hóa này và mỗi ví dụ đã được đặt thành biến,

>>> for k in mydict.keys():
...     print(k)
b
a
6:JSON format. For now, pretend we've done this serialization step and that each of the examples has been set to the variable,
>>> for k in mydict.keys():
...     print(k)
b
a
6:

Trạng thái GitHub

GitHub có API trạng thái, trong đó nó cung cấp các tin nhắn có thể đọc được bằng máy, ví dụ: "Có chức năng của github.com không?".

Đây là trạng thái trực tiếp trông như thế nào, như một tệp văn bản JSON:

>>> mydict = {"z": 92, "world": "hello"}
>>> print(mydict['world'])
hello
>>> print(mydict["z"])
9

Trông giống như một từ điển, phải không? Giả vờ rằng nó được gán cho biến

>>> for k in mydict.keys():
...     print(k)
b
a
6. Đây là cách chúng ta có thể sử dụng đối tượng:

mydict = {"hello": "world", 
          0: "a", 
          1: "b", 
          "2": "not a number"
          (1, 2, 3): "a tuple!"}
0

Tin nhắn GitHub

Tương tự như thông báo trạng thái đơn, ngoại trừ việc trả về danh sách các tin nhắn, tức là danh sách các từ điển:list of messages, i.e. a list of dictionaries:

mydict = {"hello": "world", 
          0: "a", 
          1: "b", 
          "2": "not a number"
          (1, 2, 3): "a tuple!"}
1

Để in ra ngày, cơ thể và mức độ trạng thái của mỗi tin nhắn:

mydict = {"hello": "world", 
          0: "a", 
          1: "b", 
          "2": "not a number"
          (1, 2, 3): "a tuple!"}
2

Đầu ra:

mydict = {"hello": "world", 
          0: "a", 
          1: "b", 
          "2": "not a number"
          (1, 2, 3): "a tuple!"}
3

Người dùng Instagram

API Instagram cho phép chúng tôi tra cứu [người dùng riêng lẻ] ((https://www.instagram.com/developer/endpoints/users/#get_users):

mydict = {"hello": "world", 
          0: "a", 
          1: "b", 
          "2": "not a number"
          (1, 2, 3): "a tuple!"}
4

Đây là cách truy cập các giá trị khác nhau bên trong từ điển lồng nhau đó:

mydict = {"hello": "world", 
          0: "a", 
          1: "b", 
          "2": "not a number"
          (1, 2, 3): "a tuple!"}
5

Beyoncé (trên Spotify) như một từ điển

Dưới đây là một đoạn trích về cách API của Spotify (thông qua điểm cuối get-artist) đại diện cho Beyoncé (xem tệp JSON tại đây):

mydict = {"hello": "world", 
          0: "a", 
          1: "b", 
          "2": "not a number"
          (1, 2, 3): "a tuple!"}
6

Lưu ý làm thế nào khóa

>>> for k in mydict.keys():
...     print(k)
b
a
8 chỉ ra một từ điển, bản thân nó chứa một khóa duy nhất có tên
>>> for k in mydict.keys():
...     print(k)
b
a
9 chỉ vào trang của Beyoncé trên trang web Spotify. Các điểm chính của
newdict = {}
00 vào danh sách các đối tượng chuỗi, vì Oeuvre của Beyoncé không thể được chứa trong một thể loại duy nhất. Các điểm chính của ____101 trong danh sách các từ điển, vì Spotify phục vụ nhiều kích thước của hình ảnh của một nghệ sĩ và mỗi hình ảnh có nhiều thuộc tính, ví dụ:
newdict = {}
02,
newdict = {}
03 và
newdict = {}
04.

Khóa

newdict = {}
05 cũng chỉ vào một từ điển. Để có được số lượng người theo dõi Spotify của Beyoncé - được liên kết với khóa
newdict = {}
06, đây là cách chúng tôi sẽ truy cập giá trị lồng nhau:number of Spotify followers – which is associated with the
newdict = {}
06 key, this is how we would access the nested value:

(Giả sử biến,

newdict = {}
07, trỏ đến từ điển ở trên)

mydict = {"hello": "world", 
          0: "a", 
          1: "b", 
          "2": "not a number"
          (1, 2, 3): "a tuple!"}
7

Để in các thuộc tính của từng phiên bản của hình ảnh liên quan đến Beyoncé, chúng ta có thể sử dụng một vòng lặp lồng nhau:

mydict = {"hello": "world", 
          0: "a", 
          1: "b", 
          "2": "not a number"
          (1, 2, 3): "a tuple!"}
8

Các loại từ điển khác

Chúng có thể được tìm thấy trong [Mô -đun ____108 của Python] (https://docs.python.org/3/l Library/collections.html. Tôi sẽ viết về chúng sau (tk)

Đặt hàng

TK

DefaultDict

TK

Một tuple có danh sách có thể là một chìa khóa trong từ điển không?

Một tuple chứa một danh sách không thể được sử dụng làm khóa trong từ điển.Trả lời: Đúng.Một danh sách là có thể thay đổi.Do đó, một tuple chứa một danh sách không thể được sử dụng làm khóa trong từ điển.. Answer: True. A list is mutable. Therefore, a tuple containing a list cannot be used as a key in a dictionary.

Một danh sách có thể là một giá trị trong một python từ điển?

Bạn có thể sử dụng danh sách Python làm giá trị từ điển.Trên thực tế, bạn có thể sử dụng các đối tượng Python tùy ý làm giá trị từ điển và tất cả các đối tượng có thể băm làm khóa từ điển.Bạn có thể xác định danh sách [1, 2] là giá trị dict bằng dict [key] = [1, 2] hoặc với d = {key: [1, 2]}.. In fact, you can use arbitrary Python objects as dictionary values and all hashable objects as dictionary keys. You can define a list [1, 2] as a dict value either with dict[key] = [1, 2] or with d = {key: [1, 2]} .

Một đối tượng có thể là một chìa khóa trong python từ điển?

Thuộc tính của các giá trị từ điển khóa từ điển không có giới hạn.Chúng có thể là bất kỳ đối tượng Python tùy ý nào, đối tượng tiêu chuẩn hoặc đối tượng do người dùng xác định.They can be any arbitrary Python object, either standard objects or user-defined objects.