How to extract dictionary single key-value pair in variables

You have a list. You must index the list in order to access the elements.

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

items() returns a list of tuples so:

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

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

Or using next, iter:

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

d = {"a": 1}

you can do

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

d.keys() will actually return list of all keys and d.values() return list of all values, since you have a single key:value pair in d you will be accessing the first element in list of keys and values

This is best if you have many items in the dictionary, since it doesn’t actually create a list but yields just one key-value pair.

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

Of course, if you have more than one item in the dictionary, there’s no way to know which one you’ll get out.

In Python 3:

Short answer:

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

or:

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

or:

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

Long answer:

d.items(), basically (but not actually) gives you a list with a tuple, which has 2 values, that will look like this when printed:

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

You can convert it to the actual list by wrapping with list(), which will result in this value:

[('a', 1)]

If you just want the dictionary key and don’t care about the value, note that (key, ), = foo.items() doesn’t work. You do need to assign that value to a variable.

So you need (key, _), = foo.items()

Illustration in 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)

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

Use the .popitem() method.

k, v = d.popitem()

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!