Collections / Data Structures in Python · basic | Python

The Collection Engine Architecture

Python organizes compound data structures into four distinct built-in collections. Choosing the right collection depends on how your application needs to access data, whether the elements must remain ordered, and whether the data structures need to be mutable or thread-safe.

1. Lists: Dynamic Mutable Arrays

A List is an ordered, mutable sequence that can hold heterogeneous data types. Internally, Python lists are implemented as dynamic arrays containing a contiguous block of reference pointers to other objects stored on the heap.

A. Operational Lifecycles and Methods

Python
# Initialization of a dynamic tracking array
cluster_nodes = ["Node_A", "Node_B", "Node_C"]

# 1. Append: Adds an element to the end of the list in O(1) amortized time
cluster_nodes.append("Node_D")

# 2. Insert: Inserts an element at a specific index. Requires shifting remaining items (O(n) time)
cluster_nodes.insert(1, "Node_Proxy") # ['Node_A', 'Node_Proxy', 'Node_B', 'Node_C', 'Node_D']

# 3. Remove/Pop: Removes items by value or position index
cluster_nodes.remove("Node_Proxy")    # Removes first matching value structure
popped_node = cluster_nodes.pop()     # Removes and returns the last item (O(1) time)

# 4. Sorting and Reversal
cluster_nodes.sort()                  # In-place sort using the Timsort algorithm

B. List Comprehension Mechanics

List comprehensions provide a declarative syntax to generate or transform lists. They execute at the bytecode layer faster than standard imperative for loops by optimizing internal loop boundaries.

Python
# Syntax Blueprint: [expression for item in iterable if condition]
raw_ports = [80, 443, 8080, 22, 9000]

# Generate a filtered list containing only secure or alternative ports
secure_ports = [port for port in raw_ports if port != 80 and port != 22]
# Outputs: [443, 8080, 9000]

C. Nested Lists (Multi-Dimensional Arrays)

Lists can contain other lists as elements, allowing you to model matrices, data grids, or complex nested structures.

Python
# 2x3 Server Matrix Configuration Map
server_grid = [
    ["Srv_A1", "Srv_A2", "Srv_A3"],
    ["Srv_B1", "Srv_B2", "Srv_B3"]
]

# Traversal lookup: Row index 1, Column index 2
print(server_grid[1][2]) # Outputs: "Srv_B3"

2. Tuples: Fixed Immutable Records

A Tuple is an ordered, immutable sequence. Once a tuple is declared in memory, its elements and their positions cannot be altered, appended, or reallocated.

Performance Note: Because tuples are immutable, Python allocates a fixed, single block of memory for them at creation time. This makes tuples lighter and faster to iterate over than lists, which over-allocate memory to handle future append operations.

Tuple Packing & Unpacking Workflow

Python
# Tuple Packing: Grouping multiple independent data structures into a single container
network_record = ("192.168.1.1", 443, "HTTPS", "ACTIVE")

# Tuple Unpacking: Extracting elements back into individual variables
ip_address, port_id, protocol, status = network_record

# Extended Unpacking using the Star (*) Operator
host_ip, *connection_metadata = network_record
# host_ip = "192.168.1.1"
# connection_metadata = [443, "HTTPS", "ACTIVE"]

3. Sets: Unique Unordered Hash Tables

A Set is an unordered collection of unique, hashable items. Python sets are implemented internally using a hash table structure, which allows them to check if an item is in the set in $O(1)$ constant time—making them incredibly fast compared to $O(n)$ list searches.

Python
# Instantiation (Duplicates are automatically discarded by the hashing engine)
active_ips = {"10.0.0.1", "10.0.0.2", "10.0.0.1"} # {'10.0.0.1', '10.0.0.2'}
Mathematical Set Operations
Python
set_alpha = {80, 443, 8080}
set_beta = {22, 443, 9000}

# 1. Intersection: Elements present in BOTH sets
print(set_alpha & set_beta)  # {443}

# 2. Union: Combined unique elements from both sets
print(set_alpha | set_beta)  # {80, 443, 8080, 22, 9000}

# 3. Difference: Elements in set_alpha that are missing from set_beta
print(set_alpha - set_beta)  # {80, 8080}

# 4. Symmetric Difference: Elements in either set, but NOT in both
print(set_alpha ^ set_beta)  # {80, 8080, 22, 9000}

Frozen Sets (`frozenset`)

A standard set is mutable, which means it cannot be used as a dictionary key or placed inside another set because its hash value can change. A frozenset is an immutable version of a set. Once created, its elements are locked, making it hashable and safe to use as an unchangeable lookup key.

Python
# Instantiate an immutable frozen set
immutable_set = frozenset([80, 443])
# immutable_set.add(8080) # Throws AttributeError: 'frozenset' object has no attribute 'add'

4. Dictionaries: Associative Key-Value Maps

A Dictionary (dict) is an unindexed, mutable collection of key-value pairs. Dictionaries use highly optimized internal hash tables to look up values based on their keys in $O(1)$ constant time.

The Key Constraint: Keys must be of an immutable, hashable data type (e.g., strings, numbers, tuples, or frozensets). Mutable structures like lists or other dictionaries cannot be used as keys.

A. Essential Dictionary Methods

Python
configuration = {"host": "127.0.0.1", "port": 8080, "ssl": True}

# 1. Safe Extraction via .get(): Prevents KeyError crashes if a key is missing
db_user = configuration.get("db_user", "fallback_admin") # Returns default fallback value

# 2. View Projections: Dynamic view tracking layers that update when the dict changes
keys_view = configuration.keys()     # dict_keys(['host', 'port', 'ssl'])
values_view = configuration.values() # dict_values(['127.0.0.1', 8080, True])
items_view = configuration.items()   # Stream of (key, value) tuple pairs

# 3. Merging Dictionaries (Python 3.9+ Merge Operator)
overrides = {"port": 9000, "debug": False}
merged_config = configuration | overrides # Merges systems, overriding old matching keys

B. Dictionary Comprehension

Enables declarative mapping transformations over key-value structures.

Python
# Syntax Blueprint: {key_expr: value_expr for item in iterable}
base_metrics = {"node_1": 12, "node_2": 45, "node_3": 8}

# Generate an updated map where values exceeding 10 are scaled up
scaled_metrics = {k: v * 10 for k, v in base_metrics.items() if v > 10}
# Outputs: {'node_2': 450}

Collections Architectural Reference Matrix

Collection Structure	Internal Engine Model	Element Access Complexity	Mutability Profile	Critical Production Guardrail
`list`	Dynamic Contiguous Array of Object Pointers.	Indexed Lookup: $O(1)$ Search Value: $O(n)$	Mutable	Appending or popping elements from the end of a list is fast ( $O(1)$ ). Inserting or deleting items near the beginning is slow ( $O(n)$ ) because all subsequent pointers must be shifted in memory.
`tuple`	Single Fixed Memory Layout Allocation block.	Indexed Lookup: $O(1)$ Search Value: $O(n)$	Immutable	While the tuple container itself cannot be modified, if it contains a mutable child element (like a list inside a tuple), that inner list can still be modified in place.
`set` / `frozenset`	Open-Addressing Hash Table Layout.	Membership Check (`in`): $O(1)$	Mutable / Immutable	Sets do not maintain traditional position tracking indexes. Never write code that assumes set items will appear in a reliable, predictable position sequence.
`dict`	High-Density Compact Hash Map Framework.	Key Lookup: $O(1)$ Value Search: $O(n)$	Mutable	Modifying a dictionary structure (adding or removing items) while iterating over it will throw a runtime `RuntimeError: dictionary changed size during iteration`. Loop over a copy of its keys instead.

Collections / Data Structures