Hướng dẫn can list be nested in dictionary python? - danh sách có thể được lồng trong python từ điển không?

Tôi có một từ điển với một khóa và một cặp giá trị, các giá trị được lưu trữ trong một danh sách. Nhưng tôi giữ danh sách trống để tôi có thể. Phụ lục các giá trị của nó, tôi dường như không thể làm điều này

Show
>>>myDict = {'Numbers':[]}
>>>myDict['Numbers'[1].append(user_inputs) 

Dường như không hoạt động, trả về một lỗi. Làm cách nào để tham khảo danh sách trong MyDICT để tôi có thể nối các giá trị của nó.

Ngoài ra, có thể có một từ điển bên trong một danh sách và cũng có một danh sách khác bên trong? nếu vậy? cú pháp của nó là gì hoặc bạn có thể giới thiệu bất kỳ cách nào khác tôi có thể làm điều này

>>>myDict2 = {'Names': [{'first name':[],'Second name':[]}]}

Tôi có thay đổi danh sách lồng thứ hai thành một tuple không ?? Vui lòng giữ nó đến Python 2.7

Hỏi ngày 28 tháng 8 năm 2014 lúc 21:03Aug 28, 2014 at 21:03

Hướng dẫn can list be nested in dictionary python? - danh sách có thể được lồng trong python từ điển không?

4

Bạn gặp lỗi vì cú pháp của bạn là sai. Các phần sau liên quan đến giá trị danh sách cho khóa

myDict['Numbers'].append(user_inputs)
2:

myDict['Numbers'].append(user_inputs)

Bạn có thể làm tổ các đối tượng Python một cách tùy tiện; Cú pháp

myDict['Numbers'].append(user_inputs)
3 của bạn hoàn toàn chính xác. Chỉ các khóa cần phải là bất biến (vì vậy một danh sách so với danh sách), nhưng các khóa của bạn là tất cả các chuỗi:

>>> myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
>>> myDict2['Names']
[{'first name': [], 'Second name': []}]
>>> myDict2['Names'][0]
{'first name': [], 'Second name': []}
>>> myDict2['Names'][0]['first name']
[]

Đã trả lời ngày 28 tháng 8 năm 2014 lúc 21:03Aug 28, 2014 at 21:03

Martijn Pieters ♦ Martijn PietersMartijn Pieters

994K277 Huy hiệu vàng3915 Huy hiệu bạc3259 Huy hiệu đồng277 gold badges3915 silver badges3259 bronze badges

2

Bạn nên truy cập danh sách với

myDict['Numbers'].append(user_inputs)
4:

>>>myDict['Numbers'].append(user_inputs) 

Bạn có thể có các dicts bên trong một danh sách.

Điều duy nhất là các khóa từ điển phải là bất biến, vì vậy bạn không thể có các dict hoặc danh sách dưới dạng khóa.

Đã trả lời ngày 28 tháng 8 năm 2014 lúc 21:04Aug 28, 2014 at 21:04

Bạn có thể muốn xem xét thư viện JSON, hỗ trợ kết hợp các từ điển và danh sách lồng nhau.

Ngoài ra, bạn cũng có thể quan tâm đến phương pháp SetDefault của lớp từ điển.

Định dạng là một cái gì đó như:

new_dict = dict()
some_list = ['1', '2', '3', ...]
for idx, val in enumerate(some_list):
    something = get_something(idx)
    new_dict.setdefault(val, []).append(something)

Đã trả lời ngày 28 tháng 8 năm 2014 lúc 21:27Aug 28, 2014 at 21:27

Brian Bruggemanbrian BruggemanBrian Bruggeman

4.7082 Huy hiệu vàng33 Huy hiệu bạc 50 Huy hiệu Đồng2 gold badges33 silver badges50 bronze badges

2

# Danh sách lập chỉ mục: Người đăng ký hiện đã được truy cập ..

dictionary = {'key' : 'value',
'key_2': 'value_2'}

Sublist = nestedList [2].

# Truy cập phần tử đầu tiên bên trong danh sách bên trong:.


phần tử = nestedList [2] [0].

Trong Python, một từ điển là một bộ sưu tập các mặt hàng không có thứ tự. Ví dụ:

nested_dict = { 'dictA': {'key_1': 'value_1'},
                'dictB': {'key_2': 'value_2'}}

Ở đây, từ điển có một cặp

myDict['Numbers'].append(user_inputs)
5 được đặt trong các dấu ngoặc xoăn
myDict['Numbers'].append(user_inputs)
6.


Để tìm hiểu thêm về từ điển, vui lòng truy cập từ điển Python.

Từ điển lồng nhau trong Python là gì?

Trong Python, một từ điển lồng nhau là một từ điển trong một từ điển. Đó là một tập hợp các từ điển thành một từ điển duy nhất.

Ở đây, Nested_dict là một từ điển lồng nhau với từ điển
myDict['Numbers'].append(user_inputs)
7 và
myDict['Numbers'].append(user_inputs)
8. Chúng là hai từ điển mỗi người có khóa và giá trị riêng.

Khi chúng tôi chạy trên chương trình, nó sẽ xuất hiện:

{1: {'name': 'John', 'age': '27', 'sex': 'Male'}, 2: {'name': 'Marie', 'age': '22', 'sex': 'Female'}}

Tạo một từ điển lồng nhau


Chúng ta sẽ tạo ra từ điển của những người trong một từ điển.

Ví dụ 1: Cách tạo từ điển lồng nhau

________số 8

>>>myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
0

Khi chúng tôi chạy trên chương trình, nó sẽ xuất hiện:

>>>myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
1

Trong chương trình trên, mọi người là một từ điển lồng nhau. Từ điển nội bộ

myDict['Numbers'].append(user_inputs)
9 và
>>> myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
>>> myDict2['Names']
[{'first name': [], 'Second name': []}]
>>> myDict2['Names'][0]
{'first name': [], 'Second name': []}
>>> myDict2['Names'][0]['first name']
[]
0 được gán cho mọi người. Ở đây, cả từ điển đều có khóa
>>> myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
>>> myDict2['Names']
[{'first name': [], 'Second name': []}]
>>> myDict2['Names'][0]
{'first name': [], 'Second name': []}
>>> myDict2['Names'][0]['first name']
[]
1,
>>> myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
>>> myDict2['Names']
[{'first name': [], 'Second name': []}]
>>> myDict2['Names'][0]
{'first name': [], 'Second name': []}
>>> myDict2['Names'][0]['first name']
[]
2,
>>> myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
>>> myDict2['Names']
[{'first name': [], 'Second name': []}]
>>> myDict2['Names'][0]
{'first name': [], 'Second name': []}
>>> myDict2['Names'][0]['first name']
[]
3 với các giá trị khác nhau. Bây giờ, chúng tôi in kết quả của mọi người.


Các yếu tố truy cập của một từ điển lồng nhau

Để truy cập phần tử của từ điển lồng nhau, chúng tôi sử dụng cú pháp lập chỉ mục >>> myDict2 = {'Names': [{'first name':[],'Second name':[]}]} >>> myDict2['Names'] [{'first name': [], 'Second name': []}] >>> myDict2['Names'][0] {'first name': [], 'Second name': []} >>> myDict2['Names'][0]['first name'] [] 4 trong Python.

>>>myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
2

Khi chúng tôi chạy trên chương trình, nó sẽ xuất hiện:

>>>myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
3

Ví dụ 2: Truy cập các phần tử bằng cú pháp []

Trong chương trình trên, chúng tôi in giá trị của khóa

>>> myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
>>> myDict2['Names']
[{'first name': [], 'Second name': []}]
>>> myDict2['Names'][0]
{'first name': [], 'Second name': []}
>>> myDict2['Names'][0]['first name']
[]
1 bằng cách sử dụng
>>> myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
>>> myDict2['Names']
[{'first name': [], 'Second name': []}]
>>> myDict2['Names'][0]
{'first name': [], 'Second name': []}
>>> myDict2['Names'][0]['first name']
[]
6 từ Từ điển nội bộ
myDict['Numbers'].append(user_inputs)
9. Tương tự, chúng tôi in giá trị của
>>> myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
>>> myDict2['Names']
[{'first name': [], 'Second name': []}]
>>> myDict2['Names'][0]
{'first name': [], 'Second name': []}
>>> myDict2['Names'][0]['first name']
[]
2 và
>>> myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
>>> myDict2['Names']
[{'first name': [], 'Second name': []}]
>>> myDict2['Names'][0]
{'first name': [], 'Second name': []}
>>> myDict2['Names'][0]['first name']
[]
3 từng cái một.

Thêm phần tử vào từ điển lồng nhau

>>>myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
4

Khi chúng tôi chạy trên chương trình, nó sẽ xuất hiện:

>>>myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
5

Ví dụ 3: Làm thế nào để thay đổi hoặc thêm các phần tử trong từ điển lồng nhau?


Trong chương trình trên, chúng tôi tạo ra một từ điển trống >>>myDict['Numbers'].append(user_inputs) 0 bên trong những người từ điển.

Sau đó, chúng tôi thêm cặp

myDict['Numbers'].append(user_inputs)
5 i.e
>>>myDict['Numbers'].append(user_inputs) 
2 bên trong từ điển
>>>myDict['Numbers'].append(user_inputs) 
0. Tương tự, chúng tôi làm điều này cho khóa
>>> myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
>>> myDict2['Names']
[{'first name': [], 'Second name': []}]
>>> myDict2['Names'][0]
{'first name': [], 'Second name': []}
>>> myDict2['Names'][0]['first name']
[]
2,
>>> myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
>>> myDict2['Names']
[{'first name': [], 'Second name': []}]
>>> myDict2['Names'][0]
{'first name': [], 'Second name': []}
>>> myDict2['Names'][0]['first name']
[]
3 và
>>>myDict['Numbers'].append(user_inputs) 
6 từng cái một. Khi chúng tôi in
>>>myDict['Numbers'].append(user_inputs) 
7, chúng tôi sẽ nhận được các cặp từ điển
myDict['Numbers'].append(user_inputs)
5
>>>myDict['Numbers'].append(user_inputs) 
0.

Ví dụ 4: Thêm một từ điển khác vào từ điển lồng nhau

>>>myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
6

Khi chúng tôi chạy trên chương trình, nó sẽ xuất hiện:

>>>myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
7

Trong chương trình trên, chúng tôi xóa các cặp

myDict['Numbers'].append(user_inputs)
5 của
>>>myDict['Numbers'].append(user_inputs) 
6 khỏi Từ điển nội bộ
>>>myDict['Numbers'].append(user_inputs) 
0 và
new_dict = dict()
some_list = ['1', '2', '3', ...]
for idx, val in enumerate(some_list):
    something = get_something(idx)
    new_dict.setdefault(val, []).append(something)
5. Sau đó, chúng tôi in
>>>myDict['Numbers'].append(user_inputs) 
7 và
new_dict = dict()
some_list = ['1', '2', '3', ...]
for idx, val in enumerate(some_list):
    something = get_something(idx)
    new_dict.setdefault(val, []).append(something)
0 để xác nhận các thay đổi.

Ví dụ 6: Làm thế nào để xóa từ điển khỏi một từ điển lồng nhau?

>>>myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
8

Khi chúng tôi chạy trên chương trình, nó sẽ xuất hiện:

{1: {'name': 'John', 'age': '27', 'sex': 'Male'}, 2: {'name': 'Marie', 'age': '22', 'sex': 'Female'}}

Trong chương trình trên, chúng tôi xóa cả từ điển nội bộ

>>>myDict['Numbers'].append(user_inputs) 
0 và
new_dict = dict()
some_list = ['1', '2', '3', ...]
for idx, val in enumerate(some_list):
    something = get_something(idx)
    new_dict.setdefault(val, []).append(something)
5 bằng cách sử dụng
dictionary = {'key' : 'value',
'key_2': 'value_2'}
4 từ những người từ điển lồng nhau. Sau đó, chúng tôi in những người từ điển lồng nhau để xác nhận thay đổi.


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

Sử dụng các vòng lặp, chúng ta có thể lặp qua từng yếu tố trong một từ điển lồng nhau.

Ví dụ 7: Làm thế nào để lặp lại thông qua một từ điển lồng nhau?

myDict['Numbers'].append(user_inputs)
0

Khi chúng tôi chạy trên chương trình, nó sẽ xuất hiện:

myDict['Numbers'].append(user_inputs)
1

Trong chương trình trên, chúng tôi xóa cả từ điển nội bộ

>>>myDict['Numbers'].append(user_inputs) 
0 và
new_dict = dict()
some_list = ['1', '2', '3', ...]
for idx, val in enumerate(some_list):
    something = get_something(idx)
    new_dict.setdefault(val, []).append(something)
5 bằng cách sử dụng
dictionary = {'key' : 'value',
'key_2': 'value_2'}
4 từ những người từ điển lồng nhau. Sau đó, chúng tôi in những người từ điển lồng nhau để xác nhận thay đổi.

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

Sử dụng các vòng lặp, chúng ta có thể lặp qua từng yếu tố trong một từ điển lồng nhau.


Ví dụ 7: Làm thế nào để lặp lại thông qua một từ điển lồng nhau?

  1. Trong chương trình trên, vòng lặp đầu tiên trả về tất cả các phím trong những người từ điển lồng nhau. Nó bao gồm ID P_ID của mỗi người. Chúng tôi sử dụng các ID này để giải nén thông tin p_info của mỗi người.
  2. Vòng lặp thứ hai đi qua thông tin của mỗi người. Sau đó, nó trả về tất cả các khóa
    >>> myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
    >>> myDict2['Names']
    [{'first name': [], 'Second name': []}]
    >>> myDict2['Names'][0]
    {'first name': [], 'Second name': []}
    >>> myDict2['Names'][0]['first name']
    []
    
    1,
    >>> myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
    >>> myDict2['Names']
    [{'first name': [], 'Second name': []}]
    >>> myDict2['Names'][0]
    {'first name': [], 'Second name': []}
    >>> myDict2['Names'][0]['first name']
    []
    
    2,
    >>> myDict2 = {'Names': [{'first name':[],'Second name':[]}]}
    >>> myDict2['Names']
    [{'first name': [], 'Second name': []}]
    >>> myDict2['Names'][0]
    {'first name': [], 'Second name': []}
    >>> myDict2['Names'][0]['first name']
    []
    
    3 của từ điển của mỗi người.
  3. Bây giờ, chúng tôi in khóa thông tin của người và giá trị cho khóa đó.
  4. Những điểm chính cần nhớ:
  5. Từ điển lồng nhau là một bộ sưu tập từ điển không có thứ tự

Từ điển có thể có danh sách lồng nhau không?

Hôm nay chúng ta sẽ nói về danh sách và từ điển lồng nhau.Danh sách và từ điển lồng nhau thường được sử dụng để cấu trúc tốt hơn dữ liệu của bạn.Về mặt lý thuyết, không có giới hạn nào đối với độ sâu làm tổ và bạn có thể có một danh sách bên trong một danh sách khác, nằm trong một danh sách khác, bản thân nó cũng nằm trong một danh sách khác, v.v.Theoretically there are no limits to the depth of nesting and you can have a list inside another list, which is inside yet another list, which itself also is inside another list, etc.

Từ điển Python có thể giữ danh sách không?

Đúng.Các giá trị trong một dict có thể là bất kỳ loại đối tượng Python nào.Các phím có thể là bất kỳ đối tượng có thể băm nào (không cho phép một danh sách, nhưng cho phép một tuple).does not allow a list, but does allow a tuple).

Làm thế nào để tôi lập một danh sách lồng nhau trong Python?

# Tạo danh sách ..
nestedList = [1, 2, ['a', 1], 3].
# Danh sách lập chỉ mục: Người đăng ký hiện đã được truy cập ..
Sublist = nestedList [2].
# Truy cập phần tử đầu tiên bên trong danh sách bên trong:.
phần tử = nestedList [2] [0].