Top 50 Pandas Interview Questions in 2024

Pandas in Python is a powerful library for data manipulation and analysis. It provides versatile data structures like DataFrames and Series, facilitating operations on structured data. Pandas simplifies tasks in handling and analyzing datasets with functionalities for data cleaning, exploration, and transformation. Its integration with other libraries makes it a cornerstone for data scientists and analysts.

Utilize the pd.DataFrame() function, passing data like a dictionary, array, or series as input to create a DataFrame in Pandas. This function helps structure and organize data into rows and columns, forming the foundation of data manipulation in Pandas.

The difference between a Series and a DataFrame in Pandas is that a Series represents a one-dimensional labeled array, while a DataFrame is a two-dimensional labeled data structure. A Series is a single column, while a DataFrame is a collection of columns forming a table-like structure.

Utilize functions like isnull(), notnull(), and dropna() to identify and eliminate missing data in Pandas, and methods like fillna() enable the replacement of missing data with specific values or statistical measures. Imputing missing values using interpolation or group-specific fill methods are employed for more nuanced data handling.

Pandas GroupBy operations involve the process of splitting data into groups based on specified criteria. It enables aggregation, transformation, and analysis within these grouped datasets. This method allows applying functions to grouped data, performing operations, and obtaining insights across subsets. GroupBy operations are pivotal for summarizing data, enabling comparisons, and facilitating efficient analysis in pandas.

Merging DataFrames in Pandas is done using the merge() function, combining data based on specified columns, similar to SQL joins. This method allows for different types of joins such as inner, outer, left, and right merges. The syntax involves specifying the DataFrames to merge and the columns to merge on, offering flexibility in consolidating data efficiently.

The purpose of head() and tail() methods in Pandas is to display the initial or last rows of a DataFrame, providing a quick view of the data's structure and content. head() shows the top rows, while tail() displays the bottom rows, aiding in understanding the DataFrame's layout and the nature of its information at a glance.

Utilize the loc[] or iloc[] methods coupled with conditional statements to filter data in a Pandas DataFrame. These methods enable selection based on specific criteria, allowing extraction of desired rows or columns meeting defined conditions. For instance, employing loc[] enables filtering based on labels, while iloc[] facilitates filtering by integer location, providing versatile means to extract data that matches particular requirements.

The iloc and loc methods in Pandas serve distinct purposes in data selection.

iloc refers to integer-location based indexing and allows selecting data by row/column numbers, like selecting rows by their position or specific columns.

loc is label-based indexing used to select data by labels or boolean arrays, allowing you to access rows or columns using their labels or conditions.

Both methods are pivotal for precise data extraction and manipulation within Pandas DataFrames, with iloc relying on integer positions and loc on labels or conditions for data retrieval.

The drop_duplicates() method is used to handle duplicate data in a Pandas DataFrame. This function identifies and eliminates duplicate rows based on specified columns, keeping the first occurrence by default. Alternatively, the duplicated() method identifies duplicates, returning a boolean Series marking duplicates. You can handle duplicates by choosing to drop them, extract or manipulate them based on your analysis requirements.

A Pandas Index is a data structure that labels and identifies rows or columns in a DataFrame. It serves as a unique identifier for efficient data retrieval, alignment, and manipulation within Pandas. The Index enables quick access, slicing, and alignment of data, ensuring efficient data organization and manipulation. It provides a way to uniquely label and reference rows or columns, facilitating operations like selection, merging, and reshaping of data in Pandas DataFrames.

Use the astype() method, specifying the desired data type for the column to convert column data types in a Pandas DataFrame. This method allows seamless transformation of data types, aiding in operations like numerical calculations or categorical conversions. It's a crucial tool for ensuring appropriate data representation and manipulation within the DataFrame.

A pivot table in Pandas is a data summarization tool that helps restructure and analyze data. It aggregates and reshapes data, presenting a multi-dimensional summary. Use the pivot_table() function to create a pivot table in Pandas. This function allows you to specify the DataFrame, the index, columns, and values to aggregate, generating a structured table reflecting your specified data relationships.

Use the to_csv() method to save a DataFrame to a CSV file in Pandas. This method allows you to specify the file path and any necessary parameters, like the delimiter or whether to include the index. For instance, df.to_csv('file_name.csv') saves the DataFrame to a CSV file named 'file_name.csv' in the current directory. Adjust the parameters as needed, such as defining separators or excluding the index during saving, using the available options in to_csv().

The use of apply() function in Pandas is to execute a specific function along an axis of a DataFrame or Series. It enables the application of custom or predefined functions to each element or row/column. This function helps perform complex operations efficiently across the data by applying user-defined or built-in functions.

Use double square brackets containing the column names within them to select multiple columns in a Pandas DataFrame. For instance, df[['Column1', 'Column2']] would retrieve both 'Column1' and 'Column2' simultaneously. This method enables the extraction of specific columns, providing a concise way to work with targeted data within the DataFrame.

Time series data in Pandas is handled efficiently using the DateTime functionality. Pandas enables slicing, indexing, and performing time-based operations effortlessly by converting time data into DateTime objects. Utilize the pd.to_datetime() function to convert strings to DateTime objects, enabling easy manipulation and analysis. Additionally, Pandas offers functions like resampling and rolling statistics, facilitating insightful time-based analysis and visualization.

The benefits of utilizing Pandas in data analysis are substantial. Pandas offers a versatile and powerful toolkit for handling data, enabling efficient data manipulation, cleaning, and transformation. Its ability to work with structured data in tabular form, utilizing DataFrames and Series, simplifies data handling tasks.

Pandas integrates seamlessly with other Python libraries, making it conducive to a wide range of data analysis and manipulation operations. Its flexibility and ease of use contribute significantly to streamlining data processing workflows, aiding in effective exploratory data analysis and facilitating complex operations like grouping, filtering, and merging datasets effortlessly.

Utilize the sort_values() method, specifying the columns you want to sort, for sorting data in a DataFrame in Pandas. It arranges the data in ascending or descending order based on the specified criteria. This method allows you to organize your DataFrame in a structured manner, aiding in analysis and presentation of information efficiently.

Performing aggregation in Pandas involves utilizing functions like sum(), mean(), max(), or min() to condense data across rows or columns. Apply these functions to specific columns or the entire DataFrame to derive summary statistics or insights. Utilizing groupby operations alongside aggregation functions helps create meaningful summaries based on categories or criteria within the data.

Pandas handles large datasets efficiently through chunking and memory optimization. It employs methods like read_csv() with parameters like chunksize for handling sizable data in parts, minimizing memory consumption. Leveraging appropriate data types and employing functions like groupby() or apply() boosts performance when working with substantial datasets, ensuring efficiency in computations. Utilizing operations like vectorization and avoiding iterations helps optimize performance in Pandas when dealing with large data.

Multi-indexing in Pandas refers to the ability to set multiple indices for rows and columns, creating a hierarchical structure. It allows organizing and accessing data efficiently, especially in complex datasets with multiple dimensions or categories. This technique enables enhanced data representation and advanced operations like grouping, slicing, and aggregation across multiple levels simultaneously.

Its advantages include improved data organization, streamlined analysis, and the ability to handle intricate datasets more effectively, offering a deeper level of data exploration and manipulation within Pandas.

Utilize vectorized operations to optimize Pandas' operations for speed and efficiency, and avoid iterative processes wherever possible. Leverage methods like apply() and prefer built-in functions over custom ones for enhanced performance. Use appropriate data types and consider chunking data for large datasets to reduce memory usage and enhance processing speed.

Employ parallel processing techniques like Dask or modin for handling significant volumes of data efficiently. Efficiently utilizing memory and employing appropriate algorithms enhances Pandas' performance in data manipulation and analysis tasks.

Window functions in Pandas are employed for data analysis by applying functions to specific windowed portions of datasets. These functions operate within a defined window or frame, allowing computations on subsets of data, such as rolling averages, cumulative sums, or aggregations.

Employ Pandas methods like rolling(), expanding(), or ewm() (exponentially weighted functions) combined with statistical or custom functions to perform analyses within these defined windows.

Here are some strategies listed below to deal with very large files or datasets that do not fit into memory.

• Chunking: Process data in smaller, manageable portions (chunks) to perform operations incrementally, reducing memory load.
• Dask Integration: Utilize Dask, a parallel computing library, which operates similarly to Pandas but handles larger-than-memory datasets by leveraging parallelism.
• Data Filtering and Selection: Optimize memory usage by loading only relevant columns or subsets of data needed for analysis.
• File Formats: Choose file formats like HDF5 or Parquet that support efficient reading and writing of data in chunks, enabling handling large datasets more effectively.
• Database Integration: Leverage database systems (e.g., SQL databases) to query and process data directly from storage without fully loading into memory.
• Out-of-Core Computation: Use libraries like datatable or Vaex designed for out-of-core computations, enabling manipulation of datasets that exceed memory limits.
• Incremental Processing: Apply incremental processing techniques, where computations are broken down into smaller steps, allowing handling of large datasets step by step.
• Cloud Computing: Utilize cloud services and distributed computing frameworks (e.g., AWS S3, Google BigQuery) to process and analyze data without local memory constraints.

Integrating Pandas with other data analysis libraries or frameworks involves leveraging its compatibility and interoperability with tools like NumPy, Matplotlib, and Scikit-learn. Pandas effortlessly interacts with NumPy arrays, allowing seamless data exchange and manipulation. Pandas, through Matplotlib, facilitates visualization by directly accepting its DataFrame structures for plotting data.

Pandas integrates well with Scikit-learn, aiding in data preprocessing and transformation, which are pivotal steps in machine learning pipelines. This integration empowers analysts and data scientists to combine Pandas' data manipulation capabilities with the specialized functionalities of these libraries, enhancing the overall data analysis process.

The pivot() function in Pandas restructures data by pivoting columns into rows and vice versa based on specified index and column values. It facilitates transforming datasets for analysis.

On the other hand, the melt() function performs the reverse operation, converting columns into a single column while maintaining other identifying information, aiding in reshaping data for clearer insights and analysis.

A scenario in data analysis where the groupby() in combination with transform() or aggregate() functions proves valuable is when you need to calculate group-specific statistics.

Suppose you have a dataset with sales information across various regions. You can group the data by region using groupby() and then utilize transform() to apply calculations like obtaining individual z-scores for each sale entry within its respective region.

aggregate() is beneficial to compute group-level summary statistics, such as calculating total sales per region or finding the maximum value within each group, providing valuable insights into regional performance without losing granularity in the data.

Handling time zone conversions in Pandas involves using the tz_localize() and tz_convert() functions. The former sets a time zone without conversion, while the latter converts from one time zone to another. Using these functions ensures accurate time representations, crucial for various time-based analyses and comparisons within datasets.

Here are some of the best practices for ensuring data quality and consistency when working with Pandas.

• Data Inspection: Always start by thoroughly inspecting your data using info(), describe(), or head() to understand its structure, missing values, and outliers.
• Handling Missing Data: Use isnull(), fillna(), or dropna() to manage missing values appropriately, based on the context and impact on analysis.
• Data Type Validation: Ensure data types are accurate. Use functions like astype() or to_datetime() to convert columns to appropriate types.
• Data Cleaning: Apply methods like str.replace() or str.extract() to clean textual data and remove inconsistencies or anomalies.
• Duplicate Values: Detect and eliminate duplicate entries using duplicated() and drop_duplicates() to avoid skewed analysis.
• Consistent Formatting: Standardize data formats across columns, especially when dealing with categorical data or timestamps.
• Robust Indexing: Utilize Pandas' index efficiently to maintain data integrity and facilitate faster operations.
• Data Validation: Implement checks using conditional statements or functions like assert to validate data against expected criteria.
• Version Control: Employ version control systems to track changes, ensuring reproducibility and maintaining a reliable record.
• Documentation and Logging: Maintain detailed documentation and logs of data transformations, ensuring traceability and facilitating error identification.

Use boolean indexing in Pandas to select rows based on column values in a DataFrame. For instance:

# Select rows where column 'A' equals a specific value
selected_rows = df[df['A'] == some_value]
# Select rows where column 'B' is greater than a value
elected_rows = df[df['B'] > some_other_value]

This method filters rows based on specified conditions, creating a new DataFrame selected_rows containing rows that meet the criteria set within the brackets. Adjust the column name and conditions according to your specific requirements.

# Assuming 'df' is your DataFrame and 'column_name' is the name of the column
mean_value = df['column_name'].mean()
print("Mean of the column:", mean_value)

This code uses the mean() function on the specified column within the DataFrame 'df' to calculate and display the mean value. Adjust 'column_name' to the actual name of the column you want to compute the mean for.

Use the merge() function to join two DataFrames on a common column in Pandas. Here's an example listed below.

import pandas as pd
# Creating two sample DataFrames
df1 = pd.DataFrame({'ID': [1, 2, 3], 'Name': ['Alice', 'Bob', 'Charlie']})
df2 = pd.DataFrame({'ID': [1, 2, 4], 'Age': [25, 30, 28]})
# Joining based on the 'ID' column
merged_df = pd.merge(df1, df2, on='ID', how='inner')
print(merged_df)

This code snippet demonstrates joining two DataFrames (df1 and df2) using the merge() function based on the 'ID' column. Adjust the how parameter to specify the type of join (e.g., 'inner', 'outer', 'left', 'right') as needed for your analysis.

Use the pivot function to pivot a DataFrame from long to wide format in Pandas. This function reshapes the data based on the specified index and columns. Here's an example code:

# Assuming 'df' is the DataFrame
wide_df = df.pivot(index='index_column_name', columns='column_to_pivot', values='value_column')

Replace 'index_column_name', 'column_to_pivot', and 'value_column' with the appropriate column names from your DataFrame. This rearranges the data, turning it from a long format to a wide one, grouping values according to the specified index and columns.

Below is an example code snippet that creates a new column in a Pandas DataFrame based on the values of another column.

import pandas as pd
# Assuming df is the DataFrame and 'existing_column' is the column to derive the new column from
df['new_column'] = df['existing_column'] * 2  # Creating a new column based on existing_column values multiplied by 2

This code snippet assumes you have a DataFrame named df and creates a new column named 'new_column' by multiplying the values in the 'existing_column' by 2. You can replace the operation (* 2) with any logic that suits your specific requirement for the new column creation.

Handle string manipulation in Pandas using the .str accessor, enabling various string operations on DataFrame columns containing strings.

For instance, convert a column to uppercase using .str.upper():

import pandas as pd
# Creating a DataFrame
data = {'Names': ['Alice', 'Bob', 'Charlie']}
df = pd.DataFrame(data)
# Converting 'Names' column to uppercase
df['Names'] = df['Names'].str.upper()
print(df)

This code will output:

Names

0 ALICE

1  BOB

2  CHARLIE

The .str accessor provides a wide range of string methods such as lower(), contains(), split(), and more, facilitating efficient string manipulations within Pandas DataFrames.

Here's a concise example demonstrating the use of groupby() to aggregate data and calculate sum and average in Pandas.

import pandas as pd
# Sample DataFrame
data = {'Category': ['A', 'B', 'A', 'B', 'A', 'B'],	'Values': [10, 15, 20, 25, 30, 35]}
df = pd.DataFrame(data)
# Grouping by 'Category' and calculating sum and average
grouped = df.groupby('Category').agg({'Values': ['sum', 'mean']})
print(grouped)

This code creates a DataFrame, groups the data by the 'Category' column, and then calculates the sum and average of the 'Values' column for each category using groupby() along with agg(). Adjust column names and DataFrame structure as needed for your specific use case.

Reshaping a DataFrame using the melt() function in Pandas involves transforming wide data into long format, which proves to be useful for analysis or visualization purposes.

import pandas as pd
# Example DataFrame
data = {'Name': ['John', 'Emma', 'Alex'], 'Math': [85, 78, 92], 'Science': [90, 88, 94], 'History': [80, 75, 85]}
df = pd.DataFrame(data)
# Reshaping using melt()
melted_df = df.melt(id_vars=['Name'], var_name='Subject', value_name='Score')
print(melted_df)

This code snippet demonstrates using melt() to reshape the DataFrame df, transforming columns ('Math', 'Science', 'History') into 'Subject' and their corresponding values into 'Score', keeping 'Name' as an identifier (id_vars).

Here's a code snippet demonstrating how to filter a DataFrame for rows where a column's value is within a given range using Pandas.

# Assuming 'df' is your DataFrame and 'column_name' is the specific column you want to filter
filtered_df = df[(df['column_name'] >= lower_value) & (df['column_name'] <= upper_value)]

Replace 'df' with the name of your DataFrame and 'column_name' with the actual column name you wish to filter. lower_value and upper_value should be replaced with the range values you want to use for filtering. This code will create a new DataFrame, filtered_df, containing rows where the column's value falls within the specified range.

Use the reset_index() method to convert the index of a DataFrame into a regular column in Pandas.

# Assuming 'df' is your DataFrame
df.reset_index(inplace=True)

This code snippet will transform the DataFrame's index into a column, and a new default index will replace the original.

Here's a brief example of performing time series analysis using Pandas.

import pandas as pd
# Assuming 'df' is a DataFrame with a datetime index
# Resampling to get daily data
daily_data = df.resample('D').mean()
# Rolling window calculation for a 7-day moving average
rolling_average = df['column_name'].rolling(window=7).mean()
# Adding a new column with lagged data
df['lagged_column'] = df['column_name'].shift(1)
# Calculating the difference between consecutive values
df['value_diff'] = df['column_name'].diff()
# Extracting components from datetime index
df['year'] = df.index.year
df['month'] = df.index.month
df['day'] = df.index.day

This example showcases common time series operations in Pandas like resampling for daily data, computing rolling averages, handling lagged values, calculating differences, and extracting date components from a datetime index.

Here's a brief code snippet showcasing how to handle outliers in a DataFrame column using Pandas.

import pandas as pd
# Consider 'column_name' as the column containing outliers
# 'threshold' is the threshold value beyond which data points are considered outliers
threshold = 3  # Adjust this threshold value as needed
# Calculate the mean and standard deviation
mean_value = df['column_name'].mean()
std_value = df['column_name'].std()
# Identify outliers using the z-score method
outliers = df[(df['column_name'] - mean_value).abs() > threshold * std_value]
# Handle outliers (for example, replace them with NaN)
df.loc[outliers.index, 'column_name'] = pd.NA  # Replace outliers with NaN
# Alternatively, you can remove outliers
# df = df[(df['column_name'] - mean_value).abs() <= threshold * std_value]

This code calculates the z-score for the data in a specific column and identifies outliers based on a chosen threshold (multiples of standard deviation). Then, it either replaces the outliers with NaN values or removes them from the DataFrame, based on the approach you prefer. Adjust the 'column_name' and 'threshold' variables to fit your dataset and criteria for outlier detection.

Use Pandas to impute missing values in a DataFrame based on the mean of each column. Here's a concise way to do it using Pandas.

import pandas as pd
# Assuming 'df' is your DataFrame
df.fillna(df.mean(), inplace=True)

This code snippet uses the fillna() method in Pandas to replace missing values (NaN) with the mean of each column, achieved by calling df.mean() on the DataFrame. Setting inplace=True ensures the changes are applied directly to the DataFrame.

Here's a concise example using Pandas and Scikit-Learn to perform linear regression on a dataset.

import pandas as pd
from sklearn.linear_model import LinearRegression
# Assuming 'data' is your DataFrame with 'X' and 'y' columns
X = data[['X_column']]  # Replace 'X_column' with your predictor variable
y = data['y_column']	# Replace 'y_column' with your target variable
# Creating a linear regression model
model = LinearRegression()
# Fitting the model with your data
model.fit(X, y)
# Printing the coefficients
print("Coefficient:", model.coef_)
print("Intercept:", model.intercept_)

This code snippet demonstrates the basic process of fitting a linear regression model to a dataset using Pandas to handle the data and Scikit-Learn (LinearRegression) for modeling. Adjust the column names as per your dataset's structure.

Use the technique of encoding to convert categorical data into a numerical format suitable for machine learning models. There are two common methods: Label Encoding and One-Hot Encoding.

Label Encoding:

This method assigns a unique numerical value to each category in the feature column.

import pandas as pd
from sklearn.preprocessing import LabelEncoder
# Creating a DataFrame with categorical data
data = {'Category': ['A', 'B', 'C', 'A', 'B']}
df = pd.DataFrame(data)
# Initializing the LabelEncoder
label_encoder = LabelEncoder()
# Encoding the categorical column
df['Encoded_Category'] = label_encoder.fit_transform(df['Category'])
print(df)

One-Hot Encoding:

This technique creates binary columns for each category, assigning a 1 or 0 to indicate the presence of a category in the dataset.

# Using Pandas' get_dummies() function for one-hot encoding
one_hot_encoded = pd.get_dummies(df['Category'])
df = pd.concat([df, one_hot_encoded], axis=1)
print(df)

These methods help transform categorical data into a numerical format, making it feasible for machine learning algorithms to interpret and process the information effectively.

Pandas offers robust capabilities for text preprocessing. Start by loading your text data into a DataFrame. Assuming a column named 'text':

import pandas as pd
# Assuming 'df' is your DataFrame
# Example: df = pd.read_csv('your_data.csv')
# Lowercasing text
df['text'] = df['text'].str.lower()
# Removing punctuation
df['text'] = df['text'].str.replace('[^\w\s]', '')
# Tokenization (splitting text into words)
df['tokens'] = df['text'].str.split()
# Removing stop words (example using NLTK library)
from nltk.corpus import stopwords
stop_words = set(stopwords.words('english'))
df['tokens'] = df['tokens'].apply(lambda x: [word for word in x if word not in stop_words])
# Lemmatization (using NLTK WordNetLemmatizer)
from nltk.stem import WordNetLemmatizer
lemmatizer = WordNetLemmatizer()
df['lemmatized'] = df['tokens'].apply(lambda x: [lemmatizer.lemmatize(word) for word in x])

This code showcases common text preprocessing steps using Pandas in combination with libraries like NLTK for tasks such as lowercasing, removing punctuation, stop words, tokenization, and lemmatization. Adjust these steps based on the specific requirements of your NLP task.

Here's a concise way to demonstrate data visualization directly from a Pandas DataFrame using Matplotlib.

import pandas as pd
import matplotlib.pyplot as plt
# Assuming 'df' is your DataFrame
# Visualization using Pandas and Matplotlib
df.plot(x='your_column', y='another_column', kind='line')  # For instance, a line plot
plt.title('Your Title Here')
plt.xlabel('X-axis Label')
plt.ylabel('Y-axis Label')
plt.show()

This code snippet demonstrates plotting a line graph by specifying columns from the DataFrame ('your_column' and 'another_column'). Modify the 'kind' parameter to create different types of plots such as scatter plots, bar plots, etc., by changing the value to 'scatter', 'bar', etc. Adjust the title and axis labels accordingly for your visualization.

Several strategies enhance memory usage during data analysis to manage large datasets efficiently in Pandas. Using chunking through the chunksize parameter while reading files with read_csv() or read_excel() enables processing in smaller segments, reducing memory overhead. Here's an example of how chunking works.

import pandas as pd
chunk_size = 100000  # Define the chunk size suitable for your system
# Process data in smaller chunks
chunks = pd.read_csv('your_large_file.csv', chunksize=chunk_size)
result = pd.concat(chunk for chunk in chunks)
# Further analysis on 'result'

Employing data types optimization with astype() to downcast numerical columns or using categorical data types with pd.Categorical() for categorical variables significantly reduces memory consumption. Leveraging sparse data structures like SparseDataFrame or SparseArray for datasets with a high density of zeros also conserves memory.

These techniques, along with selective loading of necessary columns, employing disk-based computing using Dask or Modin libraries, and utilizing external memory tools like HDF5 format for out-of-memory computations, collectively assist in handling large datasets efficiently within Pandas.

Here's a code snippet demonstrating a SQL-style join of two DataFrames in Pandas.

import pandas as pd
# Assuming df1 and df2 are the two DataFrames to be joined based on a common column 'key'
result = pd.merge(df1, df2, on='key', how='inner')  # Use 'how' parameter for different types of joins

This code utilizes the pd.merge() function in Pandas, specifying the DataFrames (df1 and df2), the common column to join on ('key'), and the type of join (how='inner' for an inner join, but you can use other options like 'left', 'right', or 'outer' as needed).

Create reusable functions or scripts to automate data cleaning on regularly updated data using Pandas. These functions encompass various cleaning steps, such as handling missing values, standardizing formats, or removing duplicates.

import pandas as pd
def clean_data(df):
	# Example: Handling missing values by filling with median
	df.fillna(df.median(), inplace=True)
	# Example: Converting date strings to datetime format
	df['Date'] = pd.to_datetime(df['Date'])
	# Other cleaning steps can be added here
	return df

# Assuming you have a function to regularly fetch and update data
data = fetch_updated_data()
# Applying the cleaning function to the new data
cleaned_data = clean_data(data)

Repeatedly apply these operations to incoming or updated datasets by encapsulating cleaning steps within a function like clean_data(). This ensures consistent and automated data cleaning processes.