Dictionary methods

Dictionaries have a number of useful built-in methods. The following table provides a summary and more details can be found in the Python Documentation.

Method Parameters Description
keys none Returns a list of the keys in the dictionary
values none Returns a list of the values in the dictionary
items none Returns a list of the key-value pairs in the dictionary
get key Returns the value associated with key; None otherwise
get key,alt Returns the value associated with key; alt otherwise

As we saw earlier with strings and lists, dictionary methods use dot notation, which specifies the name of the method to the right of the dot and the name of the object on which to apply the method immediately to the left of the dot. The empty parentheses in the case of keys indicate that this method takes no parameters. If x is a variable whose value is a dictionary, x.keys is the method object, and x.keys() invokes the method, returning a value.

The keys method returns a list of the keys, not necessarily in the same order they were added to the dictionary or any other particular order.

It’s so common to iterate over the keys in a dictionary that you can omit the keys method call in the for loop — iterating over a dictionary implicitly iterates over its keys.

The values and items methods are similar to keys. They return lists of objects which can be iterated over. Note that the item objects are tuples containing the key and the associated value.

Note

Technically, .keys(), .values(), and .items() don’t return actual lists. Like the range function described previously, in python 3 they return objects that produce the items one at a time, rather than producing and storing all of them in advance as a list. Unless the dictionary has a whole lot of keys, this won’t make a difference for performance. In any case, as with the range function, it is safe for you to think of them as returning lists. For the python interpreter built into this textbook, they actually do produce lists. In a native python interpreter, if you print out type(inventory.keys()), you will find that it is something other than an actual list.

The in and not in operators can test if a key is in the dictionary:

This operator can be very useful since looking up a non-existent key in a dictionary causes a runtime error.

The get method allows us to access the value associated with a key, similar to the [ ] operator. The important difference is that get will not cause a runtime error if the key is not present. It will instead return None. There exists a variation of get that allows a second parameter that serves as an alternative return value in the case where the key is not present. This can be seen in the final example below. In this case, since “cherries” is not a key, return 0 (instead of None).

Check your understanding

    sort-instances-1: What is printed by the following statements?

    mydict = {"cat":12, "dog":6, "elephant":23, "bear":20}
answer = mydict.get("cat")//mydict.get("dog")
print(answer)
  • 2
  • get returns the value associated with a given key so this divides 12 by 6.
  • 0.5
  • 12 is divided by 6, not the other way around.
  • bear
  • Take another look at the example for get above. get returns the value associated with a given key.
  • Error, divide is not a valid operation on dictionaries.
  • The integer division operator is being used on the values returned from the get method, not on the dictionary.

    sort-instances-2: What is printed by the following statements?

    mydict = {"cat":12, "dog":6, "elephant":23, "bear":20}
print("dog" in mydict)
  • True
  • Yes, dog is a key in the dictionary.
  • False
  • The in operator returns True if a key is in the dictionary, False otherwise.

    sort-instances-3: What is printed by the following statements?

    mydict = {"cat":12, "dog":6, "elephant":23, "bear":20}
print(23 in mydict)
  • True
  • 23 is a value in the dictionary, not a key.
  • False
  • Yes, the in operator returns True if a key is in the dictionary, False otherwise.

    sort-instances-4: What is printed by the following statements?

    total = 0
mydict = {"cat":12, "dog":6, "elephant":23, "bear":20}
for akey in mydict:
   if len(akey) > 3:
      total = total + mydict[akey]
print(total)
  • 18
  • Add the values that have keys longer than 3 characters, not those with exactly 3 characters.
  • 43
  • Yes, the for statement iterates over the keys. It adds the values of the keys that have length greater than 3.
  • 0
  • This is the accumulator pattern. Total starts at 0 but then changes as the iteration proceeds.
  • 61
  • Not all the values are added together. The if statement only chooses some of them.
Next Section - Aliasing and copying