You create a new key/value pair on a dictionary by assigning a value to that key

d = {'key': 'value'} print(d)  # {'key': 'value'}  d['mynewkey'] = 'mynewvalue'  print(d)  # {'key': 'value', 'mynewkey': 'mynewvalue'} 

If the key doesn't exist, it's added and points to that value. If it exists, the current value it points to is overwritten.

To add multiple keys simultaneously, use dict.update():

>>> x = {1:2} >>> print(x) {1: 2}  >>> d = {3:4, 5:6, 7:8} >>> x.update(d) >>> print(x) {1: 2, 3: 4, 5: 6, 7: 8} 

For adding a single key, the accepted answer has less computational overhead.

I feel like consolidating info about Python dictionaries:

Creating an empty dictionary

data = {} # OR data = dict() 

Creating a dictionary with initial values

data = {'a': 1, 'b': 2, 'c': 3} # OR data = dict(a=1, b=2, c=3) # OR data = {k: v for k, v in (('a', 1), ('b',2), ('c',3))} 

Inserting/Updating a single value

data['a'] = 1  # Updates if 'a' exists, else adds 'a' # OR data.update({'a': 1}) # OR data.update(dict(a=1)) # OR data.update(a=1) 

Inserting/Updating multiple values

data.update({'c':3,'d':4})  # Updates 'c' and adds 'd' 

Python 3.9+:

The update operator |= now works for dictionaries:

data |= {'c':3,'d':4} 

Creating a merged dictionary without modifying originals

data3 = {} data3.update(data)  # Modifies data3, not data data3.update(data2)  # Modifies data3, not data2 

Python 3.5+:

This uses a new feature called dictionary unpacking.

data = {**data1, **data2, **data3} 

Python 3.9+:

The merge operator | now works for dictionaries:

data = data1 | {'c':3,'d':4} 

Deleting items in dictionary

del data[key]  # Removes specific element in a dictionary data.pop(key)  # Removes the key & returns the value data.clear()  # Clears entire dictionary 

Check if a key is already in dictionary

key in data 

Iterate through pairs in a dictionary

for key in data: # Iterates just through the keys, ignoring the values for key, value in d.items(): # Iterates through the pairs for key in d.keys(): # Iterates just through key, ignoring the values for value in d.values(): # Iterates just through value, ignoring the keys 

Create a dictionary from two lists

data = dict(zip(list_with_keys, list_with_values)) 

"Is it possible to add a key to a Python dictionary after it has been created? It doesn't seem to have an .add() method."

Yes it is possible, and it does have a method that implements this, but you don't want to use it directly.

To demonstrate how and how not to use it, let's create an empty dict with the dict literal, {}:

my_dict = {} 

Best Practice 1: Subscript notation

To update this dict with a single new key and value, you can use the subscript notation (see Mappings here) that provides for item assignment:

my_dict['new key'] = 'new value' 

my_dict is now:

{'new key': 'new value'} 

Best Practice 2: The update method - 2 ways

We can also update the dict with multiple values efficiently as well using the update method. We may be unnecessarily creating an extra dict here, so we hope our dict has already been created and came from or was used for another purpose:

my_dict.update({'key 2': 'value 2', 'key 3': 'value 3'}) 

my_dict is now:

{'key 2': 'value 2', 'key 3': 'value 3', 'new key': 'new value'} 

Another efficient way of doing this with the update method is with keyword arguments, but since they have to be legitimate python words, you can't have spaces or special symbols or start the name with a number, but many consider this a more readable way to create keys for a dict, and here we certainly avoid creating an extra unnecessary dict:

my_dict.update(foo='bar', foo2='baz') 

and my_dict is now:

{'key 2': 'value 2', 'key 3': 'value 3', 'new key': 'new value',   'foo': 'bar', 'foo2': 'baz'} 

So now we have covered three Pythonic ways of updating a dict.

Magic method, __setitem__, and why it should be avoided

There's another way of updating a dict that you shouldn't use, which uses the __setitem__ method. Here's an example of how one might use the __setitem__ method to add a key-value pair to a dict, and a demonstration of the poor performance of using it:

>>> d = {} >>> d.__setitem__('foo', 'bar') >>> d {'foo': 'bar'}   >>> def f(): ...     d = {} ...     for i in xrange(100): ...         d['foo'] = i ...  >>> def g(): ...     d = {} ...     for i in xrange(100): ...         d.__setitem__('foo', i) ...  >>> import timeit >>> number = 100 >>> min(timeit.repeat(f, number=number)) 0.0020880699157714844 >>> min(timeit.repeat(g, number=number)) 0.005071878433227539 

So we see that using the subscript notation is actually much faster than using __setitem__. Doing the Pythonic thing, that is, using the language in the way it was intended to be used, usually is both more readable and computationally efficient.

dictionary[key] = value