Python NumPy Tutorial: Learn Python Numpy With Examples

NumPy is the core library for numerical computing in Python. It provides fast, efficient, and flexible tools for handling large datasets. With NumPy, you can perform complex mathematical operations, manipulate arrays, and streamline data processing tasks. It is essential for data analysis, scientific computing, and machine learning workflows. 

In this guide, you'll read more about NumPy in Python. We'll cover what NumPy is, why it’s important, and how to install it. You’ll learn array creation, indexing, and slicing. We’ll explore mathematical, statistical, and linear algebra operations. Advanced topics like broadcasting, boolean indexing, and random number generation will also be included. 

Explore data science online courses from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs, or Masters Programs to fast-track your career.  

Installing NumPy in Python 

Before you start exploring NumPy, you need to install it. This step is essential in any python numpy tutorial because NumPy is not included in the default Python setup. Installing it is quick and beginner-friendly. 

Step 1: Check Your Python Version 

NumPy works with Python 3.x versions. To verify your version, open your terminal or command prompt and type: 

python --version 
 

If your version is 3.x, you can proceed. Otherwise, install or upgrade Python from the official Python website. 

Begin your data science journey with upGrad’s industry-aligned programs. Learn from leading experts, master essential tools and techniques, and build job-ready skills through hands-on projects and real-world applications. 

• MS in Data Science from Liverpool John Moores University 
• Generative AI Mastery Certificate for Data Analysis 
• Executive Post Graduate Certificate Programme in Data Science & AI From IIITB 

Step 2: Install NumPy Using pip 

The easiest way to install NumPy in Python is with pip. This step is key in any numpy in python tutorial. 

pip install numpy 
 

• Works on Windows, macOS, and Linux. 
• Verify the installation in Python: 

import numpy as np 
print(np.__version__) 
 

You should see the installed NumPy version. 

Step 3: Using a Virtual Environment (Recommended) 

A virtual environment helps manage packages without affecting system Python. Steps: 

1. Create a virtual environment: 

python -m venv myenv 
 

1. Activate it: 

1. Install NumPy inside the environment: 

pip install numpy 
 

1. Deactivate after use: 

deactivate 
 

Using virtual environments is best practice in any numpy tutorial in python. 

Also Read: How to Install Python on macOS 

Step 4: Install NumPy Using Anaconda (Optional) 

For users of Anaconda, NumPy comes pre-installed. Update it using: 

conda update numpy 
 

Or create a new environment with NumPy: 

conda create -n myenv numpy 
conda activate myenv 
 

Step 5: Verify Your Installation 

Check that NumPy is ready for use by running: 

import numpy as np 
a = np.array([1, 2, 3]) 
print(a) 
 

Output: 

[1 2 3] 
 

This confirms NumPy is installed and ready for your python numpy tutorial exercises. 

Common Installation Issues 

Step 6: Quick Tips for Beginners 

• Use a virtual environment to avoid package conflicts. 
• Keep NumPy updated: 

pip install --upgrade numpy 
 

• Use conda for managing multiple scientific packages alongside NumPy. 

Installing NumPy is a simple first step in any numpy tutorial in python. Once installed, you can move on to array operations, mathematical functions, and more advanced tasks efficiently. 

Also Read: How to Install Python in Windows (Even If You're a Beginner!) 

NumPy Arrays 

In this python numpy tutorial, the core concept you will work with is the NumPy array. Arrays are the foundation of NumPy and allow you to store and manipulate data efficiently. Unlike Python lists, NumPy arrays are faster, use less memory, and support advanced mathematical operations. 

1. Introduction to NumPy Arrays 

A NumPy array is called an ndarray (n-dimensional array). It can be: 

• 1D arrays – like a list of numbers 
• 2D arrays – like a table or matrix 
• 3D arrays – for more complex structures, like images 

Example: 

import numpy as np 
 
# 1D array 
arr1 = np.array([1, 2, 3, 4, 5]) 
 
# 2D array 
arr2 = np.array([[1, 2, 3], [4, 5, 6]]) 
 

2. Creating NumPy Arrays 

NumPy provides several ways to create arrays: 

• np.array() – create an array from a list or tuple 
• np.zeros() – create an array filled with zeros 
• np.ones() – create an array filled with ones 
• np.arange() – create an array with a range of numbers 
• np.linspace() – create an array with evenly spaced numbers 

Table: Array creation functions 

Also Read: Python Array: Declaration, Operations, and NumPy Implementation Guide 

3. Array Indexing and Slicing 

Accessing elements in NumPy arrays is straightforward: 

• Use square brackets [ ] for indexing 
• Use : for slicing 

Examples: 

arr = np.array([10, 20, 30, 40, 50]) 
print(arr[0])    # Output: 10 
print(arr[1:4])  # Output: [20 30 40] 
 

For 2D arrays, use row, column notation: 

matrix = np.array([[1,2,3],[4,5,6]]) 
print(matrix[0,2])  # Output: 3 
print(matrix[:,1])  # Output: [2 5] 
 

4. Array Data Types 

Every NumPy array has a data type (dtype). It ensures consistency and faster computation. 

• Check type: arr.dtype 
• Convert type: arr.astype(float) 

Table: Common NumPy data types 

5. Why NumPy Arrays Are Better Than Lists 

• Performance: Faster computation with large datasets 
• Memory-efficient: Uses less memory than lists 
• Vectorized operations: Supports element-wise math without loops 

Example: 

arr = np.array([1,2,3,4]) 
print(arr * 2)  # Output: [2 4 6 8] 
 

Summary: 

NumPy arrays are the backbone of any python numpy tutorial. They let you store data in 1D, 2D, or 3D structures, perform fast computations, and manage data efficiently. Mastering array creation, indexing, slicing, and understanding data types will set a strong foundation for all further NumPy operations. 

Also Read: Python AI Projects: Best 30 Artificial Intelligence Projects 

NumPy Operations 

Once you understand NumPy arrays, the next step in any python numpy tutorial is performing operations on them. NumPy makes mathematical, statistical, and linear algebra operations simple and fast. You can apply operations element-wise without writing loops. 

1. Mathematical Operations 

NumPy supports basic arithmetic on arrays: 

• Addition, subtraction, multiplication, division 
• Element-wise operations apply to every item in the array 

Example: 

import numpy as np 
 
arr1 = np.array([1, 2, 3]) 
arr2 = np.array([4, 5, 6]) 
 
print(arr1 + arr2)  # Output: [5 7 9] 
print(arr1 * 2)     # Output: [2 4 6] 
 

2. Statistical Operations 

NumPy provides built-in functions to calculate statistics quickly: 

• np.sum() – sum of elements 
• np.mean() – average value 
• np.median() – median value 
• np.std() – standard deviation 

Example: 

arr = np.array([10, 20, 30, 40]) 
print(np.sum(arr))    # 100 
print(np.mean(arr))   # 25.0 
print(np.std(arr))    # 11.1803 
 

Table: Common Statistical Functions 

Also Read: Arithmetic Operators in Python 

3. Linear Algebra Operations 

NumPy makes linear algebra simple for vectors and matrices: 

• Matrix addition and subtraction 
• Dot product using np.dot() 
• Transpose using .T 
• Inverse using np.linalg.inv() 

Example: 

matrix1 = np.array([[1,2],[3,4]]) 
matrix2 = np.array([[5,6],[7,8]]) 
 
print(matrix1 + matrix2) 
# Output: [[ 6  8] 
#          [10 12]] 
 
print(np.dot(matrix1, matrix2)) 
# Output: [[19 22] 
#          [43 50]] 
 

4. Universal Functions (ufuncs) 

NumPy offers ufuncs that apply operations to each element of an array efficiently: 

• np.sqrt() – square root 
• np.exp() – exponential 
• np.log() – natural logarithm 
• np.sin(), np.cos() – trigonometric operations 

Example: 

arr = np.array([1,4,9]) 
print(np.sqrt(arr))  # Output: [1. 2. 3.] 
 

Table: Useful NumPy ufuncs 

5. Why Operations in NumPy Are Efficient 

• Vectorized operations remove the need for loops. 
• Optimized for large datasets. 
• Supports multi-dimensional arrays for advanced calculations 

Summary: 

NumPy operations are at the heart of any python numpy tutorial. From basic arithmetic and statistics to matrix manipulations and ufuncs, these tools let you handle data efficiently. Mastering these operations will prepare you for data analysis, scientific computing, and machine learning tasks. 

Also Read: Top 50 Python Project Ideas with Source Code in 2025 

NumPy Array Manipulation 

After learning basic NumPy operations, the next step in any python numpy tutorial is manipulating arrays. NumPy provides tools to reshape, join, split, and manage arrays efficiently. These techniques are essential for preparing data for analysis or machine learning. 

1. Reshaping Arrays 

You can change the shape of an array without altering its data. 

• reshape() – Changes the dimensions of an array 
• flatten() – Converts a multi-dimensional array into 1D 
• ravel() – Similar to flatten but returns a view 

Example: 

arr = np.array([[1,2,3],[4,5,6]]) 
reshaped = arr.reshape(3,2) 
print(reshaped) 
# Output: 
# [[1 2] 
#  [3 4] 
#  [5 6]] 
 

Also Read: Pandas vs NumPy in Data Science: Top 15 Differences 

2. Joining and Splitting Arrays 

NumPy lets you combine or divide arrays for flexibility. 

• Joining: 
• np.concatenate() – Join arrays along an axis 
• np.vstack() – Stack arrays vertically 
• np.hstack() – Stack arrays horizontally 
• Splitting: 
• np.split() – Divide arrays into multiple sub-arrays 

Example: 

a = np.array([1,2,3]) 
b = np.array([4,5,6]) 
 
joined = np.concatenate([a,b]) 
print(joined)  # Output: [1 2 3 4 5 6] 
 

Table: Joining and Splitting Functions 

3. Copy vs View 

Understanding the difference between a copy and a view is important in NumPy. 

• View: Points to the same memory as the original array. Changes affect both arrays. 
• Copy: Creates a new array. Changes do not affect the original. 

Example: 

arr = np.array([1,2,3]) 
view = arr.view() 
copy = arr.copy() 
 
view[0] = 10 
print(arr)   # Output: [10  2  3] 
copy[1] = 20 
print(arr)   # Output: [10  2  3] (unchanged) 
 

Table: Copy vs View 

Also Read: Most Frequently Asked NumPy Interview Questions and Answers 

4. Why Array Manipulation Matters 

• Reshaping helps prepare data for ML models. 
• Joining and splitting support data preprocessing. 
• Understanding copy vs view prevents accidental data changes. 

Summary: 

Array manipulation is a core topic in any python numpy tutorial. By mastering reshaping, joining, splitting, and understanding memory views, you can efficiently handle and preprocess data for analysis or machine learning. These skills make working with NumPy arrays flexible and error-free. 

Real-Life Examples of NumPy in Python 

After learning arrays, operations, and manipulations, it’s important to see NumPy in action. In this section of our python numpy tutorial, we’ll explore practical examples that show how NumPy is used in real-world scenarios. These examples will help you understand why NumPy is a vital tool in data analysis, scientific computing, and machine learning. 

1. Data Analysis with NumPy Arrays 

NumPy is widely used to process and analyze numerical data. For example, if you have sales data for a week: 

import numpy as np 
 
sales = np.array([150, 200, 300, 250, 400, 500, 350]) 
print("Total sales:", np.sum(sales)) 
print("Average sales:", np.mean(sales)) 
print("Maximum sales:", np.max(sales)) 
 

Output: 

Total sales: 2150 
Average sales: 307.14 
Maximum sales: 500 
 

Use case: You can quickly calculate totals, averages, and other statistics for large datasets without loops. 

Also Read: What is Data Analytics: Definition, Types, Applications & Challenges 

2. Image Processing 

Images are stored as multi-dimensional arrays, and NumPy makes it easy to manipulate them. 

image = np.random.randint(0, 256, size=(5,5,3))  # Random 5x5 RGB image 
print("Red channel:", image[:,:,0])  # Accessing red color values 
 

Use case: NumPy is often combined with libraries like OpenCV or PIL to modify, filter, or analyze images efficiently. 

3. Machine Learning Data Preparation 

Machine learning models require numeric data in arrays. NumPy helps transform raw data into structured arrays: 

# Example: Height and weight data 
height = np.array([150, 160, 170, 180]) 
weight = np.array([50, 60, 65, 80]) 
 
# Calculate Body Mass Index (BMI) 
bmi = weight / (height/100)**2 
print("BMI values:", bmi) 
 

Output: 

BMI values: [22.22 23.44 22.49 24.69] 
 

Use case: NumPy allows you to perform batch calculations efficiently for training ML models. 

Also Read: Top 48 Machine Learning Projects [2025 Edition] with Source Code 

4. Financial Analysis 

NumPy is commonly used in finance for tasks like analyzing stock prices or calculating returns: 

prices = np.array([100, 102, 105, 103, 108]) 
returns = (prices[1:] - prices[:-1]) / prices[:-1] 
print("Daily returns:", returns) 
 

Output: 

Daily returns: [0.02 0.02941176 -0.01904762 0.04854369] 
 

Use case: Investors can quickly analyze trends and volatility in stock data. 

5. Scientific Computing and Simulations 

NumPy arrays are essential for simulations in physics, chemistry, and engineering. For instance, generating points for a sine wave: 

x = np.linspace(0, 2*np.pi, 10) 
y = np.sin(x) 
print("Sine values:", y) 
 

Use case: Simulations, modeling, and experiments often rely on efficient array computations. 

Mastering these applications is a key part of any python numpy tutorial. Once you practice these examples, you can handle almost any numerical data efficiently and effectively. 

Best Practices When Using NumPy 

Working efficiently with NumPy is not just about knowing functions and operations. In this part of our python numpy tutorial, we’ll cover best practices that help you write clean, fast, and reliable code while avoiding common mistakes. 

1. Prefer Vectorized Operations Over Loops 

NumPy is optimized for vectorized operations, which means you should avoid Python loops for array computations. 

Example: 

import numpy as np 
 
arr = np.array([1, 2, 3, 4, 5]) 
 
# Vectorized operation 
arr_squared = arr ** 2 
print(arr_squared)  # Output: [ 1  4  9 16 25] 
 
# Avoid using loops 
arr_squared_loop = [x**2 for x in arr] 
 

Why: Vectorized operations are faster and more memory-efficient, especially for large datasets. 

Also Read: Python While Loop Statements: Explained With Examples 

2. Use Appropriate Data Types 

NumPy arrays support different data types (dtype). Choosing the right type improves performance and reduces memory usage. 

• Use float32 instead of float64 if high precision is not required. 
• Use int32 or int16 for integer data. 

Example: 

arr = np.array([1, 2, 3], dtype=np.float32) 
print(arr.dtype)  # Output: float32 
 

Table: Common Data Types and Memory Usage 

3. Avoid Creating Unnecessary Copies 

NumPy arrays can create views or copies. Views save memory because they point to the same data. Copies consume extra memory. 

• Use .view() when you don’t need a separate array. 
• Use .copy() when you need an independent array. 

Example: 

arr = np.array([1, 2, 3]) 
view_arr = arr.view() 
copy_arr = arr.copy() 
 

Why: Efficient memory usage is critical when working with large datasets. 

4. Keep Arrays Contiguous in Memory 

Contiguous arrays are stored in a single memory block. NumPy performs faster on these arrays. 

• Avoid unnecessary reshaping that breaks contiguity. 
• Use np.ascontiguousarray() if needed. 

Example: 

arr = np.arange(9).reshape(3,3) 
contiguous_arr = np.ascontiguousarray(arr) 
 

5. Use Built-In Functions 

NumPy functions are optimized and faster than custom Python code. 

• Prefer np.sum(), np.mean(), np.dot(), etc., over manual loops. 
• This ensures performance and readability. 

Example: 

arr = np.array([1,2,3,4,5]) 
total = np.sum(arr)  # Faster than sum([1,2,3,4,5]) 
 

6. Handle Large Arrays Carefully 

• Break arrays into smaller chunks if possible. 
• Avoid loading extremely large datasets into memory at once. 
• Use memory-mapped arrays with np.memmap for huge files. 

7. Document Your Code 

• Clearly comment array shapes, types, and transformations. 
• Helps readability and avoids mistakes, especially with multi-dimensional arrays. 

Also Read: Top 15 Image Processing Projects Using Python That’ll Wow Recruiters! 

Summary: 

Following these practices in your python numpy tutorial ensures: 

• Faster and more efficient code 
• Lower memory usage 
• Fewer bugs and errors 
• Better readability and maintainability 

By vectorizing operations, using correct data types, managing copies, and leveraging built-in functions, you can work with NumPy confidently on any dataset. 

Conclusion 

This python numpy tutorial has introduced you to the core features of NumPy, including arrays, mathematical operations, and array manipulation. Understanding these concepts allows you to process data efficiently and perform complex computations. Following best practices ensures your code is fast, memory-efficient, and reliable. From real-life data analysis to scientific computing and machine learning, mastering numpy in python tutorial techniques prepares you to work with large datasets and solve practical problems confidently. 

If you are curious to learn about data science, check out IIIT-B & upGrad’s Executive Diploma in Data Science & AI which is created for working professionals and offers 10+ case studies & projects, practical hands-on workshops, mentorship with industry experts, 1-on-1 with industry mentors, 400+ hours of learning and job assistance with top firms. 

Stay informed and inspired with our popular Data Science articles, offering expert insights, trends, and practical tips for aspiring data professionals!

Read our popular Data Science Articles

Elevate your career by learning essential Data Science skills such as statistical modeling, big data processing, predictive analytics, and SQL!

Top Data Science Skills to Learn to upskill

Unlock the power of data with our popular Data Science courses, designed to make you proficient in analytics, machine learning, and big data!

Explore our Popular Data Science Courses