Python Dictionaries and Sets

A dictionary stores pairs: a key identifies an item, and its value holds the information you want. A contact list is a useful model: a name leads to a phone number. A dictionary lookup uses a key, even when that key happens to be a number.

Write the pairs

ages = {"Ana": 31, "Ben": 27, "Cara": 35}
print(ages["Ben"])
print(len(ages))

This prints 27 and then 3. The colon joins each key to its value; commas separate the pairs. len counts pairs. Both {} and dict() create an empty dictionary.

Each key appears only once. In {"a": 1, "b": 2, "a": 3}, the later value for "a" replaces the earlier one, leaving {'a': 3, 'b': 2}. Two different keys may have the same value: {"Ana": "blue", "Ben": "blue"} still has two items.

Build from other data

Choose the form that matches the input:

colors = dict(red=1, blue=2)
coordinates = dict([("x", 10), ("y", 20)])
labels = dict(zip(["a", "b", "c"], [1, 2, 3]))

The first form makes string keys from the argument names. The second reads a sequence of two-item pairs. The third pairs corresponding elements of two lists, producing {'a': 1, 'b': 2, 'c': 3}. The strings in the first form are 'red' and 'blue', not variable lookups.

Pick usable keys

Dictionary keys must be hashable. Strings and numbers work, as do tuples made entirely of hashable items. Lists, dictionaries, and ordinary sets do not work as keys. For a location, use (2, 3), a tuple, instead of [2, 3], a list:

board = {(0, 0): "start", (2, 3): "treasure"}
print(board[(2, 3)])

This prints treasure. The parentheses make the coordinate pair one key. A tuple containing a list still fails the hashability rule. Dictionary values have no such restriction: a value can be a list, another dictionary, or any other type.

Equal numeric keys refer to the same entry. Because 1, 1.0, and True compare equal, {1: "one", 1.0: "float one"} holds one pair, with the value 'float one'. The string "1" is a separate key from the number 1.

Keep order and identity separate

Since Python 3.7, dictionaries preserve insertion order. The ages above appear as Ana, Ben, Cara when printed or looped over. They still have keys, not list positions: ages[0] asks for the key 0 and raises KeyError: 0.

Dictionaries are mutable. After backup = ages, both names refer to the same dictionary. Setting backup["Ana"] = 32 also changes the value reached through ages. To copy the outer dictionary, write backup = ages.copy() or backup = dict(ages). Separate outer dictionaries can still share nested lists and dictionaries.

A lookup should match what a missing key means in your program. Sometimes it signals a mistake. Sometimes it is normal, such as a product that has not been counted yet. Python gives you separate ways to handle those cases.

Read an existing value

stock = {"apples": 12, "pears": 0, "plums": 7}
print(stock["plums"])

The square-bracket lookup returns 7. Keys match exactly: "Plums" is different from "plums". Reading stock["kiwis"] raises KeyError: 'kiwis', because that key is absent. It does not supply an empty value or a count of zero.

Use this direct lookup when a key is required. An error then draws attention to incomplete data or a spelling mistake at the place it occurs.

Test for a key

The expression key in stock tests whether a key exists. "pears" in stock is True, although its stored value is zero. "kiwis" not in stock is also True.

item = "kiwis"
if item in stock:
    print(stock[item])
else:
    print("No stock record for", item)

Here the missing key leads to a message. The lookup happens only in the branch where the key exists.

Membership on a dictionary searches keys. 12 in stock is False; to ask whether any item has a stored value of 12, write 12 in stock.values(). The collection you put after in determines what is searched.

Read with a default

stock.get("kiwis") returns None without raising KeyError. Supply a second argument to choose a different default: stock.get("kiwis", 0) returns 0. Neither call inserts a new item. After both calls, the dictionary still contains only apples, pears, and plums.

The default replaces a missing lookup, not a stored value. stock.get("pears", 99) returns 0, because pears already has a value.

Do not confuse zero with missing

if stock.get("pears"): checks the truth of the returned value. Zero is false, so that branch is skipped. The same test also skips a missing key whose lookup returns None. To distinguish those cases, test key membership directly.

Process a whole order

prices = {"coffee": 3.5, "tea": 2.75}
order = ["tea", "coffee", "tea", "soda"]
total = 0
for item in order:
    if item in prices:
        total += prices[item]
    else:
        print("No price for", item)
print(total)

The first tea brings the total to 2.75, coffee brings it to 6.25, and the second tea brings it to 9.0. Soda produces the message No price for soda and adds nothing. A direct lookup on every pass would fail on soda; silently using a default price of zero would hide the missing price. The separate branch makes that missing information visible.

Dictionary updates use keys to identify what changes. Assigning a value can add a new pair or replace an old value. Removing a pair can also return information you need, such as the quantity removed from an inventory.

Add and replace

scores = {"Ana": 8}
scores["Ben"] = 6
scores["Ana"] = 9
scores["Ben"] += 2
print(scores)

The result is {'Ana': 9, 'Ben': 8}. Ben is added, Ana is updated, and then Ben's existing score increases. The += line first reads the old value, so it raises KeyError for a missing key. Dictionaries have no append method.

Combine dictionaries

update copies pairs into an existing dictionary. With those scores, scores.update({"Ben": 7, "Cara": 10}) changes Ben to 7 and adds Cara with 10.

Since Python 3.9, the merge operator can build a new dictionary:

left = {"x": 1, "y": 2}
right = {"y": 5, "z": 3}
merged = left | right
print(merged)

This prints {'x': 1, 'y': 5, 'z': 3}. The right side wins for a shared key. left stays unchanged; left |= right would update it in place.

update() returns None. Writing scores = scores.update(new_scores) changes the old dictionary and then makes scores refer to None. Call update on its own line. Assign the result of left | right when you want a new merged dictionary.

Remove pairs

For {"a": 1, "b": 2, "c": 3}, popitem() returns ('c', 3). This uses insertion order, not alphabetical order or the largest value.

Follow an inventory change

inventory = {"pens": 10, "pads": 4}
inventory["pens"] -= 3
inventory["clips"] = 50
removed = inventory.pop("pads")

The sale leaves 7 pens. Adding clips creates a new key. Removing pads stores 4 in removed, leaving {'pens': 7, 'clips': 50}. The return from pop lets the program use the removed quantity after the pair is gone.

Insert only when absent

setdefault(key, default) returns the existing value, or inserts and returns the default when the key is missing. For stock = {"apples": 12, "pears": 0, "plums": 7}, stock.setdefault("kiwis", 0) inserts kiwis and returns 0. stock.setdefault("apples", 99) returns 12 and leaves apples unchanged. This insertion is the difference from get.

Updating an existing key leaves its place unchanged. Starting with {"a": 1, "b": 2, "c": 3}, setting d["a"] = 10 keeps "a" first. Deleting "a" and inserting it again puts it after "c". A replacement value and a newly inserted pair affect order differently.

Choose a loop that gives you the part of each pair you need. A dictionary alone supplies keys. Its views can supply values or whole pairs, so you do not have to recover information that the loop could hand you directly.

Visit keys, values, or pairs

temps = {"Mon": 68, "Tue": 75, "Wed": 71}
for day, temp in temps.items():
    print(day, temp)

The temperatures are in degrees Fahrenheit. This prints Mon 68, Tue 75, and Wed 71 on separate lines, in insertion order. Each item is a two-element tuple that the loop unpacks into day and temp.

With for day in temps:, use temps[day] inside the loop when you need the matching value. If the program needs both parts each time, .items() usually states the job more clearly.

Understand views

keys(), values(), and items() return views, which reflect later changes to their dictionary. They are not lists and have no positional indexing. temps.keys()[0] raises TypeError. Convert to a list when you need a snapshot with positions: list(temps) gives ['Mon', 'Tue', 'Wed'].

Compute a total or find a matching key

sum(temps.values()) returns 214, and dividing by len(temps) gives an average of about 71.33. max(temps.values()) returns 75. To find which day has that value, write max(temps, key=temps.get), which returns 'Tue'.

The key= argument supplies a function used for comparison. Here Python visits day keys and calls temps.get for each one to obtain its temperature. Write the function name without calling it: temps.get, not temps.get(). If values tie, max returns the first key it encounters.

Sort a report

sorted(temps) returns keys in alphabetical order. sorted(temps.items()) returns pairs sorted by key. To sort day keys by temperature, use sorted(temps, key=temps.get), producing ['Mon', 'Wed', 'Tue']. Add reverse=True for ['Tue', 'Wed', 'Mon']. These calls return lists; they do not rearrange temps.

grades = {"Ana": 88, "Ben": 72, "Cara": 95}
passing = 0
for name, grade in grades.items():
    print(f"{name}: {grade}")
    if grade >= 75:
        passing += 1

The report prints each name with its grade. Ana and Cara meet the threshold, so passing ends at 2.

Remove entries without disrupting the scan

Do not add or delete keys while iterating directly over a dictionary. Changing its size can raise RuntimeError: dictionary changed size during iteration. Replacing an existing value is allowed.

To remove cooler days, use for day in list(temps): and delete temps[day] when its value is below 70. The loop walks a separate list of keys, leaving {'Tue': 75, 'Wed': 71} in the dictionary. Building a new filtered dictionary is another way to keep the scan separate from the changes.

A new dictionary often comes from a rule applied to existing data. Start with a loop you can explain, then use a comprehension when the same rule fits clearly into one expression.

Build one pair at a time

words = ["kiwi", "fig", "banana"]
lengths = {}
for word in words:
    lengths[word] = len(word)

Each pass chooses a word as the key and its length as the value. The result is {'kiwi': 4, 'fig': 3, 'banana': 6}. The dictionary is created before the loop so that earlier pairs remain available on later passes.

A dictionary comprehension expresses the same work:

lengths = {word: len(word) for word in words}

Read the for part to see what is visited, then the expression before it to see what pair is produced. The colon separates the key expression from the value expression. Without that colon, {word for word in words} builds a set.

Keep some items

An if clause filters the input:

grades = {"Ana": 88, "Ben": 72, "Cara": 95}
high_grades = {
    name: grade
    for name, grade in grades.items()
    if grade >= 80
}

Ana and Cara pass the test, giving {'Ana': 88, 'Cara': 95}. Ben's pair is left out. The input dictionary is unchanged; the result holds only pairs that meet the condition.

Transform values

A comprehension can keep the days while converting Fahrenheit readings to Celsius:

temps = {"Mon": 68, "Tue": 75, "Wed": 71}
celsius = {
    day: round((f - 32) * 5 / 9, 1)
    for day, f in temps.items()
}

The result is {'Mon': 20.0, 'Tue': 23.9, 'Wed': 21.7}. For Tuesday, subtracting 32 gives 43; multiplying by 5 and dividing by 9 gives about 23.89. round(..., 1) stores 23.9. The key stays the same while the value changes.

Pair lists carefully

dict(zip(names, scores)) pairs each name with the score at the same position. zip stops when the shorter input ends. Pairing ["Ana", "Ben", "Cara"] with [90, 85] gives {'Ana': 90, 'Ben': 85}. No error reports Cara's missing score, so check the input lengths when every name must have one.

Swap keys and values

favorites = {"Ana": "blue", "Ben": "red", "Cara": "blue"}
by_color = {color: name for name, color in favorites.items()}

The result is {'blue': 'Cara', 'red': 'Ben'}. Both Ana and Cara would need the same new key, so Cara's later pair replaces Ana's. Inversion preserves all pairs only when the old values are unique and hashable. A list value cannot become a dictionary key at all. To keep several names under one color, store a list of names under that color.

Use an ordinary loop when the job needs several statements, messages, or checks. A comprehension is useful because it makes a short rule visible; squeezing a larger procedure into it makes the rule harder to follow.

A frequency table answers how often each distinct item occurs. Its keys identify the items; its values are counters. The dictionary grows when a new item appears, while later appearances increase an existing count.

Trace a counter

counts = {}
for letter in "banana":
    if letter in counts:
        counts[letter] += 1
    else:
        counts[letter] = 1

The first letter creates 'b': 1. The next creates 'a': 1, and then 'n': 1. The next "a" raises its existing count to 2. After the last two letters, the dictionary is {'b': 1, 'a': 3, 'n': 2}. Its order records when each letter first appeared, not which letter is most common.

Use zero before the first occurrence

The two branches can become one assignment:

counts = {}
for letter in "banana":
    counts[letter] = counts.get(letter, 0) + 1

The right side reads the previous count, using zero when the key is missing, then adds one. The left side stores that new count. get itself does not insert anything; the assignment does.

Using only counts[letter] += 1 fails when a letter is new. Moving counts = {} inside the loop causes a different problem: each pass erases the earlier counts. Initialize once before processing the items.

Decide what counts as the same word

For text, case and punctuation affect the keys. The strings "The" and "the" differ, as do "dog." and "dog". Clean the forms before using them as keys:

text = "The cat saw the dog. The dog ran."
counts = {}
for word in text.lower().split():
    word = word.strip(".,!?")
    counts[word] = counts.get(word, 0) + 1

This produces {'the': 3, 'cat': 1, 'saw': 1, 'dog': 2, 'ran': 1}. lower handles case, split separates words at whitespace, and strip removes the listed punctuation characters from the ends. It does not remove punctuation from the middle of a word.

Find the most common items

For this nonempty table, max(counts, key=counts.get) returns 'the'. To find the two most common words, use sorted(counts, key=counts.get, reverse=True)[:2], giving ['the', 'dog']. Equal counts keep their original order when sorted.

The pattern also counts numbers or tuples. For rolls [3, 6, 3, 1, 6, 3], it builds {3: 3, 6: 2, 1: 1}. A value never observed has no entry. Read it with a default of zero when that is useful.

Recognize the library shortcut

from collections import Counter
letter_counts = Counter("banana")
print(letter_counts.most_common(1))
print(letter_counts["z"])

This prints [('a', 3)] and then 0. The import makes Counter available from Python's standard library. A Counter is a dictionary designed for counts: its keys are hashable items, and direct lookup of a missing item returns zero. Its displayed counts for this input are Counter({'a': 3, 'n': 2, 'b': 1}).

A dictionary can store a whole group under each key. The key names the category, and a list holds the items assigned to it. This keeps every member available for later totals, averages, or reports.

Build separate lists for groups

words = ["apple", "bean", "avocado", "beet", "corn"]
groups = {}
for word in words:
    first = word[0]
    if first not in groups:
        groups[first] = []
    groups[first].append(word)

For "apple", the program creates an empty list under "a" and appends the word. "bean" starts a separate "b" list. "avocado" joins the existing "a" list. The result is {'a': ['apple', 'avocado'], 'b': ['bean', 'beet'], 'c': ['corn']}.

The empty list is created only for a new label. Creating it on every pass would discard the earlier members of that group.

Shorten the initialization

groups.setdefault(word[0], []).append(word) performs the same grouping step. setdefault returns the existing list if there is one. Otherwise it stores the supplied empty list and returns it. The following append changes that returned list.

Another option creates lists automatically:

from collections import defaultdict
groups = defaultdict(list)
for word in words:
    groups[word[0]].append(word)

Pass list, the function that creates a fresh list, without parentheses. On a missing-key lookup, this defaultdict creates and stores a new empty list. Even a read such as groups["z"] inserts that missing key. Use "z" in groups when you only want to check whether a group exists.

Keep the lists independent

groups = dict.fromkeys(["a", "b"], []) places the same list under both keys. Appending 1 through groups["a"] then gives {'a': [1], 'b': [1]}. The lists are shared, not copied.

To start with separate lists, use {key: [] for key in keys}, setdefault with a fresh [], or defaultdict(list). Each new category must receive its own list object.

Add amounts per category

Counting adds one per occurrence. A category total adds each item's amount:

expenses = [("food", 12.5), ("travel", 30),
            ("food", 7.25), ("books", 18)]
totals = {}
for category, amount in expenses:
    totals[category] = totals.get(category, 0) + amount

Food starts at 12.5 and then gains 7.25, ending at 19.75. Travel totals 30 and books total 18. Storing amount alone would replace the previous total instead of adding to it.

Average or deduplicate a group

For scores = {"A": [80, 90], "B": [70]}, loop over scores.items() and calculate sum(values) / len(values). Group A averages 85.0; group B averages 70.0. Test if values: before dividing so an empty group is handled separately.

When repeats should disappear within each group, use sets as values. tags.setdefault(post, set()).add(tag) creates a set for a new post and adds its tag. A repeated tag remains one element; a list would keep each occurrence.

A record brings related fields together, such as a student's age, major, and grades. A nested dictionary stores another dictionary as a value. The outer keys can identify records, while the inner keys identify fields.

Read one level at a time

students = {
    "ana": {"age": 19, "major": "math", "grades": [88, 92]},
    "ben": {"age": 22, "major": "history", "grades": [75, 81, 79]},
}

students["ana"] gives Ana's record dictionary. Adding ["major"] reads its major, so students["ana"]["major"] returns 'math'. For Ben's latest grade, students["ben"]["grades"][-1] reaches the record, then its list, then the last list element, 79.

Each lookup acts on the object returned by the previous lookup. The same square-bracket syntax can mean a dictionary key at one level and a list position at another.

Change a field or add a record

students["ana"]["age"] = 20
students["ben"]["email"] = "ben@example.com"
students["cara"] = {"age": 21, "major": "art", "grades": []}
students["cara"]["grades"].append(90)

The first two lines change or add fields inside existing records. The third adds a whole record under a new ID. The fourth reaches Cara's grades list and appends a score to it.

Assigning students["dev"]["age"] = 30 fails because the outer lookup for "dev" happens first and raises KeyError: 'dev'. Create the record before assigning its fields.

For an optional read, students.get("dev", {}).get("age") returns None. The first default is an empty dictionary, so the second get has a dictionary to read even when the record is absent. For these records, each outer value is itself a dictionary.

Choose a shape that fits access

A list of dictionaries keeps rows in order:

rows = [{"name": "Ana", "city": "Austin"},
        {"name": "Ben", "city": "Denver"}]
print(rows[1]["city"])

This prints Denver: list index first, field key second. A dictionary of lists, such as {"A": [80, 90], "B": [70]}, stores several values per label. These structures can be combined when a record needs both named fields and an ordered list.

When names uniquely identify rows, build by_name = {row["name"]: row for row in rows}. Then by_name["Ben"] finds Ben's row directly. The values are the existing row dictionaries, so edits through this index also affect those rows. If names repeat, a later row replaces an earlier one under that key.

Copy nested data deliberately

backup = students shares the entire dictionary. backup = students.copy() makes a separate outer dictionary but keeps the same inner records. After that shallow copy, backup["ana"]["age"] = 99 also changes Ana's age in students.

import copy
independent = copy.deepcopy(students)
independent["ana"]["age"] = 25

For these nested dictionaries and lists, the deep copy makes separate inner objects as well. Changing the copied age leaves the original age alone. Use consistent field names across records so the same lookup code works for each record.

Processing nested data means keeping track of which level the loop has reached. An outer loop chooses a record. A field lookup reaches a value inside that record, and an inner loop can then visit the elements of a stored list.

Summarize one record per pass

students = {
    "ana": {"major": "math", "grades": [88, 92]},
    "ben": {"major": "history", "grades": [75, 81, 79]},
    "cara": {"major": "art", "grades": []},
}
for name, info in students.items():
    grades = info["grades"]
    major = info["major"]
    if grades:
        average = sum(grades) / len(grades)
        print(f"{name}: {major}, average {average:.1f}")
    else:
        print(f"{name}: {major}, no grades")

Ana's scores total 180, so her average is 90.0. Ben's total is 235 over three scores, giving about 78.33; the format :.1f displays 78.3. Cara's list is empty, so the program prints cara: art, no grades without dividing by zero.

Assigning grades and major inside the loop gives each name the current record's values. The average also belongs inside the loop: it must be calculated separately for each student.

Read optional fields

info.get("email", "no email") supplies text for an optional email field. A direct info["email"] would raise KeyError for a record without it. A default belongs at the level where the field may be missing. The outer dictionary's get would search student IDs, not email fields.

Select records

math_students = []
for name, info in students.items():
    if info["major"] == "math":
        math_students.append(name)

This produces ['ana']. The condition reads a field of the current record; the appended value is the outer key. If the report needed whole records, it could append info instead. Decide which kind of result the next part of the program needs.

Visit every stored score

count = 0
for info in students.values():
    for grade in info["grades"]:
        if grade > 80:
            count += 1

The inner loop visits Ana's 88 and 92, then Ben's 75, 81, and 79. Cara's empty list adds no passes. Three scores exceed 80: 88, 92, and 81. The count is initialized outside both loops because it describes all students together. Resetting it inside the outer loop would keep only the last record's count.

Count records by a field

majors = {}
for info in students.values():
    major = info["major"]
    majors[major] = majors.get(major, 0) + 1

Each record contributes one to its major. For Ana and Ben alone, the result is {'math': 1, 'history': 1}; including Cara adds 'art': 1. To total or group a different field, keep the outer record loop and change the value it contributes.

For readable reports, print one formatted line per record instead of the whole nested dictionary. In an f-string, store a field in a variable first, as above, or use the opposite quote style inside the braces, as in f"{name}: {info['major']}".

A set records which distinct values are present. It keeps each element once and has no guaranteed order. Sets suit membership checks and removing duplicates when the number of occurrences is unimportant.

Create a set

colors = {"red", "green"}
numbers = set([3, 1, 3, 2, 1])
print(len(numbers))
print(sorted(numbers))

This prints 3 and then [1, 2, 3]. Repeated inputs become a single element. An empty set is set(); {} makes an empty dictionary.

set("banana") visits the string's characters, leaving the distinct letters "a", "b", and "n". {"banana"} supplies the whole string as one element. As with dictionary keys, equal numeric values count once: {1, 1.0, True} has one element.

Elements must be hashable. Numbers, strings, and tuples of hashable values work; lists, dictionaries, and ordinary sets do not. Use (1, 2) for a coordinate element instead of [1, 2]. A frozenset is an immutable set and can itself be a set element or dictionary key.

Work without positions

colors[0] raises TypeError because a set has no positions. Its printed order is not guaranteed, and string elements may print in a different order on another run. sorted(colors) produces a new sorted list when the elements can be compared. It does not give the set an order.

Change the members

add("blue") adds one string. update(["blue", "gold"]) adds two strings. Using update("blue") instead adds separate characters, because a string is iterable. Sets have no append method.

Preserve first appearances when needed

list(set(items)) removes duplicates but loses their original order. If first appearances matter, use dictionary insertion order:

items = [3, 1, 3, 2, 1]
unique = list(dict.fromkeys(items))
print(unique)

This prints [3, 1, 2]. The values become dictionary keys, so each appears once in the order first encountered.

You can also keep the roles explicit:

seen = set()
unique = []
for item in items:
    if item not in seen:
        seen.add(item)
        unique.append(item)

The set answers whether an item has appeared; the list keeps first appearances in order. Both forms require hashable input items.

Count distinct items or check membership

For the eight words in "the cat saw the dog the dog ran".split(), len(set(words)) is 5: the, cat, saw, dog, and ran. This counts different words, not their frequencies.

A blocked-sender set lets sender in blocked answer whether an address is present. For large collections, set and dictionary membership is typically much faster than searching a list one item at a time.

Set operations express questions about membership in two collections. Use the operation that matches the question: anyone in either collection, only shared members, or members left after exclusions.

Read the four operations

Suppose the course enrollments are:

python = {"Ana", "Ben", "Cara", "Dev"}
sql = {"Ben", "Dev", "Eli"}

Union includes all five students once. Intersection keeps only the two shared students. Difference starts from the left set and excludes anything in the right set. Reversing the difference changes the question: sql - python contains only Eli. Symmetric difference keeps the two nonoverlapping parts; it equals union minus intersection.

The named forms are python.union(sql), python.intersection(sql), python.difference(sql), and python.symmetric_difference(sql).

Test a relationship

a <= b asks whether every member of a belongs to b. That is the subset test. a < b also requires b to have at least one extra member, making a a proper subset. a >= b and a > b test the corresponding superset relationships.

print({"Ben"} <= sql)
print(sql <= sql)
print(sql < sql)
print(python.isdisjoint(sql))

These print True, True, False, and False. A set is a subset of itself but not a proper subset of itself. Disjoint sets have no shared member; Python and SQL share Ben and Dev. The method forms issubset and issuperset also return Boolean results.

Keep results separate or change a set

result = a | b creates a new set, leaving both inputs unchanged. The in-place forms a |= b, a &= b, a -= b, and a ^= b change a to the union, intersection, difference, or symmetric difference. Any other name referring to that same set sees the change.

Named set methods accept iterables such as lists. python.union(["Fay"]) works. The ordinary set operators require set operands: {"a"} | ["b"] raises TypeError.

Use | to combine sets, not +. Also keep & separate from and: {1, 2} and {3} returns {3} because the left set is truthy. It does not calculate common members.

Find missing requirements

required = {"python", "sql", "git"}
skills = {"python", "excel", "git"}
missing = required - skills
extra = skills - required
qualified = required <= skills

The missing set contains "sql"; the extra set contains "excel". The intersection contains "git" and "python". qualified is False, because at least one required skill is absent. A candidate may have many skills and still fail the subset test: the particular required members must all be present.

Choose a collection by the job the program must do with it. Order, repeats, named lookup, and changeability are separate needs. A program may use several collection types because different parts of its data serve different jobs.

Compare the built-in collections

A list suits a sequence of events: the order matters, and the same event can occur more than once. A tuple suits a fixed group of related values, such as coordinates. A tuple can hold a mutable object, so the tuple's fixed slots do not make every contained object immutable. Only a tuple of hashable items can be a dictionary key or set element.

A dictionary suits named information: an ID leads to a record or a product name leads to a quantity. Its values can repeat and can be whole collections. A set suits a membership question: the program needs to know whether an ID is present, not a separate value for it.

Preserve the information the task needs

Converting [1, 2, 1] to a set loses both the repeated occurrence and the sequence. That is useful for a distinct-item list, but wrong for a complete event log. A dictionary such as {"reader": True, "editor": True} can often become {"reader", "editor"} when the values carry no additional information. If each role needs a permission level, keep the dictionary.

Equality follows each collection's meaning. [1, 2] == [2, 1] is False, because sequence order differs. {1, 2} == {2, 1} is True. Dictionaries with equal key-value pairs compare equal even if the keys were inserted in different orders. Their insertion order affects iteration, not that equality test.

Compare dictionary keys as sets

store_a = {"pens": 10, "pads": 4, "ink": 2}
store_b = {"pads": 7, "clips": 30, "ink": 5}
common = store_a.keys() & store_b.keys()
only_a = store_a.keys() - store_b.keys()

The common keys are "ink" and "pads"; only_a contains "pens". These are products carried, regardless of their quantities. The two stores have different amounts of ink, but ink is still a shared key.

Dictionary key views support set operations because keys are unique and hashable. Value views do not support these operators: store_a.values() & {1} raises TypeError. Converting values to a set is possible when they are hashable, but discards repeated values and asks a different question from comparing product keys.

Combine shapes in one program

A library can use a dictionary from book IDs to record dictionaries, a set of currently borrowed IDs, and a list of today's checkouts in time order. A tuple such as ("Dune", 1965) holds a title and year together. The dictionary finds a book's details; the set checks borrowing status; the list preserves the day's history.