Зміст словника для деструктуризації та прив’язки

Я намагаюся "деструктурувати" словник та пов'язати значення з іменами змінних після його ключів. Щось на зразок

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

Але оскільки словники не впорядковані, немає жодної гарантії, що params.values()повернуть значення у порядку (a, b). Чи є хороший спосіб це зробити?

Якщо ви боїтеся питань , пов'язаних з використанням словника місцевих жителів і ви віддаєте перевагу слідувати вашій вихідної стратегії, впорядковані словники з пітона 2.7 і 3.1 collections.OrderedDicts дозволяють відновлювати вам словникові елементи в тому порядку , в якому вони були першими вставленими

from operator import itemgetter

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

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

Замість складних лямбда-функцій або розуміння словника, ви можете також використовувати вбудовану бібліотеку.

Одним із способів зробити це з меншим повторенням, ніж пропозиція Йохена, є допоміжна функція. Це надає гнучкість для переліку імен змінних у будь-якому порядку і лише деструктурує підмножину того, що є в dict:

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

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

Крім того, замість Joaquin's OrderedDict ви можете відсортувати ключі та отримати значення. Єдине, що вам потрібно, - вам потрібно вказати імена змінних в алфавітному порядку і деструктурувати все, що є в dict:

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

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

Python здатний лише "деструктурувати" послідовності, а не словники. Отже, щоб написати те, що ви хочете, вам доведеться зіставити потрібні записи у відповідну послідовність. Як на мене, найближчий збіг, який я міг знайти - це (не дуже сексуально):

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

Це також працює з генераторами:

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

Ось повний приклад:

>>> 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

Може, ви дійсно хочете зробити щось подібне?

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

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

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

Ось ще один спосіб зробити це подібно до того, як працює призначення деструктуризації в JS:

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

Те, що ми зробили, було розпакувати словник params за ключовими значеннями (використовуючи **) (як у відповіді Йохена ), потім ми взяли ці значення в лямбда-підпис і призначили їх відповідно до назви ключа - і ось бонус - ми також отримайте словник того, чого немає в підписі лямбди, тож якщо у вас було:

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

Після того, як лямбда буде застосована, змінна rest тепер буде містити: {'c': 3}

Корисно для пропуску непотрібних клавіш зі словника.

Сподіваюся, це допомагає.

спробуйте це

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

результат:

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

Попередження 1: як зазначено в документах, це не гарантовано буде працювати на всіх реалізаціях Python:

Деталізація реалізації CPython: Ця функція покладається на підтримку кадру стеку Python в інтерпретаторі, яка не гарантується у всіх реалізаціях Python. Якщо робота в реалізації без підтримки кадру стека Python, ця функція повертає None.

Попередження 2: ця функція робить код коротшим, але, ймовірно, це суперечить філософії Python, щоб бути якомога явнішим. Більше того, це не стосується питань, на які вказував Джон Крістофер Джонс у коментарях, хоча ви можете зробити подібну функцію, яка працює з атрибутами замість клавіш. Це лише демонстрація того, що ви можете це зробити, якщо дуже хочете!

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'

Це рішення дозволяє вибрати деякі клавіші, а не всі, як у JavaScript. Це також безпечно для словників, що надаються користувачем

Ну, якщо ви хочете їх у класі, ви завжди можете зробити це:

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

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

На основі відповіді @ShawnFumo я придумав таке:

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

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

(Зверніть увагу на порядок предметів у дикті)

Оскільки словники гарантовано зберігають порядок вставки в Python> = 3.7 , це означає, що сьогодні це просто безпечно та ідіоматично:

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

Вихід:

1
2

Я не знаю, чи це хороший стиль, але

locals().update(params)

зробить трюк. Тоді у вас є a, bі все, що було у вашому paramsдикті, доступне як відповідні локальні змінні.