splitting a dictionary in python into keys and values

Question

How can I take a dictionary and split it into two lists, one of keys, one of values. For example take:

{'name': 'Han Solo', 'firstname': 'Han', 'lastname': 'Solo', 'age': 37, 'score': 100, 'yrclass': 10}

and split it into:

['name', 'firstname', 'lastname', 'age', 'score', 'yrclass']
# and
['Han Solo', 'Han', 'Solo', 36, 100, 10]

Any ideas guys?

Answer 1

Not that hard, try help(dict) in a console for more info :)

keys = dictionary.keys()
values = dictionary.values()

For both keys and values:

items = dictionary.items()

Which can be used to split them as well:

keys, values = zip(*dictionary.items())

Note 0 The order of all of these is consistent within the same dictionary instance. The order of dictionaries in Python versions below 3.6 is arbitrary but constant for an instance. Since Python 3.6 the order depends on the insertion order.

Note 1 In Python 2 these all return a list() of results. For Python 3 you need to manually convert them if needed: list(dictionary.keys())

Answer 2

as a compliment to @Wolph answer,

its important to say that using zip may be much slower!

---

Added split_with_tuple - as split returns view objects as of python3

In [1]: def split(d):
   ...:     return d.keys(), d.values()
   ...:
   ...:

In [2]: def split_with_tuple(d):
   ...:     return tuple(d.keys()), tuple(d.values())
   ...:
   ...:

In [3]: def split_with_zip(d):
   ...:     return zip(*d.items())
   ...:
   ...:

In [4]: d = {i:str(i) for i in range(10000)}

In [5]: %timeit split(d)
265 ns ± 12.2 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [6]: %timeit split_with_tuple(d)
151 µs ± 772 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [7]: %timeit split_with_zip(d)
950 µs ± 15.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)