Matrix initialization

Prevents aliasing bugs when creating a two‑dimensional list of identical values.

Scientific computing: initializing a weight matrix for a neural network layer; Graphics programming: setting up a transformation matrix for 2D rendering; Data science: building a zero‑filled contingency table for statistical analysis.

Educational Python tutorials, scientific computing libraries, game development contexts, any code that manipulates 2D arrays without external dependencies.

matrix: List[List[float]] = [[fill_value]*cols for _ in range(rows)]

...: List[List[float]] = [[...]*... for _ in range(...)]

variable_name: valid Python identifier, fill_value: any Python object (e.g., numeric literal), cols: int ≥ 0, rows: int ≥ 0

• Nested loops for processing
• NumPy arrays for heavy numeric work
• list‑based matrix operations such as transposition or multiplication.

• Using [[fill_value]*cols]*rows (creates shared rows
• leads to bugs)
• using numpy.zeros((rows
• cols)) for efficient numeric arrays
• building rows with a for‑loop and append (more verbose but clear).

Using [[fill_value]*cols]*rows – cause: outer list multiplication creates references to the same inner list; consequence: modifying one row affects all rows. Omitting the underscore and using a real variable – cause: unnecessary variable that may be mistakenly used later; consequence: confusion or accidental reuse. Using range(cols) for both dimensions – cause: confusion between rows and columns; consequence: incorrectly sized matrix. Using mutable default like [] as fill_value – cause: all cells share the same mutable object; consequence: unintended cross‑cell modifications.

numpy.zeros – creates a NumPy array instead of nested lists, offering vectorized operations; list comprehension with append – builds rows via explicit loop, more flexible but slower; copy.deepcopy – duplicates an existing matrix, useful when starting from a template.

Coming from MATLAB: may assume matrix*vector works directly → In Python lists, need to use loops or NumPy for linear algebra. Coming from Java: may try to declare a fixed‑size 2D array → Python lists are dynamic; size must be specified with range or literals.

• matrix initialization
• matrix transposition
• matrix multiplication
• element‑wise mapping

Do not use when a fixed‑size, low‑level array is required for performance; the list‑of‑lists approach has higher memory overhead and poorer cache locality than NumPy. Performance impact: each inner list is a separate Python object, causing extra indirection; for large matrices consider NumPy. Boundary conditions: if rows or cols is zero, the result is an empty list or a list of empty lists, which is valid but may break downstream code expecting a non‑empty matrix.

Guarantees that each row can be modified independently without unintended side effects, making debugging and reasoning about matrix algorithms straightforward.

Think of building a brick wall where each row is a separate layer of bricks; copying the same layer would let a crack propagate through all layers, but independent layers keep the wall strong.

The type annotation List[List[float]] is optional; omitting it yields the same runtime behavior but loses static type information.

Use NumPy's np.zeros((rows, cols)) for efficient numeric matrices and vectorized operations.