Numpy and Inbuilt Functions (Python)

Introduction to NumPy

NumPy, short for Numerical Python, is a fundamental package for scientific computing in Python. It provides support for large multi-dimensional arrays and matrices, along with a collection of mathematical functions to operate on these arrays. NumPy is one of the core libraries for data analysis and machine learning due to its efficiency and the ability to perform complex mathematical operations seamlessly.

Importance in Data Analysis and Machine Learning

NumPy is crucial in data analysis and machine learning for several reasons:

Efficient Storage and Computation: NumPy arrays are more compact and faster compared to Python lists. This is because NumPy leverages continuous memory blocks and highly optimized C and C++ code for performance. Operations on NumPy arrays are executed in compiled code, making them significantly faster.
Interoperability: Many data analysis and machine learning libraries, such as pandas, SciPy, scikit-learn, and TensorFlow, are built on top of NumPy. This makes it easy to integrate and use these libraries together.
Mathematical Functions: NumPy provides a wide array of mathematical functions that are essential for data analysis and machine learning. These functions include statistical operations, linear algebra routines, and Fourier transforms.
Multi-dimensional Arrays: NumPy’s support for multi-dimensional arrays (also known as ndarrays) allows for the efficient handling of datasets that are more complex than simple one-dimensional arrays.

Used for Creating Multi-dimensional Arrays

Multi-dimensional arrays are a cornerstone of numerical and scientific computing. NumPy allows the creation and manipulation of these arrays effortlessly. These arrays can be of any dimension, and NumPy’s API provides methods to create, reshape, and manipulate them in numerous ways.

High Performance Due to C++ Bindings

The high performance of NumPy comes from its core, which is written in C and C++. This ensures that array operations are executed in compiled, rather than interpreted, code. The result is operations that are much faster than those executed in pure Python. Additionally, NumPy uses optimized libraries like BLAS and LAPACK for linear algebra operations.

Creating Arrays

Importing NumPy Library

To start using NumPy, the first step is to import the library. This is typically done using the alias np to keep the code concise.

import numpy as np

Creating One-dimensional and Multi-dimensional Arrays

Creating arrays in NumPy is straightforward. The np.array function is used to create arrays from Python lists or tuples.

# One-dimensional array
one_d_array = np.array([1, 2, 3, 4, 5])

# Two-dimensional array
two_d_array = np.array([[1, 2, 3], [4, 5, 6]])

# Three-dimensional array
three_d_array = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

Using Functions like np.array and np.reshape

The np.array function converts a list into a NumPy array. For reshaping arrays, the np.reshape function is used, allowing the dimensions of the array to be changed without changing its data.

# Reshaping an array
reshaped_array = np.reshape(one_d_array, (5, 1))

Indexing and Slicing

Retrieving Data Using Indexing

Indexing in NumPy is used to access array elements. NumPy arrays support both positive and negative indices.

# Accessing elements in a one-dimensional array
print(one_d_array[0])  # Output: 1
print(one_d_array[-1])  # Output: 5

# Accessing elements in a two-dimensional array
print(two_d_array[0, 1])  # Output: 2
print(two_d_array[1, -1])  # Output: 6

Indexing in One-dimensional and Two-dimensional Arrays

In a one-dimensional array, indexing works similar to lists. In multi-dimensional arrays, a comma-separated tuple of indices is used.

# One-dimensional indexing
print(one_d_array[2])  # Output: 3

# Two-dimensional indexing
print(two_d_array[1, 2])  # Output: 6

Using Conditions and Broadcasting

NumPy supports conditional indexing and broadcasting, making operations on arrays more flexible and powerful.

# Conditional indexing
print(one_d_array[one_d_array > 2])  # Output: [3 4 5]

# Broadcasting
broadcast_array = one_d_array + 10  # Adds 10 to each element
print(broadcast_array)  # Output: [11 12 13 14 15]

Inbuilt Functions

NumPy provides numerous inbuilt functions to create and manipulate arrays.

Functions like np.arange, np.linspace, and np.ones

These functions help in creating arrays with specific values and shapes.

# Using np.arange
arange_array = np.arange(0, 10, 2)  # Output: [0 2 4 6 8]

# Using np.linspace
linspace_array = np.linspace(0, 1, 5)  # Output: [0.   0.25 0.5  0.75 1.  ]

# Using np.ones
ones_array = np.ones((2, 3))  # Output: [[1. 1. 1.]
                              #          [1. 1. 1.]]

Creating Arrays with Specific Values and Shapes

NumPy allows for creating arrays filled with zeros, ones, or any specific value using functions like np.zeros, np.ones, and np.full.

# Creating an array of zeros
zeros_array = np.zeros((2, 2))  # Output: [[0. 0.]
                                #          [0. 0.]]

# Creating an array of ones
ones_array = np.ones((3, 3))  # Output: [[1. 1. 1.]
                              #          [1. 1. 1.]
                              #          [1. 1. 1.]]

# Creating an array with a specific value
full_array = np.full((2, 3), 7)  # Output: [[7 7 7]
                                 #          [7 7 7]]

Using Random Functions for Sampling

NumPy’s random module provides functions to generate random numbers and create arrays with random values.

# Creating an array with random values
random_array = np.random.random((2, 2))  # Output: [[0.5488135  0.71518937]
                                         #          [0.60276338 0.54488318]]

# Creating an array with random integers
random_int_array = np.random.randint(1, 10, (3, 3))  # Output: [[3 7 9]
                                                     #          [3 2 4]
                                                     #          [8 8 1]]

Advanced Operations

Copy Function and Broadcasting

The np.copy function creates a deep copy of an array, ensuring that changes to the new array do not affect the original array.

# Copying an array
original_array = np.array([1, 2, 3])
copied_array = np.copy(original_array)
copied_array[0] = 99

print(original_array)  # Output: [1 2 3]
print(copied_array)    # Output: [99 2 3]

Broadcasting allows NumPy to perform element-wise operations on arrays of different shapes.

# Broadcasting example
a = np.array([1, 2, 3])
b = np.array([[1], [2], [3]])
result = a + b  # Output: [[2 3 4]
                #          [3 4 5]
                #          [4 5 6]]

Understanding Reference Types and Memory Allocation

Understanding how NumPy handles memory can help avoid common pitfalls related to copying and modifying arrays.

# Reference example
array_a = np.array([1, 2, 3])
array_b = array_a
array_b[0] = 99

print(array_a)  # Output: [99 2 3]  (because array_b is a reference to array_a)

To avoid unintended modifications, use np.copy to create a true copy.

Practical Examples and Exercises

Exercise 1: Create a 3x3 matrix with values ranging from 0 to 8.

matrix = np.arange(9).reshape(3, 3)
print(matrix)
# Output:
# [[0 1 2]
#  [3 4 5]
#  [6 7 8]]

Exercise 2: Create a 2x5 matrix with random integer values between 10 and 50.

random_matrix = np.random.randint(10, 50, (2, 5))
print(random_matrix)
# Example Output:
# [[29 18 10 45 21]
#  [40 23 49 31 37]]

Exercise 3: Create a one-dimensional array and reshape it into a 3x3 matrix. Then, retrieve the elements in the second row.

one_d_array = np.arange(1, 10)
reshaped_matrix = one_d_array.reshape(3, 3)
second_row = reshaped_matrix[1, :]
print(second_row)  # Output: [4

 5 6]

Exercise 4: Generate an array of 10 random floats and compute their mean.

random_floats = np.random.random(10)
mean_value = np.mean(random_floats)
print(mean_value)

Exercise 5: Use broadcasting to add a 1-dimensional array to each row of a 2-dimensional array.

array_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
array_1d = np.array([1, 1, 1])
result = array_2d + array_1d
print(result)
# Output:
# [[ 2  3  4]
#  [ 5  6  7]
#  [ 8  9 10]]