Programs
Updated on December 17, 2024
NumPy is one of those core Python libraries which are highly powerful and can save a lot of time for you because it handles all your numerical calculations for array-based data. Its efficient array processing capabilities make it indispensable for tasks involving large datasets or mathematical operations.
This library finds its application in everything starting from data science and machine learning, and ending with scientific modelling. Its use is very widespread in the field due to its performance, flexibility, and great ease of use with other Python libraries. Understanding NumPy provides a good background for handling a lot of advanced computing tasks.
In this blog, we will discuss more than 70 requisite NumPy interview questions. These are sectionalised for fresh graduates, intermediate level and experts. You will get more familiar with Numpy as you go through these different questions and answers.
You can install NumPy using pip, the Python package manager. Open a terminal or
command prompt and run:
pip install numpy
For specific versions:
pip install numpy==1.21.0
To verify the installation:
import numpy as np
print(np.__version__)
You can create a NumPy array using the np.array() function.
Example:
Other methods:
| Aspect | Single Precision (float32) | Double Precision (float64) |
| Bit Size | 32 bits | 64 bits |
| Precision | Approximately 7 decimal digits | Approximately 16 decimal digits |
| Memory Usage | Uses less memory per element (4 bytes) | Uses more memory per element (8 bytes) |
| Performance | Faster computations due to smaller size | Slower compared to single-precision |
| Use Cases | Graphics, machine learning models where speed is critical | Scientific computations requiring high precision |
| Range | ±3.4e−38 to ±3.4e+38 | ±1.7e−308 to ±1.7e+308 |
Use the np.dot() function.
Example:
For matrices:
| Data Type | Description |
| int32 | 32-bit integer |
| float64 | 64-bit floating point |
| complex | Complex numbers |
| bool | Boolean values |
| object | Python objects |
Example:
| Aspect | Shallow Copy | Deep Copy |
| Definition | References original data | Creates a new array |
| Changes | Reflect in both copies | Independent of each other |
Example:
arr = np.array([10, 20, 30])
print(arr[1]) # Output: 20
print(arr[1:]) # Output: [20, 30]
matrix = np.array([[1, 2], [3, 4]])
print(matrix[1, 0]) # Output: 3
Example:
For multidimensional arrays:
matrix = np.array([[1, 2], [3, 4]])
print(np.min(matrix, axis=0)) # Output: [1, 2]
print(np.max(matrix, axis=1)) # Output: [2, 4]
| Aspect | np.dot() | np.matmul() |
| Operation Type | Dot product for vectors; matrix multiplication for matrices | Matrix multiplication for 2D arrays and higher |
| Behavior with Higher Dimensions | Performs tensor dot product, which can be less intuitive | Handles stacking of matrices for higher dimensions |
| Broadcasting | Limited broadcasting capabilities | Supports more extensive broadcasting |
| Product Type | Scalar, vector, or matrix based on input dimensions | Strictly matrix product for 2D or higher arrays |
| Alternative Operators | Can be replaced by @ operator in Python 3.5+ | Same as @ operator |
The np.mean() function returns the mean of the elements in an array.
Example:
For multidimensional arrays:
| Feature | NumPy Arrays | Python Lists |
| Speed | Faster for numerical tasks | Slower |
| Memory Efficiency | Compact storage | Requires more memory |
| Broadcasting Support | Yes | No |
| Element-wise Operations | Built-in | Requires loops |
Use arithmetic operators directly:
The np.var() function calculates the variance of elements in an array.
Example:
The np.random module generates random numbers and performs sampling operations:
Example:
Use the flatten() or ravel() function:
Matrix inversion is finding a matrix A⁻¹ such that A * A⁻¹ = I, where I is the identity matrix.
Use np.linalg.inv():
Output:
Use np.vstack():
# Output:
Use np.full():
# Output:
Use np.ones() or np.zeros():
ones = np.ones((2, 2))
zeros = np.zeros((2, 2))
You can calculate a signal’s Fourier transform with NumPy’s np.fft.fft() function. This takes in the time domain of a signal into the frequency domain. Thus enabling you to look at exactly what frequencies exist. That is:
To remove missing or null values from a NumPy array, you can use boolean indexing or filtering. Although NumPy does not natively support NaN handling like Pandas, you can still identify NaN values using np.isnan().
For example:
| Aspect | Indexing | Slicing |
| Purpose | Accesses specific elements | Extracts a subarray |
| Input | Single value or index array | Start:Stop:Step format |
| Returns | A single value or a lower-dimensional array | A view or copy of the original array |
Despite these limitations, NumPy remains a powerful library for numerical computing.
The np.diag() function extracts the diagonal elements of a square matrix or creates a diagonal matrix from a 1D array.
For example:
To create a diagonal matrix:
This function is particularly useful in linear algebra, where diagonal elements play a key role in operations like eigenvalue decomposition.
Negative indexing is very useful when you don’t know the exact size of the array. All you have to do is assign an index to -1, which ultimately means the last index in the array, then -2 to the second last index in the array, and so on.
For example:
It also works with multidimensional arrays:
matrix = np.array([[1, 2], [3, 4]])
print(matrix[-1, -1]) # Output: 4
| Aspect | np.sum() | sum() |
| Library | NumPy | Built-in Python |
| Input Types | NumPy arrays, lists, tuples | Iterables like lists, tuples, etc. |
| Performance | Optimised for large numerical data | Slower for large datasets |
| Axis Parameter | Supports multi-dimensional arrays with axis argument | Only works with 1D iterables |
| Data Types | Handles various numerical data types efficiently | Primarily for integers and floats |
| Return Type | Returns a NumPy scalar or array | Returns a Python scalar |
| Broadcasting | Supports broadcasting for element-wise summation | Does not support broadcasting |
NumPy itself does not have plotting functions. However, you can use NumPy in conjunction with Matplotlib, in order to create various different types of plots. For example, you can create data with the help of NumPy and then use Matplotlib to make interesting plots.
Example:
Here, NumPy generates the data, while Matplotlib handles the plotting. This combination is widely used in data visualisation tasks.
Example:
For multidimensional arrays:
Matrix multiplication is performed using np.matmul() or the @ operator.
Example:
This calculates the dot product of rows and columns. For element-wise multiplication, use the * operator:
result = matrix1 * matrix2
print(result)
| Feature | Structured Arrays | Record Arrays |
| Definition | Arrays with complex data types (fields with names) | Subclass of structured arrays with attribute access |
| Access Method | Access fields using indexing (e.g., arr[‘field’]) | Access fields as attributes (e.g., arr.field) |
| Functionality | Suitable for heterogeneous data storage | Enhanced access and usability over structured arrays |
| Creation | np.array([…], dtype=[(‘field1’, type), …]) | arr.view(np.recarray) |
| Use Cases | Storing records with multiple data types | Easier access for data analysis and manipulation |
You can reverse an array using slicing with a step of -1.
Example:
For multidimensional arrays:
This approach reverses both rows and columns effectively.
Use np.sort() for ascending order:
Use slicing for descending order:
print(np.sort(arr)[::-1]) # Output: [4 3 2 1]
Sort along a specific axis in a multidimensional array:
Use conditional indexing:
Combine conditions:
print(arr[(arr > 2) & (arr < 5)]) # Output: [3 4]
Here, you can use np.random.randn(). This gives you the standard normal distribution:
random_numbers = np.random.randn(5)
print(random_numbers)
For custom mean and standard deviation:
mean, std = 5, 2
numbers = np.random.normal(mean, std, 5)
print(numbers)
You can use DataFrame.values or to_numpy():
# Output:
Use np.random.rand() for uniform distribution:
random_numbers = np.random.rand(5)
print(random_numbers)
Use np.random.randint() for integers:
random_integers = np.random.randint(1, 10, 5)
print(random_integers)
Yes, you can use astype():
Use np.reshape():
# Output:
Use -1 to let NumPy calculate the dimension:
reshaped = arr.reshape(-1, 2)
Masked arrays allow the hiding of specific elements.
You can use np.ma.masked_where() to mask based on a condition:
arr = np.array([1, 2, 3, 4])
masked = np.ma.masked_where(arr > 2, arr)
print(masked)
# Output: [1 2 — –]
Masked arrays are useful in computations where some data points are invalid or missing.
It works seamlessly with NumPy and Matplotlib for data visualisation. NumPy handles the numerical calculations, while Matplotlib creates the plots.
Import Libraries:
import numpy as np
import matplotlib.pyplot as plt
Generate Data with NumPy:
x = np.linspace(0, 10, 100)
y = np.sin(x)
Create Plot with Matplotlib:
Understanding slicing differences is key in NumPy.
| Aspect | arr[:, 0] | arr[:, [0]] |
| Result Shape | 1D array (n,) | 2D array (n, 1) |
| Usage | Access as a flat array | Maintain 2D structure |
Example:
# Output:
To determine if a NumPy array is empty, use the size attribute.
Method: Using size Attribute
Output:
Alternative Method: Using len()
if len(empty_array) == 0:
print(“The array is empty.”)
Note:
NumPy provides attributes to determine an array’s structure.
Key Attributes:
Example:
Outliers can be identified using the Interquartile Range (IQR):
# Output: [100]
The np.reshape() function resizes an existing array without changing the data.
Purpose:
Example:
# Output:
Using -1: Allows NumPy to automatically determine one dimension.
python
Copy code
reshaped = np.reshape(original, (3, -1))
print(reshaped)
# Output:
NumPy supports arrays of various sizes. Each size is suitable for different jobs.
| Dimension | Description | Example |
| 1D Array | Single axis, linear sequence | [1, 2, 3, 4] |
| 2D Array | Two axes, rows and columns | [[1, 2], [3, 4]] |
| Multi-Dimensional | Three or more axes, complex structures | [[[1,2],[3,4]], [[5,6],[7,8]]] |
NumPy manages numerical exceptions like division by zero or overflow using its error-handling system.
Default Behavior:
Managing Exceptions with np.seterr():
Options:
Example: Handling Division by Zero:
np.seterr(divide=’warn’)
result = np.array([1, 2, 3]) / 0
print(result) # Output: [inf inf inf] with a warning
Eigenvalues are essential in various scientific and engineering fields. NumPy provides functions to compute them efficiently.
A * v = λ * v
where v is the eigenvector.
Using np.linalg.eig():
# Output: [3. 2.]
Explanation:
Norms measure the size or length of vectors and matrices, crucial in optimisation and machine learning.
Types of Norms:
Using np.linalg.norm():
Key Points:
Applications:
NumPy’s norm function provides a versatile tool for various computational needs.
QR decomposition splits the matrix into an orthogonal matrix Q and an upper triangular matrix R.
Purpose:
Using np.linalg.qr():
Output:
Applications:
NumPy’s QR Decomposition function is a powerful tool for various matrix operations.
Understanding shape and size is fundamental for array manipulation.
| Attribute | Description | Example |
| shape | Tuple indicating the size in each dimension. | (3, 4) for 2D array |
| size | Total number of elements in the array. | 12 for (3, 4) array |
Example:
Universal Functions, or ufuncs, are core to NumPy’s performance, enabling fast element-wise operations.
Key Features:
Common Ufuncs:
Example:
# Output: [0.0, 1.0, 0.0]
Yes, NumPy implements SIMD (single instruction, multiple data) through custom low-level libraries such as BLAS and LAPACK. These libraries allow NumPy to perform the same operations on multiple data points simultaneously, specially optimised for calculating large numbers. By taking advantage of SIMD instructions, NumPy can handle vector addition. Even efficiently multiplies matrices and more. This parallel processing capability greatly accelerates array operations, making NumPy a powerful tool for scientific computing and data analysis. Modern CPUs with advanced SIMD features also help increase NumPy performance. This ensures that complex mathematical operations are carried out quickly.
| Function | Description | Example |
| vstack() | Stacks arrays vertically (row-wise) | Combines two 1D arrays as rows in a 2D array |
| hstack() | Stacks arrays horizontally (column-wise) | Concatenates two 1D arrays side by side |
Example:
# Output: [1 2 3 4 5 6]
Here, for adding rows, you can use vstack() and when you need to add columns, you can use hstack().
fliplr and flipud are used to flip arrays horizontally or vertically.
| Method | Description | Example |
| fliplr() | Flips array left to right (horizontally) | Reverses columns in each row |
| flipud() | Flips array up to down (vertically) | Reverses rows in the array |
Example:
# Output:
# Output:
Here, you can use fliplr for horizontal flips and flipud for vertical flips.
Implementing a moving average can be achieved using convolution.
Steps:
Example:
# Output: [2. 3. 4. 5.]
This method efficiently calculates the average over a sliding window without explicit loops.
array_split() divides an array into multiple sub-arrays, handling uneven splits gracefully.
Example:
# Output: [array([1, 2, 3]), array([4, 5, 6]), array([7])]
Hare, array_split() will ensure if all elements are included or not, even if splits could be uneven.
When you use split() method, it will divide any given array into equal parts. But you must give a divisible number, which can equally divide the array into that divisible number of splits only.
Example:
# Output: [array([1, 2]), array([3, 4]), array([5, 6])]
# Uneven split raises ValueError
np.split(arr, 4) # Raises ValueError
Use split() when you need equal-sized sub-arrays and the array size allows it.
Vectorisation and broadcasting are interconnected features that enhance NumPy’s efficiency.
Vectorisation:
Broadcasting:
Relation: When you use vectorization, it generally relies on broadcasting, which is used to perform seamless element-wise operations, across varying array shapes.
Example:
# Output: [2 4 6]
Here, broadcasting allows the scalar b to be multiplied with each element of array a via vectorisation.
Identifying local maxima involves comparing each element with its neighbours.
Steps:
Example:
This method efficiently locates indices of local peaks within a 1D array.
Vectorization in NumPy refers to executing operations on entire arrays without explicit loops, leveraging optimised low-level implementations.
Example:
# Output: [5 7 9]
Here, the addition is applied element-wise across the arrays without looping.
Interchanging axes can be done using np.swapaxes() or np.transpose().
Using swapaxes():
Using transpose():
# Transpose axes
transposed = arr.transpose(2, 1, 0)
print(transposed.shape) # Output: (4, 3, 2)
These functions effectively interchange the specified axes, altering the array’s structure for different computational needs.
Changing dimensions can be achieved using reshape() or np.newaxis.
Example Using reshape():
# Output:
Example Using np.newaxis:
# Output:
These methods adjust the array’s dimensions, facilitating various computational and data processing tasks.
To insert spaces between characters, use NumPy’s string operations.
Example:
# Output:
Alternative Method:
spaced = np.array([‘ ‘.join(list(s)) for s in arr])
print(spaced)
Both approaches effectively add spaces between characters in each string element of the array.
Use np.arange() or np.linspace() to create the desired range.
Using arange():
import numpy as np
arr = np.arange(10, 61) # 10 to 60 inclusive
print(arr)
Using linspace() with dtype=int:
arr = np.linspace(10, 60, num=51, dtype=int)
print(arr)
Output:
[10 11 12 … 58 59 60]
These methods generate an integer array containing values from 10 to 60 efficiently.
arange() and linspace() both create sequences of numbers but differ in parameters and usage.
| Function | Description | Parameters |
| arange() | Creates array with evenly spaced values based on start, stop, step | start, stop, step |
| linspace() | Creates array with a specified number of evenly spaced values between start and stop | start, stop, num |
Key Differences:
array() and asarray() both create NumPy arrays but differ in copying behavior.
| Function | Description | Copy Behavior |
| array() | Creates a new array object from input data | Always makes a copy |
| asarray() | Converts input to array without copying if possible | Does not copy if input is already an array |
Example:
Choose based on whether a new copy is necessary or referencing is sufficient.
| Feature | flatten() | ravel() |
| Functionality | Returns a copy of the array flattened into 1D | Returns a flattened view of the array if possible |
| Memory | Always creates a new copy | Returns a view when possible, otherwise a copy |
| Modifiability | Changes to the flattened array do not affect the original | Changes affect the original array if a view is returned |
| Method Type | Method of ndarray | Method of ndarray |
| Usage Scenario | When an independent 1D array is needed | When a flattened array is needed without extra memory |
| Aspect | np.where() | np.nonzero() |
| Purpose | Select elements based on a condition | Find indices of non-zero elements |
| Usage | np.where(condition, x, y) or np.where(condition) | np.nonzero(array) |
| Return Type | Tuple of arrays for indices or modified array | Tuple of arrays containing indices |
| Flexibility | Can return elements from two arrays based on condition | Only returns indices where condition is True |
| Common Use | Conditional selection and assignment | Identifying locations of non-zero values |
| Feature | Broadcasting | Standard Element-Wise Operations |
| Definition | Automatically expands arrays to match shapes | Requires arrays to have identical shapes |
| Flexibility | Allows operations on arrays with different dimensions | Limited to same-shaped arrays |
| Mechanism | Follows specific rules to align array dimensions | Directly applies operations element by element |
| Use Cases | Performing operations between scalar and array, or differently shaped arrays | Operations on arrays of the same shape |
| Performance | Optimises memory and computation by avoiding explicit replication | May require explicit replication for shape matching |
| Feature | np.save() | np.savetxt() |
| File Format | Binary .npy format | Text-based formats like .txt, .csv |
| Data Types | Supports all NumPy data types, including objects | Primarily numerical data, limited to strings |
| Efficiency | Faster and more space-efficient due to binary storage | Slower and larger file sizes due to text encoding |
| Compatibility | Best used with NumPy for loading via np.load() | Can be opened with text editors and other software |
| Human-Readable | Not human-readable | Human-readable |
| Usage Scenario | Saving and loading NumPy arrays for computational use | Exporting data for sharing, analysis in other tools |
NumPy remains an indispensable tool for anyone working with numerical data in Python. Its powerful array structures and optimised performance make it ideal for tasks ranging from simple data manipulation to complex scientific computations. Whether you’re a beginner or an experienced professional, mastering NumPy can significantly enhance your data processing capabilities.
This comprehensive list of over 70 interview questions and answers covers all essential aspects, helping you build confidence and demonstrate your expertise effectively. Embrace NumPy to streamline your workflows and excel in data-driven roles. Learn Python and its libraries like NumPy with the Integrated Program in Data Science, Artificial Intelligence & Machine Learning offered by Hero Vired in collaboration with Open Learning and get a professional certificate.
Updated on December 17, 2024
Accelerator Program in Business Analytics & Data Science
Integrated Program in Data Science, AI and ML
Accelerator Program in AI and Machine Learning
Certificate Program in Full Stack Development with Specialization for Web and Mobile
Certificate Program in DevOps and Cloud Engineering
Certificate Program in Application Development
Certificate Program in Cybersecurity Essentials & Risk Assessment
Integrated Program in Finance and Financial Technologies
Certificate Program in Financial Analysis, Valuation and Risk Management
© 2024 Hero Vired. All rights reserved
