In Python 3
The easiest (most terse) answer is probably:
k, = d.keys()
Example:
>>> d = {"a": 1}
>>> k, = d.keys()
>>> k
'a'
The same idea can be applied for values()
and items()
as well:
>>> v, = d.values()
>>> v
1
>>> (k, v), = d.items()
>>> k
'a'
>>> v
1
You'll get the same benefits mentioned above, i.e. ValueError
if your dict
has more than 1 key:
>>> 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)
Additional Details
There was also some confusion about the trailing comma (,
) in k, = d.keys()
. Though it's unsolicited (and off-topic), here's the best way I can explain it.
The trailing comma is simply notation for "expression list" assignment (a.k.a "tuple assignment"). Without it, you'll just have assigned a dict_keys
object instead of the value of the first (and only) value contained by that same object:
>>> k = d.keys()
>>> k
dict_keys(['a'])
Specifics can be found in The Python Language Reference, 7. Simple statements (although that document is a little too dense, for my taste).
Basically, multiple variables can be unpacked (or assigned) to multiple variables on a single line as long as a 1-to-1 assignment is preserved (unless using starred assignment *
).
>>> (a, b, c) = (1, 2, 3)
>>> a
1
And because parentheses are optional, the following is equivalent:
>>> a, b, c = 1, 2, 3
>>> b
2
Because (a, b, c) = (1, 2, 3)
<==> a, b, c = 1, 2, 3
, the same list assigment expression can be used for single item, except tuples with a single item must have a trailing comma.
Without it, the parentheses are evaluated as an expression, and assign the contained resulting value:
>>> t = (1)
>>> type(t)
<class 'int'>
>>> t
1
While this can seem strange at first, but if you look a repr()
of a tuple
with a single item, you'll see it is consistently represented with a trailing comma:
>>> tuple([1])
(1,)
>>> t = ('a',)
>>> type(t)
<class 'tuple'>
>>> t
('a',)
That being said, syntactically, you can technically perform a tuple assignment with a single item with (or without) the optional parenthesis, just so long as you include the trailing comma:
# weird, but okay...
>>> (a,) = (1,)
>>> a
1
# technically, sure... but please don't do this.
>>> a, = 1,
>>> a
1
In fact, assigning any value with a trailing comma is evaluated a tuple:
# assignment with a trailing comma (without parentheses)
>>> t = 1,
>>> type(t)
<class 'tuple'>
>>> t
(1,)
While this syntax seems strange, and isn't commonly used, it does pop up from time to time to solve uncommon problems (like this one).
If it helps, you can always include optional parenthesis, because "Explicit is better than implicit.":
# 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
Hope that helps.
TL;DR
Q: How do you [unpack] a [key||value] from a dict
with a single item?
A: Creatively, with sweet syntactic sugar, baby!