目录
7.1.2 df.shape / df.columns / df.index
7.1.3 df.info() / df.describe()
一、基础操作
Series：
一维数据结构，类似于一个带索引的数组。
每个元素都有一个对应的索引值，索引是唯一的。
通常用于表示单列数据。
通过一个列表、数组或字典创建。
DataFrame：
二维数据结构，类似于一个表格，由行和列组成。
每列可以有不同的数据类型（如整数、浮点数、字符串等）。
每行和每列都有索引，行索引称为
index，列索引称为columns。通常用于表示多列数据。
通过字典、列表的列表、或从文件（如 CSV、Excel）中读取创建。
1.1 创建df对象
1.1.1 读入表格数据
df = pd.read_csv('./data/titanic.csv')
df.head() #可以读前5行数据
1.1.2 手动创建df
data = {'country':['aaa','bbb','ccc'],
'population':[10,12,14]}
df_data = pd.DataFrame(data)
1.2 .info()
返回当前的信息
df.info()
输出：<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 PassengerId 891 non-null int64
1 Survived 891 non-null int64
2 Pclass 891 non-null int64
3 Name 891 non-null object
4 Sex 891 non-null object
5 Age 714 non-null float64
6 SibSp 891 non-null int64
7 Parch 891 non-null int64
8 Ticket 891 non-null object
9 Fare 891 non-null float64
10 Cabin 204 non-null object
11 Embarked 889 non-null object
dtypes: float64(2), int64(5), object(5)
memory usage: 83.7+ KB1.3 df.index
返回索引对象
RangeIndex(start=0, stop=891, step=1)1.4 df.columns
返回 DataFrame 的列名
Index(['PassengerId', 'Survived', 'Pclass', 'Name', 'Sex', 'Age', 'SibSp',
'Parch', 'Ticket', 'Fare', 'Cabin', 'Embarked'],
dtype='object')1.5 df.dtypes
返回 DataFrame 中每列的数据类型
PassengerId int64
Survived int64
Pclass int64
Name object
Sex object
Age float64
SibSp int64
Parch int64
Ticket object
Fare float64
Cabin object
Embarked object
dtype: object1.6 df.values
返回 DataFrame 中的数据部分，以二维数组（NumPy 数组）的形式。
array([[1, 0, 3, ..., 7.25, nan, 'S'],
[2, 1, 1, ..., 71.2833, 'C85', 'C'],
[3, 1, 3, ..., 7.925, nan, 'S'],
...,
[889, 0, 3, ..., 23.45, nan, 'S'],
[890, 1, 1, ..., 30.0, 'C148', 'C'],
[891, 0, 3, ..., 7.75, nan, 'Q']], dtype=object)1.7 .set_index()
自己指定索引
df = df.set_index('Name')
1.8 df['xxx']
xxx表示列名，返回Series类型
age = df['Age']
1.9 .describe()
可以得到数据的基本统计特性
df.describe() 
1.10 .isin()
判断元素是否在给定内容中
s.isin([1,3,4])
1.12 .where()
保留满足条件的数据，替换不满足条件的数据
df.where(df < 0)
df.where(df < 0,999) #将大于0的数全部替换为999 
1.13 .query()
用于通过字符串表达式对 DataFrame 进行条件筛选
df.query('(a<b) & (b<c)')
1.14 Series类型运算
.mean() / .max() / .min()，广播+-*%
age = age + 10
age.mean()
age.max()
age.min()二、Pandas索引结构
2.1 选择多列
df[['Age','Fare']]
2.2 loc / iloc
- loc 用label来去定位
- iloc 用position来去定位
df.iloc[0:5]
df.iloc[0:2]
2.3 自定义索引
df = df.set_index('Name')
df.loc['Heikkinen, Miss. Laina']
也支持切片操作
df.loc['Heikkinen, Miss. Laina':'Allen, Mr. William Henry']
2.4 bool索引
df[df['Fare'] > 40][0:5]
下边两种写法相同
df.loc[df['Sex'] == 'male'][['Fare','Age']]
df.loc[df['Sex'] == 'male',['Fare','Age']]2.5 制定多列索引
s2 = pd.Series(np.arange(6),index = pd.MultiIndex.from_product([[0,1],['a','b','c']]))
三、数值运算操作
创建DataFrame
df = pd.DataFrame([[1,2,3],[4,5,6]],index = ['a','b'],columns = ['A','B','C'])
3.1 .sum()
默认axis=0
3.2 .mean()
默认axis=0
3.3 .min() / .max()
默认axis=0
3.4 .median()
默认axis=0
3.5 二元统计
3.5.1 df.cov()
计算 DataFrame 中各列之间的协方差矩阵。
df.cov()
3.5.2 df.corr()
计算 DataFrame 中各列之间的相关系数矩阵。
df.corr()
3.5.3 .value_counts()
统计元组数量
df['Age'].value_counts()
df['Age'].value_counts(ascending = True)
三、对象的增删改查
3.1 Series结构的增删改查
data = [10,11,12]
index = ['a','b','c']
s = pd.Series(data = data,index = index) 
3.1.1 查操作
s[0] --> 10
s[0:2]
mask = [True,False,True]
s[mask]
s.loc['b'] --> 11
s.iloc[1] --> 113.1.2 改操作
s1['a'] = 100
s1.replace(to_replace = 100,value = 101,inplace = False)inplace表示是否要在s1上修改
修改index
s1.index = ['a','b','d']
s1.rename(index = {'a':'A'},inplace = True)3.1.3 增操作
data = [100,110]
index = ['h','k']
s2 = pd.Series(data = data,index = index)
输出：
h 100
k 110
dtype: int64.concat([xx,xx])
s3 = pd.concat([s1,s2])
输出：
A 101
b 11
c 12
h 100
k 110
dtype: int64
pd.concat([s1,s2],ignore_index = True)
输出：
0 101
1 11
2 12
3 100
4 110
dtype: int64直接新增新索引
s3['j'] = 500
输出：
A 101
b 11
c 12
h 100
k 110
j 500
dtype: int643.1.4 删操作
del s1['A']
s1.drop(['b','d'],inplace = True)3.2 DataFrame结构的增删改查
data = [[1,2,3],[4,5,6]]
index = ['a','b']
columns = ['A','B','C']
df = pd.DataFrame(data=data,index=index,columns = columns)
3.2.1 查操作
df['A']
输出：
a 1
b 4
Name: A, dtype: int64df.iloc[0]
df.loc['a']3.2.2 改操作
df.loc['a','A'] --> 1
df.loc['a']['A'] = 1503.2.3 增操作
df.loc['c'] = [1,2,3]
df3 = pd.concat([df,df2],axis = 0)
df2['Tang'] = [10,11]
3.2.4 删操作
df5.drop(['j'],axis=0,inplace = True) --> 去除1行
df5.drop(['A','B','C'], axis = 1,inplace = True) --> 去除多列
del df5['Tang'] --> 去除1列四、合并操作
left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
4.1 .merge()
res = pd.merge(left, right)
4.2 多索引合并
left = pd.DataFrame({'key1': ['K0', 'K1', 'K2', 'K3'],
'key2': ['K0', 'K1', 'K2', 'K3'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key1': ['K0', 'K1', 'K2', 'K3'],
'key2': ['K0', 'K1', 'K2', 'K4'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
使用on参数
res = pd.merge(left,right,on='key1')
res = pd.merge(left, right, on = ['key1', 'key2'])
使用how参数
outer为并集
res = pd.merge(left, right, on = ['key1', 'key2'], how = 'outer', indicator = True)
left按照左合并，right按照右合并
res = pd.merge(left, right, how = 'left')
res = pd.merge(left, right, how = 'right')
4.3 join
left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'key': ['K0', 'K1', 'K0', 'K1']})
right = pd.DataFrame({'C': ['C0', 'C1'],
'D': ['D0', 'D1']},
index=['K0', 'K1'])result = left.join(right, on='key')
五、数据透视表
import pandas as pd
example = pd.DataFrame({'Month': ["January", "January", "January", "January",
"February", "February", "February", "February",
"March", "March", "March", "March"],
'Category': ["Transportation", "Grocery", "Household", "Entertainment",
"Transportation", "Grocery", "Household", "Entertainment",
"Transportation", "Grocery", "Household", "Entertainment"],
'Amount': [74., 235., 175., 100., 115., 240., 225., 125., 90., 260., 200., 120.]})
5.1 .pivot()
example_pivot = example.pivot(index = 'Category',columns= 'Month',values = 'Amount')
求和
example_pivot.sum(axis = 0)
5.2 .pivot_table()
默认求均值
df.pivot_table(index = 'Sex',columns='Pclass',values='Fare')
aggfunc参数定义求法
df.pivot_table(index = 'Sex',columns='Pclass',values='Fare',aggfunc='max')
计数
df.pivot_table(index = 'Sex',columns='Pclass',values='Fare',aggfunc='count')
pd.crosstab(index = df['Sex'],columns = df['Pclass']) #计数，同上
六、 时间操作
6.1 创建时间序列
6.1.1. pd.to_datetime()
将字符串或其他格式转换为 datetime64[ns] 类型。
pd.to_datetime('2023-04-01')
pd.to_datetime(['2023-01-01', '2023-02-01'])
6.1.2. pd.date_range()
创建固定频率的时间序列。
pd.date_range(start='2023-01-01', end='2023-01-10', freq='D')
常用频率参数包括：
'D'：日
'H'：小时
'M'：月
'Y'：年
'W'：周
6.2 时间戳与时间区间
6.2.1. Timestamp
单个时间点，Pandas 对 datetime 的封装：
ts = pd.Timestamp('2023-01-01 12:00:00')
ts.year # 2023
ts.month # 1
6.2.2. Timedelta
表示时间间隔：
delta = pd.Timedelta('2 days 3 hours')
也可以进行加减操作：
pd.Timestamp('2023-01-01') + pd.Timedelta(days=3)
6.3 时间的运算与筛选
6.3.1. 时间加减
df['new_date'] = df['date'] + pd.Timedelta(days=7)
6.3.2. 筛选特定时间段
df[(df['date'] >= '2023-01-01') & (df['date'] <= '2023-03-01')]
6.4 设置索引并重采样
6.4.1. 设置时间索引
df.set_index('date', inplace=True)
6.4.2. 取时间索引中的某个数值
data[data.index.month == 1]
6.4.3. 重采样 resample()
将数据按时间频率重新分组，常用于聚合、统计：
df.resample('M').mean() # 按月取平均
df.resample('W').sum() # 按周求和
6.5 时间格式的处理
6.5.1. 提取时间的各部分
df['date'].dt.year
df['date'].dt.month
df['date'].dt.weekday
6.5.2. 格式化输出
df['date'].dt.strftime('%Y-%m-%d')
6.6 常见时间函数总结
| 函数名 | 作用 |
|---|---|
pd.to_datetime() |
转换为日期时间格式 |
pd.date_range() |
创建规则时间序列 |
.dt.year/.month/... |
提取时间字段 |
pd.Timedelta() |
表示时间间隔 |
.resample() |
重采样 |
.strftime() |
时间格式化为字符串 |
七、常用操作
7.1 查看数据结构与基本信息
7.1.1 df.head() / df.tail()
查看前几行或后几行数据：
df.head(5)
df.tail(3)
7.1.2 df.shape / df.columns / df.index
快速了解数据的行列信息：
df.shape # 返回 (行数, 列数)
df.columns # 返回列名
df.index # 返回索引
7.1.3 df.info() / df.describe()
了解字段类型和统计信息：
df.info() # 查看每列数据类型和非空数量
df.describe() # 查看数值列统计信息
7.2 数据选择与过滤
7.2.1 选择列
df['列名']
df[['列1', '列2']]
7.2.2 选择行
df.iloc[0] # 按位置
df.loc[0] # 按标签
df[df['列'] > 100] # 条件筛选
7.2.3 多重条件
df[(df['A'] > 10) & (df['B'] < 5)]
6.3 数据修改与添加
7.3.1 新增列
df['新列'] = df['A'] + df['B']
7.3.2 修改数据
df.loc[0, 'A'] = 999
7.3.3 删除列/行
df.drop('列名', axis=1) # 删除列
df.drop([0, 1], axis=0) # 删除行
7.4 缺失值处理
7.4.1 检查缺失值
df.isnull()
df.isnull().any(axis=0)
7.4.2 删除缺失值
df.dropna()
7.4.3 填充缺失值
df.fillna(5)
df.fillna(method='ffill') # 前向填充
7.5. 分组与聚合
7.5.1 分组统计
单分组和多重分组
df.groupby('列名').sum()
df.groupby('列名')['目标列'].mean()
grouped = df.groupby('A')
grouped.count()
grouped = df.groupby(['A','B'])
grouped.count() 
改变索引
grouped = df.groupby(['A','B'],as_index = False)
grouped.aggregate(np.sum)
#上下等价
df.groupby(['A','B']).sum().reset_index()
传函数名的自定义分组
def get_letter_type(letter):
if letter.lower() in 'aeiou':
return 'a'
else:
return 'b'
grouped = df.groupby(get_letter_type,axis = 1)
grouped.count() 
多索引时指定某一个索引分组
level=0表示第一个索引，level=1表示第一个索引，以此类推
grouped = s.groupby(level =0) #或写为level='first'
grouped.sum() 
7.5.2 拆分范围
根据bins中给定的范围将ages内容拆分到(10,40],(40,80]内
ages = [15,18,20,21,22,34,41,52,63,79]
bins = [10,40,80]
bins_res = pd.cut(ages,bins)
7.5.3 一列多算
使用.agg([xx,xx,xx])
grouped = df.groupby('A')
grouped['C'].agg([np.sum,np.mean,np.std])
#上下等价
grouped['C'].agg(['sum','mean','std'])
列重命名
grouped['C'].agg(res_sum=np.sum,res_mean='mean',res_std='std')
7.6. 排序与去重
7.6.1 排序
df.sort_values(by='列名', ascending=False)
7.6.2 去重
df.drop_duplicates()
7..7 数据合并与连接
7.7.1 拼接 concat
pd.concat([df1, df2], axis=0) # 行拼接
pd.concat([df1, df2], axis=1) # 列拼接
7.7.2 合并 merge
pd.merge(df1, df2, on='key') # 内连接
pd.merge(df1, df2, how='left', on='key') # 左连接
7.8 常见函数速查表
| 操作分类 | 函数 | 说明 |
|---|---|---|
| 查看数据 | head() / info() |
查看基本信息 |
| 选择数据 | iloc / loc |
按位置或标签选取 |
| 缺失值 | isnull() / fillna() |
检查与填充缺失值 |
| 分组 | groupby() / agg() |
聚合运算 |
| 合并拼接 | merge() / concat() |
数据合并 |
| 应用函数 | apply() / lambda |
自定义处理 |
八、字符串操作
通过 .str 接口完成
8.1 字符串小写/大写/首字母大写
df['列名'].str.lower() # 全部转小写
df['列名'].str.upper() # 全部转大写
df['列名'].str.title() # 每个单词首字母大写
8.2 去除空格、换行等
df['列名'].str.strip() # 去除首尾空格
df['列名'].str.lstrip() # 去除左侧空格
df['列名'].str.rstrip() # 去除右侧空格
也可处理特殊字符，如换行符 \n：
df['列名'].str.replace('\n', '')
8.3 查找与匹配字符串
8.3.1 包含判断
df['列名'].str.contains('关键词')
例如：
s[s.str.contains('Ag')]
可添加正则与忽略大小写：
df['列名'].str.contains('abc', case=False, regex=True)
8.3.2 匹配字符串开头/结尾
df['列名'].str.startswith('前缀')
df['列名'].str.endswith('后缀')
8.4 替换、分割与拼接
8.4.1 替换
df['列名'].str.replace('旧', '新', regex=False)
也支持正则替换：
df['列名'].str.replace('\d+', '', regex=True) # 去除所有数字
8.4.2 字符串分割
.str.split()
举例：
s.str.split('_')
s.str.split('_',expand = True) 
s.str.split('_',expand = True,n=1) #n=1表示切1次 
8.4.3 拼接字符串
df['新列'] = df['列A'] + '-' + df['列B']
注意拼接前需转换为字符串：
df['列A'].astype(str) + df['列B']
8.5 提取子串与正则提取
8.5.1 提取固定位置子串
df['列名'].str[0:4] # 提取前4位
df['列名'].str[-2:] # 提取最后2位
8.5.2 正则提取
df['列名'].str.extract('(\d{4})') # 提取年份
8.6 字符串长度统计
df['列名'].str.len()
8.7 .get_dummies()
用于将字符串数据转换为虚拟变量（one-hot 编码）。这种方法特别适合处理包含多个分类标签的字符串数据
s.str.get_dummies(sep = '|') 
1表示该行有此字母，0表示该行没有此字母
8.8 常用字符串函数速查表
| 操作类型 | 方法 | 示例 |
|---|---|---|
| 大小写转换 | str.lower() |
转小写 |
| 去空格 | str.strip() |
去首尾空格 |
| 查找包含 | str.contains('a') |
包含判断 |
| 替换字符 | str.replace('a','b') |
替换字符串 |
| 分割 | str.split('-') |
按分隔符切分 |
| 拼接 | 列1 + '-' + 列2 |
拼接列 |
| 提取 | str.extract('正则') |
提取内容 |
| 统计长度 | str.len() |
计算字符串长度 |
| 获取one-hot | str.get_dummies() |
得到对应one-hot值 |