Dicts

Question 1

What are dictionaries in Python?

Answer 1

Dictionary is an unordered collection of one-to-one relationships between keys and values
»> my_dict = {“key”: “value”, “name”: “nick”}

Unordered means that keys order may change if you call my_dict few times.

Question 2

How to return value from dict by given key?

Answer 2

d[key_name], e.g.:
»> my_dict[“name”]
“nick”

or d.get(key_name), but this approach doesn’t throw KeyError on key_name non-existence.

Question 3

What happens when you call d[“key_name”] and such key doesn’t exist?

Answer 3

KeyError: ‘key_name’

Question 4

Which datatypes are allowed to be dict’s keys?

Answer 4

Values that are not hashable - strings, integers, tuples. Floats can be too, but their values can be approximated and floored that’s why avoid their usage as keys.

Question 5

Name 6 ways of dict declaration.

Answer 5

1. dict literal {key: value} or dict comprehension in {}
2. dict()
3. dict(**kwargs)
4. dict(mapping, **kwargs)
5. dict(iterable, **kwargs)
6. dict.fromkeys(iterable, )

Literals are the fastest way.

Question 6

How to create dict with it’s literals?

Answer 6

Use {key: value} or dict comprehension in {}
»> a = {“one”: 1, “two”: 2, “three”: 3} # dict literal {key:value}
»> b = {key: value for key, value in [(“one”, 1), (“two”, 2), (“three’” 3)]} # comprehension
»> a == b # True

Question 7

What if positional arguments or kwargs aren’t given to dict() ?

Answer 7

An empty dictionary is created.
»> d = dict(); print d
{}

Question 8

How keyword args in dict(**kwargs) can be used?

Answer 8

> > > b = dict(one=1, two=2, three=3)

But keep in mind that keyword names can’t be used as an expression:
»> dict(1=”a”)
SyntaxError: keyword can’t be an expression
»> dict(“1”=”a”)
SyntaxError: keyword can’t be an expression
»> dict(a=”a”)
{a: “a”}

Question 9

How to use dict(mapping)?

Answer 9

A mapping is a collection of key/value pairs that allow key access to value - it “maps” keys to values. The most obvious mapping builtin type is the dict. Or you can use list of tuples of pairs:
»> d = dict([(‘two’, 2), (‘one’, 1), (‘three’, 3)])
{‘three’: 3, ‘two’: 2, ‘one’: 1}

Question 10

How to use dict(iterable)?

Answer 10

An iterable is an object that can be iterated - which basically means you can use it in a for obj in iterable: statement. This include sequence types (strings, lists, etc) as well as quite a few other (files, dbapi cursors, generators etc), and, well, dicts too.

Each item in the iterable must itself be an iterable with exactly two objects. The first object of each item becomes a key in the new dictionary, and the second object the corresponding value. If a key occurs more than once, the last value for that key becomes the corresponding value in the new dictionary.
»>dict([‘ab’, ‘cd’, ‘ef’])
{‘a’: ‘b’, ‘c’: ‘d’, ‘e’: ‘f’}

Question 11

What if you provide kwargs alongside mapping or iterable like in dict([(‘a’, 1)], a=2)?

Answer 11

{‘a’: 2}

If keyword arguments are given, the keyword arguments and their values are added to the dictionary created from the positional argument. If a key being added is already present, the value from the keyword argument replaces the value from the positional argument.

Question 12

How to assign new item (key and value) to existing dict?

Answer 12

> > > d[‘new_key’] = ‘value’
or
d.setdefault(‘new_key’, ‘value’) # if key doesn’t exist - create it with default value None or value; if exists - do nothing.

Question 13

How to change / update existing key in dict?

Answer 13

Just rewrite it as d[‘old_key’] = ‘some new value’

You cannot have duplicate keys in the dict, assigning a value to an existing key will wipe out the old value.

Question 14

What if I want dict to be ordered?

Answer 14

use collections.OrderedDict which remembers insertion order:
from collections import OrderedDict
help(OrderedDict)

Question 15

d={}
d[‘key’] = 1
d[‘Key’] = 2

Are keys case-sensitive?

Answer 15

Yes, they’re!

> > > print d
{‘Key’: 2, ‘key’: 1}

Question 16

Which datatypes are allowed to be dict’s values?

Answer 16

Dict values can be any datatype.

Question 17

How to delete item from the dict by given key?

Answer 17

> > > del d[‘Key’] # doesn’t return nothing on success, else - KeyError
or
d.pop(key, “default_value”) # a. if key exists - remove it and b. return it; c. no such key? - keyerror or default value when provided.

Question 18

How to clear the whole dict to empty {} condition?

Answer 18

d.clear()

Question 19

How to get dict’s items as iterable value?

Answer 19

> > > d.items() # list of tuples like [(‘Key’, 2), (‘key’, 1)]
# or
d.iteritems() iterable generator obj to iterate through it, looks almost the same as the list above, but saves typical generator objects behavior

Question 20

How to get list of all dict’s keys?

Answer 20

> > > d.keys() # list of keys like [‘Key’, ‘key’]
d.iterkeys() # generator obj
iter(d) # almost the same generator obj, but iter(d) == d.iterkeys() comparison gives False

Question 21

How to get list of all dict’s values?

Answer 21

> > > d.values() # list of values like [2, 1]

|&raquo_space;> d.itervalues() # generator obj

Question 22

What can you use to get length of dictionary?

Answer 22

built-in len method:

|&raquo_space;> len(d) # returns number of items

Question 23

Is it possible to add custom behavior on KeyError key absence?

Answer 23

Yeah, two ways:

1. Use d.get(‘key’, ‘optional default value to return if no such key’)
2. overwrite it with __missing__ method for your custom dict class:

>>> class Counter(dict):
...     def \_\_missing\_\_(self, key):
...         return 0
>>> c = Counter()
>>> c['red']
0

Question 24

How to check for existence / absence of key in the dictionary?

Answer 24

> > > key in d # returns True/False if key is in d.keys()
key not in d
d.has_key(key) # BUT it is outdated, use statements above.

Question 25

How to copy dict to new one?

Answer 25

> > > new_d = d.copy() # shallow copy, but doesn’t work for nested complicated objects in values places. If you want deep copy - use import copy; help(copy.deepcopy) otherwise.

Question 26

How works dict.fromkeys method?

Answer 26

dict.fromkeys(sequence, value=None)
builds new dictionary with keys from iterable object and optional_default_value for them.

> > > dict.fromkeys(‘hello’, ‘default value’)
{‘h’: ‘default value’, ‘e’: ‘default value’, ‘l’: ‘default value’, ‘o’: ‘default value’}
d = dict.fromkeys([1,2], ‘default value’)
{1: ‘default value’, 2: ‘default value’}
dict.fromkeys(d.iterkeys(), ‘default value’)
{1: ‘default value’, 2: ‘default value’}

Keep in mind that duplicated or more keys gonna be overwritten.

Question 27

How to remove arbitrary item from dict?

Answer 27

d.popitem()

Question 28

What is item in dictionary?

Answer 28

Single one-to-one relationship of key: value.

Question 29

How to merge two dicts?

Answer 29

base_dict.update(other_dict) # update base_dict with contents of other_dict including rewrite for existing values. other_dict has higher precedence.

>>> base_dict = {"a": 1}
>>> other_dict = {"a": 2, "b": 2}
>>> base_dict.update(other_dict)
>>> base_dict
{'a': 2, 'b': 2}

Question 30

What are dict views?

Answer 30

The objects returned by d.viewkeys(), d.viewvalues() and d.viewitems() are view objects. They provide a dynamic view on the dictionary’s entries, which means that when the dictionary changes, the view reflects these changes.

Dictionary views can be iterated over to yield their respective data, and support membership tests.

Question 31

What are membership tests on dict views?

Answer 31

Membership tests are set-like checks on membership, intersection and differences between two dict views or two dict viewkeys:

> > > dictview & other
Return the intersection of the dictview and the other object as a new set.
dictview | other
Return the union of the dictview and the other object as a new set.
dictview - other
Return the difference between the dictview and the other object (all elements in dictview that aren’t in other) as a new set.
dictview ^ other
Return the symmetric difference (all elements either in dictview or other, but not in both) of the dictview and the other object as a new set.

Question 32

Is it possible to use trailing comma after last item pair in the dict?

Answer 32

Sure, also put a space between the trailing comma and the closing brace (acc. PEP8):

> > > role = {“By day”: “A typical programmer”,
“By night”: “Still a typical programmer”, }

Question 33

What is shallow copy?

Answer 33

A shallow copy constructs a new compound object and then (to the extent possible) inserts references into it to the objects found in the original.

import copy
copy.copy(x) # return shallow copy of x
# or 
your_dict.copy() # return shallow copy of your_dict

Question 34

What is deep copy?

Answer 34

A deep copy constructs a new compound object and then, recursively, inserts copies into it of the objects found in the original.

import copy
copy.deepcopy(x) # return deepcopy of x