1import pandas as pd
2import numpy as np
3
4df = pd.DataFrame({
5    "A": [1.0, 2.0, np.inf, 4.0],
6    "B": [-np.inf, 5.0, 6.0, 7.0],
7    "C": [8.0, 9.0, 10.0, np.inf]
8})
9
10# Detect infinite values
11print(np.isinf(df))
12#        A      B      C
13# 0  False   True  False
14# 1  False  False  False
15# 2   True  False  False
16# 3  False  False   True
17
18# Count infinities per column
19print(np.isinf(df).sum())
20# A    1
21# B    1
22# C    1
23
24# Count total infinities
25print(np.isinf(df).sum().sum())  # 3
26
27# Check which rows have any infinity
28rows_with_inf = df[np.isinf(df).any(axis=1)]
29print(rows_with_inf)

1# Replace inf with NaN, then drop rows with NaN
2cleaned = df.replace([np.inf, -np.inf], np.nan).dropna()
3print(cleaned)
4#      A    B     C
5# 1  2.0  5.0   9.0
6
7# Drop only in specific columns
8cleaned = df.replace([np.inf, -np.inf], np.nan).dropna(subset=["A", "B"])
9print(cleaned)
10#      A    B      C
11# 1  2.0  5.0    9.0
12# 3  4.0  7.0  inf    # C still has inf because we only checked A and B

1# Replace inf with 0
2df_zero = df.replace([np.inf, -np.inf], 0)
3print(df_zero)
4#      A    B     C
5# 0  1.0  0.0   8.0
6# 1  2.0  5.0   9.0
7# 2  0.0  6.0  10.0
8# 3  4.0  7.0   0.0
9
10# Replace with column maximum (finite values only)
11for col in df.columns:
12    finite_max = df.loc[np.isfinite(df[col]), col].max()
13    df[col] = df[col].replace([np.inf, -np.inf], finite_max)
14
15# Replace positive inf with max, negative inf with min
16df_capped = df.copy()
17for col in df_capped.select_dtypes(include=[np.number]).columns:
18    finite = df_capped[col][np.isfinite(df_capped[col])]
19    df_capped[col] = df_capped[col].replace(np.inf, finite.max())
20    df_capped[col] = df_capped[col].replace(-np.inf, finite.min())

1# Treat inf as NaN globally (affects all pandas operations)
2pd.options.mode.use_inf_as_na = True
3
4df = pd.DataFrame({"A": [1.0, np.inf, 3.0], "B": [4.0, 5.0, -np.inf]})
5
6# Now dropna() catches inf values automatically
7cleaned = df.dropna()
8print(cleaned)
9#      A    B
10# 0  1.0  4.0
11
12# mean() also ignores inf (treated as NaN)
13print(df.mean())
14# A    2.0
15# B    4.5
16
17# Reset to default behavior
18pd.options.mode.use_inf_as_na = False

1# Keep only rows where all values are finite
2df_clean = df[np.isfinite(df).all(axis=1)]
3print(df_clean)
4
5# Keep only rows where specific columns are finite
6df_clean = df[np.isfinite(df["A"]) & np.isfinite(df["B"])]
7
8# Using query with a helper column
9df["is_finite"] = np.isfinite(df).all(axis=1)
10df_clean = df[df["is_finite"]].drop(columns="is_finite")

1# Cap values to a reasonable range instead of dropping
2df_clipped = df.clip(lower=-1e10, upper=1e10)
3print(df_clipped)
4
5# This replaces inf with 1e10 and -inf with -1e10
6# Useful when you want to preserve row count

1# Safe division that avoids inf
2def safe_divide(a, b, fill=0):
3    return np.where(b != 0, a / b, fill)
4
5df["ratio"] = safe_divide(df["A"], df["B"])
6
7# Safe log that avoids -inf
8df["log_A"] = np.log(df["A"].clip(lower=1e-10))
9
10# Detect inf before it enters the pipeline
11def validate_dataframe(df):
12    inf_count = np.isinf(df.select_dtypes(include=[np.number])).sum().sum()
13    if inf_count > 0:
14        print(f"Warning: {inf_count} infinite values detected")
15    return inf_count == 0