如何在變量中提取字典單鍵值對

Question

我的字典中只有一個鍵值對。 我想將鍵分配給一個變量，並將其值分配給另一個變量。 我已經嘗試過以下方法，但我得到了同樣的錯誤。

>>> d = {"a": 1}

>>> d.items()
[('a', 1)]

>>> (k, v) = d.items()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: need more than 1 value to unpack

>>> (k, v) = list(d.items())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: need more than 1 value to unpack

我知道我們可以一個一個地提取鍵和值，或者通過 for 循環和iteritems()來提取，但是沒有一種簡單的方法可以在一個語句中分配兩者嗎？

Answer 1

添加另一個級別，帶有一個元組（只是逗號）：

(k, v), = d.items()

或列表：

[(k, v)] = d.items()

或挑出第一個元素：

k, v = d.items()[0]

前兩個具有額外的優勢，如果您的字典有多個鍵，它們會拋出異常，並且兩者都適用於 Python 3，而后者必須拼寫為k, v = next(iter(d.items()))工作。

演示：

>>> d = {'foo': 'bar'}
>>> (k, v), = d.items()
>>> k, v
('foo', 'bar')
>>> [(k, v)] = d.items()
>>> k, v
('foo', 'bar')
>>> k, v = d.items()[0]
>>> k, v
('foo', 'bar')
>>> k, v = next(iter(d.items()))  # Python 2 & 3 compatible
>>> k, v
('foo', 'bar')

Answer 2

items()返回一個元組列表，因此：

(k,v) = d.items()[0]

Answer 3

>>> d = {"a":1}
>>> [(k, v)] = d.items()
>>> k
'a'
>>> v
1

或使用next ， iter ：

>>> k, v = next(iter(d.items()))
>>> k
'a'
>>> v
1
>>>

Answer 4

d = {"a": 1}

你可以做

k, v = d.keys()[0], d.values()[0]

d.keys()實際上將返回所有鍵的列表，而d.values()返回所有值的列表，因為您在d中有一個鍵：值對，您將訪問鍵和值列表中的第一個元素

Answer 5

在 Python 3 中：

簡短的回答：

[(k, v)] = d.items()

或者：

(k, v) = list(d.items())[0]

或者：

(k, v), = d.items()

長答案：

d.items() ，基本上（但實際上不是）給你一個帶有元組的列表，它有 2 個值，打印時看起來像這樣：

dict_items([('a', 1)])

您可以通過使用list()包裝將其轉換為實際列表，這將產生以下值：

[('a', 1)]

Answer 6

使用.popitem()方法。

k, v = d.popitem()

Answer 7

如果字典中有很多項，這是最好的，因為它實際上並沒有創建一個列表，而是只產生一個鍵值對。

k, v = next(d.iteritems())

當然，如果您的字典中有不止一項，則無法知道您會刪除哪一項。

Answer 8

你有一個清單。 您必須索引列表才能訪問元素。

(k,v) = d.items()[0]

Answer 9

如果您只想要字典鍵而不關心值，請注意(key, ), = foo.items()不起作用。 您確實需要將該值分配給變量。

所以你需要(key, _), = foo.items()

Python 3.7.2 中的插圖：

>>> foo = {'a': 1}
>>> (key, _), = foo.items()
>>> key
'a'
>>> (key, ), = foo.items()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 1)

Answer 10

key = list(foo.keys())[0]
value = foo[key]

Answer 11

在 Python 3 中

最簡單（最簡潔）的答案可能是：

k, = d.keys()

例子：

>>> d = {"a": 1}
>>> k, = d.keys()
>>> k
'a'

同樣的想法也可以應用於values()和items() ：

>>> v, = d.values()
>>> v
1

>>> (k, v), = d.items()
>>> k
'a'
>>> v
1

您將獲得上述相同的好處，即ValueError如果您的dict有超過 1 個鍵：

>>> d = {"a": 1, "b": 2}
>>> k, = d.keys()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 1)

額外細節

對於k, = d.keys()中的尾隨逗號 ( , ) 也存在一些混淆。 盡管它是不請自來的（並且離題），但這是我可以解釋它的最佳方式。

尾隨逗號只是“表達式列表”賦值（又名“元組賦值”）的符號。 沒有它，您將只分配一個dict_keys對象，而不是同一對象包含的第一個（也是唯一一個）值的值：

>>> k = d.keys()
>>> k
dict_keys(['a'])

具體細節可以在The Python Language Reference, 7. Simple statements中找到（盡管該文檔有點過於密集，我的口味）。

基本上，只要保留一對一的賦值，就可以將多個變量解包（或賦值）給一行中的多個變量（除非使用星號賦值* ）。

>>> (a, b, c) = (1, 2, 3)
>>> a
1

並且因為括號是可選的，所以以下是等價的：

>>> a, b, c = 1, 2, 3
>>> b
2

因為(a, b, c) = (1, 2, 3) <==> a, b, c = 1, 2, 3 ，相同的列表賦值表達式可以用於單個項目，除了具有單個項目的元組必須有一個尾隨逗號。

沒有它，括號將作為表達式計算，並分配包含的結果值：

>>> t = (1)
>>> type(t)
<class 'int'>
>>> t
1

雖然一開始這看起來很奇怪，但如果你查看一個包含單個項目的tuple的repr() ，你會發現它始終用尾隨逗號表示：

>>> tuple([1])
(1,)

>>> t = ('a',)
>>> type(t)
<class 'tuple'>
>>> t
('a',)

話雖如此，從語法上講，您可以在技術上使用帶有（或不帶有）可選括號的單個項目執行元組賦值，只要您包含尾隨逗號：

# weird, but okay...
>>> (a,) = (1,)
>>> a
1

# technically, sure... but please don't do this.
>>> a, = 1,
>>> a
1

事實上，使用尾隨逗號分配任何值都會被評估為一個元組：

# assignment with a trailing comma (without parentheses)
>>> t = 1,
>>> type(t)
<class 'tuple'>
>>> t
(1,)

雖然這種語法看起來很奇怪，並且不常用，但它確實會不時彈出來解決不常見的問題（比如這個）。

如果有幫助，您始終可以包含可選括號，因為“ 顯式優於隱式。 ”：

# original example
>>> d = {"a": 1}

# get (only) key
>>> (k,) = d.keys()
>>> k
'a'

# get (only) value
>>> (v,) = d.values()
>>> v
1

# get (only) key and value
>>> ((k, v),) = d.items()
>>> k
'a'
>>> v
1

希望有幫助。

TL;博士

問：你如何從帶有單個項目的dict中 [解包] [key||value]？

A: 創造性地，用甜蜜的句法糖，寶貝！