NumPy¶

import numpy as np  # Importing NumPy
np.__version__  # Check version of NumPy

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

arr2 = np.array((1, 2, 3))
arr2

arr3 = np.frombuffer(b'Hello World', dtype='S1')
arr3

arr_zeros = np.zeros((2, 3))  # 2x3 array of zeros
arr_zeros

arr_ones = np.ones((2, 3))  # 2x3 array of ones
arr_ones

arr_empty = np.empty((2, 3))  # 2x3 empty array
arr_empty

arr_range = np.arange(0, 10, 2)  # Array from 0 to 9 with step 2
arr_range

arr_linspace = np.linspace(0, 1, 5)  # 5 equally spaced numbers from 0 to 1
arr_linspace

arr_random = np.random.rand(2, 3)  # 2x3 array with random numbers between 0 and 1
arr_random

arr_identity = np.eye(3)  # 3x3 identity matrix
arr_identity

arr_diag = np.diag([1, 2, 3])  # Diagonal matrix from a list
arr_diag

dt = np.dtype([('age', np.int32), ('name', np.str_, 10)])
arr_structured = np.array([(21, 'Alice'), (25, 'Bob')], dtype=dt)
arr_structured

arr_full = np.full((2, 3), 7)  # Create a 2x3 array filled with the value 7
arr_full

arr_tile = np.tile([1, 2], (2, 3))  # Repeat [1, 2] in a 2x3 grid
arr_tile

arr1.shape  # Dimensions of the array

arr1.size  # Total number of elements

arr1.ndim  # Number of dimensions

arr1.dtype  # Data type of elements

arr1_float = arr1.astype(float)  # Convert to another type
arr1_float

arr1.itemsize  # Size of one element in bytes

arr1.nbytes  # Total memory used by array

arr1.flags  # Memory layout information

arr_nan_inf = np.array([1, 2, np.nan, np.inf])
np.isnan(arr_nan_inf), np.isinf(arr_nan_inf), np.isfinite(arr_nan_inf)

arr_add = arr1 + 1  # Add 1 to each element
arr_add

arr_mul = arr1 * 2  # Multiply each element by 2
arr_mul

arr_sum = np.add(arr1, arr2)  # Add arrays element-wise
arr_sum

arr_diff = np.subtract(arr1, arr2)  # Subtract arrays element-wise
arr_diff

arr_sum_total = np.sum(arr1)  # Sum of all elements
arr_sum_total

arr_mean = np.mean(arr1)  # Mean of elements
arr_mean

arr_max = np.max(arr1)  # Maximum value
arr_max

arr_min = np.min(arr1)  # Minimum value
arr_min

arr_prod = np.prod(arr1)  # Product of elements
arr_prod

arr_cumsum = np.cumsum(arr1)  # Cumulative sum of elements
arr_cumsum

arr_cumprod = np.cumprod(arr1)  # Cumulative product of elements
arr_cumprod

arr_exp = np.exp(arr1)  # Exponential of each element
arr_exp

arr_log = np.log(arr1)  # Natural logarithm
arr_log

arr_log10 = np.log10(arr1)  # Base-10 logarithm
arr_log10

arr_expm1 = np.expm1(arr1)  # Compute exp(x) - 1
arr_expm1

arr_sin = np.sin(arr1)  # Sine of each element
arr_sin

arr_cos = np.cos(arr1)  # Cosine of each element
arr_cos

arr_tan = np.tan(arr1)  # Tangent of each element
arr_tan

arr_arcsin = np.arcsin(arr1 / 10)  # Inverse sine
arr_arcsin

arr_arccos = np.arccos(arr1 / 10)  # Inverse cosine
arr_arccos

arr_arctan = np.arctan(arr1 / 10)  # Inverse tangent
arr_arctan

arr_round = np.round(arr1_float, decimals=2)  # Round to 2 decimal places
arr_round

arr_floor = np.floor(arr1_float)  # Floor operation
arr_floor

arr_ceil = np.ceil(arr1_float)  # Ceiling operation
arr_ceil

arr_trunc = np.trunc(arr1_float)  # Truncate elements to integers
arr_trunc

arr_reshaped = arr1.reshape((3, 1))  # Reshape to 3x1 array
arr_reshaped

arr_flattened = arr1.flatten()  # Flatten the array to 1D
arr_flattened

arr_raveled = np.ravel(arr1)  # Return a flattened array
arr_raveled

arr_T = arr1.reshape((1, 3)).T  # Transpose of the array
arr_T

arr_custom_T = np.transpose(arr1.reshape((3, 1)), (1, 0))  # Custom transpose
arr_custom_T

arr_concat = np.concatenate((arr1, arr2))  # Join arrays
arr_concat

arr_hstack = np.hstack((arr1.reshape((3, 1)), arr2.reshape((3, 1))))  # Horizontal stack
arr_hstack

arr_vstack = np.vstack((arr1, arr2))  # Vertical stack
arr_vstack

arr_split = np.split(arr_concat, 3)  # Split into 3 equal parts
arr_split

arr_hsplit = np.hsplit(arr_hstack, 2)  # Split horizontally
arr_hsplit

arr_vsplit = np.vsplit(arr_vstack, 2)  # Split vertically
arr_vsplit

arr_expanded = np.expand_dims(arr1, axis=0)  # Expand dimensions
arr_expanded

arr_squeezed = np.squeeze(arr_expanded)  # Remove single-dimensional entries
arr_squeezed

arr_tiled = np.tile(arr1, (2, 3))  # Repeat array
arr_tiled

arr_repeated = np.repeat(arr1, 3)  # Repeat elements of an array
arr_repeated

arr_rot90 = np.rot90(arr1.reshape((3, 1)))  # Rotate array by 90 degrees
arr_rot90

arr_fliplr = np.fliplr(arr1.reshape((3, 1)))  # Flip array left to right
arr_fliplr

arr_flipud = np.flipud(arr1.reshape((3, 1)))  # Flip array upside down
arr_flipud

arr_dot = np.dot(arr1, arr2)  # Dot product
arr_dot

arr_matmul = np.matmul(arr1.reshape((3, 1)), arr2.reshape((1, 3)))  # Matrix multiplication
arr_matmul

arr_matmul_op = arr1.reshape((3, 1)) @ arr2.reshape((1, 3))  # Matrix multiplication using @
arr_matmul_op

A = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])
x = np.linalg.solve(A, b)  # Solve linear equations Ax = b
x

arr_eigvals, arr_eigvecs = np.linalg.eig(A)  # Eigenvalues and eigenvectors
arr_eigvals, arr_eigvecs

arr_inv = np.linalg.inv(A)  # Inverse of a matrix
arr_inv

arr_det = np.linalg.det(A)  # Determinant of a matrix
arr_det

U, S, V = np.linalg.svd(A)  # Singular Value Decomposition
U, S, V

arr_norm = np.linalg.norm(arr1)  # Compute matrix or vector norm
arr_norm

arr_cond = np.linalg.cond(A)  # Compute the condition number of a matrix
arr_cond

arr_mean = np.mean(arr1)  # Mean
arr_mean

arr_median = np.median(arr1)  # Median
arr_median

arr_var = np.var(arr1)  # Variance
arr_var

arr_std = np.std(arr1)  # Standard deviation
arr_std

arr_percentile = np.percentile(arr1, 50)  # 50th percentile (median)
arr_percentile

arr_corr = np.corrcoef(arr1, arr2)  # Correlation coefficient
arr_corr

arr_cov = np.cov(arr1, arr2)  # Covariance
arr_cov

arr_hist, arr_bins = np.histogram(arr1, bins=3)  # Histogram of an array
arr_hist, arr_bins

from scipy import stats
arr_binned_statistic = stats.binned_statistic(arr1, arr1, statistic='mean', bins=3)  # Compute binned statistics
arr_binned_statistic.statistic

arr_broadcast_add = arr1 + 5  # Add 5 to all elements
arr_broadcast_add

arr_broadcast_array = arr1 + np.array([1, 2, 3])  # Add array [1, 2, 3] to each row
arr_broadcast_array

arr_broadcast_mult = arr1 * np.array([1, 2, 3])  # Element-wise multiplication with broadcasting
arr_broadcast_mult

arr_broadcast_expand = np.expand_dims(arr1, axis=0) + arr1  # Broadcasting with dimension expansion
arr_broadcast_expand

first_element = arr1[0]  # First element
first_element

last_element = arr1[-1]  # Last element
last_element

element_0_2 = arr1[0]  # First element
third_element = arr1[2]  # Third element
first_element, third_element

arr_slice_1_3 = arr1[1:3]  # Elements from index 1 to 2
arr_slice_1_3

arr_slice_all = arr1[:]  # All elements
arr_slice_all

arr_slice_skip = arr1[::2]  # Every other element
arr_slice_skip

arr_fancy_index = arr1[[0, 2]]  # Elements 0 and 2
arr_fancy_index

arr_bool_mask = arr1[arr1 > 2]  # Elements greater than 2
arr_bool_mask

arr_where = np.where(arr1 > 2, arr1, -arr1)  # Replace negative values with their absolute value
arr_where

arr_set_values = arr1.copy()
arr_set_values[arr_set_values > 2] = 0  # Set all positive elements to 0
arr_set_values

arr_ix = np.ix_([0, 1], [2, 3])  # Create a mesh grid from indexing arrays
arr_ix

arr_rand = np.random.rand(2, 3)  # Uniform distribution (0, 1)
arr_rand

arr_randn = np.random.randn(2, 3)  # Standard normal distribution
arr_randn

arr_randint = np.random.randint(0, 10, size=(2, 3))  # Random integers between 0 and 9
arr_randint

arr_perm = np.random.permutation(arr1)  # Randomly permute an array
arr_perm

arr_choice = np.random.choice(arr1, size=3, replace=False)  # Random sample without replacement
arr_choice

arr_binomial = np.random.binomial(n=10, p=0.5, size=10)  # Binomial distribution
arr_binomial

arr_poisson = np.random.poisson(lam=3, size=10)  # Poisson distribution
arr_poisson

np.random.seed(42)  # Set random seed for reproducibility
arr_rand_seed = np.random.rand(2, 3)
arr_rand_seed

np.save('array.npy', arr1)  # Save array to binary file
arr_loaded = np.load('array.npy')  # Load array from binary file
arr_loaded

np.savetxt('array.txt', arr1)  # Save array to text file
arr_loaded_txt = np.loadtxt('array.txt')  # Load array from text file
arr_loaded_txt

np.savez('arrays.npz', arr1=arr1, arr2=arr2)  # Save multiple arrays to a compressed file
npzfile = np.load('arrays.npz')
npzfile['arr1'], npzfile['arr2']

arr1

arr_csv = np.genfromtxt('data.csv', delimiter=',')  # Load data from CSV file
arr_csv

p = np.poly1d([1, 2, 3])  # Define a polynomial p(x) = 1x^2 + 2x + 3
p(2)  # Evaluate polynomial at x = 2

p.roots  # Find roots of the polynomial

x = np.array([1, 2, 3, 4])
y = np.array([1, 4, 9, 16])
p_fit = np.polyfit(x, y, deg=2)  # Fit a polynomial of degree 2 to data points (x, y)
p_fit

p_deriv = p.deriv()  # Derivative of the polynomial
p_deriv

p_integ = p.integ()  # Integral of the polynomial
p_integ

def add_five(x):
    return x + 5

vectorized_func = np.vectorize(add_five)  # Apply a function element-wise to an array
vectorized_func(arr1)

x = np.array([1, 2, 3])
y = np.array([4, 5, 6])
X, Y = np.meshgrid(x, y)  # Create a coordinate grid from 1D arrays x and y
X, Y

arr_add_at = np.array([1, 2, 3])
np.add.at(arr_add_at, [0, 1], 5)  # Increment elements at indices `idx` by 5
arr_add_at

arr_sorted = np.sort(arr1)  # Sort array
arr_sorted

arr_argsort = np.argsort(arr1)  # Indices of the sorted array
arr_argsort

arr_where_condition = np.where(arr1 > 2)  # Indices where the condition is met
arr_where_condition

arr_count_nonzero = np.count_nonzero(arr1)  # Count non-zero elements
arr_count_nonzero

arr_flags = arr1.flags  # Check memory layout (C_CONTIGUOUS, F_CONTIGUOUS)
arr_flags

arr_contig = np.ascontiguousarray(arr1)  # Convert to C-contiguous array
arr_contig.flags

memmap_arr = np.memmap('data.dat', dtype='float32', mode='w+', shape=(3, 3))  # Memory-mapped file
memmap_arr

arr_copy = arr1.copy()  # Create a deep copy of the array
arr_copy

arr_view = arr1.view()  # Create a view of the array (shallow copy)
arr_view

arr_take = np.take(arr1, [0, 2])  # Take elements at indices 0 and 2
arr_take

arr_put = arr1.copy()
np.put(arr_put, [0, 2], [-1, -2])  # Set elements at indices 0 and 2
arr_put

arr_choose = np.choose([0, 1], arr1)  # Construct an array from elements chosen from `arr1`
arr_choose

arr_lexsort = np.lexsort((arr2, arr1))  # Sort by `arr1`, then by `arr2`
arr_lexsort

arr_determinant = np.linalg.det(A)  # Determinant of a matrix
arr_determinant

arr_rank = np.linalg.matrix_rank(A)  # Rank of a matrix
arr_rank

arr_trace = np.trace(A)  # Sum of diagonal elements (trace)
arr_trace

arr_kron = np.kron(arr1, arr2)  # Kronecker product of two arrays
arr_kron

arr_outer = np.outer(arr1, arr2)  # Outer product of two arrays
arr_outer

arr_solve = np.linalg.solve(A, b)  # Solve Ax = b for x
arr_solve

arr_lstsq = np.linalg.lstsq(A, b, rcond=None)  # Solve Ax = b using least squares
arr_lstsq[0]

arr_dtype = np.array([1, 2, 3], dtype=np.float32)  # Specify data type
arr_dtype

arr_converted_dtype = arr1.astype(np.int32)  # Convert array to specified data type
arr_converted_dtype

arr_complex = np.array([1+2j, 3+4j], dtype=np.complex64)  # Complex data type
arr_complex

arr_dtype_check = arr_complex.dtype  # Check data type
arr_dtype_check

np.issubdtype(arr_complex.dtype, np.number)  # Check if the data type is a subtype of `np.number`