{"title":"NumPy Basics","description":"","content":"NumPy is the foundation that the rest of scientific Python is built on. Pandas, scikit-learn, SciPy, PyTorch, TensorFlow, and every plotting library that draws a curve either wrap NumPy arrays or use the same memory layout. Any numeric work in Python beyond a small list of prices eventually touches NumPy. This lesson covers what NumPy is, why it's faster than a Python list of numbers, how to create arrays, and the attributes to inspect on every array.\n\n---\n\n# Why NumPy Exists\n\nA Python list is a flexible container. It can hold an integer, a string, a customer object, and another list, all in the same sequence. That flexibility has a cost. Every item in a Python list is a full Python object: an integer like `42` is a `PyLongObject` with a reference count, a type pointer, and the actual value, sitting somewhere on the heap. The list itself is an array of pointers to those scattered objects.\n\nWhen `sum(prices)` runs on a list of one million prices, Python walks one million pointers, dereferences each one to find the actual `float` object, unboxes the C `double` inside, adds it to a running total, and boxes the result back into a `PyFloat` so it can continue. The arithmetic is fast. The boxing, unboxing, pointer chasing, and per-item type checking is what eats the time.\n\nNumPy throws all of that out. An array of one million prices in NumPy is one contiguous block of memory holding one million raw `double` values, packed end to end. No pointers, no per-item objects, no type checks per addition. `prices.sum()` hands the block to a C loop that adds doubles to a register. The whole operation runs at the speed of native C, not the speed of Python's interpreter.\n\nThe speedup is usually 10x to 100x for arithmetic-heavy work, sometimes more. That's not a micro-optimization, that's the difference between a script finishing overnight and a script finishing during a coffee break.\n\n\n```mermaid\nflowchart LR\n subgraph List[\"Python list of 4 prices\"]\n L[List object]:::cyan --> P1[Ptr]:::orange\n L --> P2[Ptr]:::orange\n L --> P3[Ptr]:::orange\n L --> P4[Ptr]:::orange\n P1 --> F1[PyFloat
29.99]:::teal\n P2 --> F2[PyFloat
14.99]:::teal\n P3 --> F3[PyFloat
9.99]:::teal\n P4 --> F4[PyFloat
49.99]:::teal\n end\n\n subgraph Array[\"NumPy array of 4 prices\"]\n A[Array header]:::green --> B[\"29.99 | 14.99 | 9.99 | 49.99
contiguous doubles in one block\"]:::green\n end\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nThe list version scatters the values across the heap behind a layer of pointers. The array packs the same four numbers into a single tight block. The CPU benefits from the array because each value sits exactly where the one before it ended, so the prefetcher and the cache work efficiently.\n\nTwo other constraints come with the contiguous layout. First, every value in a NumPy array has the same type, which is what makes the packing possible. An `int` and a `string` cannot share the same array. Second, the size is fixed at creation time. Appending to a NumPy array means allocating a brand new block, copying everything over, and freeing the old one. Lists were designed for that pattern, arrays were not.\n\nThat sounds like a downside, and for some workloads it is. NumPy isn't meant to replace lists everywhere. It fits the work of doing math on a lot of numbers, which is most of data science, machine learning, scientific computing, and any analytics dashboard that has to crunch order data for a million customers a night.\n\n---\n\n# Installing NumPy\n\nNumPy is not part of the Python standard library. Install it with pip:\n\n\n```python\n# In your terminal, not in Python\n# pip install numpy\n```\n\n\nAnaconda and other scientific Python distributions already include NumPy. Once installed, the standard import is `numpy as np`. The convention is universal across tutorials, documentation, and Stack Overflow answers, so following it keeps other code readable.\n\n\n```python\nimport numpy as np\n\nprint(np.__version__)\n```\n\n\nThe reported version depends on what pip pulled down. Anything in the 1.x or 2.x range works for the basics this lesson covers. NumPy 2.0 (released mid-2024) introduced some breaking changes for advanced users but nothing in the basics moves.\n\n---\n\n# Creating Arrays\n\nThe most direct way to make an array is `np.array`, which takes any sequence of numbers and turns it into a NumPy array. A flat list produces a 1D array, a list of lists produces a 2D array, and so on.\n\n\n```python\nimport numpy as np\n\nprices = np.array([29.99, 14.99, 9.99, 49.99])\nprint(prices)\nprint(type(prices))\n```\n\n\nThe returned value is an `ndarray`, which is NumPy's array type. The repr drops the commas in a list and prints the values separated by spaces. Same data, different container.\n\nA 2D array models tabular data. It is a matrix of rows and columns: each row is a record, each column is a field. Below is a small \"orders\" table where each row is `(order_id, quantity, total)`:\n\n\n```python\nimport numpy as np\n\norders = np.array([\n [1001, 2, 59.98],\n [1002, 1, 89.99],\n [1003, 3, 14.97],\n])\n\nprint(orders)\n```\n\n\nThe array printed as a 3-by-3 grid because that's its shape, and the values are in scientific notation because NumPy chose `float64` as the `dtype`. Keeping the IDs and quantities as integers requires asking for an `int` array.\n\n`np.array` is fine when the data is already in hand. Often it isn't; the goal is a block of a specific size filled with a specific value. NumPy has dedicated constructors for that.\n\n### Filled Arrays: `zeros`, `ones`, `full`\n\n`np.zeros(shape)` allocates an array of the given shape filled with zeros. The shape can be an integer for a 1D array or a tuple for higher dimensions.\n\n\n```python\nimport numpy as np\n\n# Stock counts for 5 products, all starting at zero\nstock = np.zeros(5)\nprint(stock)\n\n# A 3-by-4 grid of zeros (3 customers, 4 product categories spent)\nspend = np.zeros((3, 4))\nprint(spend)\n```\n\n\nThe default `dtype` is `float64`, which is why the zeros print with a trailing dot. Pass `dtype=int` for integer zeros:\n\n\n```python\nimport numpy as np\n\nstock = np.zeros(5, dtype=int)\nprint(stock)\n```\n\n\n`np.ones(shape)` is the mirror image: an array of the given shape filled with ones. It seeds a multiplier, a mask, or any \"default to one\" pattern.\n\n\n```python\nimport numpy as np\n\n# A discount multiplier per product, default 1.0 (no discount)\nmultiplier = np.ones(5)\nprint(multiplier)\n```\n\n\nFor any other fill value, use `np.full(shape, value)`:\n\n\n```python\nimport numpy as np\n\n# Every product on the wishlist starts at a 5-star wish rating\nwish_rating = np.full(4, 5.0)\nprint(wish_rating)\n```\n\n\n`np.zeros` and `np.ones` allocate and initialize the whole block. For very large arrays where every value is overwritten before being read, `np.empty(shape)` allocates without initializing, which is faster but leaves whatever bytes happened to be there. Use `np.empty` only when every cell is guaranteed to be written.\n\n### Ranged Arrays: `arange` and `linspace`\n\nFor a sequence of evenly spaced values, there are two builders. `np.arange(start, stop, step)` works like Python's built-in `range`: it produces values starting at `start`, stepping by `step`, stopping before `stop`.\n\n\n```python\nimport numpy as np\n\n# Day numbers 0 through 6 for a week of sales\ndays = np.arange(7)\nprint(days)\n\n# Hour markers from 9 to 18 in 1-hour steps\nhours = np.arange(9, 19)\nprint(hours)\n\n# Prices from $5 to $50 in $5 steps\nprice_tiers = np.arange(5, 55, 5)\nprint(price_tiers)\n```\n\n\n`np.arange` works fine with integer steps. With floating-point steps it becomes jittery because of float rounding: `np.arange(0, 1, 0.1)` doesn't always return exactly ten elements. For evenly spaced floats, use `np.linspace(start, stop, num)`, which asks for the number of points rather than the step, and includes both endpoints by default.\n\n\n```python\nimport numpy as np\n\n# 11 evenly spaced discount levels from 0% to 50%\ndiscounts = np.linspace(0, 0.5, 11)\nprint(discounts)\n```\n\n\nEleven values, the first is exactly `0.0`, the last is exactly `0.5`, and the step is computed automatically. `linspace` is the better choice when hitting exact endpoints matters, which covers most cases of generating plot axes, model parameters, or test inputs.\n\n### Random Arrays\n\nFor arrays of random values, the modern API is `np.random.default_rng()`, which returns a `Generator` object with methods on it. The older top-level functions like `np.random.random` still work but share global state, which is awkward for testing and reproducibility.\n\n\n```python\nimport numpy as np\n\n# Seed for reproducibility: same seed gives same numbers every run\nrng = np.random.default_rng(seed=42)\n\n# 5 uniform random numbers between 0 and 1\nratings = rng.random(5)\nprint(ratings)\n\n# 4 integers between 1 and 5 inclusive (stars for a product review)\nstars = rng.integers(1, 6, size=4)\nprint(stars)\n\n# 3 samples from a normal distribution with mean 100 and std 15\norder_totals = rng.normal(loc=100, scale=15, size=3)\nprint(order_totals)\n```\n\n\n`integers(low, high, size=n)` follows the half-open convention: `high` is exclusive. So `rng.integers(1, 6, size=4)` produces values in `[1, 2, 3, 4, 5]`. `rng.integers(1, 5)` does not include 5, which is the common confusion.\n\nSeeding the generator (`seed=42`) makes the sequence deterministic. Running the same code twice with the same seed produces the same numbers, which is the goal when writing tests or sharing reproducible examples.\n\n---\n\n# Array Attributes\n\nEvery NumPy array carries metadata about itself. The five attributes that come up most are `shape`, `dtype`, `ndim`, `size`, and `itemsize`. None of them are methods; they are plain attributes, no parentheses.\n\n\n```python\nimport numpy as np\n\norders = np.array([\n [1001, 2, 59.98],\n [1002, 1, 89.99],\n [1003, 3, 14.97],\n])\n\nprint(\"shape:\", orders.shape)\nprint(\"dtype:\", orders.dtype)\nprint(\"ndim:\", orders.ndim)\nprint(\"size:\", orders.size)\nprint(\"itemsize:\", orders.itemsize)\n```\n\n\n\n| Attribute | Meaning |\n| ---------- | ------------------------------------------------------------------------ |\n| `shape` | Tuple of dimension sizes. `(3, 3)` means 3 rows and 3 columns. |\n| `dtype` | The element type. `float64` is a 64-bit floating point. |\n| `ndim` | Number of dimensions. `len(shape)` returns the same number. |\n| `size` | Total number of elements. Product of all values in `shape`. |\n| `itemsize` | Bytes per element. `float64` uses 8 bytes, `int32` uses 4 bytes. |\n\n\nTotal memory used by the array's data buffer is `size * itemsize`. The `orders` array holds nine doubles, so `9 * 8 = 72` bytes plus a small fixed overhead for the array header. A million-row, three-column `float64` array is `3,000,000 * 8 = 24 MB`, a back-of-the-envelope calculation worth keeping at hand.\n\nThe `dtype` is what makes a NumPy array different from a list of numbers. Common dtypes:\n\n\n| Dtype | Bytes | Range / precision |\n| ----------- | ----- | -------------------------------------------------- |\n| `int8` | 1 | -128 to 127 |\n| `int32` | 4 | About -2.1 billion to 2.1 billion |\n| `int64` | 8 | The default integer on most 64-bit systems |\n| `float32` | 4 | About 7 decimal digits of precision |\n| `float64` | 8 | About 15 decimal digits of precision, the default |\n| `bool` | 1 | `True` or `False` |\n\n\nNumPy picks a dtype at array creation. For a list of integers it picks `int64`; for a list with any float in it, `float64`. The choice can be overridden with the `dtype` keyword:\n\n\n```python\nimport numpy as np\n\n# A list of small counts: int8 is enough and uses 1/8 the memory of int64\nstock = np.array([5, 0, 12, 3], dtype=np.int8)\nprint(stock)\nprint(\"dtype:\", stock.dtype, \"itemsize:\", stock.itemsize)\n```\n\n\nFor four elements the saving is meaningless. For a million-element array of small counts, going from `int64` to `int8` drops memory from 8 MB to 1 MB. That trade-off becomes relevant once arrays are large enough to matter.\n\n---\n\n# Lists vs Arrays: A Concrete Comparison\n\nThe differences between a Python list and a NumPy array are easiest to see side by side. Same task, two implementations.\n\nDoubling every price in a 1-million-element collection:\n\n\n```python\nimport numpy as np\nimport time\n\n# Python list version\nprices_list = [9.99] * 1_000_000\n\nstart = time.perf_counter()\ndoubled_list = [p * 2 for p in prices_list]\nlist_time = time.perf_counter() - start\n\n# NumPy version\nprices_array = np.full(1_000_000, 9.99)\n\nstart = time.perf_counter()\ndoubled_array = prices_array * 2\narray_time = time.perf_counter() - start\n\nprint(f\"List took: {list_time * 1000:.2f} ms\")\nprint(f\"Array took: {array_time * 1000:.2f} ms\")\nprint(f\"Speedup: {list_time / array_time:.1f}x\")\n```\n\n\nThe exact numbers depend on the CPU, but the ratio matters. The list version walks a million Python objects, multiplying each by `2` in pure interpreter code. The array version hands the whole block to a C loop that multiplies doubles in a register-friendly pipeline. Forty times faster is typical, and the gap widens for arrays large enough that cache effects matter.\n\nThere are real differences beyond speed:\n\n\n| Property | Python list | NumPy array |\n| ----------------------- | ------------------------------------ | ---------------------------------------- |\n| Element types | Anything, can be mixed | One fixed dtype, all elements same |\n| Size | Grows dynamically with `append` | Fixed at creation, \"append\" copies |\n| Memory layout | Pointers to scattered objects | Contiguous block of raw values |\n| Math on the whole thing | Loop in Python | Single C-level operation |\n| Multi-dimensional shape | Lists of lists, indexing is awkward | Native, `arr[i, j]` indexing |\n| Element-wise operators | Only `+` (concatenation) and `*` (repeat) | All arithmetic operators, element-wise |\n\n\nThe two are not interchangeable. Lists fit heterogeneous collections, cases where the size is unknown ahead of time, or non-numeric work like joining strings or organizing dictionaries. Arrays fit the moment arithmetic on many numbers in a known shape is involved.\n\n---\n\n# NumPy vs Pandas vs Raw Python\n\nNumPy isn't the only tool in this space. Pandas sits on top of NumPy and adds two things that make tabular data easier: column labels (`df[\"price\"]` instead of `arr[:, 2]`) and a row index (which can be a timestamp, a customer ID, anything). Each column of a pandas `DataFrame` is a NumPy array.\n\nA short guide:\n\n- **Raw Python (lists, dicts):** For one-off scripts, mixed-type data, small datasets where readability beats speed, and any code that mostly moves text around.\n- **NumPy:** For numeric arrays where every element is the same type, the shape is regular, and the work is fast math. Image data, audio samples, model weights, simulations.\n- **Pandas:** When each column has its own type (a name string, a price float, a placed-at timestamp), for SQL-style filtering and grouping, or when missing values are part of the data. Anything that started life as a CSV usually wants to be a DataFrame.\n\n\n```mermaid\nflowchart TD\n START[What kind of data?]:::cyan --> Q1{Mostly numeric,
uniform type?}:::orange\n Q1 -->|No, mixed columns| PD[Use pandas]:::teal\n Q1 -->|Yes| Q2{Need column labels
or row index?}:::orange\n Q2 -->|Yes| PD\n Q2 -->|No, raw math| NP[Use NumPy]:::green\n Q1 -->|Small, mixed,
not really tabular| PY[Stick with Python
lists or dicts]:::red\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThe boundaries blur in practice. A common workflow: pandas reads a CSV into a DataFrame, the data is filtered and cleaned with pandas, then `df.values` or `df[\"col\"].to_numpy()` drops down to the underlying NumPy array for heavy numeric work, and pandas wraps the result back up for display or saving. None of these are mutually exclusive.\n\nFor the rest of this section, NumPy handles the math and the array operations, and pandas handles labeled tabular data. The two work together.\n\n---\n\n# A First Real Example\n\nTo pull these pieces together, consider a small end-to-end calculation. Daily revenue for one week across three product categories (electronics, books, clothing) is the input. The goal is the total revenue per category and the average per day.\n\n\n```python\nimport numpy as np\n\n# Rows are days (Mon-Sun), columns are categories (electronics, books, clothing)\nrevenue = np.array([\n [4520, 1200, 880],\n [3980, 1450, 720],\n [4100, 1380, 910],\n [5240, 1610, 1040],\n [6890, 1820, 1330],\n [9120, 2150, 1880],\n [7460, 1980, 1540],\n])\n\nprint(\"shape:\", revenue.shape)\nprint(\"size:\", revenue.size)\nprint(\"dtype:\", revenue.dtype)\nprint()\n\n# Total per category (sum across days, which is axis 0)\nper_category = revenue.sum(axis=0)\nprint(\"Revenue per category:\", per_category)\n\n# Average per day across categories (mean across columns, axis 1)\nper_day = revenue.mean(axis=1)\nprint(\"Average per day: \", per_day)\n\n# Grand total\nprint(\"Grand total: \", revenue.sum())\n```\n\n\nThe grid is `(7, 3)` because there are seven days and three categories. The `axis` argument to `sum` and `mean` controls which dimension to collapse: `axis=0` collapses rows (giving one value per column), `axis=1` collapses columns (giving one value per row). Calling `.sum()` with no `axis` collapses everything to a single grand total.\n\nThe aggregations (`sum`, `mean`, and axes) are the focus of the operations chapter coming up. The array's shape and dtype, which look like bookkeeping at first, are exactly what makes operations like \"sum across days\" or \"average across categories\" a one-liner. With the shape correct, the math falls out.","pageType":"python"}

NumPy Basics

Get Premium