Collections

This is a cheatsheet of Python’s collection classes.

Summary Comparison

Action	List	Tuple	Set	Dictionary
Create	a = [ ] a = list() a = [1, 2]	t = () # empty t = tuple() t = (1, 2)	s = set( ) s = {1, 2}	d = { } d = dict( ) d = { k1:v1, k2:v2 } d = dict(dict2)
Add Insert	a.append(obj) a.insert(idx, obj)	t = t + ( obj, )	s.add(3)	d['b'] = 2
Contains	if obj in a	if obj in t	if obj in s	if key in d
Remove	a.remove(obj) a.pop(index) a.pop()	NA	s.remove(obj) s.pop() s.discard('value')	d.pop(key) d.pop(key, def_val) del d[key] d.popitem()
Get Set	v = a[index]	v = t[index] i1, i2 = t i1, *mid, i2 = t i1, *last = t	NA	v = d['a'] v = d.get('a', v)

List

Operation	API
Create	my_list = [] my_list = [x ** 2 for x in [1, 3, 5, 7]] # comprehension my_list = list() # constructor my_list = list(iterable) # construct list from any iterable
Add	my_list.append(5) my_list.append(list2) # my_list has list2 as the last item
Remove	my_list.remove('value') # inplace, no return value last = my_list.pop() # return and inplace remove last item in the list value = my_list.pop(index) del list[index] # inplace, no return value
Contains	if 'value' in my_list: # in operator
Get	n = my_list[index]
Set	my_list[index] = value
Size	len(my_list) # len is built-in function
Insert	my_list.insert(index, value)
Extend	my_list.extend(list2) # add all items in list2, not list2 as an item my_list += [5, 4, 3] # extends the list with items in the other list # don’t confuse append with extend
Remove all	my_list.clear() my_list = [] del my_list[:]
indexOf	my_list.index('value') my_list.index('value', startIndex) my_list.index('value', startIndex, endIndex)
Sort	my_list.sort() # inplace sorting my_list = sorted(my_list) # reassignment
Reverse	rev_list = my_list.reverse() rev_list = my_list[::-1] rev_list = list(reversed(my_list)) # reversed returns an iterator sorted_rev_list = sorted(my_list, reverse=True)
Copy	cloned_list = list.copy() # recall reference semantics

Tuple

Operation	API
Create	t = tuple() t = (1, ) # need the comma to differentiate from an integer t = (1, 2) # constructor t = tuple(iterable) # construct tuple from any iterable
Add	t = t + (3, ) # tuples are immutable! t += (3, ) # same as above with shorthand operator t = (*t, 3) # same as above, but uses unpacking
Remove	# cannot remove since tuples are immutable t = t[1:] # use slicing to create new tuple
Contains	if 'value' in t: # in operator
Get	n = t[index]
Set	NA # cannot set since tuples are immutable
Size	len(t) # len is built-in function
Insert	# cannot insert since tuples are immutable # we can concatenate with the + operator t = t[index] + (3, ) + t[index:]
Extend	# + operator will concatenate which is extend t += t2 # concatenate add all items in t2 t += (*t2, ) # same as above but using unpacking
Remove all	t = tuple() # construct an empty tuple
indexOf	t.index('value') t.index('value', startIndex) t.index('value', startIndex, endIndex)
Sort	t = tuple(sorted(t)) # sorted returns a list, recreate tuple
Reverse	rev_t = t[::-1] # fastest rev_t = tuple(reversed(t)) # reversed returns an iterator sorted_rev_t = tuple(sorted(t, reverse=True))
Copy	cloned_t = tuple(t) # recall reference semantics cloned_t = (*t, ) # copy via unpacking

Set

Operation	API
Create	my_set = set() # constructor my_set = set(iteratable) # create set from any iterable my_set = { x**2 for x in range(11) } # comprehension # Note: empty { } creates a dictionary not a set
Add	my_set.add(5) my_set.update({1, 2, 3}) # inplace union of the sets
Remove	my_set.remove('value') # raise error if not found my_set.discard('value') # no error raised if not found my_set.pop() # remove a RANDOM item from the set my_set.difference_update(set2) # inplace removes set2 items diff_set = my_set - remove_set # difference operator
Contains	if value in my_set: # in operator
Size	len(my_set) # len is built-in function
Remove All	my_set.clear() my_set = set()
Union	my_set = set1.union(set2) # union does not change the set my_set = s1 | s2 # same as above
Intersection	my_set = s1.intersection(s2) # does not change the set my_set = s1 & s2 # same as above
Difference	my_set = s1.difference(s2) # difference does not change the set my_set = s1 - s2 # same as above
Copy	clone_set = my_set.copy() # recall reference semantics
Get	NA Can only determine if item is in set or not
Set	NA Cannot set the value of a specific element
Insert	NA Just add the object to the set. There is no order of elements.
indexOf Sort Reverse	NA There is no order in a set

Dictionary

Operation	API
Create	d = dict() d = { } # empty dictionary d = {k1:v1} # initialize a set with 1 key/value pair
Add	d[key] = value # adds or sets the value d.update(dict2) # inplace addition of all items in dict2 d = { **d1, **d2 } # creates with all unpacked items of d1 & d2
Remove	last = d.popitem() # return & remove the last item inserted item = d.pop(key) # return value & remove item at key del d[key] # remove item at key, returns None
Contains	if key in d: # in operator. Finds key only
Get	value = d[key] # raises error if no key value = d.get(key, def_value) # avoids error if not found
Set	d[key] = value # adds or sets the value d.setdefault(key, def_value) # sets only if key not in d. returns d[key]
Size	len(d) # len is built-in function
Insert	NA # dictionary order cannot change
Extend	d.update(dict2) # inplace addition of all items in dict2
Remove All	d.clear() d = dict()
indexOf	# No easy way. Must iterate through values key = [k for k, v in d.items() if v == target][0] # error if not present
Sort	# python retains original order of dictionary. recreate dictionary sorted_d = { key:d[key] for key in sorted(d.keys()) }
Reverse	rev_dict = { k:d[k] for k in reversed(d.keys())}
Copy	clone_dict = d.copy()
Misc	my_dict.keys() my_dict.values() my_dict.items()

Simple Comprehensions

# list comprehension
my_list = [ n for n in range(100) ]

# set comprehension
my_set = { n for n in range(100) }

# dictionary comprehensions & construction
my_dict = { key: value for key, value in zip(range(10), range(10, 20)) } 
my_dict = dict( zip([k for k in range(10)], [v for v in range(10,20)]))
values = [ 6, 4, 2, 1, 3, 5]
my_dict = { key: values[key] for key in range(len(values)) }
my_dict = { key: value for key, value in enumerate(values) }

# There is NO tuple comprehension