1/29/25, 12:01 PM about:blank

Cheat Sheet: Python Data Structures Part-2

Dictionaries
Package/Method Description Code Example

Example:
A dictionary is a built-in data type that represents a
Creating a
collection of key-value pairs. Dictionaries are enclosed dict_name = {} #Creates an empty dictionary
Dictionary
in curly braces {}. person = { "name": "John", "age": 30, "city": "New York"}

Syntax:

Value = dict_name["key_name"]
You can access the values in a dictionary using their
Accessing Values Example:
corresponding keys.
name = person["name"]
age = person["age"]

Syntax:

dict_name[key] = value
Inserts a new key-value pair into the dictionary. If the
Add or modify key already exists, the value will be updated; otherwise, Example:
a new entry is created.
person["Country"] = "USA" # A new entry will be created.
person["city"] = "Chicago" # Update the existing value for the same key

Syntax:
del dict_name[key]
Removes the specified key-value pair from the
del
dictionary. Raises a KeyError if the key does not exist. Example:
del person["Country"]

Syntax:

The update() method merges the provided dictionary dict_name.update({key: value})

update() into the existing dictionary, adding or updating key-
value pairs. Example:
person.update({"Profession": "Doctor"})

Syntax:

The clear() method empties the dictionary, removing all dict_name.clear()

clear() key-value pairs within it. After this operation, the
dictionary is still accessible and can be used further. Example:

grades.clear()

Example:
You can check for the existence of a key in a dictionary
key existence if "name" in person:
using the in keyword print("Name exists in the dictionary.")

Syntax:
new_dict = dict_name.copy()
Creates a shallow copy of the dictionary. The new
copy() dictionary contains the same key-value pairs as the Example:
original, but they remain distinct objects in memory.
new_person = person.copy()
new_person = dict(person) # another way to create a copy of dictionary

Syntax:

Retrieves all keys from the dictionary and converts them keys_list = list(dict_name.keys())
keys() into a list. Useful for iterating or processing keys using
list methods. Example:

person_keys = list(person.keys())

values() Extracts all values from the dictionary and converts them Syntax:
into a list. This list can be used for further processing or

about:blank 1/3
1/29/25, 12:01 PM about:blank
analysis. values_list = list(dict_name.values())

Example:

person_values = list(person.values())

Syntax:

Retrieves all key-value pairs as tuples and converts them items_list = list(dict_name.items())
items() into a list of tuples. Each tuple consists of a key and its
corresponding value. Example:

info = list(person.items())

Sets
Package/Method Description Code Example

Syntax:
set_name.add(element)
Elements can be added to a set using the `add()` method. Duplicates are automatically
add()
removed, as sets only store unique values. Example:

fruits.add("mango")

Syntax:
set_name.clear()
The `clear()` method removes all elements from the set, resulting in an empty set. It
clear()
updates the set in-place. Example:

fruits.clear()</td>

Syntax:
new_set = set_name.copy()
The `copy()` method creates a shallow copy of the set. Any modifications to the copy
copy()
won't affect the original set. Example:
new_fruits = fruits.copy()

Example:
A set is an unordered collection of unique elements. Sets are enclosed in curly braces
Defining Sets empty_set = set() #Creating an Empty
`{}`. They are useful for storing distinct values and performing set operations. Set fruits = {"apple", "banana", "orange"}

Syntax:
set_name.discard(element)
Use the `discard()` method to remove a specific element from the set. Ignores if the
discard()
element is not found. Example:

fruits.discard("apple")

Syntax:
is_subset = set1.issubset(set2)
The `issubset()` method checks if the current set is a subset of another set. It returns
issubset()
True if all elements of the current set are present in the other set, otherwise False. Example:

is_subset = fruits.issubset(colors)

Syntax:

The `issuperset()` method checks if the current set is a superset of another set. It is_superset = set1.issuperset(set2)
issuperset() returns True if all elements of the other set are present in the current set, otherwise
False. Example:

is_superset = colors.issuperset(fruits)

Syntax:

The `pop()` method removes and returns an arbitrary element from the set. It raises a removed_element = set_name.pop()
pop() `KeyError` if the set is empty. Use this method to remove elements when the order
Example:
doesn't matter.
removed_fruit = fruits.pop()

about:blank 2/3
1/29/25, 12:01 PM about:blank

Syntax:
set_name.remove(element)
Use the `remove()` method to remove a specific element from the set. Raises a
remove()
`KeyError` if the element is not found. Example:
fruits.remove("banana")

Syntax:
union_set = set1.union(set2)
intersection_set = set1.intersection(set2)
difference_set = set1.difference(set2)
sym_diff_set = set1.symmetric_difference(set2)
Perform various operations on sets: `union`, `intersection`, `difference`, `symmetric
Set Operations
difference`. Example:

combined = fruits.union(colors)
common = fruits.intersection(colors)
unique_to_fruits = fruits.difference(colors)
sym_diff = fruits.symmetric_difference(colors)

Syntax:
set_name.update(iterable)
The `update()` method adds elements from another iterable into the set. It maintains
update()
the uniqueness of elements. Example:
fruits.update(["kiwi", "grape"])

© IBM Corporation. All rights reserved.

about:blank 3/3