本文目录导读：
我来介绍几种用Pandas进行数据归一化到特定区间的方法：
最大最小值归一化 (Min-Max Normalization)
将数据缩放到[0,1]区间或自定义区间：
import pandas as pd
import numpy as np
# 创建示例数据
data = {
'A': [10, 20, 30, 40, 50],
'B': [100, 200, 300, 400, 500],
'C': [1, 2, 3, 4, 5]
}
df = pd.DataFrame(data)
print("原始数据：")
print(df)
# 方法1：手动实现归一化到[0,1]
def minmax_normalize(series):
return (series - series.min()) / (series.max() - series.min())
df_normalized = df.apply(minmax_normalize)
print("\n归一化到[0,1]：")
print(df_normalized)
# 方法2：使用lambda表达式
df_normalized_lambda = df.apply(lambda x: (x - x.min()) / (x.max() - x.min()))
print("\n使用lambda表达式：")
print(df_normalized_lambda)
# 方法3：归一化到指定区间[a,b]
def normalize_to_range(series, a=0, b=1):
min_val = series.min()
max_val = series.max()
return a + (series - min_val) * (b - a) / (max_val - min_val)
# 归一化到[0, 100]
df_to_100 = df.apply(lambda x: normalize_to_range(x, 0, 100))
print("\n归一化到[0,100]：")
print(df_to_100)
使用sklearn的MinMaxScaler
from sklearn.preprocessing import MinMaxScaler
# 方法4：使用sklearn
scaler = MinMaxScaler(feature_range=(0, 1)) # 可以设置自定义区间
df_scaled = pd.DataFrame(
scaler.fit_transform(df),
columns=df.columns,
index=df.index
)
print("\n使用sklearn归一化到[0,1]：")
print(df_scaled)
# 归一化到[0, 100]
scaler_custom = MinMaxScaler(feature_range=(0, 100))
df_scaled_custom = pd.DataFrame(
scaler_custom.fit_transform(df),
columns=df.columns,
index=df.index
)
print("\n使用sklearn归一化到[0,100]：")
print(df_scaled_custom)
实际应用案例
# 创建更真实的数据集
data_real = {
'年龄': [25, 30, 35, 40, 45, 50, 55, 60],
'收入': [5000, 8000, 12000, 15000, 20000, 25000, 30000, 35000],
'工作年限': [1, 3, 5, 8, 10, 15, 20, 25],
'评分': [60, 65, 70, 75, 80, 85, 90, 95]
}
df_real = pd.DataFrame(data_real)
print("原始数据：")
print(df_real)
print("\n数据统计：")
print(df_real.describe())
# 归一化到[0,1]
df_norm = df_real.apply(lambda x: (x - x.min()) / (x.max() - x.min()))
print("\n归一化到[0,1]后的数据：")
print(df_norm.round(3))
# 归一化到[-1,1]
def normalize_to_neg1_1(series):
min_val = series.min()
max_val = series.max()
# 映射到[-1, 1]
return 2 * (series - min_val) / (max_val - min_val) - 1
df_neg1_1 = df_real.apply(normalize_to_neg1_1)
print("\n归一化到[-1,1]：")
print(df_neg1_1.round(3))
处理异常值的归一化
# 创建包含异常值的数据
data_with_outliers = {
'正常列': [10, 20, 30, 40, 50],
'异常列': [10, 20, 30, 1000, 50] # 1000是异常值
}
df_outliers = pd.DataFrame(data_with_outliers)
print("包含异常值的数据：")
print(df_outliers)
# 使用百分位数裁剪后再归一化
def robust_normalize(series, low_percentile=5, high_percentile=95):
"""使用百分位数裁剪后再归一化"""
low = np.percentile(series, low_percentile)
high = np.percentile(series, high_percentile)
# 裁剪数据
clipped = series.clip(low, high)
# 归一化
return (clipped - clipped.min()) / (clipped.max() - clipped.min())
df_robust = df_outliers.apply(robust_normalize)
print("\n鲁棒归一化后的数据：")
print(df_robust.round(3))
批量处理多个DataFrame
# 创建多个数据集
dfs = {
'df1': pd.DataFrame({'A': [10, 20, 30], 'B': [100, 200, 300]}),
'df2': pd.DataFrame({'A': [5, 15, 25], 'B': [50, 150, 250]})
}
# 批量归一化
def batch_normalize(df_list, range_min=0, range_max=1):
normalized_dfs = {}
for name, df in df_list.items():
scaler = MinMaxScaler(feature_range=(range_min, range_max))
normalized_dfs[name] = pd.DataFrame(
scaler.fit_transform(df),
columns=df.columns,
index=df.index
)
return normalized_dfs
normalized_results = batch_normalize(dfs, 0, 100)
for name, df_norm in normalized_results.items():
print(f"\n{name} 归一化结果：")
print(df_norm)
保存和恢复归一化参数
# 保存归一化参数以便后续恢复
scaler = MinMaxScaler(feature_range=(0, 1))
scaler.fit(df)
# 保存参数
normalization_params = {
'min_': scaler.data_min_,
'max_': scaler.data_max_,
'feature_range': scaler.feature_range
}
print("归一化参数：")
print(f"最小值: {normalization_params['min_']}")
print(f"最大值: {normalization_params['max_']}")
print(f"范围: {normalization_params['feature_range']}")
# 对新数据使用相同的参数进行归一化
new_data = pd.DataFrame({'A': [35], 'B': [250], 'C': [3.5]})
new_data_scaled = pd.DataFrame(
scaler.transform(new_data),
columns=new_data.columns
)
print("\n新数据归一化结果：")
print(new_data_scaled)
关键要点：
- 选择合适的归一化区间：通常使用[0,1]或[-1,1]
- 处理异常值：使用百分位数裁剪避免极端值影响
- 保持参数：对测试数据使用与训练数据相同的归一化参数
- 注意数据类型：确保数据是数值类型
- 区分训练集和测试集：使用相同的归一化参数
这些方法可以根据你的具体需求选择合适的实现方式。
