Dynamic Array Implementation

Python lists are implemented as dynamic arrays thatt automatically resize when elements are added or removed. The underlying mechanism uses contiguous memory allocation with over-allocation strategies to optimize performence.

When a list exceeds its current capacity, Python allocates a larger memory block (typically 1.125 times the current size) and copies existing elements. This approach makes append operations amortized O(1) time complexity, while insertions at arbitrary positions remain O(n).

Core List Operations

Creating Lists

mixed_data = [42, "text", 3.14, [1, 2, 3]]
empty_collection = []
constructed = list(range(5))

Element Access and Modification

sample = [10, 20, 30, 40]
print(sample[1])      # Output: 20
print(sample[-2])     # Output: 30

sample[0] = 99        # Modify first element
print(sample)         # Output: [99, 20, 30, 40]

Slicing Operations

original = [1, 2, 3, 4, 5, 6]
segment = original[1:4]    # [2, 3, 4]
reverse = original[::-1]   # [6, 5, 4, 3, 2, 1]

Adding Elements

numbers = [1, 2, 3]
numbers.append(4)          # [1, 2, 3, 4]
numbers.extend([5, 6])     # [1, 2, 3, 4, 5, 6]
numbers.insert(1, 1.5)     # [1, 1.5, 2, 3, 4, 5, 6]

Removing Elements

values = [1, 2, 3, 4, 5, 6]
values.remove(3)           # Remove first occurrence of 3
popped = values.pop(2)     # Remove and return element at index 2
del values[0]              # Delete first element
values.clear()             # Empty the list

Sorting and Searching

unsorted = [3, 1, 4, 1, 5, 9]
unsorted.sort()                       # In-place sort
sorted_copy = sorted(unsorted)        # Return new sorted list
position = unsorted.index(4)          # Find index of element
count = unsorted.count(1)             # Count occurrences

Advanced Techniques

List Comprehensions

squares = [x*x for x in range(10)]
even_squares = [x*x for x in range(10) if x % 2 == 0]
matrix = [[i*j for j in range(3)] for i in range(3)]

Functional Programming Patterns

from functools import reduce

names = ["Alice", "Bob", "Charlie"]
scores = [85, 90, 88]

# Zipping and enumeration
for idx, (name, score) in enumerate(zip(names, scores)):
    print(f"{idx}: {name} - {score}")

# Mapping and filtering
doubled = list(map(lambda x: x*2, scores))
high_scores = list(filter(lambda x: x > 85, scores))

# Reduction
total = reduce(lambda a, b: a + b, scores)

Slice Assignment

data = [1, 2, 3, 4, 5]
data[1:4] = [20, 30, 40]    # [1, 20, 30, 40, 5]
data[::2] = [100, 200, 300] # [100, 20, 200, 40, 300]

Practical Application: Data Grouping

student_records = [
    ['Alice', 92], ['Bob', 75], ['Charlie', 58], 
    ['Diana', 35], ['Eve', 15], ['Frank', 82]
]

grade_categories = [[] for _ in range(5)]

for record in student_records:
    score = record[1]
    if score >= 80:
        grade_categories[0].append(record)
    elif score >= 60:
        grade_categories[1].append(record)
    elif score >= 40:
        grade_categories[2].append(record)
    elif score >= 20:
        grade_categories[3].append(record)
    else:
        grade_categories[4].append(record)

for i, category in enumerate(grade_categories):
    print(f"Category {i+1}: {len(category)} students")