NumPy Nedir? Python ile Sayısal Veri Analizi

What is NumPy?

NumPy is the foundational library for numerical computing in Python. Its core data structure, the ndarray, holds elements of a single type in a multi-dimensional grid. The difference from a list is this: every element in a NumPy array has the same type and they sit contiguously in memory. That constraint buys you something big in return — a mathematical operation can be applied to the whole array at once.

So NumPy is not only a tool you use directly, it is infrastructure. pandas, scikit-learn, SciPy, matplotlib and many others pass numerical data around as NumPy arrays. Even if you never leave pandas as an analyst, knowing what runs underneath helps when you are debugging.

ndarray and the three attributes

There are three things you will keep checking when working with arrays: ndim (how many axes), shape (how many elements along each axis) and dtype (what type the elements are). Make printing those three your first reflex when something breaks; most cases get solved right there.

import numpy as np

scores = np.array([72, 85, 91, 68])
matrix = np.array([[12, 15, 14],
                   [18, 17, 20]])

print(scores.ndim, scores.shape, scores.dtype)  # 1 (4,) int64
print(matrix.ndim, matrix.shape)                # 2 (2, 3)

print(np.zeros((2, 3)))      # filled with zeros
print(np.arange(0, 10, 2))   # [0 2 4 6 8] — by step
print(np.linspace(0, 1, 5))  # [0. 0.25 0.5 0.75 1.] — evenly spaced

A shape of (2, 3) means two rows and three columns. Mixing up arange and linspace is a common slip: the first takes a step size, the second takes how many values you want. With floating-point steps, arange can produce one element more or fewer than you expected because of rounding; if you want an evenly spaced grid, linspace is safer.

Indexing, slicing and masks

One-dimensional arrays slice like Python lists. In multi-dimensional arrays you separate each axis with a comma. The form you will use most in analysis is the boolean mask: you write a condition and the array returns the elements that satisfy it.

values = np.array([11, 24, 8, 31, 19])

print(values[1])             # 24
print(values[1:4])           # [24  8 31] — 4 excluded
print(values[values >= 18])   # [24 31 19]

readings = np.array([[5.2, 7.1, 6.8],
                     [4.9, 8.3, 7.5]])

print(readings[0, 1])        # 7.1 — first row, second column
print(readings[:, 0])         # [5.2 4.9] — first column of every row

There is a detail here that catches most people once: basic slicing usually returns a view, not a copy. Change the slice and the source array changes too.

a = np.arange(6).reshape(2, 3)
b = a[:, 0]      # a view
b[0] = 99

print(a[0, 0])    # 99  → the source array changed too

c = a[:, 0].copy()   # an independent copy
c[0] = -1
print(a[0, 0])    # 99  → the source is untouched

The behaviour is deliberate and saves memory. But pass a slice into a function and modify it in place, and you corrupt the caller's data as well. If what you modify needs to be independent, write .copy().

Element-wise maths and ufuncs

For two arrays of the same shape, addition, subtraction and multiplication happen element by element. NumPy's universal functions (ufuncs) — sqrt, exp, log, sin — are applied to each element separately.

a = np.array([2.0, 4.0, 8.0])
b = np.array([1.0, 3.0, 5.0])

print(a + b)          # [ 3.  7. 13.]
print(a * b)          # [ 2. 12. 40.]
print(a ** 2)         # [ 4. 16. 64.]
print(np.sqrt(a))
print(np.where(a > 3, "high", "low"))

Here is the most frequently confused point: in NumPy, * is not matrix multiplication. It is element-wise. For the linear-algebra product use the @ operator or np.matmul.

A = np.array([[1, 2], [3, 4]])
B = np.array([[2, 0], [1, 2]])

print(A * B)   # [[2 0]
              #  [3 8]]  → element-wise
print(A @ B)   # [[ 4  4]
              #  [10  8]] → matrix product

Both return without an error; pick the wrong one and your code keeps running while quietly producing wrong numbers. So when you write linear algebra, choose consciously.

Statistical summaries and axis

sum, mean, median, std, min and max summarise an array. For multi-dimensional arrays the critical parameter is axis, and that is where most mistakes happen. Think of it this way: axis names the axis to be collapsed. In a two-dimensional table, axis=0 collapses the rows and leaves one value per column; axis=1 collapses the columns and leaves one value per row.

grades = np.array([[70, 82, 91],
                   [88, 76, 84],
                   [95, 90, 87]])

print(grades.mean())         # 84.78 — all values
print(grades.mean(axis=0))   # [84.33 82.67 87.33] — per course
print(grades.mean(axis=1))   # [81. 82.67 90.67] — per student

If you are unsure which one you want, test it on a small example: applying axis=0 to a 3×3 array should give three values, and those values should belong to the columns. Verify it once and you will not hesitate on real data.

Broadcasting: working across shapes

Broadcasting lets arrays with compatible shapes be combined without copying data. The rule: shapes are compared right to left, and at each position the dimensions must either be equal or one of them must be 1.

X = np.array([[10., 100.],
              [12., 130.],
              [14., 110.]])          # shape (3, 2)

col_mean = X.mean(axis=0)                  # shape (2,)
centred = X - col_mean                        # (3,2) - (2,) broadcasts

print(centred.mean(axis=0))              # ~[0. 0.]

The (2,) array is aligned from the right, stretched to (3, 2), and the same column means are subtracted from every row. If you wanted a row-wise operation instead, you would reshape X.mean(axis=1) into a column vector with .reshape(-1, 1).

That last row is a real warning: add a (4, 1) to a (1, 5) by accident and you get a 20-element array. On real data that can mean an intermediate array a thousand times larger than you expected. When you hit an error, or the result looks odd, print the shapes first.

Where the performance actually comes from

NumPy's speed comes from two things: the data sits contiguously in memory in a single type, and the operations run in compiled code. Python's per-element object overhead and loop cost disappear.

readings = np.array([12.5, 14.0, 9.5, 16.0])

# Looped: Python-level work per element
celsius = [(x - 32) * 5 / 9 for x in readings]

# Vectorised: one expression, whole array
celsius = (readings - 32) * 5 / 9

Even so, "NumPy is always faster" is not true. On arrays of a few hundred elements, setup cost can dominate. Every intermediate operation also produces a new array, so a long chain quietly creates several copies. If timing matters, measure it — do not guess.

NumPy and pandas: which, when?

pandas is designed to manage tabular data with labelled rows and columns, and it leans on NumPy for a good share of its numerical work. The rough division of labour: labels, mixed column types, joins, grouping and missing-value handling belong to pandas; homogeneous numeric arrays, matrix operations and library inputs belong to NumPy.

import pandas as pd

df = pd.DataFrame({
    "product": ["A", "B", "C"],
    "price": [10.0, 15.0, 12.0],
    "quantity": [3, 2, 5],
})

df["revenue"] = df["price"] * df["quantity"]   # pandas side

X = df[["price", "quantity"]].to_numpy()        # NumPy side
print(X.mean(axis=0))

to_numpy() does not carry labels: column names and the row index are not in the array. So write the column order explicitly — trying to remember later which column went into the model in which position is one of the quietest sources of error. And if you convert columns of different types together, NumPy picks a common type and your numbers can turn into strings.

Checklist

• Print the shape. Start debugging with ndim, shape and dtype.
• Use @ for matrix products. * is element-wise and fails silently.
• Verify the axis direction on a small example. Testing once on a 3×3 array is enough.
• Check broadcasting dimensions. Make sure you are not creating an unexpectedly large intermediate.
• Take a .copy() when you need one. A slice is usually a view, not a copy.
• Decide NaN behaviour explicitly. Using nanmean is a choice, not a default.
• Fix the column order. After to_numpy() there are no labels left.
• Measure performance on your own data. Vectorising may not pay off on small arrays.

Conclusion

Learning NumPy really means learning four concepts: the shape of an ndarray, element-wise operations, the direction of axis, and the broadcasting rules. Once those settle, your code gets shorter and you start to understand why pandas, scikit-learn and matplotlib behave the way they do.

The practical approach: explore the table with pandas, hand the numeric core to NumPy, write the result back into the table with labels. And when something goes wrong, you know where to look first — shape and dtype.