How to find the first key in a dictionary? (python)

On a Python version where dicts actually are ordered, you can do

my_dict = {'foo': 'bar', 'spam': 'eggs'}
next(iter(my_dict)) # outputs 'foo'

For dicts to be ordered, you need Python 3.7+, or 3.6+ if you're okay with relying on the technically-an-implementation-detail ordered nature of dicts on CPython 3.6.

For earlier Python versions, there is no "first key", but this will give you "a key", especially useful if there is only one.

A dictionary is not indexed, but it is in some way, ordered. The following would give you the first existing key:

list(my_dict.keys())[0]

Update: as of Python 3.7, insertion order is maintained, so you don't need an OrderedDict here. You can use the below approaches with a normal dict

Changed in version 3.7: Dictionary order is guaranteed to be insertion order. This behavior was an implementation detail of CPython from 3.6.

source

Python 3.6 and earlier*

If you are talking about a regular dict, then the "first key" doesn't mean anything. The keys are not ordered in any way you can depend on. If you iterate over your dict you will likely not get "banana" as the first thing you see.

If you need to keep things in order, then you have to use an OrderedDict and not just a plain dictionary.

import collections
prices  = collections.OrderedDict([
    ("banana", 4),
    ("apple", 2),
    ("orange", 1.5),
    ("pear", 3),
])

If you then wanted to see all the keys in order you could do so by iterating through it

for k in prices:
    print(k)

You could, alternatively put all of the keys into a list and then work with that

keys = list(prices)
print(keys[0]) # will print "banana"

A faster way to get the first element without creating a list would be to call next on the iterator. This doesn't generalize nicely when trying to get the nth element though

>>> next(iter(prices))
'banana'

_{* CPython had guaranteed insertion order as an implementation detail in 3.6.}

If you just want the first key from a dictionary you should use what many have suggested before

first = next(iter(prices))

However if you want the first and keep the rest as a list you could use the values unpacking operator

first, *rest = prices

The same is applicable on values by replacing prices with prices.values() and for both key and value you can even use unpacking assignment

>>> (product, price), *rest = prices.items()
>>> product
'banana'
>>> price
4

Note: You might be tempted to use first, *_ = prices to just get the first key, but I would generally advice against this usage unless the dictionary is very short since it loops over all keys and creating a list for the rest has some overhead.

Note: As mentioned by others insertion order is preserved from python 3.7 (or technically 3.6) and above whereas earlier implementations should be regarded as undefined order.

UPDATE: I decided to test it again, now in January of 2023, on my Windows 11 PC, with a Ryzen 9 5900x. So that it's easier for me to re-run it (and so you, dear reader, can run it easily) I've made a Gist of it here: https://gist.github.com/maludwig/d38054ec05d01ad91df5dade8aa47d9d

The results are in, and first_5 remains the winner!

12100238 / s with first_1
 9094216 / s with first_2
 9219988 / s with first_3
 7370554 / s with first_4
13525210 / s with first_5
 9810076 / s with first_6
 8676864 / s with first_7

Everything is a lot faster (CPU is better too, since it's been a few years since the first test). But there have also clearly been optimizations made (see comments for details), especially in first_1.

first_1 is 5.43x faster
first_2 is 4.77x faster
first_3 is 4.62x faster
first_4 is 4.15x faster
first_5 is 3.67x faster
first_6 is 3.47x faster
first_7 is 3.34x faster

Current scoreboard:
  #1: first_5 (previously #1)
  #2: first_1 (previously #4)
  #3: first_6 (previously #2)
  #4: first_3 (previously #5)
  #5: first_2 (previously #6)
  #6: first_7 (previously #3)
  #7: first_4 (previously #7)

So I found this page while trying to optimize a thing for taking the only key in a dictionary of known length 1 and returning only the key. The below process was the fastest for all dictionaries I tried up to size 700.

I tried 7 different approaches, and found that this one was the best, on my 2014 Macbook with Python 3.6:

def first_5():
    for key in biased_dict:
        return key

The results of profiling them were:

  2226460 / s with first_1
  1905620 / s with first_2
  1994654 / s with first_3
  1777946 / s with first_4
  3681252 / s with first_5
  2829067 / s with first_6
  2600622 / s with first_7

All the approaches I tried are here:

def first_1():
    return next(iter(biased_dict))


def first_2():
    return list(biased_dict)[0]


def first_3():
    return next(iter(biased_dict.keys()))


def first_4():
    return list(biased_dict.keys())[0]


def first_5():
    for key in biased_dict:
        return key


def first_6():
    for key in biased_dict.keys():
        return key


def first_7():
    for key, v in biased_dict.items():
        return key

The dict type is an unordered mapping, so there is no such thing as a "first" element.

What you want is probably collections.OrderedDict.

Well as simple, the answer according to me will be

first = list(prices)[0]

converting the dictionary to list will output the keys and we will select the first key from the list.

Assuming you want to print the first key:

print(list(prices.keys())[0])

If you want to print first key's value:

print(prices[list(prices.keys())[0]])

As many others have pointed out there is no first value in a dictionary. The sorting in them is arbitrary and you can't count on the sorting being the same every time you access the dictionary. However if you wanted to print the keys there a couple of ways to it:

for key, value in prices.items():
    print(key)

This method uses tuple assignment to access the key and the value. This handy if you need to access both the key and the value for some reason.

for key in prices.keys():
    print(key)

This will only gives access to the keys as the keys() method implies.

Use a for loop that ranges through all keys in prices:

for key, value in prices.items():
     print(key)
     print("price: %s" % value)

Make sure that you change prices.items() to prices.iteritems() if you're using Python 2.x

d.keys()[0] to get the individual key.

Update:- @AlejoBernardin , am not sure why you said it didn't work. here I checked and it worked. import collections

prices  = collections.OrderedDict((

    ("banana", 4),
    ("apple", 2),
    ("orange", 1.5),
    ("pear", 3),
))
prices.keys()[0]

'banana'

Python version >= 3.7 # where dictionaries are ordered

prices = {
    "banana" : 4,
    "apple" : 2,
    "orange" : 1.5,
    "pear" : 3
}

# you can create a list of keys using list(prices.keys())

prices_keys_list = list(prices.keys())

# now you can access the first key of this list 

print(prices_keys_list[0])   # remember 0 is the first index

# you can also do the same for values using list(prices.values())

prices_values_list = list(prices.values())

print(prices_values_list[0])

As @mavix mentioned in a comment to another post:

In python3, dict.keys() returns a 'dict_keys' object instead of a list, which does not support indexing Blockquote

One solution to this would be converting that object into a list by iterating through it. It's not the most elegant solution and shouldn't really be used if can be avoided.

first_key = [key for key in prices.keys()][0]
#           ^Converts keys into a list    ^Takes the first key from the list