Dictionaries

Python dicts are a heterogeneous, ordered*, mutable containers of key value pairs. Each entry consists of a key (immutable) and a value (anything) - they are designed for the efficient lookup of values using a key.

{'abc': 123, 'def': 456}

{'abc': 123, 'def': 456}

dict([('abc', 123), ('def', 456)])

{'abc': 123, 'def': 456}

dict(hello=123, world=456) # can't use `def` here as it is reserved keyword

{'hello': 123, 'world': 456}

Allowed key values

The keys for a dict must be immutable objects (e.g. integer, double, string, or tuple). Values may be of any type (mutable or immutable).

{1: "abc", 1.1: (1,1), "one": ["a","n"], (1,1): lambda x: x**2}

{1: 'abc', 1.1: (1, 1), 'one': ['a', 'n'], (1, 1): <function <lambda> at 0x11cca6e80>}

{[1]: "bad"}

TypeError: unhashable type: 'list'

{(1, [2]): "bad"}

TypeError: unhashable type: 'list'

dict “subsetting”

The [] operator exists for dicts but is used for key-based value look ups,

x = {1: 'abc', 'y': 'hello', (1,1): 3.14159}

x[1]

'abc'

x['y']

'hello'

x[(1,1)]

3.14159

x[0]

KeyError: 0

x['def']

KeyError: 'def'

Value inserts & replacement

Since dictionaries are mutable, it is possible to insert new key value pairs as well as replace the value associated with an existing key.

x = {1: 'abc', 'y': 'hello', (1,1): 3.14159}

x['def'] = -1
x

{1: 'abc', 'y': 'hello', (1, 1): 3.14159, 'def': -1}

x['y'] = 'goodbye'
x

{1: 'abc', 'y': 'goodbye', (1, 1): 3.14159, 'def': -1}

Removing keys

x

{1: 'abc', 'y': 'goodbye', (1, 1): 3.14159, 'def': -1}

del x[(1,1)]
x

{1: 'abc', 'y': 'goodbye', 'def': -1}

x.clear()
x

{}

x[1] = None
x

{1: None}

Other common methods

x = {1: 'abc', 'y': 'hello'}

len(x)

2

list(x)

[1, 'y']

tuple(x)

(1, 'y')

1 in x

True

'hello' in x

False

x.keys()

dict_keys([1, 'y'])

x.values()

dict_values(['abc', 'hello'])

x.items()

dict_items([(1, 'abc'), ('y', 'hello')])

x | {(1,1): 3.14159}

{1: 'abc', 'y': 'hello', (1, 1): 3.14159}

x | {'y': 'goodbye'}

{1: 'abc', 'y': 'goodbye'}

Iterating dictionaries

Dictionaries can be used with for loops (and comprehensions). They will both iterate over the keys only. To iterate over the keys and values use items().

for z in {1: 'abc', 'y': 'hello'}:
  print(z)

1
y

[z for z in {1: 'abc', 'y': 'hello'}]

[1, 'y']

for k,v in {1: 'abc', 'y': 'hello'}.items():
  print (k,v)

1 abc
y hello

[(k,v) for k,v in {1: 'abc', 'y': 'hello'}.items()]

[(1, 'abc'), ('y', 'hello')]

Exercise 1

Write a function that takes two dictionaries as arguments and merges them into a single dictionary. If there are any duplicate keys, the value from the second dictionary should be used.

x = {"a": 1, "b": 2, "c": 3}
y = {"c": 5, "d": 6, "e": 7}

def merge(d1, d2):
  return None

Sets

In Python a set is a heterogeneous, unordered, mutable container of unique immutable elements.

A set is constructed using {} (without using :) or via set(),

{1,2,3,4,1,2}

{1, 2, 3, 4}

set((1,2,3,4,1,2))

{1, 2, 3, 4}

set("mississippi")

{'i', 'p', 'm', 's'}

{1,2,[1,2]}

TypeError: unhashable type: 'list'

Subsetting sets

Sets do not use the [] operator for element checking or removal,

x = set(range(5))
x

{0, 1, 2, 3, 4}

x[4]

TypeError: 'set' object is not subscriptable

del x[4]

TypeError: 'set' object doesn't support item deletion

Modifying sets

Sets have their own special methods for adding and removing elements,

x = set(range(5))
x

{0, 1, 2, 3, 4}

x.add(9)
x

{0, 1, 2, 3, 4, 9}

x.remove(9)
x.remove(8)

KeyError: 8

x

{0, 1, 2, 3, 4}

x.discard(0)
x.discard(8)
x

{1, 2, 3, 4}

Set operations

x = set(range(5))
x

{0, 1, 2, 3, 4}

3 in x

True

x.isdisjoint({1,2})

False

x <= set(range(6))

True

x >= set(range(3))

True

5 in x

False

x.isdisjoint({5})

True

x.issubset(range(6))

True

x.issuperset(range(3))

True

Set operations (cont)

x = set(range(5))
x

{0, 1, 2, 3, 4}

x | set(range(10))

{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

x & set(range(-3,3))

{0, 1, 2}

x - set(range(2,4))

{0, 1, 4}

x ^ set(range(3,9))

{0, 1, 2, 5, 6, 7, 8}

x.union(range(10))

{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

x.intersection(range(-3,3))

{0, 1, 2}

x.difference(range(2,4))

{0, 1, 4}

x.symmetric_difference(range(3,9))

{0, 1, 2, 5, 6, 7, 8}

More comprehensions

It is possible to use comprehensions with both sets and dicts,

Set comprehension,

{x.lower() for x in "The quick brown fox jumped a lazy dog"}

{'h', 'u', 'k', 'm', 'd', 'y', 'z', ' ', 'l', 'b', 'r', 'w', 'e', 'c', 'a', 'g', 'x', 'i', 't', 'j', 'f', 'o', 'p', 'q', 'n'}

names = ["Alice", "Bob", "Carol", "Dave"]
grades = ["A", "A-", "A-", "B"]

{name: grade for name, grade in zip(names, grades)}

{'Alice': 'A', 'Bob': 'A-', 'Carol': 'A-', 'Dave': 'B'}

tuple comprehensions

Note that tuple comprehensions do not exist,

# Not a tuple
(x**2 for x in range(5))

<generator object <genexpr> at 0x11cd99a40>

the above code constructs a generator (more on these later).

If necessary you can use a list comprehension and then cast to a tuple,

# Is a tuple - via casting a list to tuple
tuple([x**2 for x in range(5)])

(0, 1, 4, 9, 16)

tuple(x**2 for x in range(5))

(0, 1, 4, 9, 16)

deques (double ended queue)

Deques are heterogeneous, ordered, mutable collections of elements and behave in much the same way as lists. They are designed to be efficient for adding and removing elements from the beginning and end of the collection.

from collections import deque
deque(("A",2,True))

deque(['A', 2, True])

growing and shrinking

x = deque(range(3))
x

deque([0, 1, 2])

x.appendleft(-1)
x.append(3)
x

deque([-1, 0, 1, 2, 3])

x.popleft()

-1

x.pop()

3

x

deque([0, 1, 2])

maxlen

deques can be constructed with an optional maxlen argument which sets their maximum size - if this is exceeded values from the opposite end will be dropped.

x = deque(range(3), maxlen=4)
x

deque([0, 1, 2], maxlen=4)

x.append(0)
x

deque([0, 1, 2, 0], maxlen=4)

x.append(0)
x

deque([1, 2, 0, 0], maxlen=4)

x.append(0)
x

deque([2, 0, 0, 0], maxlen=4)

x.appendleft(-1)
x

deque([-1, 2, 0, 0], maxlen=4)

x.appendleft(-1)
x

deque([-1, -1, 2, 0], maxlen=4)

x.appendleft(-1)
x

deque([-1, -1, -1, 2], maxlen=4)

Big-O notation

Common terminology

Note that these terms ignore all smaller order terms as well as the constant in front of the highest order term (this can be signficant in practice).

Vector / Array

Linked List

Hash table

Time complexity in Python

Exercise 2

For each of the following scenarios, which is the most appropriate data structure and why?

• A fixed collection of 100 integers.

• A queue (first in first out) of customer records.

• A stack (first in last out) of customer records.

• A count of word occurrences within a document.

• The heights of the bars in a histogram with even binwidths.

Data structures in R

To tie things back to Sta 523 - the following R objects are implemented using the following data structures.

• Atomic vectors - Array of the given type (int, double, etc.)

• Generic vectors (lists) - Array of SEXPs (R object pointers)

• Environments - Hash map with string-based keys

• Pairlists - Linked list