List Fundamentals

Python lists are dynamic, ordered collections enclosed in square brackets []. They support heterogeneous data types and maintain insertion order while allowing in-place modification.

data_pool = [42, "config_str", 3.14, True]

Retrieval and Search Mechanisms

Index Access and Slicing

Elements are retrieved using zero-based integer indices. Negative values traverse from the end of the sequence.

log_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
first_entry = log_levels[0]
last_entry = log_levels[-1]

# Advanced slicing with step parameters
numeric_seq = list(range(1, 21))
reversed_seq = numeric_seq[::-1]
step_two = numeric_seq[::2]
front_ten = numeric_seq[:10]

Query Methods and Membership Checks

The index() method locates the first occurrence within optional boundaries. count() returns occurrence frequency. len() calculates the total number of items.

error_codes = [200, 404, 301, 200, 500]
position = error_codes.index(301, 0, 4)  # Returns 2
occurrences = error_codes.count(200)      # Returns 2
total_items = len(error_codes)            # Returns 5

Note: index() raises a ValueError if the target is absent, whereas count() safely returns 0.

The in and not in operators validate presence.

active_users = ["alice", "bob", "charlie"]
is_active = "bob" in active_users          # True
is_guest = "dave" not in active_users      # True

Element Insertion Strategies

Appending vs Extending

append() attaches a single object to the tail. extend() unpacks an iterable and injects each element individually.

queue = ["task_1", "task_2"]
queue.append("task_3")
queue.extend(["task_4", "task_5"])
# Result: ['task_1', 'task_2', 'task_3', 'task_4', 'task_5']

# Appending a sequence creates nesting
queue.append(["task_6", "task_7"])

Targeted Insertion

insert(index, element) places data at a specific offset, shifting existing items right.

stream = [10, 30, 40]
stream.insert(1, 20)
# Result: [10, 20, 30, 40]

# Slice assignment for front-loading
stream[:0] = [-5, 0]

Sequence Concatenation

The + operator generates a new combined list, while += modifies the original in-place using the __iadd__ protocol.

base = ["A", "B"]
new_list = base + ["C", "D"]
base += ("E", "F")  # Works with any iterable

Removal and Clearing

del Statement

Removes items by index or deletes the variable reference entirely.

temporary = ["temp1", "temp2", "temp3"]
del temporary[0]
# To destroy the container reference: del temporary

pop() and remove()

pop() extracts and returns an element by index (defaults to the last). remove() finds the first matching value and deletes it without returning it.

stack = ["init", "process", "finalize"]
extracted = stack.pop(1)  # Returns "process"
stack.remove("init")      # Modifies list in-place

clear()

Empties the list while preserving the container object.

buffer = ["log1", "log2"]
buffer.clear()
print(buffer)  # []

Modificatino and Ordering

Direct Index Assignment

settings = ["auto", "manual"]
settings[0] = "automatic"

Reversing and Sorting

reverse() flips order in-place. sort() arranges items, using reverse=True for descending order.

values = [8, 3, 5, 1, 9]
values.reverse()
values.sort()  # Ascending
values.sort(reverse=True)  # Descending

# Sorting mixed types requires uniform key conversion
mixed = ["apple", 42, "banana", 15, {"id": 1}]
stringified = [str(item) for item in mixed]
stringified.sort(reverse=True)

Updating Mutable Containers

Lists containing dictionaries allow direct attribute mutation during traversal.

inventory = [{"id": 1, "title": "Sci-Fi"}, {"id": 2, "title": "Fantasy"}]
for record in inventory:
    record["label"] = f"{record['id']}_{record['title']}"

Duplication

The .copy() method creates a shallow clone, allocating new memory while preserving references to nested objects.

original = ["X", "Y", "Z"]
clone = original.copy()
print(id(original) != id(clone))  # True

Iteration Patterns

for Loop

Directly yields elements.

colors = ["red", "green", "blue"]
for shade in colors:
    print(shade)

while Loop

Relies on index tracking.

index = 0
while index < len(colors):
    print(colors[index])
    index += 1

Nested List Navigation

Multidimensional structures are accessed via chained bracket notation.

matrix = [
    ["user_1", "user_2", "user_3"],
    ["admin_1", "admin_2", "admin_3"]
]
sub_group = matrix[0]
target_element = matrix[1][1]  # Returns "admin_2"