• What is Numpy?

NumPy (Numerical Python) is a Python library used for fast and efficient numerical computations with arrays.

• Why use Numpy?

NumPy is a Python library that lets you efficiently store, manipulate, and perform fast mathematical operations on large arrays of numbers.

• Who’s it for?

NumPy is for anyone who works with numerical data in Python, including:

• Data scientists – analyzing datasets, computing statistics, preparing data for machine learning

• Machine learning / AI engineers – handling tensors, matrices, and input data for models

• Scientists & researchers – performing simulations, experiments

• Installing NumPy

If you have Anaconda/Jupyter:

NumPy comes pre-installed with Anaconda/Jupyter.

Just type this at the top of your notebook:

import numpy as np

You're ready to go.

If you don't have Anaconda:

Open your terminal or command prompt and run:

pip install numpy

Then import it the same way:

import numpy as np

What does as np mean? It's just a shortcut.

• Verify it’s installed:

And to verify its installed you can put this in your script in your jupyter notebook or your python script ,we’d look in to that later but for now :

import numpy as np
print(np.__version__)

#Result example:2.4.3

this will print out a result of the version you are currently using ,these may not be the

• Importing NumPy:

I know i have added this before but it is really important so please before you can use NumPy, you need to import it into your Python script. This is the very first thing you do to get started.

import numpy as np

That is it.

The np part is just a shortcut or well said an alias so that instead of typing numpy every time, you just type np..

as np is a standard alias used to shorten numpy when writing code.

• Your First NumPy Array:

An array is just a list of numbers that NumPy can work with. Here is how you create one:

import numpy as np
my_array = np.array([10, 20, 30, 40, 50])
print(my_array)

Output:
[10 20 30 40 50]

This is your first numpy array ,and to reflect more on that we would look at types of arrays ,1D array and 2D array and 3D array..

import numpy as np
a = np.array([10, 20, 30])          # 1D array
b = np.array([[1, 2], [3, 4]])      # 2D array
c = np.array([[[1,  2,  3],         # 3D  array (2, 2, 3)
               [4,  5,  6]],
              [[7,  8,  9],
               [10, 11, 12]]])

• Use case: Setting up a NumPy environment for a data analysis project

When starting a data analysis project, NumPy is used to set up a fast and efficient environment for working with numerical data.

After installing and importing Numpy , as shown earlier ,then you load or create your dataset as a NumPy array this way :

data = np.array([10, 20, 30, 40, 50])

And once the data is in an array, you can quickly perform operations like this:

print(data.mean())   # average
print(data.sum())    # total
print(data.shape)    # structure of the data

In NumPy, array reshaping is about changing the shape (dimensions) of an array without altering its data. NumPy provides three main ways to do this: reshape, ravel, and flatten.

• Reshape:

reshape changes the shape of an array without changing the data and also returns a view (no new memory) when possible and you must provide a shape compatible with the number of elements.

import numpy as np

arr = np.array([[1, 2], [3, 4], [5, 6]])
# shape = (3,2) → total elements = 6

reshaped = arr.reshape(2, 3)  # new shape (2,3)
print(reshaped)
# [[1 2 3]
#  [4 5 6]]

• Ravel:

ravel flattens the array into a 1D array, returns a view whenever possible (changes to the raveled array may affect the original array).

flat_view = arr.ravel()
print(flat_view)
# [1 2 3 4 5 6]

flat_view[0] = 100
print(arr)
# [100 2 ...] → original array is modified because ravel often returns a view

• Flatten:

flatten is used flatten an array into 1D.Always returns a copy, so the original array is not affected.

flat_copy = arr.flatten()
flat_copy[0] = 100
print(arr)        # original array unchanged
print(flat_copy)  # first element changed

This section is about doing calculations on Numpy arrays, Operations are vectorized (no loops required).

• Element-wise operations (+, -, *, //, /) :

+ -Addition

- -Subtraction

* -Multiplication

/ -Division

// -Floor division

a=np.array([1,2,3,4,5,6])
b=np.array([2,3,5,3.1,8,9])

print(a+b)    #[ 3.   5.   8.   7.1 13.  15. ]
print(a-b)    #[-1.  -1.  -2.   0.9 -3.  -3. ]
print(a/b)    #[0.5        0.66666667 0.6        1.29032258 0.625      0.66666667]
print(a * b)   #[ 2.   6.  15.  12.4 40.  54. ]
print(a // b)  #[0. 0. 0. 1. 0. 0.]

• Power and Modulus:

Power (``) → raises numbers

Modulus (%) → gives remainder

print(b%a)    #[0.  1.  2.  3.1 3.  3. ]
print(a ** 2)  #[ 1  4  9 16 25 36]

Explanation:

• 2^2 = 4, 3^2 = 9

• 3 % 2 = 1 (remainder when divided)

• Aggregations(sum, mean, min, max, std):

sum – total of all elements

mean – average value

min – smallest value

max – largest value

std – standard deviation (measure of spread)

var -(square of standard deviation)

median -(middle value)

arr =np.array([1,2,3])

print(np.sum(arr))         #6
print(np.median(arr))      #2.0
print(np.std(arr))         #0.816496580927726
print(np.min(arr))         #1
print(np.max(arr))         #3
print(np.var(arr))         #0.6666666666666666

Indexing and slicing let you access or extract specific elements or subarrays from a NumPy array. It’s similar to Python lists, but works for multi-dimensional arrays too.NumPy indexing is faster and supports multi-dimensional access.

arr = np.array([10, 20, 30, 40, 50, 60])

• 1D Array Indexing :

import numpy as np

arr = np.array([10, 20, 30, 40, 50])

# Access a single element (0-based index)
print(arr[0])  # 10
print(arr[3])  #40

• 1D Array Slicing:

# Slice: arr[start:stop:step]
print(arr[1:4])   # [20 30 40]  (from index 1 to 3)
print(arr[:3])    # [10 20 30]  (start to index 2)
print(arr[2:])    # [30 40 50]  (index 2 to end)
print(arr[::2])   # [10 30 50]  (every 2nd element)

• 2D Array Indexing :

arr2d = np.array([[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9]])

# Access single element: arr2d[row, column]
print(arr2d[0, 1])  # 2
print(arr2d[2, 2])  # 9

• 2D Array Slicing:

# Slice rows
print(arr2d[0:2, :])  # first 2 rows
# [[1 2 3]
#  [4 5 6]]

# Slice columns
print(arr2d[:, 1:3])  # last 2 columns
# [[2 3]
#  [5 6]
#  [8 9]]

# Slice subarray
print(arr2d[1:3, 0:2])  
# [[4 5]
#  [7 8]]

• Boolean Indexing (Conditional)

# Select elements based on condition
print(arr[arr > 30])  # [40 50]

• Multidimensional Slicing :

import numpy as np

matrix = np.array([[1, 2, 3, 4],
                   [4, 5, 6, 7],
                   [7, 8, 9, 10]])
                   

• Modifying values:

You can change values directly

arr = np.array([10, 20, 30])

arr[1] = 100
print(arr)   # [10 100 30]

Also works with slicing:

arr[0:2] = 0
print(arr)   # [0 0 30]

• Advanced indexing:
  • np.take() :

  Another way to select elements using indices.

  arr = np.array([10, 20, 30, 40])
  
  print(np.take(arr, [1, 3]))   # [20 40]

  • Indexing with Multiple Arrays (2D specific):

  arr2d = np.array([[1, 2],
                    [3, 4]])
  
  print(arr2d[[0, 1], [1, 0]])   # [2 3]

Broadcasting is a feature in NumPy that allows arrays of different shapes to be used together in arithmetic operations, So literally NumPy automatically expands the smaller array to match the shape of the larger one.Broadcasting avoids copying data, making operations memory-efficient.

Rules of Broadcasting :

NumPy compares shapes element by element from the trailing (right-most) dimension:

• If the dimensions are equal, they are compatible.

• If one dimension is 1 ,it is stretched to match the other.

• if dimensions differ and neither is 1,broadcasting fails.

Simple Scalar Broadcasting

arr=np.array([1,2,3,4])
arr + 10                #[11,12,13,14]  <------ 10 is broadcast across all elements 
arr * 2                 #[2,4,6,8]
arr **2                 #[1,4,9,16]

1D + Scalar Broadcasting

a=np.array([1,2,3])
b=5
print(a + b)        #[6,7,8]

#shape breakdown:
#a   ->(3,)
#b --->()     <----- Scalar Stretched to (3,)

2D Array + 1D Array

matrix =np.array([[1,2,3],[4,5,6]])
row =np.array ([10,20,30])

matrix + row 
#[[11,22,33],[14,25,36]]


#Shape breakdown:
#matrix -----> (2,3)
#row  ------> (3,)    <------broadcast along axis 0

Column Vector Broadcasting

matrix =np.array([[1,2,3],[4,5,6]])
col =np.array ([[10],[20]])

matrix + col 
#[[11,12,13],[24,25,26]]

#Shape breakdown
#matrix ->(2,3)
#col -> (2,1)   <-----broadcasting along axis 1

Broadcasting Failure Example

a=np.array([[1,2,3]])   #shape (1,3)
b=np.array([[1,2]])     # shape (1,2)

a + b # ValueError:Operands could not be broadcast 
      #3 and 2 are incompatible (neither is 1)

Universal Functions (ufuncs) are NumPy functions that operate element-wise on arrays without explicit loops. They are implemented in optimized C code, so they are very fast.

Math ufuncs

import numpy as np

arr = np.array([1, 4, 9, 16])

print(np.sqrt(arr))            # [1. 2. 3. 4.]
print(np.exp(arr))             # [2.718... 54.598... 8103.083... 8886110.52...]
print(np.log(arr))             # natural log:  [0.         1.38629436 2.19722458 2.77258872]
print(np.log10(arr))           # base-10 log:  [0.         0.60205999 0.95424251 1.20411998]
print(np.abs(np.array([-1, -2, 3])))  # [1 2 3]

Trigonometric ufuncs

import numpy as np

angles = np.array([0, np.pi / 2, np.pi])

print(np.sin(angles))  # [0. 1. 0.] (approx)
print(np.cos(angles))  # [ 1.  0. -1.]
print(np.tan(angles))  # [0. large 0.]

Rounding

import numpy as np

arr = np.array([1.2, 2.7, 3.5, -1.8])

print(np.floor(arr))  # [ 1.  2.  3. -2.]  (always rounds down)
print(np.ceil(arr))   # [ 2.  3.  4. -1.]  (always rounds up)
print(np.round(arr))  # [ 1.  3.  4. -2.]  (rounds to nearest)

Comparison ufuncs

import numpy as np

a = np.array([1, 5, 3])
b = np.array([2, 4, 3])

print(np.maximum(a, b))  # [2 5 3]  (element-wise max)
print(np.minimum(a, b))  # [1 4 3]  (element-wise min)

Methods of ufuncs

Key features

import numpy as np

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])

result = np.add(arr1, arr2)
print(result)  # [5 7 9]

Stacking combines arrays into one larger array.

Splitting divides an array into smaller arrays.

The numpy.random module is used to generate random numbers, arrays, and samples from probability distributions.

• Setting a Seed: To ensure your results are the same every time your code runs, use a random seed.

import numpy as np
rng = np.random.default_rng(42)   # recommended modern approach

• Common Random Functions:
  • Uniform Distribution (0 to 1):

  rng.random(3)        # 1D array
  rng.random((2, 3))   # 2×3 matrix

  • Standard Normal Distribution:

  rng.standard_normal(4)

  • Random Integers:

  rng.integers(1, 10, 5)

  • Random Selection:

  rng.choice([10, 20, 30, 40], size=3)

  • Shuffling Arrays:

  arr = np.array([1, 2, 3, 4, 5])
  
  rng.shuffle(arr)      # modifies original array
  print(arr)

  • Shuffle vs Permutation

  rng.permutation(arr)  # returns a new shuffled array

• Probability Distributions:
  • Normal Distribution:

  rng.normal(loc=0, scale=1, size=5)

  • Uniform Distribution:

  rng.uniform(low=0, high=10, size=5)

  • Binomial Distribution

  rng.binomial(n=10, p=0.5, size=5)

NumPy provides a powerful linear algebra module, np.linalg, used for matrix operations in machine learning, data science, and engineering.

• Matrix Multiplication:

Matrix multiplication combines two arrays based on linear algebra rules (not element-wise).

import numpy as np

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

B = np.array([[5, 6],
              [7, 8]])

np.dot(A, B)
# [[19 22]
#  [43 50]]

A @ B   # preferred modern syntax

• Transpose

  np.linalg.inv(A)
  # [[-2.   1. ]
  #  [ 1.5 -0.5]]

The transpose flips rows into columns.

A = np.array([[1, 2, 3],
              [4, 5, 6]])

A.T
# [[1 4]
#  [2 5]
#  [3 6]]

• Determinant and Inverse

  Determinant

  The determinant is a scalar value that describes properties of a matrix (e.g., invertibility).

  A = np.array([[1, 2],
                [3, 4]])
  
  np.linalg.det(A)   # -2.0

• Eigenvalues and Eigenvectors

  Eigenvalues and eigenvectors describe how a matrix transforms space.

  A = np.array([[4, 2],
                [1, 3]])
  
  eigenvalues, eigenvectors = np.linalg.eig(A)
  
  print(eigenvalues)    # [5. 2.]
  print(eigenvectors)   # columns are eigenvectors

Solving a Linear System

# Solving a system of equations:
# 2x + y = 8
# x + 3y = 13

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

b = np.array([8, 13])

np.linalg.solve(A, b)  # [3. 2.]

Key Notes

• Matrix multiplication is not element-wise (use for element-wise)

• Use @ for matrix multiplication

• np.linalg functions require compatible shapes

• Not all matrices have an inverse (determinant must not be zero)

• Prefer np.linalg.solve() over inv(A) @ b