Master the Pandas Dropna() Method [In-Depth Tutorial]

Written by - Deepak Prasad

Getting started with Pandas dropna() Method

In the world of data analysis and data science, handling missing values is a common but crucial task. Missing or incomplete information can distort your analysis and lead to misleading conclusions. That's where Python's Pandas library comes in handy, offering a suite of powerful tools for data manipulation. One such tool is the dropna() method. In essence, pandas dropna is a go-to function that helps you remove missing values from your DataFrame or Series swiftly and efficiently. Whether you are dealing with a simple dataset or a complex, multi-dimensional DataFrame, dropna() offers various parameters to tailor the missing data removal process to your needs.

This introduction provides a brief overview of what the Pandas dropna() function is and why it's essential in the Pandas library, making it accessible to both new and experienced users while optimizing for search engine visibility.


Syntax Explained

The basic syntax for using pandas dropna is as follows:

DataFrame.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)

Or if you are working with a Series:



Parameters Explained

Here's a quick rundown of the parameters you can use with dropna:

  • axis: Specifies whether to remove missing values along rows (axis=0) or columns (axis=1).
  • how: Determines if rows/columns with 'any' or 'all' missing values should be dropped.
  • thresh: Requires that many non-NA values.
  • subset: Allows you to specify which columns to consider for dropping rows.
  • inplace: Modifies the DataFrame in place if set to True.


Examples for Each Parameter

1. axis: Removing Missing Values Along Rows/Columns

By default, axis is set to 0, which means dropna will remove rows containing missing values.

# Remove rows with missing values

To remove columns containing missing values, set axis to 1.

# Remove columns with missing values

2. how: 'any' vs 'all'

The how parameter allows you to specify whether to remove rows (or columns) that have 'any' or 'all' NaN values.

# Remove rows where all values are NaN

# Remove rows where any of the values is NaN

3. thresh: Minimum Number of Non-NA Values

This parameter allows you to specify a minimum number of non-NA values for the row/column to be kept.

# Keep only the rows with at least 2 non-NA values.

4. subset: Applying dropna on Specific Columns

You can use the subset parameter to specify which columns to check for NaN values.

# Remove rows where column 'A' has missing values

5. inplace: Altering DataFrame in Place

The inplace parameter allows you to modify the DataFrame directly, without returning a new DataFrame.

# Remove rows with missing values and alter the DataFrame in place


Basic Use-Cases of Pandas dropna() with Examples

Handling missing data is a common hurdle in data analysis, and pandas dropna provides a handy way to clean up your DataFrame. Below, we'll go through some of the most basic use-cases where dropna comes in handy.

1. Dropping Rows with At Least One NaN Value

A common operation is to remove all rows containing at least one NaN value. You can achieve this using pandas dropna by keeping the default parameters.

import pandas as pd
import numpy as np

# Create a DataFrame with missing values
df = pd.DataFrame({'A': [1, np.nan, 3], 'B': [4, np.nan, np.nan], 'C': [7, 8, 9]})

# Use pandas dropna to remove any rows containing at least one NaN value

This will return a new DataFrame with only the rows that have no NaN values.

2. Dropping Columns with All NaN Values

Sometimes, you might want to remove columns where all values are missing. In this case, you can use pandas dropna with the axis=1 and how='all' parameters.

# Create a DataFrame with missing values
df = pd.DataFrame({'A': [1, 2, 3], 'B': [np.nan, np.nan, np.nan], 'C': [7, 8, 9]})

# Use pandas dropna to remove columns where all values are NaN
df.dropna(axis=1, how='all')

The DataFrame will now exclude any columns where all values are NaN.

3. Dropping Rows Based on NaN Values in a Specific Column

At times, you may need to drop rows based on missing values in a specific column. The subset parameter of pandas dropna allows you to specify the columns to consider when dropping rows.

# Create a DataFrame with missing values
df = pd.DataFrame({'A': [1, np.nan, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})

# Use pandas dropna to remove rows where column 'A' has missing values

This will return a DataFrame with rows that have non-NaN values in column 'A'.


Advanced Use-Cases of Pandas dropna() with Examples

As versatile as pandas dropna is for handling missing data, its capabilities extend even further when combined with other Pandas methods. In this section, we will explore some advanced use-cases, detailing how you can leverage dropna in more complex scenarios.


Combining dropna with Other Pandas Methods

1. Using fillna Before dropna

In some instances, you may want to fill some missing values before dropping rows or columns. Here's how you can use fillna alongside pandas dropna.

# Create a DataFrame with missing values
df = pd.DataFrame({'A': [1, np.nan, np.nan], 'B': [4, 5, np.nan], 'C': [7, 8, 9]})

# Fill NaN values in column 'A' with 0
df['A'].fillna(0, inplace=True)

# Now use pandas dropna to remove rows with missing values in column 'B'

2. Using replace and dropna

You can use replace to substitute specific values with NaN and then apply dropna.

# Replace all instances of value 5 with NaN
df.replace(5, np.nan, inplace=True)

# Use pandas dropna to remove any rows containing at least one NaN value

3. Using isna to Find NaN Values Before dropna

If you want to examine which values are missing before you drop them, use isna.

# Identify rows where 'B' is NaN
mask = df['B'].isna()

# Use this mask with pandas dropna to remove these rows
df.dropna(subset=['B'], inplace=mask)


Conditional Dropping: Using query or Boolean Indexing Before dropna

Sometimes, you may want to drop rows based on certain conditions along with NaN checks. This can be achieved by combining query or boolean indexing with pandas dropna.

1. Using query

# Create a DataFrame with missing values
df = pd.DataFrame({'A': [1, 2, np.nan], 'B': [4, 5, 6], 'C': [7, 8, np.nan]})

# Use query to filter rows where 'B' is greater than 4
filtered_df = df.query('B > 4')

# Now use pandas dropna to remove rows with NaN values from the filtered DataFrame

2. Using Boolean Indexing

# Create a DataFrame with missing values
df = pd.DataFrame({'A': [1, 2, np.nan], 'B': [4, 5, 6], 'C': [7, 8, np.nan]})

# Use boolean indexing to filter rows
filtered_df = df[df['B'] > 4]

# Use pandas dropna to remove any remaining rows with NaN values


Performance Considerations

When working with large datasets, the performance of data manipulation operations becomes critical. Here, we'll explore some performance considerations when using pandas dropna, specifically focusing on memory usage and execution time.

1. Memory Usage

Using dropna can either increase or decrease memory usage, depending on the DataFrame structure and how the dropna method is used.

  • Decrease: If you're removing a significant number of rows or columns, memory usage will likely decrease.
  • Increase: If you're not using inplace=True, a new DataFrame will be created, temporarily doubling the memory requirement.
import pandas as pd
import numpy as np
import time

# Generate a DataFrame with random data and some NaN values
df_size = 5000000
df = pd.DataFrame({
    'A': np.random.rand(df_size),
    'B': [x if x > 0.2 else np.nan for x in np.random.rand(df_size)],
    'C': np.random.rand(df_size)

# Measure initial memory usage
initial_memory = df.memory_usage().sum() / 1e6  # in MB
print(f"Initial memory usage: {initial_memory:.2f} MB")

# Measure time and memory usage when using dropna without inplace=True
start_time = time.time()
new_df = df.dropna()
end_time = time.time()
elapsed_time_without_inplace = end_time - start_time  # in seconds

memory_without_inplace = new_df.memory_usage().sum() / 1e6  # in MB
print(f"Elapsed time without inplace=True: {elapsed_time_without_inplace:.4f} seconds")
print(f"Memory usage without inplace=True: {memory_without_inplace:.2f} MB")

# Measure time and memory usage when using dropna with inplace=True
start_time = time.time()
end_time = time.time()
elapsed_time_with_inplace = end_time - start_time  # in seconds

memory_with_inplace = df.memory_usage().sum() / 1e6  # in MB
print(f"Elapsed time with inplace=True: {elapsed_time_with_inplace:.4f} seconds")
print(f"Memory usage with inplace=True: {memory_with_inplace:.2f} MB")

This script creates a DataFrame with 5 million rows and three columns containing random floats and NaN values. It then uses the dropna method both with and without the inplace=True parameter, measuring the elapsed time and memory usage in each case.


Initial memory usage: 120.00 MB
Elapsed time without inplace=True: 0.9107 seconds
Memory usage without inplace=True: 127.98 MB
Elapsed time with inplace=True: 0.5919 seconds
Memory usage with inplace=True: 127.98 MB

Let us understand the results:

  • Elapsed Time: Using inplace=True is noticeably faster in this case. The time savings can be significant, especially for larger datasets or more complicated workflows.
  • Memory Usage: Interestingly, the memory usage after the operation remains the same whether inplace=True is used or not. This might seem counterintuitive, but it's essential to understand that pandas may perform various optimizations under the hood. Although inplace=True is designed to save memory by modifying the DataFrame in place, the actual memory footprint can depend on many factors, including internal optimizations by pandas.

2. Execution Time

Execution time can vary based on DataFrame size and the specific parameters used in dropna. To measure execution time, you can use Python's built-in time module.

import time
import pandas as pd
import numpy as np

df_size = 5000000  # 5 million rows for demonstration
df = pd.DataFrame({
    'A': np.random.rand(df_size),
    'B': [x if x > 0.2 else np.nan for x in np.random.rand(df_size)],
    'C': np.random.rand(df_size)

start_time_without_inplace = time.time()
new_df = df.dropna()  # Replace this line with your specific operation
end_time_without_inplace = time.time()
elapsed_time_without_inplace = end_time_without_inplace - start_time_without_inplace

start_time_with_inplace = time.time()
df.dropna(inplace=True)  # Replace this line with your specific operation
end_time_with_inplace = time.time()
elapsed_time_with_inplace = end_time_with_inplace - start_time_with_inplace

print(f"Elapsed time without inplace=True: {elapsed_time_without_inplace:.4f} seconds")
print(f"Elapsed time with inplace=True: {elapsed_time_with_inplace:.4f} seconds")

Test Results

  • Elapsed time without inplace=True: Approximately 0.534 seconds
  • Elapsed time with inplace=True: Approximately 0.372 seconds

The test reveals that using inplace=True when invoking dropna resulted in a faster execution time. Specifically, we observed a decrease in time from about 0.534 seconds to 0.372 seconds, a relative speed-up of around 30%.

While the inplace=True parameter is designed to modify the DataFrame in place and save memory, it also appears to provide a computational advantage, particularly for larger DataFrames. This can be particularly beneficial in data processing pipelines where multiple operations are performed sequentially and every millisecond counts.


Tips for Different Experience Levels with pandas dropna() Method

The dropna method in pandas is versatile enough to accommodate users with varying levels of expertise. Below are tailored tips for beginners, intermediate, and advanced users to make the most of this function.

1. Beginners: Simple Strategies for Cleaning a Dataset Quickly

If you're new to data cleaning, using pandas dropna in its default mode can quickly help you clean up your dataset by removing rows with any missing values.

import pandas as pd
import numpy as np

# Sample DataFrame
df = pd.DataFrame({'A': [1, 2, np.nan], 'B': [4, np.nan, 6], 'C': [7, 8, 9]})

# Using pandas dropna to remove rows with any missing values
clean_df = df.dropna()

This single line of code will remove all rows where any element is missing, providing you with a DataFrame that has complete data.

2. Intermediate: Fine-Tuning Parameters for More Control

Intermediate users can fine-tune the dropna parameters to exercise more control over how missing data is handled.

Example: Removing columns with more than 50% missing data

# Calculate the percentage of missing values for each column
missing_percent = df.isna().mean().round(4) * 100

# Use pandas dropna to drop columns based on a missing percentage threshold
filtered_df = df.dropna(axis=1, thresh=int(df.shape[0] * 0.5))

3. Advanced: Creating Custom Functions that Use dropna in Pipelines

For those with advanced skills, you can integrate dropna into custom data cleaning pipelines to automate more complex data preparation tasks.

Example: Custom function to drop columns based on missing data percentage

def drop_columns_based_on_na(df, threshold=0.5):
    Drops columns based on a missing value threshold.
    df (DataFrame): The input DataFrame
    threshold (float): The missing value threshold for dropping a column (0 to 1)
    DataFrame: The <a href="" title="4 ways to drop columns in pandas DataFrame" target="_blank" rel="noopener noreferrer">DataFrame with columns dropped</a> based on the threshold
    missing_percent = df.isna().mean()
    keep_cols = missing_percent[missing_percent < threshold].index.tolist()
    return df[keep_cols]
# Use pandas dropna within the custom function
cleaned_df = drop_columns_based_on_na(df)

This custom function uses pandas dropna internally and allows you to easily reuse this missing-data cleaning logic across different projects.


Comparison with Alternative Methods

Handling missing values isn't a one-size-fits-all problem. Different methods offer different advantages and trade-offs. Below, we compare pandas dropna with alternative methods like fillna, interpolate, and custom functions using apply and transform.

Method Use-Case Pros Cons Example Code
dropna Remove rows or columns with missing values Simple and quick to use, precise Data loss df.dropna(inplace=True)
fillna Fill missing values with a specific value or method No data loss, multiple fill strategies Might introduce bias df.fillna(0, inplace=True)
interpolate Estimate missing values using interpolation More accurate filling, various methods available Assumes a specific data distribution df.interpolate(method='linear', inplace=True)
Custom apply or transform Custom logic to handle missing values Highly customizable Requires more code, might be slower df['A'].transform(lambda x: x.fillna(x.mean()))

1. fillna

The fillna method fills the missing values with a specified number or using a method like mean, median, etc. This method prevents data loss but could introduce bias if not carefully managed.

# Filling with zeros
df.fillna(0, inplace=True)

2. interpolate

Interpolation provides an estimation of missing values based on other values in the series. This is particularly useful for time-series data or when the data follows a trend.

# Linear interpolation
df.interpolate(method='linear', inplace=True)

3. Custom Functions Using apply and transform

For more specific requirements, custom functions can be applied to DataFrames or Series. This method is the most flexible but can be more time-consuming to implement and test.

# Filling NaN based on mean of the column
df['A'] = df['A'].transform(lambda x: x.fillna(x.mean()))


Frequently Asked Questions about Pandas dropna() Method

What Does dropna Do in pandas?

dropna is a method used to remove missing values (NaNs) from a DataFrame or Series in pandas. By default, it removes any row with at least one missing value.

How Do I Use dropna to Remove Rows?

To remove rows containing any NaN values, simply use df.dropna(). This will return a new DataFrame with rows containing NaN values removed.

Can dropna Remove Columns with Missing Values?

Yes, to remove columns with any missing values, you can set the axis parameter to 1: df.dropna(axis=1).

What Does the how Parameter Do?

The how parameter specifies how to drop missing values. Use how='any' to drop rows or columns that have at least one NaN value, or how='all' to drop rows or columns where all elements are NaN.

How Do I Remove Rows Based on Specific Columns?

Use the subset parameter to specify which columns to consider for dropping rows. For example, df.dropna(subset=['column_name']) will drop rows where the specified column has a NaN value.

What is the thresh Parameter?

thresh allows you to specify a minimum number of non-NA values a row or column should have to keep it. For example, if you set thresh=2, then rows with at least two non-NA values will be kept.

What Does inplace=True Do?

Using inplace=True will modify the DataFrame directly without returning a new object. This is more memory-efficient but will overwrite your original data.

Can I Combine dropna with Other Methods Like fillna?

Yes, dropna can be effectively combined with other methods like fillna to handle missing data in a more customized way.

How Does dropna Affect Performance and Memory?

While dropna is generally fast, it can affect performance and memory depending on the DataFrame's size and the specific parameters used. For large DataFrames, consider using inplace=True for better memory efficiency.

Can I Use dropna in a Data Cleaning Pipeline?

Absolutely, dropna can be part of a larger data cleaning and preprocessing pipeline, often followed or preceded by other data manipulation methods.



The dropna method in Pandas is a versatile tool for handling missing values in a DataFrame or Series, making it invaluable for data cleaning and preprocessing. By default, dropna is capable of removing any row that contains at least one missing value, but its flexibility doesn't end there. You can customize its behavior extensively through parameters like axis, how, thresh, subset, and inplace, thereby giving you fine-grained control over how missing values are managed in your data.

Our tests also reveal that using the inplace=True parameter can offer not just memory efficiency but also a performance advantage, particularly for large datasets. Whether you're a beginner just getting started with data cleaning or an experienced data scientist looking for performance optimization, dropna offers functionalities that can be tailored to your needs.


Additional Resources

Official Documentation: For a comprehensive understanding and examples, you can read the official Pandas documentation on dropna .


Deepak Prasad

He is the founder of GoLinuxCloud and brings over a decade of expertise in Linux, Python, Go, Laravel, DevOps, Kubernetes, Git, Shell scripting, OpenShift, AWS, Networking, and Security. With extensive experience, he excels in various domains, from development to DevOps, Networking, and Security, ensuring robust and efficient solutions for diverse projects. You can reach out to him on his LinkedIn profile or join on Facebook page.

Can't find what you're searching for? Let us assist you.

Enter your query below, and we'll provide instant results tailored to your needs.

If my articles on GoLinuxCloud has helped you, kindly consider buying me a coffee as a token of appreciation.

Buy GoLinuxCloud a Coffee

For any other feedbacks or questions you can send mail to

Thank You for your support!!

Leave a Comment