Python for Data Science Cheat Sheet: Pandas, NumPy, Matplotlib & Key Functions

Python’s popularity in data science is owed to its extensive libraries, like NumPy, Matplotlib, and Pandas, which streamline data manipulation, analysis, and visualization. Each is packed with pre-written code that can be tailored to your needs. 

This Python cheat sheet will help you quickly understand each of these libraries, including their benefits and limitations for specific types of projects.

Getting Started with Python for Data Science

Python is beginner-friendly but powerful enough for complex projects. Its easy-to-learn syntax and vast ecosystem make it a top choice for data scientists. To begin, set up Python and get familiar with the tools that make data science smooth and efficient.

Jupyter Notebook, particularly, will be your playground for exploring data, running experiments, and testing models. Don’t worry; it’s simple to install and get running. Once you’re up and running, you can dive into the powerful libraries Python offers for data manipulation, analysis, and visualization. 

Key Libraries for Data Science

Python’s strength in data science lies in its libraries. In this Python cheat sheet, let’s explore the core ones you’ll need to rely on:

1. Pandas: This is your go-to for handling and manipulating data. It’s perfect for cleaning, transforming, and analyzing datasets.

2. NumPy: When it comes to handling arrays and performing complex calculations, NumPy is key.

3. Matplotlib: This is the tool for creating static, animated, and interactive visualizations. It’s perfect for showing off your data.

4. Seaborn: Built on top of Matplotlib, Seaborn makes it easy to create more beautiful, complex visualizations.

5. SciPy: Use SciPy for scientific computing tasks like optimization, integration, and statistics.

6. Scikit-learn: This is the machine learning library for Python. It includes tools for data mining, classification, regression, and clustering.

Did you know? Python was originally created by Guido van Rossum in the late 1980s as a way to make programming easier and more intuitive. Its simplicity and versatility have since made it the go-to language for everything from web development to data science!

Also Read: Data Analysis Using Python: Everything You Need to Know

Basic Python Functions Every Data Scientist Should Know

Now that you’ve got the libraries covered, let’s talk about the basic Python functions that will make your life easier.

• len(): Use this to quickly find the length of an object, such as a list or string, to know how many elements it contains.
• sum(): This function adds up all the elements in an iterable (like a list), which is useful for calculations like summing up values in a dataset.
• max() / min(): These functions help you easily find the highest or lowest value in an iterable, making them useful for identifying extremes in your data.
• type(): This function returns the data type of an object, so you can check whether an item is an integer, string, list, etc.
• sorted(): This function sorts elements in a list by default in ascending order, but you can also reverse the order or customize the sort using a key function. For example, you can sort data in descending order or sort strings by their length.

These functions are essential tools for handling and processing data, making them practical in everyday data science tasks.

Example Usage:

data = [5, 2, 9, 1]
print(len(data))  
print(sum(data))  
print(max(data))  

Outputs:

4
17
17

These functions are simple but essential for handling data and performing quick tasks in Python. Get comfortable with them, and they’ll become second nature in your data science workflow.

Also Read: Career Opportunities in Artificial Intelligence in 2025

Next in this Python cheat sheet, let’s explore one of Python’s most popular libraries and its functions, starting with NumPy.

Mastering NumPy for Fast Computations

NumPy provides efficient storage and manipulation of large data arrays, making it the backbone of scientific computing in Python. If you're working with data science, machine learning, or any field that requires number crunching, you need to know NumPy.

This NumPy cheat sheet will help you break down the key usages of this library.

Creating & Manipulating NumPy Arrays

NumPy arrays are the core structure for numerical computing in Python. They offer better performance and memory efficiency than traditional lists, making them ideal for handling large datasets and complex calculations. With NumPy, you can quickly create and manipulate arrays, unlocking faster and more efficient data processing. 

Let's explore how to leverage these powerful arrays in your data science tasks.

1. np.array(): Creates a NumPy array from a Python list.

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

Explanation: Here, we're converting a regular Python list into a NumPy array using np.array(). The output is a simple 1D array that holds the same values as the original list but with optimized performance.

Output:

[1 2 3 4]

2. np.arange(): Generates an array of evenly spaced values.

arr = np.arange(0, 10, 2)
print(arr)

Explanation: The np.arange() function generates an array starting from 0 to 10 (exclusive), with a step size of 2. This function is useful for creating ranges of numbers quickly.

Output:

[0 2 4 6 8]

3. np.zeros() and np.ones(): Create arrays filled with zeros or ones.

zeros_arr = np.zeros(3)
ones_arr = np.ones(4)
print(zeros_arr, ones_arr)

Explanation: The np.zeros() function creates an array filled with zeros, and np.ones() creates an array filled with ones. Both are useful when you need an array of a specific size, initialized with either zeros or ones.

Output:

[0. 0. 0.] [1. 1. 1. 1.]

4. np.linspace(): Creates an array with evenly spaced values over a specified range.

arr = np.linspace(0, 1, 5)
print(arr)

Explanation: np.linspace() generates 5 evenly spaced numbers between 0 and 1 (inclusive). This function is handy when you need a range of values for plotting or other analyses.

Output:

[0.   0.25 0.5  0.75 1.  ]

Also Read: Numpy Array in Python [Everything to know]

Indexing, Slicing & Reshaping Arrays

NumPy simplifies accessing, modifying, and rearranging data in arrays. With indexing and slicing, you can extract specific elements or subsets of your data with ease. Reshaping allows you to change the structure of your arrays, making them adaptable for various tasks, from mathematical operations to data visualization. 

These powerful features provide you with full control over your datasets, enhancing both flexibility and efficiency.

1. np.reshape(): Changes the shape of an array without changing its data.

arr = np.array([1, 2, 3, 4, 5, 6])
reshaped_arr = arr.reshape(2, 3)
print(reshaped_arr)

Explanation: The reshape() function allows you to change the shape of the array. In this case, we turned the original 1D array into a 2D array with 2 rows and 3 columns. The data remains the same; only its structure changes.

Output:

[[1 2 3]
[4 5 6]]

2. np.ravel(): Flattens a multi-dimensional array into a 1D array.

arr = np.array([[1, 2], [3, 4]])
flat_arr = np.ravel(arr)
print(flat_arr)

Explanation: np.ravel() takes a multi-dimensional array and flattens it into a one-dimensional array. This is useful when you need to perform operations that require a 1D structure.

Output:

[1 2 3 4]

3. np.transpose(): Switches the rows and columns of an array.

arr = np.array([[1, 2], [3, 4]])
transposed_arr = np.transpose(arr)
print(transposed_arr)

Explanation: np.transpose() swaps the rows and columns of the array, making it easier to work with matrix transformations or visualizations that require different orientations.

 Output:

[[1 3]
[2 4]]

Mathematical & Statistical Operations

NumPy offers a comprehensive set of functions for performing fast mathematical and statistical operations on arrays. Whether you're calculating averages, finding variances, or performing complex arithmetic, NumPy’s built-in methods make it easy to get precise results. These operations are optimized for speed, enabling you to process large datasets efficiently without compromising performance.

1. np.mean(), np.median(), np.std(): Compute the mean, median, and standard deviation of an array.

arr = np.array([1, 2, 3, 4, 5])
print(np.mean(arr), np.median(arr), np.std(arr))

Explanation: These functions calculate basic statistical metrics for your array. np.mean() finds the average, np.median() gives the middle value, and np.std() measures the spread of the data.

Output:

 3.0 3.0 1.4142135623730951

2. np.sum(), np.min(), np.max(): Sum the elements, and find the minimum or maximum.

arr = np.array([1, 2, 3, 4, 5])
print(np.sum(arr), np.min(arr), np.max(arr))

Explanation: These functions quickly give you the sum, minimum, and maximum values of an array. They’re great for quick data summaries.

Output:

 15 1 5

Also Read: Most Frequently Asked NumPy Interview Questions and Answers

Linear Algebra & Random Sampling

NumPy is a powerful tool for linear algebra operations, such as matrix multiplication, inversion, and dot products. It also simplifies random sampling, allowing you to generate random numbers or values from various distributions. 

These capabilities are essential for statistical modeling, simulations, and machine learning, enabling fast and efficient computations directly within your Python environment.

1. np.dot(): Computes the dot product of two arrays (vectors or matrices).

a = np.array([1, 2])
b = np.array([3, 4])
result = np.dot(a, b)
print(result)

Explanation: np.dot() computes the dot product of two arrays. In this example, it multiplies corresponding elements and sums them up (13 + 24), resulting in 11.

Output:

 11

2. np.linalg.inv(): Calculates the inverse of a square matrix.

arr = np.array([[1, 2], [3, 4]])
inverse_arr = np.linalg.inv(arr)
print(inverse_arr)

Explanation: np.linalg.inv() calculates the inverse of a matrix. This is commonly used in linear algebra when solving systems of equations or performing matrix operations.

Output:

[[-2.   1. ]
[ 1.5 -0.5]]

3. np.random.rand(): Generates random values between 0 and 1.

random_vals = np.random.rand(3)
print(random_vals)

Explanation: np.random.rand() generates random floating-point numbers between 0 and 1. This is useful when you need random values for simulations, testing, or sampling.

Output:

[0.71780957 0.82687916 0.44359519]

4. np.random.normal(): Generates random values from a normal distribution.

normal_vals = np.random.normal(0, 1, 5)
print(normal_vals)

Explanation: np.random.normal() generates random values based on a normal (Gaussian) distribution. Here, we specify a mean of 0 and a standard deviation of 1, and generate 5 random samples.

Output:

[ 1.03469767 -1.62199367  0.05388126  0.34643197  0.02980312]

NumPy’s fast computations and simple syntax make it indispensable for data scientists working with numerical data. These functions will significantly improve your productivity and efficiency in handling large datasets.

Also Read: Python Libraries Course : NumPy, Matplotlib, and Pandas

Now that we've covered NumPy's powerful array manipulations in the above NumPy cheat sheet, let’s take a look at how Pandas can handle and analyze structured data.

Essential Pandas Functions for Data Science

Pandas is a robust library for data manipulation and analysis in Python, offering powerful, flexible, and easy-to-use tools for working with structured data. With Pandas, you can clean, transform, analyze, and visualize data with just a few lines of code. 

It’s crucial for tasks such as handling large datasets, performing complex calculations, and even preparing data for machine learning.

In this Pandas cheat sheet, we’ll cover the essential functions that make Pandas a must-have for data scientists.

Reading & Writing Data

One of Pandas' core strengths is its ability to easily read from and write to various file formats, making data import and export a breeze. Whether you’re working with CSVs, Excel files, or connecting to databases, Pandas provides simple, efficient functions to load your data into a DataFrame and save it back to your preferred format. 

This flexibility allows you to seamlessly move data between different environments, supporting your workflow from data collection to analysis and reporting.

1. pd.read_csv(): Reads data from a CSV file into a DataFrame.

import pandas as pd
df = pd.read_csv('data.csv')
print(df.head())

Explanation: The read_csv() function loads data from a CSV file into a DataFrame, which is the core data structure in Pandas. You can then easily access and manipulate this data.
Output:

  name  age  gender
0  John  28   Male
1  Alice 24   Female
2  Bob   35   Male
3  Emma  29   Female

2. pd.read_excel(): Reads data from an Excel file into a DataFrame.

df = pd.read_excel('data.xlsx')
print(df.head())

Output (example):

  name  age  gender
0  John   28    Male
1  Alice  24  Female

3. pd.to_csv(): Writes DataFrame data to a CSV file.

df.to_csv('output.csv', index=False)

Explanation: This function saves your DataFrame to a CSV file. Setting index=False prevents writing the DataFrame index as an extra column in the CSV.

Output: A CSV file named output.csv is created.

4. pd.to_excel(): Writes DataFrame data to an Excel file.

df.to_excel('output.xlsx', index=False)

Output: An Excel file named output.xlsx is created.

Also Read: Exploring Pandas GUI [List of Best Features You Should Be Aware Of]

Exploring & Summarizing Data

A key part of any data analysis is understanding the structure and content of your dataset. Before jumping into complex analysis, it’s crucial to get a feel for the data you're working with. Pandas offers a variety of functions to help you explore your data quickly, from viewing the first and last few rows to summarizing statistics for numerical columns. 

These functions allow you to identify trends, spot anomalies, and check for missing or unexpected values, ensuring that you're starting your analysis on the right foot.

1. df.head(): Displays the first few rows of the DataFrame.

print(df.head())

Explanation: This is useful for quickly previewing your dataset, especially when dealing with large files.

Output:

  name  age  gender
0  John  28    Male
1  Alice 24  Female
2  Bob   35    Male
3  Emma  29  Female

2. df.tail(): Displays the last few rows of the DataFrame.

print(df.tail())

Explanation: Shows the last five rows of the dataset, helpful for getting a quick look at the end of the dataset.
Output:

  name  age  gender
4  Eve   32  Female
5  Carl  27    Male

3. df.info(): Provides a concise summary of the DataFrame, including column data types and non-null values.

print(df.info())

Explanation: info() helps you quickly check the structure of the DataFrame, including data types and missing values.

Output:

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 6 entries, 0 to 5
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   name    6 non-null      object 
 1   age     6 non-null      int64  
 2   gender  6 non-null      object 
dtypes: int64(1), object(2)
memory usage: 204.0+ bytes

4. df.describe(): Generates summary statistics (mean, median, standard deviation, etc.) for numerical columns.

print(df.describe())

Explanation: Provides a quick statistical summary for numerical columns, including the mean, standard deviation, min, max, and quartiles.

Output:

        age
count   6.000000
mean   28.500000
std     3.439287
min    24.000000
25%    25.500000
50%    28.000000
75%    30.500000
max    35.000000

5. df.shape: Returns the number of rows and columns in the DataFrame.

print(df.shape)

Explanation: Shows the number of rows and columns in the dataset.

Output:

(6, 3)

6. df.columns: Displays the column names of the DataFrame.

print(df.columns)

Explanation: Returns the names of the columns in the DataFrame.

Output:

Index(['name', 'age', 'gender'], dtype='object')

Also Read: A Comprehensive Guide to Pandas DataFrame astype()

Filtering & Selecting Data

Pandas allows you to filter and select data based on specific conditions, making it easy to work with subsets of your dataset.

1. df.loc[]: Selects rows and columns by labels.

subset = df.loc[0:3, ['name', 'age']]
print(subset)

Explanation: loc[] is label-based indexing, meaning you can use row and column labels to select data.

Output:

  name  age
0  John   28
1  Alice  24
2  Bob   35
3  Emma  29

2. df.iloc[]: Selects rows and columns by index position.

subset = df.iloc[0:3, 0:2]
print(subset)

Explanation: iloc[] allows you to select rows and columns by their index positions.

Output:

  name  age
0  John   28
1  Alice  24
2  Bob   35

3. df[df['column'] > value]: Filters rows based on a condition.

subset = df[df['age'] > 30]
print(subset)

Explanation: Filters the DataFrame based on a condition. Here, you select rows where the age column is greater than 30.

Output:

    name  age  gender
2   Bob   35    Male

Also Read: Mastering Pandas: Important Pandas Functions For Your Next Project

Modifying & Cleaning Data

Before diving into analysis, raw data often requires cleaning to ensure its accuracy and consistency. Pandas provides a range of functions that allow you to easily modify, fill, or remove unwanted or missing data. 

These tools help you handle common issues like missing values, duplicates, or incorrect data types, ensuring that your dataset is ready for meaningful analysis. Whether it's filling in missing entries, renaming columns, or dropping irrelevant rows, Pandas simplifies data cleaning so you can focus on extracting insights.

1. df.drop(): Removes rows or columns.

df = df.drop('gender', axis=1)
print(df)

Explanation: Drops a column or row from the DataFrame. axis=1 means we drop a column (for rows, use axis=0).

Output:

  name  age
0  John   28
1  Alice  24
2  Bob   35
3  Emma  29
4  Eve   32
5  Carl  27

2. df.rename(): Renames columns or rows.

df = df.rename(columns={'name': 'full_name'})
print(df)

Explanation: The rename() function allows you to change the name of specific columns or rows, which is especially useful for standardizing column names or correcting typos in your data.

Output:

  full_name  age
0     John    28
1     Alice   24
2     Bob     35
3     Emma    29
4     Eve     32
5     Carl    27

3. df.fillna(): Fills missing values with a specified value or method.

df = df.fillna(0)
print(df)

Explanation: Fills missing data with a specified value. Here, we fill NaN values with 0.

Output:

  full_name  age
0     John   28
1     Alice  24
2     Bob    35
3     Emma   29
4     Eve    32
5     Carl   27

4. df.dropna(): Removes rows with missing values.

df = df.dropna()
print(df)

Output: A DataFrame with any rows containing NaN values removed.

5. df.duplicated(): Identifies duplicate rows in the DataFrame.

duplicates = df.duplicated()
print(duplicates)

Output:

[False False False False False False]

6. df.replace(): Replaces values in the DataFrame.

df = df.replace({'age': {28: 30}})
print(df)

Output:

  full_name  age
0     John   30
1    Alice  24
2     Bob   35
3     Emma  29
4     Eve   32
5    Carl  27

Also Read: 60 Most Asked Pandas Interview Questions and Answers [ANSWERED + CODE]

Grouping & Aggregation

Grouping and aggregation are powerful tools for transforming large datasets into meaningful insights. By grouping data based on certain features or categories, you can perform calculations, summaries, and statistical analysis on each group independently. 

This allows you to uncover trends, patterns, and relationships that might be hidden in the raw data. Whether you're calculating averages, sums, or applying custom functions, grouping and aggregation enable you to analyze subsets of your data in a more structured and efficient way.

1. df.groupby(): Groups data by one or more columns.

grouped = df.groupby('age')
print(grouped.mean())

Explanation: The groupby() function groups the data based on the age column, allowing you to perform operations like calculating the mean of each group. In this case, it computes the average of numerical columns for each unique age.

Output:

      age
age       
24.0   24.0
27.0   27.0
29.0   29.0
30.0   30.0
32.0   32.0
35.0   35.0

2. df.agg(): Applies aggregation functions on groups.

grouped = df.groupby('age').agg({'age': 'sum'})
print(grouped)

Explanation: The agg() function applies aggregation operations on grouped data. In this case, we group the data by age and then calculate the sum of the age column within each group. This is useful for performing custom aggregations on grouped data.

Output:

      age
age       
24.0   24.0
27.0   27.0
29.0   29.0
30.0   30.0
32.0   32.0
35.0   35.0

3. df.pivot_table(): Creates a pivot table for multi-dimensional analysis.

pivot = df.pivot_table(values='age', index='full_name', aggfunc='mean')
print(pivot)

Output:

          age
full_name     
Alice       24
Bob         35
Carl        27
Emma        29
Eve         32
John        30

Merging & Joining Datasets

In data analysis, it's common to work with multiple datasets that need to be combined to provide a comprehensive view of the data. Pandas offers powerful methods for merging and joining datasets, making it easy to combine tables based on common columns or indices. 

This includes combining data from different sources, matching records by a unique identifier, or appending datasets vertically or horizontally. Pandas ensures these operations are fast and flexible. Mastering merging and joining is essential for creating unified datasets that can be used for deeper analysis or modeling.

1. pd.concat(): Concatenates DataFrames along a particular axis (rows or columns).

import pandas as pd
# Example DataFrames
df1 = pd.DataFrame({'name': ['John', 'Alice'], 'age': [28, 24]})
df2 = pd.DataFrame({'name': ['Bob', 'Emma'], 'age': [35, 29]})
# Concatenating DataFrames along rows (axis=0)
combined = pd.concat([df1, df2], axis=0)
print(combined)

Explanation: The pd.concat() function is used to concatenate two or more DataFrames along a specified axis. When axis=0 is used, it combines the DataFrames vertically by stacking rows from each DataFrame. This is useful when you want to merge datasets with similar columns.

Output:

  name  age
0  John   28
1  Alice  24
0  Bob   35
1  Emma  29

Note: The row indices are preserved from the original DataFrames. You can reset the index if needed using .reset_index().

2. pd.merge(): Merges two DataFrames on a common column.

 import pandas as pd
# Example DataFrames
df1 = pd.DataFrame({'id': [1, 2], 'name': ['John', 'Alice']})
df2 = pd.DataFrame({'id': [1, 2], 'age': [28, 24]})
# Merging DataFrames on the 'id' column
merged = pd.merge(df1, df2, on='id')
print(merged)

Explanation: The pd.merge() function is used to merge two DataFrames based on a common column or index. In this case, you are merging df1 and df2 using the id column. The result is a single DataFrame that contains all columns from both DataFrames, where the id values match. This is similar to performing a SQL join.

Output:

  id   name  age
0   1   John   28
1   2  Alice   24

Note: The on parameter specifies the column on which to merge the two DataFrames. You can also perform other types of joins (e.g., left, right, outer) using the how parameter, which allows more control over how rows from each DataFrame are included in the result.

3. df.join(): Joins columns from another DataFrame.

 import pandas as pd
# Example DataFrames
df1 = pd.DataFrame({'id': [1, 2], 'name': ['John', 'Alice']})
df2 = pd.DataFrame({'id': [1, 2], 'age': [28, 24]})
# Joining DataFrames on the 'id' column
joined = df1.join(df2.set_index('id'), on='id')
print(joined)

 Explanation: The df.join() function is used to join columns from another DataFrame. In this case, we join df2 to df1 using the id column. We first set the id column of df2 as the index with set_index('id') and then join it with df1 using the on='id' parameter. 

This operation is similar to a SQL join, but it uses the index of one DataFrame and the column from the other.

Output:

  id   name  age
0   1   John   28
1   2  Alice   24

Note: The on='id' parameter indicates that we are joining the DataFrames based on the id column in df1 and the id index in df2. The result contains all columns from df1 with the age column from df2.

These essential Pandas functions will help you handle large datasets efficiently. 

Also Read: Pandas Cheat Sheet in Python for Data Science: Complete List for 2025

With the Pandas cheat sheet covered, let’s look at how you can perform data visualization using Python’s Matplotlib and Seaborn libraries.

Matplotlib & Seaborn Cheat Sheet: Data Visualization in Python

Matplotlib offers advanced plotting capabilities that enhance data visualization for deeper insights. Time-series plots are particularly useful for tracking trends over time, allowing for a clear representation of fluctuations and patterns. 

Stacked bar charts help compare multiple categories by visually stacking different segments within each bar, making it easier to analyze proportions. Multi-plot grids enable the arrangement of multiple visualizations in a single figure, facilitating side-by-side comparisons of different datasets or variables.

Additionally, color customization, including colormaps and transparency settings, enhances clarity and aesthetics, making it easier to distinguish between different data elements.

Let’s start with the Matplotlib cheat sheet and see how it excels in different scenarios.

Basic Plotting with Matplotlib

Matplotlib is a powerful library for creating static, animated, and interactive visualizations in Python. It offers intuitive functions for generating common plot types, from line graphs to histograms.

1. plt.plot(): Creates a simple line plot.

 import matplotlib.pyplot as plt
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
plt.plot(x, y)
plt.show()

Explanation: plt.plot() generates a line plot of y versus x. It's ideal for visualizing trends over time or continuous data.

Output: A simple line plot showing the relationship between x and y.

2. plt.scatter(): Creates a scatter plot.

x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
plt.scatter(x, y)
plt.show()

Explanation: plt.scatter() is used to create a scatter plot, which shows the relationship between two variables in a dataset.

Output: A scatter plot showing individual data points as dots.

3. plt.bar(): Creates a bar chart.

categories = ['A', 'B', 'C', 'D']
values = [3, 7, 2, 5]
plt.bar(categories, values)
plt.show()

Explanation: plt.bar() creates a bar chart, which is useful for visualizing categorical data.

Output: A bar chart representing the categories and their corresponding values.

4. plt.hist(): Creates a histogram.

data = [1, 2, 2, 3, 4, 4, 4, 5, 5, 6]
plt.hist(data, bins=5)
plt.show()

Explanation: plt.hist() generates a histogram, which shows the distribution of a dataset.

Output: A histogram showing the frequency of data values in specified bins.

5. plt.boxplot(): Creates a box plot.

data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
plt.boxplot(data)
plt.show()

Explanation: plt.boxplot() creates a box plot, which visualizes the spread and potential outliers of a dataset.

Output: A box plot showing the median, quartiles, and outliers of the data.

Customizing Plots

Matplotlib allows you to customize plots with labels, titles, legends, and grids. Here are some commonly used functions for improving your plots.

1. plt.xlabel(): Adds a label to the x-axis of the plot, helping to describe what the x-values represent.

plt.plot(x, y)
plt.xlabel('X-axis Label')
plt.show()

2. plt.ylabel(): Adds a label to the y-axis of the plot, providing context for the y-values.

plt.plot(x, y)
plt.ylabel('Y-axis Label')
plt.show()

3. plt.title(): Adds a title to the plot, which serves as a description or context for the entire plot.

plt.plot(x, y)
plt.title('Plot Title')
plt.show()

4. plt.legend(): Adds a legend to the plot, which is helpful when there are multiple lines or elements on the plot. It labels each element for better clarity.

plt.plot(x, y, label='Line')
plt.legend()
plt.show()

5. plt.grid(): Adds a grid to the plot, making it easier to read values and identify trends in the plot.

plt.plot(x, y)
plt.grid(True)
plt.show()

These functions enhance the clarity and readability of your plots, making it easier to understand the data and its patterns.

Combined Code with the Above Functions:

import matplotlib.pyplot as plt
# Data
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
# Create plot with customizations
plt.plot(x, y, label='Line')
plt.xlabel('X-axis Label')
plt.ylabel('Y-axis Label')
plt.title('Plot Title')
plt.legend()
plt.grid(True)
# Show plot
plt.show()

Explanation: The line plot is generated, showing the relationship between x and y. The x-axis and y-axis are labeled to provide context. The title at the top describes the plot's content. The legend explains what the line represents. The grid enhances readability by helping to trace values on the plot.

Output: Here’s the resulting plot with all the customizations applied.

Also Read: Matplotlib in Python: Explained Various Plots with Examples 

Working with Subplots

When analyzing data, it's often useful to compare multiple plots side by side within the same figure. Matplotlib makes this easy by allowing you to create subplots—multiple plots in a single figure. With subplots, you can display different visualizations together, which helps in comparing trends, distributions, and relationships across multiple datasets. 

This technique is essential when you need to convey several insights in a compact and easy-to-interpret layout.

1. plt.subplot(): Creates a single subplot in a grid of subplots.

plt.subplot(1, 2, 1)  # 1 row, 2 columns, first subplot
plt.plot(x, y)
plt.subplot(1, 2, 2)  # 1 row, 2 columns, second subplot
plt.scatter(x, y)
plt.show()

Explanation: plt.subplot() divides the figure into a grid and creates individual subplots within that grid. In this example, we create a figure with 1 row and 2 columns, placing a line plot in the first and a scatter plot in the second.

Output: A figure with two side-by-side plots.

2. plt.subplots_adjust(): Adjusts the spacing between subplots.

plt.subplots_adjust(wspace=0.5, hspace=0.5)

Explanation: By increasing wspace and hspace, the subplots will have more space between them, preventing any overlap between the plots, titles, or labels.

Output: The two subplots (line plot and scatter plot) will now appear with more space between them compared to the previous example, making the figure clearer and easier to read.

upGrad’s Exclusive Data Science Webinar for you –

ODE Thought Leadership Presentation

Seaborn for Advanced Visualizations

Seaborn, built on top of Matplotlib, simplifies creating beautiful and complex statistical plots. It offers higher-level functions for advanced visualizations.

1. sns.countplot(): Creates a count plot.

 import seaborn as sns
data = ['A', 'B', 'B', 'A', 'C', 'A']
sns.countplot(x=data)
plt.show()

Explanation: sns.countplot() creates a bar plot that shows the counts of unique values in a dataset.

Output: A bar chart showing the frequency of each category (A, B, C).

2. sns.boxplot(): Creates a box plot.

data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
sns.boxplot(x=data)
plt.show()

Explanation: sns.boxplot() creates a box plot to visualize the distribution of numerical data and its summary statistics.

Output: A box plot showing the median, quartiles, and outliers of the data.

3. sns.heatmap(): Creates a heatmap.

data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
sns.heatmap(data)
plt.show()

Explanation: sns.heatmap() visualizes data as a matrix of color-coded values, making it great for showing correlations and patterns.

Output: A heatmap showing the values in the matrix with color coding.

4. sns.pairplot(): Creates a pairplot of a DataFrame.

import seaborn as sns
import matplotlib.pyplot as plt
# Load the iris dataset from seaborn
df = sns.load_dataset('iris')
# Create pairplot
sns.pairplot(df)
plt.show()

Explanation: sns.pairplot() creates a grid of scatter plots for all pairs of numerical columns in a DataFrame. It’s great for visualizing relationships between multiple variables.

Output: A grid of scatter plots and histograms for each pair of features in the iris dataset.

Here’s a comparison of Matplotlib & Seaborn functions for data visualization:

Matplotlib and Seaborn are both indispensable tools for data visualization in Python. Matplotlib provides the flexibility for custom plots, while Seaborn simplifies the creation of complex, beautiful visualizations. 

Also Read: Top 10 Data Visualization Tips You Should Know In 2025

Now that you have a good understanding of these libraries from the Matplotlib cheat sheet, let’s explore how you can preprocess and clean data in Python.

Data Preprocessing & Cleaning in Python

Data cleaning is one of the most crucial steps in the data science workflow. Raw data is often messy, with missing values, duplicates, and other inconsistencies that can skew your analysis. Fortunately, Python offers a powerful toolkit for data preprocessing that can help you clean and prepare your data for analysis.

Let’s dive into some of the most common preprocessing tasks you’ll encounter, and see how you can handle them with Python.

Handling Missing Data in Pandas

Missing data can be a real headache, but Pandas makes it easy to handle. There are two primary ways to deal with missing data: filling it in or dropping it entirely. Depending on your needs, you can choose the approach that works best for your analysis.

1. df.fillna(): Fills missing values with a specified value.

 import pandas as pd
# Example DataFrame
df = pd.DataFrame({'A': [1, 2, None, 4], 'B': [5, None, 7, 8]})
# Fill missing values with 0
df_filled = df.fillna(0)
print(df_filled)

Explanation: The fillna() method replaces None or NaN values with the specified value (in this case, 0). This is useful when you want to preserve the structure of your data and avoid losing rows or columns.

Output:

  A  B
0  1  5
1  2  0
2  0  7
3  4  8

2. df.dropna(): Drops rows with missing values.

df_dropped = df.dropna()
print(df_dropped)

Explanation: dropna() removes any rows containing NaN values. Use this when you don’t mind losing data but want to ensure you only work with complete rows.

Output:

  A    B
0  1.0  5.0
3  4.0  8.0

Removing Duplicates & Outliers

Duplicates and outliers can distort your analysis, so it's important to handle them properly.

1. df.duplicated(): Identifies duplicate rows in the DataFrame.

df = pd.DataFrame({'A': [1, 2, 2, 4], 'B': [5, 6, 6, 8]})
duplicates = df.duplicated()
print(duplicates)

 Explanation: The duplicated() method returns a Boolean Series that indicates whether a row is a duplicate of a previous one. You can then decide whether to drop the duplicates or investigate further.

Output:

0    False
1    False
2     True
3    False
dtype: bool

2. df.drop_duplicates(): Removes duplicate rows.

df_no_duplicates = df.drop_duplicates()
print(df_no_duplicates)

Explanation: drop_duplicates() removes rows that are identical to a previous one. It helps ensure that your data analysis isn’t biased by repeated entries.

Output:

  A  B
0  1  5
1  2  6
3  4  8

Also Read: Data Cleaning Techniques: Learn Simple & Effective Ways To Clean Data

Feature Scaling & Normalization

Feature scaling ensures that numerical values are on a comparable scale. This is particularly important for machine learning models like k-nearest neighbors or gradient descent, which are sensitive to the magnitude of features.

1. MinMaxScaler(): Scales features to a range between 0 and 1.

 from sklearn.preprocessing import MinMaxScaler
# Example DataFrame
df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [10, 20, 30, 40]})
scaler = MinMaxScaler()
df_scaled = scaler.fit_transform(df)
print(df_scaled)

Explanation: The MinMaxScaler() scales each feature to the range [0, 1]. This is useful when you want all features to contribute equally to the model.

Output:

[[0.   0.  ]
[0.33 0.33]
[0.67 0.67]
[1.   1.  ]]

2. StandardScaler(): Scales features to have zero mean and unit variance.

 from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
df_standardized = scaler.fit_transform(df)
print(df_standardized)

Explanation: StandardScaler() standardizes the features by removing the mean and scaling to unit variance. This is often necessary for algorithms that assume data is normally distributed.

Output:

[[-1.34164079 -1.34164079]
[-0.4472136  -0.4472136 ]
[ 0.4472136   0.4472136 ]
[ 1.34164079  1.34164079]]

Also Read: What is Normalization in DBMS? 1NF, 2NF, 3NF

Converting Data Types

Sometimes, data may need to be converted to different types, such as from strings to integers or from floats to categories. Pandas makes type conversion easy.

1. df.astype(): Converts a column to a specified data type.

df = pd.DataFrame({'A': ['1', '2', '3', '4'], 'B': ['10', '20', '30', '40']})
df['A'] = df['A'].astype(int)
df['B'] = df['B'].astype(int)
print(df)

Explanation: The astype() method allows you to convert columns to specific data types. In this case, we convert columns 'A' and 'B' from strings to integers.

Output:

  A   B
0  1  10
1  2  20
2  3  30
3  4  40

By mastering these Python functions, you'll ensure that your data is clean, consistent, and ready for analysis or machine learning tasks.

Did you Know? Statistics show that businesses can lose over $3 trillion due to bad data every year.

Also Read: Data Science Process: Key Steps, Tools, Applications, and Challenges

Next, let’s look at how Python works with large datasets, and if it’s ideal for your projects.

Working with Large Datasets in Python

Handling large datasets can be a challenge. When your data grows too big to fit into memory, processing it efficiently becomes essential. Fortunately, Python offers several tools and techniques that make working with big data manageable. 

Whether you're dealing with large CSV files, databases, or streaming data, there are strategies to help. These methods let you process and analyze data efficiently. They also help you avoid running into memory issues.

Let’s explore the best ways to handle large datasets in Python, from parallel processing to chunk-based operations.

Using Dask for Parallel Processing

Dask is highly scalable, making it well-suited for big data workloads in distributed environments. It can run seamlessly on large clusters, distributing computations across multiple machines using a task scheduling system. In cloud environments like AWS, Google Cloud, and Azure, Dask integrates with services such as Kubernetes, EC2, and cloud storage, enabling efficient handling of massive datasets. 

By dynamically managing resources and parallelizing tasks, Dask optimizes performance and minimizes memory constraints, making it an excellent choice for scalable data processing in cloud-based workflows.

Example with Dask: Parallel DataFrame operations

 import dask.dataframe as dd
# Load a large CSV file with Dask
ddf = dd.read_csv('large_dataset.csv')
# Compute the mean of a column in parallel
result = ddf['column_name'].mean().compute()
print(result)

Explanation: Here, we load a large CSV file using Dask's read_csv() function, which can handle data that doesn’t fit in memory. 

Dask automatically divides the task into smaller chunks and processes them in parallel. The .compute() function triggers the execution and aggregates the results.

Output: A computed mean value of the specified column.

Optimizing Pandas Performance with Vectorization

Pandas is great for data analysis, but when dealing with large datasets, the performance can suffer if you’re using loops. 

One of the best ways to speed things up is vectorization, which leverages Pandas' built-in operations to apply functions to entire columns or rows at once. This reduces the need for inefficient Python loops.

Example of Vectorization:

 import pandas as pd
import numpy as np
# Sample DataFrame with large dataset
df = pd.DataFrame({'A': np.random.rand(10**6), 'B': np.random.rand(10**6)})
# Apply a vectorized operation
df['C'] = df['A'] + df['B']
print(df.head())

Explanation: Here, you create a large DataFrame and apply a vectorized operation to sum two columns, A and B, without using any explicit loops. This speeds up the process significantly by allowing Pandas to use optimized C-based operations.

Output:

      A         B         C
0  0.721158  0.210071  0.931229
1  0.411349  0.391266  0.802615
2  0.689569  0.118507  0.808076
3  0.413429  0.986410  1.399839
4  0.268704  0.560906  0.829610

Working with SQLite & BigQuery for Large Datasets

Sometimes, your dataset is too large to handle in memory or too complex for a single machine to process. In these cases, using a database like SQLite or BigQuery can be helpful. 

Both allow you to store large datasets efficiently and run complex queries directly on the data without loading everything into memory.

SQLite Example:

 import sqlite3
# Connect to SQLite database (or create if it doesn't exist)
conn = sqlite3.connect('large_data.db')
# Create a table
conn.execute('CREATE TABLE IF NOT EXISTS data (id INTEGER, value REAL)')
# Insert data (for example, from a CSV)
conn.executemany('INSERT INTO data (id, value) VALUES (?, ?)', [(1, 10.5), (2, 20.3)])
# Query the data
result = conn.execute('SELECT * FROM data').fetchall()
print(result)

Explanation: This code connects to an SQLite database, creates a table, inserts data, and queries the table. SQLite is great for handling smaller big datasets on local machines. For larger-scale systems, you might use BigQuery or other cloud databases.

Output: Data from the database as a list of tuples.

BigQuery Example:

 from google.cloud import bigquery
# Initialize BigQuery client
client = bigquery.Client()
# Run a query
query = "SELECT * FROM `project.dataset.table` LIMIT 10"
results = client.query(query)
# Display results
for row in results:
    print(row)

Explanation: BigQuery allows you to run SQL queries on massive datasets stored in the cloud, without needing to download the data. It’s a good choice for working with large datasets stored in Google Cloud.

Output: Query results from BigQuery displayed row by row.

Chunk Processing in Pandas

Chunking improves memory efficiency by ensuring that only a small portion of a dataset is loaded into memory at any given time, preventing memory overflow when working with larger-than-memory datasets. Instead of attempting to load an entire dataset—which may exceed available RAM—data is processed in smaller chunks, reducing memory consumption. 

This approach enables incremental computations, where each chunk is processed independently, and results are aggregated progressively.

Example with Chunk Processing:

 import pandas as pd
# Process the file in chunks
chunk_size = 100000
for chunk in pd.read_csv('large_file.csv', chunksize=chunk_size):
    # Process each chunk here
    print(chunk.head())  # or any processing logic

Explanation: By reading the dataset in chunks using the chunksize parameter, you can process parts of a large file one by one without overwhelming memory.

Output: A preview of each chunk from the dataset.

Working with large datasets requires the right approach. Tools like Dask, vectorization, and chunk processing help you handle data more efficiently. Databases like SQLite and BigQuery provide scalable solutions for storing and querying massive datasets. 

Also Read: Top Data Analytics Tools Every Data Scientist Should Know About

Now that you have a good understanding of handling large datasets, let’s look at some advanced Python data science functions.

Advanced Python Data Science Functions

As you dive deeper into data science, you'll encounter more complex tasks like time series analysis, machine learning, and automating data pipelines. Python offers powerful libraries like Pandas, NumPy, and Scikit-learn to handle these tasks efficiently. 

Next, let’s explore advanced functions that can help you tackle these challenges and elevate your data science workflow.

Time Series Analysis in Pandas

Time series analysis is essential when you’re working with data that has a time component, like stock prices or weather data. Pandas makes it easy to work with time-based data. It allows you to perform operations like resampling, shifting, and rolling averages.

1. Creating a Time Series:

 import pandas as pd
# Create a time series
dates = pd.date_range('20230101', periods=6)
data = pd.DataFrame({'Date': dates, 'Value': [10, 20, 30, 40, 50, 60]})
print(data)

Explanation: Here, you generate a simple time series with dates starting from '2023-01-01'. The pd.date_range() function creates a range of dates, and we use them to create a DataFrame.

Output:

      Date  Value
0  2023-01-01     10
1  2023-01-02     20
2  2023-01-03     30
3  2023-01-04     40
4  2023-01-05     50
5  2023-01-06     60

2. Resampling Time Series:

data.set_index('Date', inplace=True)
resampled_data = data.resample('3D').sum()  # Resampling data every 3 days
print(resampled_data)

 Explanation: The resample() function in Pandas allows you to change the frequency of your time series data. In this case, we resample the data to 3-day intervals and compute the sum for each period.

Output:

          Value
Date              
2023-01-01     30
2023-01-04    120

Applying Machine Learning with Scikit-Learn

Machine learning is at the core of data science. Scikit-learn makes it simple to apply common machine learning algorithms, like regression and classification, with just a few lines of code.

1. Simple Linear Regression:

 from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
import numpy as np
# Example dataset
X = np.array([[1], [2], [3], [4], [5]])  # Feature
y = np.array([1, 2, 3, 4, 5])  # Target
# Train-test split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
# Apply Linear Regression
model = LinearRegression()
model.fit(X_train, y_train)
# Make predictions
predictions = model.predict(X_test)
print(predictions)

Explanation: This example shows a simple linear regression model. We split the dataset into training and testing sets, then train a linear regression model on the training data and predict on the test data.

Output (predictions):

[5.]

2. Evaluating the Model:

 from sklearn.metrics import mean_squared_error
# Calculate Mean Squared Error
mse = mean_squared_error(y_test, predictions)
print(f'Mean Squared Error: {mse}')

Explanation: The mean_squared_error() function helps you evaluate the performance of your machine learning model by comparing the predicted values to the actual ones.

Output:

Mean Squared Error: 0.0

Also Read: Top 10 Best Machine Learning Courses: 2025 Edition

Automating Data Pipelines with Python

Data pipelines are essential when dealing with complex workflows. Automating these pipelines ensures that your data processing is smooth and consistent. Python allows you to automate tasks like data extraction, transformation, and loading (ETL).

Automating ETL Process:

 import pandas as pd
# Extract data
data = pd.read_csv('raw_data.csv')
# Transform data
data['new_column'] = data['column_1'] * 2  # Example transformation
# Load transformed data
data.to_csv('processed_data.csv', index=False)
print('Data pipeline completed successfully')

Explanation: This simple ETL pipeline extracts data from a CSV file, transforms it by adding a new column, and loads the transformed data into a new CSV file. Automation ensures that you don’t manually repeat these steps every time you get new data.

Output:

Data pipeline completed successfully

With time series analysis in Pandas, machine learning with Scikit-learn, and automating data pipelines, you can tackle complex data challenges and improve your workflow.

Also Read: Top 5 Machine Learning Models Explained For Beginners 

Next, let’s look at some of the key trends you can look forward to this year.

Python for Data Science Trends in 2025

As AI and machine learning become relevant in business decision-making, Python’s flexibility and powerful ecosystem make it indispensable for handling complex data tasks. This is particularly seen in fields like AutoML, deep learning, and cloud-based data workflows. These advancements are making data science more accessible and efficient.

Let’s take a look at the key trends and advancements that are shaping the future of Python in data science.

1. The Rise of AutoML & No-Code Data Science

One of the most significant trends in data science is the rise of AutoML and no-code tools. AutoML platforms allow non-experts to build machine learning models without needing to write complex code. 

These tools automatically handle tasks like feature engineering, model selection, and hyperparameter tuning, making it easier for businesses to leverage machine learning.

In 2025, you can expect more businesses to adopt AutoML as a way to democratize AI, enabling teams without deep technical knowledge to create and deploy models. Python will play a central role in this trend, as many AutoML frameworks (such as TPOT and Auto-sklearn) are built on top of Python libraries.

Also Read: Machine Learning Career Path: 12 In-Demand Roles, Skills, and Salary Insights

2. Python vs. R vs. Julia: The Future of Data Science Languages

Python, R, and Julia have all carved out their niches in data science, but in 2025, Python is likely to continue its dominance. While R is excellent for statistical analysis and Julia is known for its speed in numerical computing, Python remains the most versatile and widely adopted language.

• Python: Preferred for general-purpose programming and machine learning due to its simplicity, vast ecosystem, and active community.
• R: Continues to be popular for statistical analysis and academic research, especially in academia and healthcare.
• Julia: Gaining traction for performance-heavy tasks, but still less widely adopted than Python.

3. Deep Learning with Python: TensorFlow & PyTorch

Deep learning is another area where Python remains the undisputed leader. Libraries like TensorFlow and PyTorch have made it easier to build and deploy deep learning models.

• TensorFlow: Developed by Google, TensorFlow is widely used for building complex neural networks, especially in production environments.
• PyTorch: Preferred for research due to its dynamic computation graph, making it easier to experiment and prototype.

You can expect even deeper integration of Python with deep learning, particularly as models grow in complexity and require more advanced tools for training and deployment.

Also Read: How To Improve Your Career Skills for a Better Job and Employability [2025]

4. Cloud-Based Python Data Science Workflows

The shift to the cloud is accelerating in 2025, and Python is at the center of this transformation. Cloud platforms like Google Cloud, AWS, and Azure are offering more robust Python support for data science workflows. This enables seamless integration for training machine learning models, processing large datasets, and deploying AI-powered applications.

Cloud-based Python tools, such as Google Colab and Jupyter Notebooks, are making it easier for data scientists to collaborate on projects without the need for powerful local machines. These platforms provide scalable compute resources and tools that accelerate model training and data processing.

Python’s versatility and the ease of integrating it with various machine learning frameworks make it the language of choice for the future.

Conclusion

Python, with its versatile libraries like Pandas and NumPy, is powering everything from data analysis to machine learning. In fact, over 75% of data scientists use Python in their daily work. 

Now is the perfect time to deepen your knowledge of Python and its applications in data science. Whether you're just starting out or looking to specialize, hands-on practice and continuous learning are key. 

Not sure where to begin? Connect with upGrad’s career counseling for personalized guidance.  You can also visit a nearby upGrad center for hands-on training to improve your Python skills and open up new career opportunities!

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

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

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