Pandas DataFrame div() Function

In Pandas, the div() function is a versatile method used to perform element-wise division between DataFrame objects, or between a DataFrame and a Series or scalar. This method allows you to divide the elements of a DataFrame by the corresponding elements of another DataFrame, Series, or a scalar value.

In this article, I will explain the Pandas DataFrame div() method, covering its syntax, parameters, and usage, and how to return a DataFrame or Series as the result of the arithmetic operation.

Key Points –

The div() function performs element-wise division between a DataFrame or Series and another DataFrame, Series, or scalar value.
The fill_value parameter allows specifying a value to use for filling missing data before performing the division, ensuring that NaN values are handled gracefully.
The result of the div() operation is a new DataFrame containing the result of the element-wise division.
The axis parameter controls the alignment of the division operation, allowing division to be performed row-wise (axis=0) or column-wise (axis=1).
When dealing with MultiIndex (hierarchical indexing), the level parameter can be used to broadcast the division across a specific level, simplifying complex division operations.

Pandas DataFrame div() Introduction

Let’s know the syntax of the div() function.


# Syntax of Pandas dataframe div()
DataFrame.div(other, axis='columns', level=None, fill_value=None)

Parameters of the DataFrame div()

Following are the parameters of the DataFrame div() function.

other - DataFrame, Series, or scalar value to divide by.
axis - {0 or ‘index’, 1 or ‘columns’}, default ‘columns’. Determines whether to divide row-wise (0 or 'index') or column-wise (1 or 'columns').
level - int or label, optional. Broadcast across a level, matching Index values on the passed MultiIndex level.
fill_value - float or None, default None. Fill missing values with this value before operating.

Return Value

It returns a DataFrame or Series with the result of the element-wise division.

Usage of Pandas DataFrame div() Function

The div() function in pandas is used to perform element-wise division between DataFrames, Series, or scalar values.

Now, let’s create Pandas DataFrame using data from a Python dictionary, where the columns are A , and B.


import pandas as pd

# Sample DataFrame
df = pd.DataFrame({
    'A': [2, 4, 6, 8, 10],
    'B': [1, 3, 5, 7, 9]
})
print("Original DataFrame:\n",df)

Yields below output.

To divide a DataFrame by a scalar using the div() method, you specify the scalar value as the other argument. This operation performs element-wise division across the entire DataFrame.


# Divide by a scalar value
scalar = 2
df2 = df.div(scalar)
print("DataFrame divided by scalar:\n", df2)

# Dividing by a Scalar
df2 = df.div(2)
print("DataFrame divided by scalar:\n", df2)

In the above example, each element in the DataFrame is divided by 2, resulting in a new DataFrame where every value has been halved.

Dividing by Another DataFrame

Alternatively, to divide one DataFrame by another using the div() method in pandas, the operation is performed element-wise, with alignment based on the indices and columns of both DataFrames.


import pandas as pd

# Sample DataFrames
df = pd.DataFrame({
    'A': [5, 10, 15],
    'B': [20, 25, 30]
})

df1 = pd.DataFrame({
    'A': [2, 4, 6],
    'B': [8, 10, 12]
})

# Divide df by df1
result = df.div(df1)
print("DataFrame divided by another DataFrame:\n", result)

# Output:
# DataFrame divided by another DataFrame:
#     A    B
# 0  2.5  2.5
# 1  2.5  2.5
# 2  2.5  2.5

Handling Mismatched Indices or Columns

If the DataFrames have mismatched indices or columns, pandas will align them and the result will have NaN for positions where data is missing in one of the DataFrames.


import pandas as pd

# DataFrames with different indices
df = pd.DataFrame({
    'A': [10, 20],
    'B': [30, 40]
}, index=['row1', 'row2'])

# Different index for 'row2'
df1 = pd.DataFrame({
    'A': [2, 3],
    'B': [5, 6]
}, index=['row1', 'row3'])  

# Divide df by df1
df2 = df.div(df1)
print("DataFrame divided by another DataFrame with different indices:\n", df2)

# Output:
# DataFrame divided by another DataFrame with different indices:
#          A    B
# row1  5.0  6.0
# row2  NaN  NaN
# row3  NaN  NaN

Dividing with Fill Value

When dividing one DataFrame by another, or by a scalar, you can use the fill_value parameter to handle missing values (NaNs) in the DataFrames. The fill_value parameter allows you to specify a value that will replace NaNs before performing the division, ensuring that the operation completes without resulting in NaNs in the result.


import pandas as pd

# Sample DataFrames with NaN values
df = pd.DataFrame({
    'A': [5, 10, None],
    'B': [None, 15, 20]
})

df1 = pd.DataFrame({
    'A': [2, None, 6],
    'B': [8, 10, None]
})

# Divide df1 by df2 with a fill_value
df2 = df.div(df1, fill_value=1)
print("DataFrame divided with fill_value:\n", df2)

# Output:
# DataFrame divided with fill_value:
#             A       B
# 0   2.500000   0.125
# 1  10.000000   1.500
# 2   0.166667  20.000

When dividing a DataFrame by a scalar and using the fill_value parameter, the approach is slightly different from when dividing by another DataFrame. In this case, fill_value is used to handle NaN values in the DataFrame before performing the division.


import pandas as pd

# Sample DataFrame with NaN values
df = pd.DataFrame({
    'A': [5, None, 10],
    'B': [15, 20, None]
})

# Divide by a scalar with fill_value
scalar = 5
result = df.div(scalar, fill_value=1)
print("DataFrame divided by scalar with fill_value:\n", result)

# Output:
# DataFrame divided by scalar with fill_value:
#       A    B
# 0  1.0  3.0
# 1  0.2  4.0
# 2  2.0  0.2

Dividing by a Series

Similarly, dividing a DataFrame by a Series allows you to perform element-wise division with alignment along a specified axis. Typically, the Series will align with either the columns or the index of the DataFrame.


import pandas as pd

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

# Sample Series
series = pd.Series([3, 2], index=['A', 'B'])

# Divide DataFrame by Series along columns
result = df.div(series, axis='columns')
print("DataFrame divided by Series:\n", result)

# Output:
# DataFrame divided by Series:
#            A    B
# 0  0.666667  0.5
# 1  1.333333  1.5
# 2  2.000000  2.5
# 3  2.666667  3.5
# 4  3.333333  4.5

Dividing by a Series Along Rows

Finally, if you want to divide a DataFrame by a Series along the rows, you need to align the Series with the DataFrame rows (using axis=index).


# Divide DataFrame by Series along index (rows)
series = pd.Series([1, 2, 3, 4, 5], index=[0, 1, 2, 3, 4])
result = df.div(series, axis='index')
print("DataFrame divided by Series along rows:\n", result)

# Output:
# DataFrame divided by Series along rows:
#       A         B
# 0  2.0  1.000000
# 1  2.0  1.500000
# 2  2.0  1.666667
# 3  2.0  1.750000
# 4  2.0  1.800000

Frequently Asked Questions on Pandas DataFrame div() Function

The div() function in pandas is used to perform element-wise division between a DataFrame and another DataFrame, Series, or scalar value. It allows for flexible handling of missing data and alignment of indices and columns during the division operation.

You can divide a DataFrame by a scalar value by passing the scalar as the other argument to the div() method.

To divide one DataFrame by another, ensure that both DataFrames have the same shape or alignable indices and columns.

To handle missing values during division with pandas' div() function, you can use the fill_value parameter. This parameter allows you to specify a value that will replace NaN values in either DataFrame before performing the division operation.

In the div() method, the axis parameter specifies the axis along which to align the other object (e.g., a Series or DataFrame) before performing the division.

Conclusion

In conclusion, the Pandas DataFrame div() function is a powerful tool for performing element-wise division operations on DataFrames. Whether you are dividing by another DataFrame, a Series, or a scalar value, div() offers flexibility and convenience. Key features include the ability to handle missing values with the fill_value parameter, specify the axis along which the operation should be performed, and manage broadcasting with MultiIndex levels.

Happy Learning!!

References

https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.mul.html