Từ điển python có thể sửa đổi được không?

Các giá trị của từ điển là các danh sách –

dict1 = {'A':[11, '2', 53], 'B':[4, 50]}
dict2 = dict[X=[5, 7, 9], Y = [41, 15]]
dict3 = dict[[[1, [6, 5, 8]], [4, [9, 1, 2]]]]

print[dict1]
print[dict2]
print[dict3]

9 và

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

0 – trong khi các khóa là các chuỗi [

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

1 và

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

2]

Trong bài hôm nay, chúng ta sẽ học cách tạo và sửa từ điển danh sách. Chúng ta cũng sẽ nói về mối quan hệ giữa từ điển danh sách và khung dữ liệu. Cuối cùng nhưng không kém phần quan trọng, chúng ta sẽ làm việc với một câu hỏi thực hành lưu trữ dữ liệu nhập của người dùng dưới dạng từ điển danh sách Python

Mục lục

Cách tạo Từ điển Python với Danh sách dưới dạng giá trị

Trước tiên, hãy thảo luận về ba cách khác nhau để tạo một danh sách từ điển Python

• Phương pháp 1. Tạo và khởi tạo từ điển bằng cách sử dụng

  {'A': [11, '2', 53], 'B': [4, 50]}
  {'X': [5, 7, 9], 'Y': [41, 15]}
  {1: [6, 5, 8], 4: [9, 1, 2]}

  3 hoặc

  {'A': [11, '2', 53], 'B': [4, 50]}
  {'X': [5, 7, 9], 'Y': [41, 15]}
  {1: [6, 5, 8], 4: [9, 1, 2]}

  4
• Phương pháp 2. Tạo một từ điển trống và thêm khóa. cặp giá trị với nó
• Phương pháp 3. Sử dụng hàm

  {'A': [11, '2', 53], 'B': [4, 50]}
  {'X': [5, 7, 9], 'Y': [41, 15]}
  {1: [6, 5, 8], 4: [9, 1, 2]}

  5 tích hợp trong Python

Phương pháp 1. Tạo và khởi tạo từ điển bằng {} hoặc dict[]

Cách trực tiếp nhất để tạo từ điển danh sách Python là tạo và khởi tạo từ điển trực tiếp

dict1 = {'A':[11, '2', 53], 'B':[4, 50]}
dict2 = dict[X=[5, 7, 9], Y = [41, 15]]
dict3 = dict[[[1, [6, 5, 8]], [4, [9, 1, 2]]]]

print[dict1]
print[dict2]
print[dict3]

Trong đoạn code trên, đầu tiên chúng ta sử dụng

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

3 để khai báo và khởi tạo

dict1 = {'A':[11, '2', 53], 'B':[4, 50]}
dict2 = dict[X=[5, 7, 9], Y = [41, 15]]
dict3 = dict[[[1, [6, 5, 8]], [4, [9, 1, 2]]]]

print[dict1]
print[dict2]
print[dict3]

6 với key sau. cặp giá trị

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

8

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

9

Tiếp theo, chúng tôi sử dụng phương thức

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

4 để tạo một từ điển khác có tên là

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

31, với khóa sau. cặp giá trị

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

32

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

33

Cuối cùng, chúng tôi sử dụng phương pháp

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

4 để tạo một từ điển có tên là

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

35, với khóa sau. cặp giá trị

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

36

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

37

Trong mỗi ví dụ trên, các giá trị của từ điển là danh sách. Nếu bạn chạy mã ở trên, bạn sẽ nhận được đầu ra sau

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

Phương pháp 2. Tạo một từ điển trống và thêm khóa. cặp giá trị với nó

Ngoài việc khai báo và khởi tạo từ điển trực tiếp, chúng ta có thể tạo một từ điển trống và thêm khóa. cặp giá trị với nó sau đó

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

3

Trong đoạn mã trên, trước tiên chúng tôi khai báo hai danh sách trống -

dict1 = {'A':[11, '2', 53], 'B':[4, 50]}
dict2 = dict[X=[5, 7, 9], Y = [41, 15]]
dict3 = dict[[[1, [6, 5, 8]], [4, [9, 1, 2]]]]

print[dict1]
print[dict2]
print[dict3]

6 và

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

31

Tiếp theo, chúng tôi thêm khóa sau. cặp giá trị thành

dict1 = {'A':[11, '2', 53], 'B':[4, 50]}
dict2 = dict[X=[5, 7, 9], Y = [41, 15]]
dict3 = dict[[[1, [6, 5, 8]], [4, [9, 1, 2]]]]

print[dict1]
print[dict2]
print[dict3]

6 trên dòng 4 và 5

dict1 = {'A':[11, '2', 53], 'B':[4, 50]}
dict2 = dict[X=[5, 7, 9], Y = [41, 15]]
dict3 = dict[[[1, [6, 5, 8]], [4, [9, 1, 2]]]]

print[dict1]
print[dict2]
print[dict3]

7

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

62

Ở dòng 7 và 8, chúng ta thêm các cặp sau vào

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

31

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

64

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

65

Nếu bạn chạy mã ở trên, bạn sẽ nhận được đầu ra sau

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

6

Phương pháp 3. Sử dụng hàm zip[] tích hợp trong Python

Cuối cùng nhưng không kém phần quan trọng, một cách thuận tiện khác để tạo từ điển danh sách là sử dụng hàm tích hợp Python có tên là

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

5

Hàm này có thể được sử dụng để 'nén' hai danh sách lại với nhau thành một bộ lặp gồm các bộ dữ liệu. Trình lặp này sau đó có thể được chuyển đổi thành từ điển bằng phương pháp

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

4

Hãy xem một ví dụ

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

3

Ở đây, trước tiên chúng tôi khai báo một danh sách có tên là

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

68 trên dòng 1. Danh sách này chứa các khóa mà chúng tôi muốn sử dụng trong từ điển của mình

Tiếp theo, chúng tôi khai báo một danh sách có tên là

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

69, chứa các giá trị mà chúng tôi muốn sử dụng trong từ điển của mình

Ở dòng 4, chúng tôi sử dụng hàm

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

5 để nén

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

68 và

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

69 cùng nhau. Điều này trả về một trình vòng lặp của các bộ dữ liệu, có thể được chuyển đổi thành từ điển bằng phương thức

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

4

Cuối cùng, trên dòng 6, chúng tôi in giá trị của

dict1 = {'A':[11, '2', 53], 'B':[4, 50]}
dict2 = dict[X=[5, 7, 9], Y = [41, 15]]
dict3 = dict[[[1, [6, 5, 8]], [4, [9, 1, 2]]]]

print[dict1]
print[dict2]
print[dict3]

6

Nếu bạn chạy mã ở trên, bạn sẽ nhận được đầu ra sau

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

1

Các khóa cho từ điển kết quả đến từ

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

35 trong khi các giá trị đến từ

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

69

Cách truy cập các mục trong Từ điển danh sách Python

Bây giờ chúng ta đã biết cách tạo từ điển gồm các danh sách, hãy thảo luận về cách chúng ta có thể truy cập bất kỳ mục nào trong từ điển

Để làm điều đó, chúng tôi sử dụng khóa của nó. Điều này mang lại cho chúng tôi giá trị của mục đó, đó là một danh sách

Để truy cập các mục bên trong danh sách đó, chúng tôi sử dụng chỉ mục của nó

một ví dụ đã được biểu diễn ở dưới

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

4

Ở đây, trước tiên chúng tôi sử dụng

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

37 để truy cập danh sách đầu tiên trong từ điển. Tiếp theo, chúng tôi sử dụng

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

38 để truy cập mục đầu tiên trong

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

39

Nếu bạn chạy mã ở trên, bạn sẽ nhận được đầu ra sau

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

8

Cách sửa đổi các mục trong Từ điển danh sách Python

Để cập nhật một mục trong từ điển danh sách Python, chúng ta có thể gán một danh sách mới cho giá trị của nó, như trong ví dụ bên dưới

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

9

Nếu bạn chạy mã ở trên, bạn sẽ nhận được đầu ra sau

dict1 = {'A':[11, '2', 53], 'B':[4, 50]}
dict2 = dict[X=[5, 7, 9], Y = [41, 15]]
dict3 = dict[[[1, [6, 5, 8]], [4, [9, 1, 2]]]]

print[dict1]
print[dict2]
print[dict3]

0

Chúng tôi cũng có thể cập nhật một mục trong từ điển danh sách Python bằng cách sử dụng phương thức

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

10

dict1 = {'A':[11, '2', 53], 'B':[4, 50]}
dict2 = dict[X=[5, 7, 9], Y = [41, 15]]
dict3 = dict[[[1, [6, 5, 8]], [4, [9, 1, 2]]]]

print[dict1]
print[dict2]
print[dict3]

1

Đoạn mã trên thêm 12 vào

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

39

Nếu bạn chạy mã ở trên, bạn sẽ nhận được đầu ra sau

dict1 = {'A':[11, '2', 53], 'B':[4, 50]}
dict2 = dict[X=[5, 7, 9], Y = [41, 15]]
dict3 = dict[[[1, [6, 5, 8]], [4, [9, 1, 2]]]]

print[dict1]
print[dict2]
print[dict3]

2

Chuyển đổi từ điển danh sách Python thành Dataframe

Từ điển danh sách Python rất hữu ích trong khoa học dữ liệu. Một thư viện phổ biến được sử dụng để phân tích dữ liệu là thư viện Pandas, sử dụng một kiểu dữ liệu đặc biệt được gọi là khung dữ liệu Pandas

Một khung dữ liệu có thể được tạo từ một danh sách từ điển Python, trong đó các khóa trong từ điển đóng vai trò là tiêu đề cột và các giá trị [i. e. danh sách] là các giá trị cột

Chẳng hạn, ảnh chụp màn hình bên dưới cho thấy cách từ điển danh sách Python [

dict1 = {'A':[11, '2', 53], 'B':[4, 50]}
dict2 = dict[X=[5, 7, 9], Y = [41, 15]]
dict3 = dict[[[1, [6, 5, 8]], [4, [9, 1, 2]]]]

print[dict1]
print[dict2]
print[dict3]

6] có thể được chuyển đổi thành khung dữ liệu Pandas [sử dụng phương thức

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

13]

Như bạn có thể thấy, mỗi phím trong từ điển [i. e.

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

14,

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

15 và

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

16] tương ứng với tiêu đề cột trong khung dữ liệu, trong khi danh sách trở thành giá trị cột

Nếu bạn quan tâm đến khung dữ liệu Pandas được sử dụng để làm gì, bạn có thể tham khảo bài đăng này để biết thêm thông tin về cách sử dụng khung dữ liệu trong Python

câu hỏi thực hành

Bây giờ chúng ta đã quen thuộc với từ điển danh sách Python, hãy chuyển sang câu hỏi thực hành cho ngày hôm nay

Đối với câu hỏi thực hành hôm nay, bạn cần viết một hàm có tên là

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

17

Bên trong chức năng, bạn nên thực hiện lặp đi lặp lại các tác vụ sau cho đến khi người dùng nhập vào

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

18 để thoát

1. Nhắc người dùng nhập tên lớp hoặc -1 để thoát
2. Nhắc người dùng nhập điểm lớp, phân tách bằng dấu phẩy
3. Lưu tên lớp [dưới dạng chuỗi] và dấu [dưới dạng danh sách số nguyên] do người dùng nhập vào từ điển danh sách Python, trong đó khóa là tên lớp và giá trị là dấu

Miễn là người dùng không nhập

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

18, hãy lặp lại tác vụ 1 đến 3 ở trên. Nếu người dùng nhập vào

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

18, hãy trả về từ điển của danh sách

Bạn có thể cho rằng người dùng luôn nhập số nguyên khi được nhắc nhập điểm lớp

Kết quả mong đợi

Đây là một ví dụ cho thấy chức năng nên làm gì. Nếu bạn chạy mã dưới đây

dict1 = {'A':[11, '2', 53], 'B':[4, 50]}
dict2 = dict[X=[5, 7, 9], Y = [41, 15]]
dict3 = dict[[[1, [6, 5, 8]], [4, [9, 1, 2]]]]

print[dict1]
print[dict2]
print[dict3]

3

chức năng sẽ hoạt động như sau

dict1 = {'A':[11, '2', 53], 'B':[4, 50]}
dict2 = dict[X=[5, 7, 9], Y = [41, 15]]
dict3 = dict[[[1, [6, 5, 8]], [4, [9, 1, 2]]]]

print[dict1]
print[dict2]
print[dict3]

4

giải pháp đề xuất

dict1 = {'A':[11, '2', 53], 'B':[4, 50]}
dict2 = dict[X=[5, 7, 9], Y = [41, 15]]
dict3 = dict[[[1, [6, 5, 8]], [4, [9, 1, 2]]]]

print[dict1]
print[dict2]
print[dict3]

5

Trong giải pháp được đề xuất ở trên, trước tiên chúng tôi xác định hàm có tên là

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

17 trên dòng 1

Bên trong hàm, chúng tôi khai báo một từ điển trống có tên là

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

42

Tiếp theo, chúng tôi sử dụng vòng lặp

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

43 để liên tục nhắc người dùng nhập liệu. Ở dòng 7, chúng tôi nhắc người dùng nhập tên lớp hoặc -1 để thoát

Nếu người dùng nhập -1, ta sử dụng câu lệnh

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

44 ở dòng 10 để thoát khỏi vòng lặp

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

45

Mặt khác, chúng tôi tiếp tục đến dòng 12 nơi chúng tôi nhắc người dùng nhập các nhãn lớp và gán đầu vào [là một chuỗi] cho một biến có tên là

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

46

Tiếp theo, trên dòng 14, chúng tôi thực hiện một số việc

Đầu tiên, chúng tôi sử dụng

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

46 để gọi phương thức

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

48 cho các chuỗi. Phương thức này tách một chuỗi thành một danh sách, sử dụng đối số làm dấu phân cách. Trong mã của chúng tôi ở trên, chúng tôi chuyển

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

49 làm dấu phân cách. Giả sử

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

80, phương thức

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

48 tách chuỗi thành danh sách

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

82

Tiếp theo, chúng tôi chuyển danh sách này và hàm

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

83 sang một hàm khác có tên là

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

84

Hàm

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

84 là một hàm tích hợp trong Python áp dụng một hàm cho tất cả các thành phần của một lần lặp [chẳng hạn như danh sách]. Trong giải pháp được đề xuất của chúng tôi ở trên, chúng tôi sử dụng hàm

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

84 để áp dụng hàm

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

83 cho tất cả các phần tử trong

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

88

Giả sử

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

88 trả về danh sách

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

82. Hàm

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

84 sau đó áp dụng hàm

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

83 cho tất cả các phần tử trong danh sách này để chuyển đổi chúng thành số nguyên. Điều này cung cấp cho chúng tôi một đối tượng bản đồ có thể được chuyển đổi thành danh sách bằng hàm

{'A': [11, '2', 53], 'B': [4, 50]}
{'X': [5, 7, 9], 'Y': [41, 15]}
{1: [6, 5, 8], 4: [9, 1, 2]}

93

Bạn có thể sửa đổi từ điển bằng Python không?

Từ điển Python có thể thay đổi hay không thay đổi?

Từ điển có thể thay đổi được không?

Là một từ điển có thể thay đổi?