pandas基础

导入库：
import pandas as pd , pandas：数据处理库，常用别名是 pd

import numpy as np , numpy：数值计算库，常用别名是 np。

1.为什么？

在人工智能和机器学习中，数据是燃料。
而 Pandas 是处理数据最强大的 Python 工具之一。

• 它能让你像在 Excel 一样操作数据（表格、行列、筛选、计算）。
• 它是 机器学习前的数据准备工具 —— 几乎所有模型训练前都要用 Pandas 清洗、整理数据。

在 AI 工作流中，顺序通常是：

数据收集 → 数据清洗（Pandas） → 特征工程 → 模型训练（Sklearn、PyTorch、TensorFlow）

2.是什么？

基于Numpy的高级数据分析库，提供了两种主要数据结构：

结构	维度	类似的概念	说明
Series	一维	列表 / Excel的一列	每个数据都有一个索引
DataFrame	二维	Excel表 / 数据表	由多个Series按列组成

3.核心结构

3.1 series

import pandas as pd

# 创建一个 Series
series = pd.Series([10, 20, 30, 40], index=['a', 'b', 'c', 'd'])
print(series)

a 10
b 20
c 30
d 40
dtype: int64

# 按索引取值
print(series['b'])  # 20

# 增加数据
series['e'] = 50

# 删除数据
series = series.drop('a')

# 修改数据
series['b'] = 99

# 重排索引
series = series.reindex(['e', 'd', 'c', 'b'])

3.2 DataFrame

data = {
    '姓名': ['小王', '小李', '小张'],
    '成绩': [90, 85, 88],
    '性别': ['男', '女', '男']
}
df = pd.DataFrame(data, index=['一班', '二班', '三班']) #行索引
print(df)

#获取
df.head()	#查看前几行
df['成绩']
df.loc['一班']
df.loc[['一班','三班'],['姓名', '成绩']]	#指定行列
df.iloc[[0,2],[0,1]]	#按位置取


# 添加列
df['班级'] = ['一班', '二班', '三班']

# 删除列
df = df.drop('性别', axis=1)

# 修改列
df['成绩'] = [95, 88, 92]


df.sort_index()          # 按行索引排序
df.sort_values('成绩')    # 按列值排序

4.层次化索引

允许在一个轴向上有多个索引级别。

4.1创建

方法1：使用MultiIndex.from_arrays（如示例）

import pandas as pd

arrays = [
    ['北京', '北京', '上海', '上海'],  # 第一级索引
    ['2023', '2024', '2023', '2024']   # 第二级索引
]
index = pd.MultiIndex.from_arrays(arrays, names=('城市', '年份'))
data = pd.Series([80, 85, 88, 90], indexindex)

方法2：使用元组列表

index = pd.MultiIndex.from_tuples([
    ('北京', '2023'),
    ('北京', '2024'), 
    ('上海', '2023'),
    ('上海', '2024')
], names=('城市', '年份'))

方法3：直接创建DataFrame

df = pd.DataFrame({
    '城市': ['北京', '北京', '上海', '上海'],
    '年份': ['2023', '2024', '2023', '2024'], 
    '数据': [80, 85, 88, 90]
}).set_index(['城市', '年份'])

城市 年份
北京 2023 80
2024 85
上海 2023 88
2024 90
dtype: int64

data['北京']        # 筛出北京的所有年份数据
data['北京']['2023']  # 筛出北京2023年的数据

5.pandas与人工智能的关系

阶段	作用
数据导入	从 CSV、Excel、SQL 等读取原始数据
数据清洗	删除空值、处理重复、替换缺失值
特征工程	提取、组合、标准化数据特征
模型训练前准备	将清洗好的数据转成 NumPy 数组或张量输入机器学习模型

6 示例

avg = df['成绩'].mean

top = df.loc[df['成绩'].idxmax(),'姓名']


gender_avg = df.groupby('性别')['成绩'].mean()

df['是否及格'] = df['成绩'] >= 60

7 数据操作与清洗

1️⃣ 缺失值处理

人工智能中的数据经常“不完整”——Pandas 提供了自动处理方法。

import numpy as np
df.loc[1, 'Age'] = None
df.loc[2, 'Salary'] = np.nan

df.fillna({'Age': df['Age'].mean(), 'Salary': df['Salary'].median()}, inplace=True)

📘 常见策略：

• dropna() 删除缺失数据
• df.fillna(0) - 用0填充
• df.fillna(method='ffill') - 用前一个值填充
• df.fillna(df.mean()) - 用各列均值填充

2️⃣ 数据筛选

# 逻辑条件筛选
df[df['Age'] > 30]

# 多条件筛选
df[(df['Age'] > 25) & (df['Salary'] > 6000)]

3️⃣ 数据排序

df.sort_values('Salary', ascending=False)   # 按薪资降序
df.sort_index()                             # 按索引排序

4️⃣ 数据分组与聚合

df.groupby('City').agg({'Age': 'mean', 'Salary': 'sum'})

📘 常用聚合函数：

• mean() 平均值
• sum() 总和
• count() 计数
• max()、min() 最大/最小

5️⃣ 处理重复与唯一值

df.drop_duplicates(subset='Name')	#指定列删除重复行，保留第一个出现的
df['City'].unique()       # 去重，返回指定列的所有唯一值
df['City'].value_counts() # 统计数量

常用参数：df.drop_duplicates

• subset：指定判断重复的列，可以是单列或多列
• keep：保留哪个重复项，'first'(默认)/'last'/False(全部删除)
• inplace：是否原地修改，True/False

特点：df[‘city’].unique()

• 返回numpy数组
• 不包含重复值
• 保持原始顺序（按第一次出现的顺序）

常用参数：df[‘city’].value_counts()

• normalize：是否返回比例而非计数，True返回频率
• ascending：是否升序排列，False(默认降序)/True
• dropna：是否排除NaN值，True(默认)/False

8 数据变换与高级操作

1️⃣ apply() 函数 —— 自定义计算

def bonus_calc(salary):
	return salary *0.1 if salary > 5000 else 0
	
df['Bonus'] = df['Salary'].apply(bonus_calc)

输出：

      Name  Salary  Bonus
0    Alice    4000      0
1      Bob    6000    600
2  Charlie    8000    800

2️⃣ eval() 表达式计算——字符串表达式进行列运算（性能好）

# 使用eval计算
df.eval('Total = Salary + Bonus', inplace=True)
df.eval('Tax = Total * 0.1', inplace=True)
print(df)

输出：

   Salary  Bonus  Total   Tax
0    4000      0   4000   400
1    6000    600   6600   660
2    8000    800   8800   880

3️⃣ 窗口函数（rolling）——对滑动窗口的数据进行计算，常用于时间序列

# 创建时间序列数据
dates = pd.date_range('2024-01-01', periods=6)
df = pd.DataFrame({
    'Date': dates,
    'Salary': [1000, 2000, 3000, 4000, 5000, 6000]
})

# 计算2期移动平均
df['Salary_MA'] = df['Salary'].rolling(window=2).mean()
print(df)

输出：

        Date  Salary  Salary_MA
0 2024-01-01    1000        NaN
1 2024-01-02    2000     1500.0
2 2024-01-03    3000     2500.0
3 2024-01-04    4000     3500.0
4 2024-01-05    5000     4500.0
5 2024-01-06    6000     5500.0

5️⃣ 数据堆叠与解堆——列转换成行索引

# 创建示例数据
df = pd.DataFrame({
    'City': ['Beijing', 'Beijing', 'Shanghai', 'Shanghai'],
    'Name': ['Alice', 'Bob', 'Charlie', 'David'],
    'Salary': [5000, 6000, 7000, 8000],
    'Bonus': [500, 600, 700, 800]
})

# 堆叠：将列转换为行索引
stacked = df.set_index(['city','Name']).stack()
print("堆叠后的数据:")
print(stacked)

shuchu:

City     Name          
Beijing  Alice   Salary    5000
                Bonus      500
         Bob     Salary    6000
                Bonus      600
Shanghai Charlie Salary    7000
                Bonus      700
         David   Salary    8000
                Bonus      800
dtype: int64

# 解堆：将行索引转换回列
unstacked = stacked.unstack()
print("\n解堆后的数据:")
print(unstacked)

输出：

City     Name    Bonus  Salary        
Beijing  Alice     500    5000
         Bob       600    6000
Shanghai Charlie   700    7000
         David     800    8000

9 数据统计与探索

1️⃣ 描述性统计

df.describe() 

输出均值、标准差std()、最小值、分位数、最大值等。

2️⃣ 分箱与离散化

# 按年龄分段
bins = [20, 30, 40, 50]
labels = ['20-29', '30-39', '40-49']
df['AgeGroup'] = pd.cut(df['Age'],bins=bins,labels=labels)

# 按分位数分薪资等级
df['SalaryQuantile'] = pd.qcut(df['Salary'], q=4, labels=['低', '中低', '中高', '高'])

10 数据可视化

import matplotlib.pyplot as plt
df.plot(x='Name', y='Salary', kind='bar', title='Salary by Name')
plt.show()

常见图形：

类型	kind参数	说明
折线图	'line'	变化趋势
柱状图	'bar'	类别比较
直方图	'hist'	分布情况
散点图	'scatter'	相关性分析

11 pandas与人工智能的结合

📘 AI 前置处理常见任务：

任务	Pandas 操作	目标
缺失值填充	fillna()	避免模型错误输入
特征选择	df[['特征1','特征2']]	提取关键属性
特征编码	pd.get_dummies()	将分类变量转为数值
特征标准化	(x - x.min())/(x.max()-x.min())	数据范围归一化
数据集划分	df.sample(frac=0.8)	训练/测试划分

• **特征编码 pd.get_dummies()**

df = pd.DataFrame({
    '城市': ['北京', '上海', '广州', '北京', '深圳'],
    '学历': ['本科', '硕士', '博士', '本科', '硕士'],
    '工资': [5000, 6000, 7000, 5500, 6500]
})

print("原始数据:")
print(df)

# 对分类变量进行独热编码
df_encoded = pd.get_dummies(df, columns=['城市', '学历'])
print("\n编码后数据:")
print(df_encoded)

输出：

   工资  城市_北京  城市_上海  城市_广州  城市_深圳  学历_本科  学历_硕士  学历_博士
0  5000      1      0      0      0      1      0      0
1  6000      0      1      0      0      0      1      0
2  7000      0      0      1      0      0      0      1
3  5500      1      0      0      0      1      0      0
4  6500      0      0      0      1      0      1      0

• 特征标准化：将数值特征缩放到相同范围，避免某些特征因数值过大而主导模型

# 最小-最大标准化（归一化）
df = pd.DataFrame({
    '年龄': [20, 35, 50, 25, 40],
    '工资': [3000, 8000, 15000, 5000, 10000],
    '购买金额': [100, 500, 1000, 200, 800]
})

print("原始数据:")
print(df)

# 最小-最大标准化
df_normalized = df.copy()
for col in ['年龄', '工资', '购买金额']:
    df_normalized[col] = (df[col] - df[col].min()) / (df[col].max() - df[col].min())

print("\n标准化后数据:")
print(df_normalized)

# 方法1：最小-最大标准化（归一化）
def 归一化(列):
    return (列 - 列.min()) / (列.max() - 列.min())

标准化成绩表 = 成绩表.copy()
for 科目 in ['语文', '数学', '英语']:
    标准化成绩表[科目] = 归一化(成绩表[科目])

其他标准化方法：

# Z-score标准化
df_zscore = df.copy()
for col in ['年龄', '工资', '购买金额']:
    df_zscore[col] = (df[col] - df[col].mean()) / df[col].std()
#（值-平均值）/标准差

• **数据集划分 df.sample(frac=0.8)**

目标：将数据划分为训练集和测试集，用于模型训练和评估

# 创建100个学生的完整数据集
np.random.seed(42)  # 确保每次运行得到相同结果，便于教学
学习数据 = pd.DataFrame({
    '学习时间': np.random.normal(5, 2, 100),    # 正态分布，均值5，标准差2
    '做题数量': np.random.normal(50, 20, 100),  # 正态分布，均值50，标准差20  
    '考试分数': np.random.randint(60, 100, 100) # 均匀分布，60-100分
})

print("🎓 100个学生的学习数据概况:")
print(f"数据集形状: {学习数据.shape}")  # (100, 3)
print("\n前5个学生数据:")
print(学习数据.head())

# 方法1：手动划分
print("\n📦 方法1: 手动划分数据集")
复习资料 = 学习数据.sample(frac=0.8, random_state=42)  # 随机抽取80%
模拟试卷 = 学习数据.drop(复习资料.index)               # 剩下的20%

print(f"📚 复习资料: {len(复习资料)} 个学生")
print(f"📝 模拟试卷: {len(模拟试卷)} 个学生")

# 方法2：使用sklearn（更专业）
print("\n🔧 方法2: 使用sklearn划分")
from sklearn.model_selection import train_test_split

# 分离特征(X)和目标变量(y)
X = 学习数据[['学习时间', '做题数量']]  # 特征：学习时间和做题数量
y = 学习数据['考试分数']               # 目标：要预测的考试分数

X_train, X_test, y_train, y_test = train_test_split(
    X, y, 
    test_size=0.2,        # 测试集比例20%
    random_state=42       # 随机种子，确保可重复
)

print(f"特征训练集: {X_train.shape}")
print(f"特征测试集: {X_test.shape}") 
print(f"目标训练集: {y_train.shape}")
print(f"目标测试集: {y_test.shape}")

最终输出：

🎓 100个学生的学习数据概况:
数据集形状: (100, 3)

前5个学生数据:
     学习时间       做题数量  考试分数
0  6.483369  59.881468     95
1  4.676542  47.383437     84
2  6.295149  45.825345     89
3  4.204893  45.817836     97
4  5.440972  70.405199     90

📦 方法1: 手动划分数据集
📚 复习资料: 80 个学生
📝 模拟试卷: 20 个学生

🔧 方法2: 使用sklearn划分
特征训练集: (80, 2)
特征测试集: (20, 2)
目标训练集: (80,)
目标测试集: (20,)