Skip to content
Learni
View all tutorials
Python

How to Get Started with NumPy in 2026

12 minBEGINNER
PythonData ScienceNumPyCalcul Scientifique
Lire en français

Introduction

NumPy, short for Numerical Python, has been Python's go-to library for numerical computing since 2006. It turns Python into a powerhouse for data science, machine learning, and scientific analysis, handling millions of data points with near-C efficiency.

Why learn it in 2026? With data exploding from generative AI and big data, NumPy remains essential: 90% of data libraries (Pandas, SciPy, TensorFlow) build on it. Picture a spreadsheet like Excel, but 100x faster and multidimensional—that's NumPy. This code-free conceptual tutorial focuses on theory to build strong intuition. You'll grasp ndarray arrays, vectorized operations, and common pitfalls for professional projects from day one. Ideal for beginners eyeing data analysis or physics simulations (128 words).

Prerequisites

  • Basic Python knowledge (lists, loops, functions).
  • Familiarity with math concepts: vectors, matrices.
  • No prior scientific computing experience needed.
  • Python environment installed (but no code here).

What is NumPy and its ndarray?

NumPy revolves around its core object: the ndarray (N-dimensional array).

Unlike flexible but slow Python lists, an ndarray is a contiguous block of homogeneous memory: all elements share the same type (int32, float64) and size. Think of it as a fixed-shape, fixed-type Excel sheet optimized for hardware.

Key properties:

  • Shape: Tuple like (3,4) for 3 rows x 4 columns.
  • Axis: 0 for columns, 1 for rows—vital for aggregations.
  • Dtype: Avoids costly conversions; defaults to float64 for precision.

Real-world example: For 1 million temperatures, a Python list uses 10x more memory and 50x more time. NumPy stores them in a compact vector block, ready for parallel computations.

Creating and Manipulating Arrays

Arrays are created from existing data or generated on the fly.

Main theoretical methods:

  • Zeros/ones/filled: Initialize empty arrays for ML weight matrices.
  • Arange/linspace: Regular sequences, like sampling points for a sine wave graph (arange: integer steps; linspace: evenly spaced points).
  • From lists: Direct conversion, but watch for forced homogenization.

Manipulation:
  • Reshape: Changes shape without copying data (e.g., 1D vector → 2D matrix).
  • Join (concatenate/stack): Combines arrays; stack adds a dimension (vstack for vertical).

Use case: In weather simulation, linspace generates 100 temperature points from 0 to 40°C, reshape arranges them into a 10x10 grid.

Vectorized Operations and Broadcasting

NumPy's heart: vectorization to skip slow loops.

Apply operations to entire arrays in one go, no element-by-element looping. Benefit: 100x faster via optimized C libraries like BLAS/LAPACK.

Broadcasting: Auto-expands shapes. Golden rule: compatible dimensions (1 or equal). Example: Adding a scalar to a vector expands the scalar; (3,4) matrix + (3,) vector applies row-wise.

Universal functions (ufuncs): sin, exp, sqrt—element-wise with broadcasting support.

Case study: Euclidean distances between 1000 points and a center. Without vectorization: nested loop (O(n²)). With: broadcasting dot product in O(n).

Indexing, Slicing, and Boolean Masks

Selective access like Python lists, but optimized.

  • Basic indexing: [i,j] for elements; slicing [start:stop:step] for subarrays (views, not copies!).
  • Fancy indexing: Index lists or boolean arrays for advanced selection.
  • Masks: Boolean array filters elements (e.g., temperatures > 30°C).
Pitfall: Slicing creates a view (shared reference); changes affect the original. Use .copy() for duplicates.

Real example: Sales dataset (1000 rows). Boolean mask 'sales > average' picks top performers without loops, then column-specific slicing extracts price/unit.

Aggregation and Statistical Functions

Summarize massive datasets in one call.

  • Sum/mean/std: Sum, average, standard deviation; axis=0 for columns.
  • Min/max/argmin: Extremes and their positions.
  • Correlation (corrcoef): Linear measure between variables.
Advantage: Implicit out-of-core handling for big data via chunking.

Case: Financial analysis. Over 10 years of returns (axis=0: years), cumsum computes cumulative gains; std(axis=0) gets volatility per asset. Result: Risk matrix in one operation.

Best Practices

  • Pick precise dtypes: int8 for image pixels (saves 75% memory); avoid object for speed.
  • Favor views over copies: Free slicing, but .copy() when needed to prevent modification bugs.
  • Always specify axis: Avoid surprises on matrices (axis=0 columns, 1 rows).
  • Vectorize everything: Benchmark speedups; if <10x, rethink your loop.
  • Profile memory: .nbytes to foresee OutOfMemory on >1GB datasets.

Common Errors to Avoid

  • View vs copy confusion: Modifying a slice changes the original; test with print(id(array)) == id(slice).
  • Broadcasting failure: Incompatible shapes (e.g., (3,4) + (4,3)) → error; fix with reshape(-1).
  • Wrong default dtype: float64 wastes space on integers; specify explicitly.
  • Unnecessary Python loops: Lose 100x speed; vectorize even for n<1000.

Next Steps