📊 Day 04 : Lists

🎯 Enterprise Objective

Lists are Python's most versatile data structure and the foundation for data manipulation. Today we master list creation, modification, comprehensions, and advanced patterns. You will learn the professional techniques that translate directly to pandas DataFrame operations.

📋 Strategic Overview

A list is an ordered, mutable collection that can hold items of any type. Lists are the most versatile data structure in Python — they grow and shrink dynamically, support indexing/slicing, and are the backbone of data pipelines.

• Data buffers: Lists hold rows of data during ETL processing

• Feature collections: Gather column names, metrics, or results dynamically

• Pipeline stages: Accumulate transformed records before writing to output

Use list() to convert any iterable: list('hello') → ['h','e','l','l','o'], list(range(5)) → [0,1,2,3,4].

Lists use the same indexing and slicing syntax as strings: lst[i] for single access, lst[start:stop:step] for slices. Unlike strings, list slicing returns a new list, and you can assign to slices to modify multiple elements at once.

• Batch selection: Select specific rows/columns from data matrices

• Pagination: data[offset:offset+limit] — paginate query results

• Window operations: data[i:i+window_size] — sliding window analysis

Slice assignment can change list length: lst[1:3] = [10, 20, 30, 40] replaces 2 elements with 4.

Lists have powerful methods for adding, removing, and reordering elements. Most methods modify the list in-place and return None. This is a common gotcha — never write lst = lst.sort().

• Data accumulation: results.append(row) — building datasets row by row

• Deduplication: .count() and .remove() for cleaning duplicates

• Sorting: data.sort(key=lambda x: x['date']) — sort records by field

Assignment (b = a) creates a reference, not a copy. .copy() or list(a) creates a shallow copy. For nested lists, you need copy.deepcopy() to get a fully independent copy.

• Data integrity: Always copy before modifying to preserve original data

• Function safety: Copy inputs inside functions to avoid side effects

• Snapshot patterns: Take deep copies as checkpoints in data transformations

With nested lists, .copy() only copies the outer list. Inner lists are still shared references. Modifying an inner list in the copy changes the original too.

A list comprehension is a concise way to create lists: [expression for item in iterable if condition]. They replace multi-line loops with a single readable line and are faster than equivalent for-loops.

# Loop version (4 lines)
result = []
for x in range(10):
    if x % 2 == 0:
        result.append(x ** 2)

# Comprehension (1 line)
result = [x**2 for x in range(10) if x % 2 == 0]

• Data filtering: clean = [x for x in data if x is not None]

• Type conversion: nums = [int(x) for x in string_list]

• Feature engineering: features = [row['age'] * row['income'] for row in records]

If a comprehension needs more than one condition or nested loops, switch to a regular for-loop. Readability always wins over cleverness.

Python provides powerful built-in functions that work on lists: len(), sum(), min(), max(), sorted(), enumerate(), zip(), map(), filter(), any(), all().

• Statistics: sum(data)/len(data) — quick mean calculation

• Validation: all(x > 0 for x in data) — check all values positive

• Paired data: zip(names, scores) — combine parallel lists

A nested list (list of lists) represents 2D data — tables, matrices, grids. Access elements with matrix[row][col]. This is the foundation for understanding DataFrames in pandas.

matrix = [
    [1, 2, 3],   # row 0
    [4, 5, 6],   # row 1
    [7, 8, 9],   # row 2
]
matrix[1][2]  # row 1, col 2 → 6

• Tabular data: CSV data is naturally a list of lists before converting to DataFrame

• Matrix operations: Row/column extraction, transposition, aggregation

• Grid problems: Game boards, pixel maps, adjacency matrices

Transpose a matrix with list(zip(*matrix)). This unpacks rows and re-zips them as columns.

Lists can function as stacks (LIFO — Last In, First Out) using append()/pop(), and as queues (FIFO — First In, First Out) using append()/pop(0). For production queues, use collections.deque for O(1) performance.

• Undo systems: Stack-based undo/redo for data transformations

• Task queues: FIFO queues for processing jobs in order

• BFS/DFS: Graph traversal algorithms use stacks and queues

Removing from the front of a list shifts all elements. For frequent front-removal, use collections.deque which is O(1).

Theory is useless without muscle memory. Complete these tasks to solidify your understanding.

✅ Instructor's End-of-Day Checklist

• [ ] I understand mutability and can avoid accidental aliasing.

• [ ] I know the difference between .sort() (in-place) and sorted() (new list).

• [ ] I can use list comprehensions for filtering and transformation.

• [ ] I understand shallow vs deep copy for nested structures.

• [ ] I can use enumerate() and zip() for Pythonic iteration.

• [ ] I have completed all 5 practice tasks.

• [ ] I have reviewed all 25 interview questions.