programming python

Hướng dẫn create nested dictionary python for loop - tạo python từ điển lồng nhau cho vòng lặp

Tôi đang gặp khó khăn khi tạo một từ điển với nhiều khóa và giá trị bên trong một từ điển khác bằng cách sử dụng vòng lặp.

Tôi có một chương trình đọc một tệp văn bản khác và sau đó nhập thông tin của nó vào từ điển. Tệp trông giống như thế này:

GPU;GeForce GTX 1070 Ti;430
CPU;AMD Ryzen 7 2700X;233
GPU;GeForce GTX 2060;400
CPU;Intel Core i7-11700;360
RAM;HyperX 16GB;180
PSU;Corsair RM850X;210

Điều tôi đang cố gắng đạt được là tôi đang cố gắng tạo một từ điển cho từng loại thành phần {GPU, CPU, RAM, PSU, v.v. và cho những người tôi đang cố gắng nhập từ từ điển khác, bao gồm từ nhiều khóa và các giá trị là {name1: price1, name2: price2, v.v.} Sau khi chạy chương trình, từ điển hoàn chỉnh sẽ trông như thế này:

"GPU": {"GeForce GTX 1070 Ti": 430, "GeForce GTX 2060 2": 233},
"CPU": {"AMD Ryzen 7 2700X": 233, "Intel Core i7-11700 : 360},
"RAM": {"HyperX 16GB": 180},
"PSU": {"Corsair RM850X": 210}

Nhưng thay vào đó, nó trông như thế này:

"GPU": {"GeForce GTX 2060 2": 233},
"CPU": {"Intel Core i7-11700 : 360},
"RAM": {"HyperX 16GB": 180},
"PSU": {"Corsair RM850X": 210}

Đây là vấn đề: Tôi không thể tạo từ điển đúng cách, bởi vì các khóa và giá trị bên trong mới ghi đè lên nhau. Làm thế nào tôi có thể làm cho vòng lặp này không làm như vậy, mà thay vào đó chỉ cần thêm các giá trị mới trong chế độ bên trong sau? I can't create the dictionary properly, because new inner keys and values override each other. How can I make this loop not to do so, but instead just add the new values in the inner dict after each other?

Đây là mã của tôi:

def main[]:
    filename = input["Enter the component file name: "]
    file = open[filename, mode="r"]

    # Defining the outer dict. This dict's keys are the component types and
    # it's values are inner dictionaries.
    outer_dict = {}

    for row in file:
        row = row.strip[]
        parts = row.split[";"]

        # Defining variables for each part per line.
        type = parts[0]
        name = parts[1]
        price = int[parts[2]]

        # Defining the inner dict. This dict's keys are the component's name
        # and it's price. There can be multiple names and prices in this dict.
        inner_dict = {}

        # Adding each name and price to the inner dictionaries.
        for i in range[1, len[parts]]:
            inner_dict[name] = price

        # Adding the created inner dict into the outer dictionary.
        outer_dict[type] = inner_dict

    file.close[]

if __name__ == "__main__":
    main[]

Cảm ơn tất cả các bạn đã giúp đỡ của bạn trước. Nó thực sự là cần thiết!

Một từ điển có thể chứa một từ điển khác, từ đó có thể chứa từ điển, v.v. đến độ sâu tùy ý. Điều này được gọi là & NBSP; Từ điển lồng nhau.nested dictionary.

Từ điển lồng nhau là một trong nhiều cách để thể hiện thông tin có cấu trúc [tương tự như ‘bản ghi, hoặc‘ cấu trúc trong các ngôn ngữ khác].structured information [similar to ‘records’ or ‘structs’ in other languages].

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

Một từ điển lồng nhau được tạo giống như cách tạo ra một từ điển bình thường. Sự khác biệt duy nhất là mỗi giá trị là một từ điển khác.

Hãy để xây dựng một từ điển lưu trữ hồ sơ nhân viên.

D = {'emp1': {'name': 'Bob', 'job': 'Mgr'},
     'emp2': {'name': 'Kim', 'job': 'Dev'},
     'emp3': {'name': 'Sam', 'job': 'Dev'}}

Người xây dựng dict []

Có một số cách để tạo một từ điển lồng nhau bằng cách sử dụng một hàm tạo loại gọi là & nbsp; dict [].

Để tạo một từ điển lồng nhau, chỉ cần chuyển khóa từ điển: cặp giá trị làm đối số từ khóa cho hàm tạo

"GPU": {"GeForce GTX 1070 Ti": 430, "GeForce GTX 2060 2": 233},
"CPU": {"AMD Ryzen 7 2700X": 233, "Intel Core i7-11700 : 360},
"RAM": {"HyperX 16GB": 180},
"PSU": {"Corsair RM850X": 210}

9.key:value pair as keyword arguments to

"GPU": {"GeForce GTX 1070 Ti": 430, "GeForce GTX 2060 2": 233},
"CPU": {"AMD Ryzen 7 2700X": 233, "Intel Core i7-11700 : 360},
"RAM": {"HyperX 16GB": 180},
"PSU": {"Corsair RM850X": 210}

9 Constructor.

D = dict[emp1 = {'name': 'Bob', 'job': 'Mgr'},
         emp2 = {'name': 'Kim', 'job': 'Dev'},
         emp3 = {'name': 'Sam', 'job': 'Dev'}]

print[D]
# Prints {'emp1': {'name': 'Bob', 'job': 'Mgr'},
#         'emp2': {'name': 'Kim', 'job': 'Dev'},
#         'emp3': {'name': 'Sam', 'job': 'Dev'}}

Bạn có thể sử dụng hàm Dict [] cùng với chức năng & nbsp; zip [] & nbsp; để kết hợp các danh sách các khóa và giá trị riêng biệt thu được động trong thời gian chạy.

IDs = ['emp1','emp2','emp3']

EmpInfo = [{'name': 'Bob', 'job': 'Mgr'},
           {'name': 'Kim', 'job': 'Dev'},
           {'name': 'Sam', 'job': 'Dev'}]

D = dict[zip[IDs, EmpInfo]]

print[D]
# Prints {'emp1': {'name': 'Bob', 'job': 'Mgr'},
#         'emp2': {'name': 'Kim', 'job': 'Dev'},
#         'emp3': {'name': 'Sam', 'job': 'Dev'}}

Bạn thường muốn tạo một từ điển với các giá trị mặc định cho mỗi khóa. Phương thức FromKeys [] cung cấp một cách để làm điều này.

IDs = ['emp1','emp2','emp3']
Defaults = {'name': '', 'job': ''}

D = dict.fromkeys[IDs, Defaults]

print[D]
# Prints {'emp1': {'name': '', 'job': ''},
#         'emp2': {'name': '', 'job': ''},
#         'emp3': {'name': '', 'job': ''}}

Truy cập các mục từ điển lồng nhau

Bạn có thể truy cập các mục riêng lẻ trong một từ điển lồng nhau bằng cách chỉ định khóa trong nhiều dấu ngoặc vuông.

D = {'emp1': {'name': 'Bob', 'job': 'Mgr'},
     'emp2': {'name': 'Kim', 'job': 'Dev'},
     'emp3': {'name': 'Sam', 'job': 'Dev'}}

print[D['emp1']['name']]
# Prints Bob

print[D['emp2']['job']]
# Prints Dev

Nếu bạn đề cập đến một khóa không có trong từ điển lồng nhau, một ngoại lệ sẽ được nêu ra.

print[D['emp1']['salary']]
# Triggers KeyError: 'salary'

Để tránh ngoại lệ như vậy, bạn có thể sử dụng từ điển đặc biệt & nbsp; get [] & nbsp; phương thức. Phương thức này trả về giá trị cho khóa nếu khóa nằm trong từ điển, khác & nbsp; ____ 20, để phương pháp này không bao giờ tăng A & nbsp; ____ ____ 21.

"GPU": {"GeForce GTX 1070 Ti": 430, "GeForce GTX 2060 2": 233},
"CPU": {"AMD Ryzen 7 2700X": 233, "Intel Core i7-11700 : 360},
"RAM": {"HyperX 16GB": 180},
"PSU": {"Corsair RM850X": 210}

Thay đổi các mục từ điển lồng nhau

Để thay đổi giá trị của một mục cụ thể trong từ điển lồng nhau, hãy tham khảo khóa của nó.

"GPU": {"GeForce GTX 1070 Ti": 430, "GeForce GTX 2060 2": 233},
"CPU": {"AMD Ryzen 7 2700X": 233, "Intel Core i7-11700 : 360},
"RAM": {"HyperX 16GB": 180},
"PSU": {"Corsair RM850X": 210}

Thêm hoặc cập nhật các mục từ điển lồng nhau

Thêm hoặc cập nhật các mục từ điển lồng nhau là dễ dàng. Chỉ cần tham khảo mục của nó bằng khóa của nó và gán một giá trị. Nếu khóa đã có trong từ điển, giá trị của nó được thay thế bằng cái mới.

"GPU": {"GeForce GTX 1070 Ti": 430, "GeForce GTX 2060 2": 233},
"CPU": {"AMD Ryzen 7 2700X": 233, "Intel Core i7-11700 : 360},
"RAM": {"HyperX 16GB": 180},
"PSU": {"Corsair RM850X": 210}

Nếu khóa là mới, nó sẽ được thêm vào từ điển với giá trị của nó.

"GPU": {"GeForce GTX 1070 Ti": 430, "GeForce GTX 2060 2": 233},
"CPU": {"AMD Ryzen 7 2700X": 233, "Intel Core i7-11700 : 360},
"RAM": {"HyperX 16GB": 180},
"PSU": {"Corsair RM850X": 210}

Hợp nhất hai từ điển lồng nhau

Sử dụng phương thức Cập nhật [] tích hợp để hợp nhất các khóa và giá trị của một từ điển lồng nhau sang một từ khác. Lưu ý rằng phương pháp này một cách mù quáng ghi đè lên các giá trị của cùng một khóa nếu có một cuộc đụng độ.

"GPU": {"GeForce GTX 1070 Ti": 430, "GeForce GTX 2060 2": 233},
"CPU": {"AMD Ryzen 7 2700X": 233, "Intel Core i7-11700 : 360},
"RAM": {"HyperX 16GB": 180},
"PSU": {"Corsair RM850X": 210}

Ở đây, bản ghi EMP2 ′ được cập nhật trong khi EMP3 được thêm vào từ điển.

Xóa các mục từ điển lồng nhau

Có một số cách để loại bỏ các mục khỏi một từ điển lồng nhau.

Xóa một mục bằng khóa

Nếu bạn biết khóa của mục bạn muốn, bạn có thể sử dụng & nbsp; pop [] & nbsp; phương thức. Nó loại bỏ khóa và trả về giá trị của nó.

"GPU": {"GeForce GTX 1070 Ti": 430, "GeForce GTX 2060 2": 233},
"CPU": {"AMD Ryzen 7 2700X": 233, "Intel Core i7-11700 : 360},
"RAM": {"HyperX 16GB": 180},
"PSU": {"Corsair RM850X": 210}

Nếu bạn không cần giá trị bị loại bỏ, hãy sử dụng câu lệnh

"GPU": {"GeForce GTX 2060 2": 233},
"CPU": {"Intel Core i7-11700 : 360},
"RAM": {"HyperX 16GB": 180},
"PSU": {"Corsair RM850X": 210}

"GPU": {"GeForce GTX 1070 Ti": 430, "GeForce GTX 2060 2": 233},
"CPU": {"AMD Ryzen 7 2700X": 233, "Intel Core i7-11700 : 360},
"RAM": {"HyperX 16GB": 180},
"PSU": {"Corsair RM850X": 210}

Xóa mục được chèn cuối cùng

Phương thức PopItem [] loại bỏ và trả về mục được chèn cuối cùng dưới dạng tuple.

"GPU": {"GeForce GTX 1070 Ti": 430, "GeForce GTX 2060 2": 233},
"CPU": {"AMD Ryzen 7 2700X": 233, "Intel Core i7-11700 : 360},
"RAM": {"HyperX 16GB": 180},
"PSU": {"Corsair RM850X": 210}

Trong các phiên bản trước 3.7,

"GPU": {"GeForce GTX 2060 2": 233},
"CPU": {"Intel Core i7-11700 : 360},
"RAM": {"HyperX 16GB": 180},
"PSU": {"Corsair RM850X": 210}

3 sẽ loại bỏ một mục ngẫu nhiên.

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

Bạn có thể lặp lại tất cả các giá trị trong một từ điển lồng nhau bằng cách sử dụng lồng nhau cho vòng lặp.

"GPU": {"GeForce GTX 1070 Ti": 430, "GeForce GTX 2060 2": 233},
"CPU": {"AMD Ryzen 7 2700X": 233, "Intel Core i7-11700 : 360},
"RAM": {"HyperX 16GB": 180},
"PSU": {"Corsair RM850X": 210}

Làm thế nào để bạn tạo ra một vòng lặp từ điển lồng nhau trong Python?

Để tạo một từ điển lồng nhau, chỉ cần chuyển khóa từ điển: cặp giá trị làm đối số từ khóa cho hàm tạo Dict [].Bạn có thể sử dụng hàm Dict [] cùng với hàm zip [], để kết hợp các danh sách riêng biệt các khóa và giá trị thu được động trong thời gian chạy.pass dictionary key:value pair as keyword arguments to dict[] Constructor. You can use dict[] function along with the zip[] function, to combine separate lists of keys and values obtained dynamically at runtime.

Từ điển Python có thể được lồng không?

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 Dicta dicta và dictb.Chúng là hai từ điển mỗi người có khóa và giá trị riêng.a nested dictionary is a dictionary inside a dictionary. It's a collection of dictionaries into one single dictionary. Here, the nested_dict is a nested dictionary with the dictionary dictA and dictB . They are two dictionary each having own key and value.

Tôi có thể sử dụng cho vòng lặp cho từ điển trong Python không?

Bạn có thể lặp qua một từ điển bằng cách sử dụng một vòng lặp.Khi lặp qua từ điển, giá trị trả về là các khóa của từ điển, nhưng cũng có các phương pháp để trả về các giá trị.. When looping through a dictionary, the return value are the keys of the dictionary, but there are methods to return the values as well.

Từ điển có thể được lồng không?

Một từ điển có thể chứa từ điển, đây được gọi là từ điển lồng nhau., this is called nested dictionaries.