Nội dung từ điển hủy cấu trúc-ràng buộc

Tôi đang cố gắng 'hủy cấu trúc' một từ điển và liên kết các giá trị với các tên biến sau các khóa của nó. Cái gì đó như

params = {'a':1,'b':2}
a,b = params.values()

Nhưng vì từ điển không được sắp xếp theo thứ tự, không có gì đảm bảo rằng params.values()sẽ trả về các giá trị theo thứ tự (a, b). Có cách nào hay để làm điều này không?

Nếu bạn sợ trong những vấn đề liên quan đến việc sử dụng của người dân địa phương điển và bạn thích làm theo chiến lược ban đầu của bạn, Từ điển Ordered từ python 2.7 và 3.1 collections.OrderedDicts phép bạn khôi phục bạn từ điển mục theo thứ tự mà họ lần đầu tiên được chèn

from operator import itemgetter

params = {'a': 1, 'b': 2}

a, b = itemgetter('a', 'b')(params)

Thay vì các hàm lambda phức tạp hoặc đọc hiểu từ điển, cũng có thể sử dụng một thư viện tích hợp sẵn.

Một cách để làm điều này mà ít lặp lại hơn gợi ý của Jochen là sử dụng hàm trợ giúp. Điều này mang lại sự linh hoạt để liệt kê các tên biến của bạn theo bất kỳ thứ tự nào và chỉ hủy cấu trúc một tập hợp con của những gì có trong dict:

pluck = lambda dict, *args: (dict[arg] for arg in args)

things = {'blah': 'bleh', 'foo': 'bar'}
foo, blah = pluck(things, 'foo', 'blah')

Ngoài ra, thay vì OrderDict của joaquin, bạn có thể sắp xếp các khóa và lấy các giá trị. Điều bắt buộc duy nhất là bạn cần chỉ định tên biến của mình theo thứ tự bảng chữ cái và hủy cấu trúc mọi thứ trong dict:

sorted_vals = lambda dict: (t[1] for t in sorted(dict.items()))

things = {'foo': 'bar', 'blah': 'bleh'}
blah, foo = sorted_vals(things)

Python chỉ có thể "hủy cấu trúc" các chuỗi, không phải từ điển. Vì vậy, để viết những gì bạn muốn, bạn sẽ phải ánh xạ các mục nhập cần thiết theo một trình tự thích hợp. Đối với bản thân tôi, kết quả phù hợp nhất mà tôi có thể tìm thấy là (không sexy lắm):

a,b = [d[k] for k in ('a','b')]

Điều này cũng hoạt động với máy phát điện:

a,b = (d[k] for k in ('a','b'))

Đây là một ví dụ đầy đủ:

>>> d = dict(a=1,b=2,c=3)
>>> d
{'a': 1, 'c': 3, 'b': 2}
>>> a, b = [d[k] for k in ('a','b')]
>>> a
1
>>> b
2
>>> a, b = (d[k] for k in ('a','b'))
>>> a
1
>>> b
2

Có lẽ bạn thực sự muốn làm điều gì đó như thế này?

def some_func(a, b):
  print a,b

params = {'a':1,'b':2}

some_func(**params) # equiv to some_func(a=1, b=2)

Đây là một cách khác để làm điều đó tương tự như cách hoạt động của một nhiệm vụ hủy cấu trúc trong JS:

params = {'b': 2, 'a': 1}
a, b, rest = (lambda a, b, **rest: (a, b, rest))(**params)

Những gì chúng tôi đã làm là giải nén từ điển params thành các giá trị khóa (sử dụng **) (như trong câu trả lời của Jochen ), sau đó chúng tôi lấy các giá trị đó trong chữ ký lambda và gán chúng theo tên khóa - và đây là một phần thưởng - chúng tôi cũng có được một từ điển về bất cứ điều gì không có trong chữ ký của lambda, vì vậy nếu bạn có:

params = {'b': 2, 'a': 1, 'c': 3}
a, b, rest = (lambda a, b, **rest: (a, b, rest))(**params)

Sau khi lambda đã được áp dụng, biến còn lại bây giờ sẽ chứa: {'c': 3}

Hữu ích để loại bỏ các khóa không cần thiết khỏi từ điển.

Hi vọng điêu nay co ich.

thử đi

d = {'a':'Apple', 'b':'Banana','c':'Carrot'}
a,b,c = [d[k] for k in ('a', 'b','c')]

kết quả:

a == 'Apple'
b == 'Banana'
c == 'Carrot'

Cảnh báo 1: như đã nêu trong tài liệu, điều này không được đảm bảo hoạt động trên tất cả các triển khai Python:

Chi tiết triển khai CPython: Hàm này dựa vào hỗ trợ khung ngăn xếp Python trong trình thông dịch, điều này không được đảm bảo tồn tại trong tất cả các triển khai của Python. Nếu chạy trong một triển khai mà không hỗ trợ khung ngăn xếp Python, hàm này trả về Không có.

Cảnh báo 2: hàm này làm cho mã ngắn hơn, nhưng nó có thể mâu thuẫn với triết lý của Python là càng rõ ràng càng tốt. Hơn nữa, nó không giải quyết các vấn đề được John Christopher Jones chỉ ra trong các nhận xét, mặc dù bạn có thể tạo một hàm tương tự hoạt động với các thuộc tính thay vì khóa. Đây chỉ là một minh chứng rằng bạn có thể làm điều đó nếu bạn thực sự muốn!

def destructure(dict_):
    if not isinstance(dict_, dict):
        raise TypeError(f"{dict_} is not a dict")
    # the parent frame will contain the information about
    # the current line
    parent_frame = inspect.currentframe().f_back

    # so we extract that line (by default the code context
    # only contains the current line)
    (line,) = inspect.getframeinfo(parent_frame).code_context

    # "hello, key = destructure(my_dict)"
    # -> ("hello, key ", "=", " destructure(my_dict)")
    lvalues, _equals, _rvalue = line.strip().partition("=")

    # -> ["hello", "key"]
    keys = [s.strip() for s in lvalues.split(",") if s.strip()]

    if missing := [key for key in keys if key not in dict_]:
        raise KeyError(*missing)

    for key in keys:
        yield dict_[key]

In [5]: my_dict = {"hello": "world", "123": "456", "key": "value"}                                                                                                           

In [6]: hello, key = destructure(my_dict)                                                                                                                                    

In [7]: hello                                                                                                                                                                
Out[7]: 'world'

In [8]: key                                                                                                                                                                  
Out[8]: 'value'

Giải pháp này cho phép bạn chọn một số khóa, không phải tất cả, như trong JavaScript. Nó cũng an toàn cho từ điển do người dùng cung cấp

Chà, nếu bạn muốn những điều này trong một lớp học, bạn luôn có thể làm điều này:

class AttributeDict(dict):
    def __init__(self, *args, **kwargs):
        super(AttributeDict, self).__init__(*args, **kwargs)
        self.__dict__.update(self)

d = AttributeDict(a=1, b=2)

Dựa trên câu trả lời @ShawnFumo, tôi đã nghĩ ra điều này:

def destruct(dict): return (t[1] for t in sorted(dict.items()))

d = {'b': 'Banana', 'c': 'Carrot', 'a': 'Apple' }
a, b, c = destruct(d)

(Chú ý thứ tự các mặt hàng trong dict)

Vì các từ điển được đảm bảo giữ thứ tự chèn của chúng trong Python> = 3.7 , điều đó có nghĩa là ngày nay việc làm này hoàn toàn an toàn và dễ hiểu:

params = {'a': 1, 'b': 2}
a, b = params.values()
print(a)
print(b)

Đầu ra:

1
2

Tôi không biết liệu đó có phải là phong cách tốt hay không, nhưng

locals().update(params)

sẽ thực hiện thủ thuật. Sau đó a, bạn có , bvà bất cứ thứ gì trong paramsmệnh lệnh của bạn có sẵn dưới dạng các biến cục bộ tương ứng.