Dictionary Key Lookup Lab
Build a dictionary as comma-separated key:value pairs, then try dictionary[key] or dictionary.get(key, default) and watch the map highlight the matching pair — or raise a KeyError if the key is missing.
Try a Lookup
● liveCreating Dictionary
A dictionary can be created as a collection of key–value pairs enclosed in curly braces { }. Each key is followed by a colon : and each pair is separated by a comma.
Here, the keys are the admission numbers (101, 102, 103, 104, 105) and the values are the names. Both keys and values can also be strings:
Keys must be hashable
A Python object must be hashable to be used as a key — it must have a fixed internal hash value throughout its lifetime. Only immutable types (integers, strings, tuples of immutable elements) are hashable.
Mutable types cannot be keys
Lists cannot be dictionary keys because they can change after creation, so they cannot maintain a stable hash value. Each key must also be unique.
Order is preserved
Although items are not accessed by numeric index, Python dictionaries preserve the order in which key–value pairs were added.
Associative arrays
Dictionaries are sometimes called associative arrays or hashes — the "index" is the key itself, which can be a string, number, or any other immutable type.
Creating with dict()
We can create an empty dictionary using {}, as empty_dict = {}. Printing it displays {} — empty dictionaries are useful when we want to start with no data and add items later.
Accessing Dictionary Elements
Dictionaries allow quick access to values based on their keys. The standard way to access a value is value = dictionary[key].
If we try to access a key that does not exist, Python raises a KeyError. The get() method works like square brackets, but instead of raising an error for a missing key, it returns None or a default value we specify.
Dictionaries with Compound Values
A single key may need to represent more than one piece of information. Dictionaries can use compound values, where the value associated with a key is a list, tuple, set, or even another dictionary.
11.3.1 Dictionary with Lists as Values
Lists are suitable when the data may change, because they are mutable. Individual items within these lists can be updated using indexing, and new items can be appended.
11.3.2 Dictionary with Tuples as Values
Tuples are preferred for fixed sets of items that should remain constant — since tuples are immutable, they protect the stored information from accidental modification.
11.3.3 Nested Dictionary
A nested dictionary contains another dictionary as its value — useful when one piece of information has several related details, such as employee records.
Updating and Managing Dictionary Data
A dictionary is a mutable data structure — its contents can be changed even after creation. Updating refers to modifying existing key–value pairs or adding new ones.
11.4.1 update() Method
Useful for merging one dictionary into another or adding multiple items at once. If the key exists, its value is updated; if not, a new key–value pair is added.
11.4.2 Adding a New Key-Value Pair
Assigning a value to a non-existent key automatically creates a new key–value pair — this is treated as an update because the dictionary's structure changes.
11.4.3 Updating Complete Values
11.4.4 Removing a Key-Value Pair
The del keyword removes a specific key and its value. If the key does not exist, del raises a KeyError.
Dictionary Functions and Operations
Python provides several methods to remove, update, and retrieve information from dictionaries.
| Function | Remarks |
|---|---|
| keys() | Returns a list-like view of all keys in the dictionary. |
| values() | Returns a list-like view of all values in the dictionary. |
| items() | Returns key–value pairs from the dictionary as tuples. |
| dictionary.update({key: value}) | Adds a new key–value pair or updates the value of an existing key. |
| dictionary.pop(key) | Removes the specified key from the dictionary and returns its value. |
| dictionary.popitem() | Removes and returns the last inserted key–value pair from the dictionary. |
Try a Dictionary Method
● liveAn Application of Dictionary — Shopping Cart
A shopping cart is a real-world example where items and their quantities can be stored and processed efficiently. Using a dictionary ensures each item is listed only once, while quantity is updated whenever the same item is added again.
add_to_cart(cart, input_list)
Adds a new item to the shopping cart. If the item already exists in the dictionary, its quantity is increased; if not, the item is added as a new key with the quantity as its value.
show_cart(cart)
Displays a complete summary of the cart: the number of different items, the total quantity of all products combined, and a tabular list of each item with its quantity.
The program is organised using functions, which makes the code clear, readable, and easy to maintain — add_to_cart() updates the dictionary on each entry, and show_cart() summarises it once all inputs are collected.
Set
A set is a collection of unique, unordered elements — its elements do not have fixed positions and cannot be accessed using indexes. Set elements must be immutable types such as numbers, strings, or tuples.
11.7.1 Creation of Set
{} makes a dictionary, not a set!
{} by itself creates an empty dictionary. To create an empty set, use the set() function: empty_set = set() — printing it displays set().
11.7.2 Set Functions and Operations
Given a = {1,2,3}, b = {3,4,5}, lng1 = {"Python","C","Java"}, lng2 = {"JavaScript","Python","Go"}:
| Function / Operator | Remarks | Example |
|---|---|---|
| union() or | | Combines all unique elements from both sets. | a|b → {1,2,3,4,5} |
| intersection() or & | Returns elements common to both sets. | a&b → {3} |
| difference() or - | Elements in a set that are not in the other set. | a-b → {1, 2} |
| add() | Adds a single new element to a set. | a.add(6) |
| remove() | Removes an element from the set (error if not present). | a.remove(3) |
| discard() | Removes an element from the set (no error if missing). | a.discard(10) |
| clear() | Removes all elements from the set. | a.clear() → set() |
Sets are especially useful when we need to find common items or unique items — operations such as union, intersection, and difference are very efficient with sets.
Set Operations Lab
Enter two comma-separated sets, pick an operation, and see how Python removes duplicates and computes the result.
Try a Set Operation
● liveApplication: Finding Unique Words in a Sentence
A sentence is split into words using split(), then converted with set() to remove duplicates.
Since sets are unordered, the exact order of elements in the output may vary each time the program runs — and note that "Hope" and "hope" are treated as different words because Python strings are case-sensitive.
Quick Recap
Tap a question to reveal the answer.
Why can't a list be used as a dictionary key?
Dictionary keys must be hashable — they need a fixed internal hash value that stays the same throughout their lifetime. Lists are mutable and can change after creation, so they cannot maintain a stable hash value, and are therefore not allowed as keys.
What is the difference between dictionary[key] and dictionary.get(key) when the key is missing?
dictionary[key] raises a KeyError if the key does not exist. dictionary.get(key) does not raise an error — it returns None, or a default value if one is supplied as a second argument.
Why are tuples preferred over lists for the values in country_info?
The country code, dialling code, and continent are fixed details that should not change. Tuples are immutable, so they protect this information from accidental modification — unlike lists, which are used when the stored data may need to change.
What does employee["Emp101"]["name"] mean in a nested dictionary?
It first looks up the key "Emp101" in the outer dictionary, which returns another dictionary. It then looks up the key "name" within that inner dictionary to retrieve the employee's name.
What happens when dictionary.update({key: value}) is called with a key that already exists?
The existing key's value is updated to the new value. If the key does not already exist, a new key–value pair is added to the dictionary instead.
What is the difference between pop(key) and popitem() on a dictionary?
pop(key) removes the specified key and returns its value. popitem() takes no key argument — it removes and returns the last inserted key–value pair as a tuple.
Why does {} create an empty dictionary and not an empty set?
Python reserves curly braces {} for dictionaries by default. To create an empty set, the set() function must be used instead — writing {} always produces an empty dictionary.
For a = {1,2,3} and b = {3,4,5}, what do a&b and a-b give?
a&b (intersection) gives {3} — the element common to both. a-b (difference) gives {1, 2} — the elements in a that are not in b.
What is the difference between remove() and discard() on a set?
Both remove an element from the set, but remove() raises an error if the element is not present, while discard() does nothing (no error) if the element is missing.
Why might the output of set("balloon") print its letters in a different order each time the program runs?
Sets are unordered collections in Python — they do not maintain a fixed sequence of elements, so the order in which the unique letters appear when printed is not guaranteed to be the same across runs.