Cheat Sheet: Python Data Structures Part-2

Dictionaries
Package/Method Description Code Example

Example:
dict_name = {} #Creates an empty dictionary
person = { "name": "John", "age": 30, "city": "New York"}

A dictionary is a built-in data type that represents a

Creating a
collection of key-value pairs. Dictionaries are
Dictionary
enclosed in curly braces {}.

Syntax:
Value = dict_name["key_name"]

You can access the values in a dictionary using their

Accessing Values
corresponding keys. Example:
name = person["name"]
age = person["age"]

Syntax:
dict_name[key] = value

Inserts a new key-value pair into the dictionary. If

Add or modify the key already exists, the value will be updated;
Example:
otherwise, 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

del Removes the specified key-value pair from the Syntax:

dictionary. Raises a KeyError if the key does not
exist. del dict_name[key]
 Example:
del person["Country"]

Syntax:

dict_name.update({key: value})

The update() method merges the provided

update() dictionary into the existing dictionary, adding or
updating key-value pairs. Example:

person.update({"Profession": "Doctor"})

Syntax:
dict_name.clear()

The clear() method empties the dictionary,

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

Example:
if "name" in person:
print("Name exists in the dictionary.")

You can check for the existence of a key in a

key existence
dictionary using the in keyword

copy() Creates a shallow copy of the dictionary. The new Syntax:

dictionary contains the same key-value pairs as the
original, but they remain distinct objects in new_dict = dict_name.copy()
memory.
 Example:

new_person = person.copy()
new_person = dict(person) # another way to create a copy of dictionary

Syntax:

keys_list = list(dict_name.keys())

Retrieves all keys from the dictionary and converts

keys() them into a list. Useful for iterating or processing
keys using list methods. Example:

person_keys = list(person.keys())

Syntax:
values_list = list(dict_name.values())

Extracts all values from the dictionary and converts

values() them into a list. This list can be used for further
processing or analysis. Example:

person_values = list(person.values())

items() Retrieves all key-value pairs as tuples and converts Syntax:

them into a list of tuples. Each tuple consists of a
key and its corresponding value. items_list = list(dict_name.items())

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
add()
automatically 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
clear()
set. It updates the set in-place. Example:
fruits.clear()

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

Example:

new_fruits = fruits.copy()
 Example:
empty_set = set() #Creating an Empty Set
fruits = {"apple", "banana", "orange"}
colors = ("orange", "red", "green")

A set is an unordered collection of unique elements. Sets are enclosed in curly

Defining Sets braces `{}`. They are useful for storing distinct values and performing set
operations.

Note: These two sets will be used in the examples that

follow.

Syntax:
set_name.discard(element)

Use the `discard()` method to remove a specific element from the set. Ignores if
discard()
the 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
issubset() returns True if all elements of the current set are present in the other set,
otherwise False. Example:

is_subset = fruits.issubset(colors)

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

Example:
is_superset = colors.issuperset(fruits)
 Syntax:
removed_element = set_name.pop()

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

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")

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

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
update()
maintains the uniqueness of elements. Example:
fruits.update(["kiwi", "grape"])

© IBM Corporation. All rights reserved.