MLA 002 Numpy & Pandas

NumPy enables efficient storage and vectorized computation on large numerical datasets in RAM by leveraging contiguous memory allocation and low-level C/Fortran libraries, drastically reducing memory footprint compared to native Python lists. Pandas, built on top of NumPy, introduces labelled, flexible tabular data manipulation—facilitating intuitive row and column operations, powerful indexing, and seamless handling of missing data through tools like alignment, reindexing, and imputation.

Links

• Notes and resources at ocdevel.com/mlg/mla-2
• Try a walking desk stay healthy & sharp while you learn & code

NumPy: Efficient Numerical Arrays and Vectorized Computation

• Purpose and Design

  • NumPy ("Numerical Python") is the foundational library for handling large numerical datasets in RAM.
  • It introduces the ndarray (n-dimensional array), which is synonymous with a tensor—enabling storage of vectors, matrices, or higher-dimensional data.

• Memory Efficiency

  • NumPy arrays are homogeneous: all elements share a consistent data type (e.g., float64, int32, bool).
  • This data type awareness enables allocation of tightly-packed, contiguous memory blocks, optimizing both RAM usage and data access speed.
  • Memory footprint can be orders of magnitude lower than equivalent native Python lists; for example, tasks that exhausted 32GB of RAM using Python lists could drop to just 6GB with NumPy structures.

• Vectorized Operations

  • NumPy supports vectorized calculations: operations (such as squaring all elements) are applied across entire arrays in a single step, without explicit Python loops.
  • These operations are operator-overloaded and are executed by delegating instructions to low-level, highly optimized C or Fortran routines, delivering significant computational speed gains.
  • Conditional operations and masking, such as zeroing out negative numbers (akin to a ReLU activation), can be done efficiently with Boolean masks.

Pandas: Advanced Tabular Data Manipulation

• Relationship to NumPy

  • Pandas builds upon NumPy, leveraging its underlying optimized array storage and computation for numerical columns in its data structures.
  • Supports additional types like strings for non-numeric data, which are common in real-world datasets.

• 2D Data Handling and Directional Operations

  • The core Pandas structure is the DataFrame, which handles labelled rows and columns, analogous to a spreadsheet or SQL table.
  • Operations are equally intuitive row-wise and column-wise, facilitating both SQL-like ("row-oriented") and "columnar" manipulations.
  • This dual-orientation enables many complex data transformations to be succinct one-liners instead of lengthy Python code.

• Indexing and Alignment

  • Pandas uses flexible and powerful indexing, enabling functions such as joining disparate datasets via a shared index (e.g., timestamp alignment in financial time series).
  • When merging DataFrames (e.g., two stocks with differing trading days), Pandas automatically aligns data on the index, introducing NaN (null) values for unmatched dates.

• Handling Missing Data (Imputation)

  • Pandas includes robust features for detecting and filling missing values, known as imputation.
    • Options include forward filling, backfilling, or interpolating missing values based on surrounding data.
  • Datasets can be reindexed against standardized sequences, such as all valid trading days, to enforce consistent time frames and further identify or fill data gaps.

• Use Cases and Integration

  • Pandas simplifies ETL (extract, transform, load) for CSV and database-derived data, merging NumPy’s computation power with tools for advanced data cleaning and integration.
  • When preparing data for machine learning frameworks (e.g., TensorFlow or Keras), Pandas DataFrames can be converted back into NumPy arrays for computation, maintaining tight integration across the data science stack.

Summary: NumPy underpins high-speed numerical operations and memory efficiency, while Pandas extends these capabilities to powerful, flexible, and intuitive manipulation of labelled multi-dimensional data -together forming the backbone of data analysis and preparation in Python machine learning workflows.