1.Pandas数据分析基础

1.1数据类型

|-----------------|----------|--------------------------------------------------------|------------|
| pandas dtype | Python类型 | Numpy类型 | 用途 |
| object | str | string_.unicode_ | 文本 |
| int64 | int | int_,int8,int16,int32,int64,unit8,unit16,unit32,unit64 | 整数 |
| float64 | float | float_,float16,float32,float64 | 浮点数 |
| bool | bool | bool_ | 布尔值 |
| datetime64 | NA | NA | 日期时间 |
| timedelta[ns] | NA | NA | 时间单 |
| category | NA | NA | 有限长度的文本值列表 |

1.1.1 类型速查

df.info()

列出变量类型、行列数量、非缺失值的数量、类型数量的统计，以及内存使用大小。

1.1.2 类型检查

object类型意味很多种可能，需要对数据的类型进行分布统计。

# 查看列a中每个数据对应的类型
df['a'].apply(type)

# 查看各数据类型的统计分布
df['a'].apply(type).value_counts()

# 对数据类型进行转换
df['a'] = df['a'].astype(float)

1.1.3 类型筛选

df.select_dtypes(include=['float'], exclude=['int64'])

1.1.4 类型转换

（1）转数值型

pd.to_numeric(s, errors='ignore')

（2）转字符型

# 通过map映射
df['a'] = df['a'].map(str)

# 通过astype修改类型
df['a'] = df['a'].astype(str)

（3）转时间类型

pd.to_datetime(df['a'], format='%Y.%m.%d')

（4）转分类型

df['a'] = df['a'].astype('category')

（5）智能转换

df.convert_dtypes()
ser.convert_dtypes()

1.2 数据结构

1.2.1 创建series

# 通过列表
s1 = pd.Series(['a', 'b', 'c'])

# 通过元组
s2 = pd.Series(('a', 'b', 'c'))

# 通过字典
s3 = pd.Series({'a':1, 'b':2, 'c':3})

# 通过标量
s4 = pd.Series(8, index=['a', 'b', 'c'])

1.2.2 创建dataframe

# 创建空dataframe

# 通过列表

# 通过字典

1.2.3 series转其他

# 转dataframe
ser.to_frame()

# 转字典
ser.to_dict()

# 转列表
ser.to_list()

# 转json
ser.to_json()

# 转标量
ser.squeeze()

1.2.4 dataframe转其他

# 转字典
df.to_dict()

# 转json
df.to_json()

# 转series
df.squeeze()

1.2.5 其他转dataframe

# 字典转
df = pd.DataFrame.from_dict(dd)

# 结构数据转
df = pd.DataFrame.from_records(nd)

# 嵌套json转
pd.json_normalize()

1.3 索引对象

1.3.1 索引操作

（1）索引属性

s.index.values
s.index.is_unique
s.index.has_duplicates    # 索引是否有重复值
s.index.hasnans      # 索引是否有缺失值
s.index.dtype
s.index.shape
s.index.names
s.index.ndim     # 索引维度
s.index.size
s.index.T
s.index.memory_usage()       # 索引占用内存大小

（2）索引计算

# 索引中是否存在一个为True
index.any()

# 索引中是否全部为True
index.all()

# 索引中的最大值和最小值
index.min()
index.max()

# 返回索引中最小值的索引位置
index.argmin()
index.argmax()

# 返回指定索引层级的所有唯一值
index.unique(level=0)
# 返回唯一值的数量
index.nuique(dropna=False)   # 默认True不包含空值

# 只标记第一个重复为True
index.duplicated(keep='first')
# 所有重复值标记为True
index.duplicated(keep=False)

# 只保留第一个重复值
index.drop_duplicated(keep='first')
# 只保留最后一个   last
# 都删除          keep=False

# 分类编码------将一组数据的唯一值进行数值映射   ?
index.factorize(sort=False, use_na_sentinel=True)

# 对索引数量进行分布统计
index.value_counts(normalize=False, sort=True, ascending=False, bins=None, dropna=True)

（3）索引修改

# 复制一个新的索引
index.copy()

# 重新制定索引值
index = pd.Index([1,2,3,4,5,6])
index.reindex(target=[1,3,4,7])

# 参数name为字符或字符的列表重命名
index.rename(name='a')     # 单层级索引
index.rename(['a', 'b']）  # 多层级索引

# 按指定位置和索引值删除
index.delete(loc=[0, 1])     # 删除0和1位置的索引
index.drop(labels=[3,4])     # 删除索引中值3和4

# 指定位置插入索引值
index.insert(loc=1, item=999)

（4）索引缺失

# 对每个索引值判断是否缺失
index,isna()
index.notna()

# 用指定值填充NaN缺失值
index.fillna(value=-999)

# 全部索引层级均缺失才删除
index.drop(how='all')

（5）索引转换

# 转换索引值类型
s.index.astype(dtype=str)

# 将索引转换为Python列表
s.index.to_list()

# 将索引转换为一维数组
s.index.ravel()

# 将索引通过mapper映射为一个新的索引结果
s.index.map(lambda x: x+pd.Timedelta('1day'))

# 转换为series
s.index.to_series(name='date')   # index默认为None

# 转换为dataframe后索引与原索引相同
s.index.to_frame(index=True, name='date')

（6）索引排序

# 返回索引排序对应的整数标识
index.argsort()

# 查询b和e在索引中的位置，指定左边界位置
index.searchsorted(['b', 'e'], side='left')

# 对索引值进行排序
index.sort_values(ascending=True)

（7）索引合并

# 对已有索引扩增新的索引
index1.append(index2)

# 两个索引的交集
index1.intersection(index2)

# 两个索引的并集
index1.union(index2)

# 两个索引的补集
index1.difference(index2)

（8）索引筛选

df.index.where(cond)
df.index.putmask(mask, value)

1.3.2 区间索引

当没有指定显式的索引时，RangeIndex区间索引就是DataFrame和Series使用的默认索引类型。

pd.RangeIndex(start=None, stop=None, step=None, dtype=None, copy=False, name=None)

1.3.3 分类索引

# 创建
pd.CategoricalIndex(data=None, categories=None, ordered=None, dtype=None, copy=False, name=None)

1.3.4 间隔索引

# 创建
pd.interval_range(start=None, end=None, periods=None, freq=None, name=None, closed='right')

1.3.5 多层级索引

# （1）创建
# 分两种情况：1.只有纯数据，索引需要新建立；2.索引可从数据中获取
# 四种方法：MultiIndex.from_arrays, MultiIndex.from_product, MultiIndex.from_tuples, MultiIndex.from_frame

# （2）筛选
# 列:筛选列一级索引
df.loc[:, 'a']
df['a']
# 同时筛选列一二级索引
df.loc[:, ('a', 'a_1')]
df['a', 'a_1']
# 同时筛选行一二级索引
df.loc['b', 'b_1']
# 筛选行一级索引
df.loc['b']
# 同时筛选行和列一二级索引，得到元素
df.loc[('b', 'b_1'), ('a', 'a_1')]

# （3）操作
# 按层级查询索引
df.index.get_level_values(level=1)        # 查找行的二级索引
df.index.get_level_values(level=0)        # 查找行的一级索引
df.columns.get_level_values(level=1)      # 查找列的二级索引
df.columns.get_level_values(level=0)      # 查找列的一级索引
# 按层级删除索引
df.index.droplevel(level=0)               # 删除行一级索引
df.index.droplevel(level=1)               # 删除行二级索引
df.columns.droplevel(level=0)             # 删除列一级索引
df.columns.droplevel(level=1)             # 删除列二级索引
# 按层级修改索引
df.index.set_levels(['北方', '南方'], level=0)     # 修改行一级索引
df.index.set_levels(['北交', '人大', '同济', '华东师范'], level=1)     # 修改行二级索引
df.columns.set_levels(['北方', '南方'], level=0)     # 修改列一级索引 
df.columns.set_levels(['北交', '人大', '同济', '华东师范'], level=1) # 修改列二级索引
# 按层级排序索引
df.index.sortlevel(level=0, ascending=False)          # 对行一级索引倒序排序
df.index.sortlevel(level=1, ascending=False)          # 对行二级索引倒序排序
df.columns.sortlevel(level=0, ascending=False)        # 对列一级索引倒序排列
df.columns.sortlevel(level=1, ascending=False)        # 对列二级索引倒序排列
# 索引层级互换
df.index.swaplevel(i=0, j=1)
df.columns.swaplevel(i=0, j=1)
# 多级索引拼接
df.columns.to_flat_index()
df.columns = ['_'.join(k) for k in df.columns.to_flat_index()]
# 多级索引拆分
df.columns = pd.MultiIndex.from_tuples(k.split('_') for k in df.columns)

1.3.6 时间索引

## 日期索引
# 以日为频率
pd.date_range(start='2022-01-01', periods=8)
# 以月为频率
pd.date_range(start='2022-01-01', periods=8, freq='M')

## 时间差索引
# 从1天时间差开始到2天时间差结束以6小时为频率的时间差索引
pd.timedelta_range(start='1 day', end='2 days', freq='6H')

## 周期索引
pd.period_range(start='2020-01-01', end='2022-01-01', freq='M')

1.4 数据排序

1.4.1 索引排序

# series降序
s.sort_index(ascending=False, na_position='first')

# dataframe按一级索引进行降序排序
df.sort_index(ascending=False, level=1, axis=0)

1.4.2 数值排序

# 按列排序
df.sort_values(by=['a', 'b'], axis=0, ascending=[True, False])

# 按行排序
df.sort_values(by=['1', '2'], axis=1, ascending=[True, False])

1.5 数据筛选

简单方法有[]，loc，iloc，at，iat。

1.5.1 []

只是一个维度的筛选行或者列，不能同时筛选。

（1）行筛选

[]的行筛选有三种方法：整数索引切片、标签切片、布尔数组。

### 整数索引切片(左闭右开）
# 以步长2筛选第1/3/5行的数据
df[1:6:2]

### 标签索引切片（左闭右闭）
df['2022-01-01', '2022-12-01']

### 布尔值筛选
df[[True,False,True,False,False]]
# 通过逻辑筛选生成布尔值序列
df[df['a']>80]
# 组合判断，需要用()独立包围条件
df[(df['a']>80) & (df['b']<90)]              # 且关系
df[(df['a']>80) | (df['b']<90)]              # 或关系

（2）列筛选

[]的列筛选有三种方法：标签索引、标签列表。

### 标签索引
df['col_1']

### 标签列表
df[['col_1', 'col_2']]

1.5.2 loc

loc只能用标签索引，不可用整数索引，因此是左闭右闭。

三种通用形式：

• 行列筛选：df.loc[行筛选，列筛选]

• 行筛选：df.loc[行筛选, :] 等价于 df.loc[行筛选]

• 列筛选：df.loc[列筛选]

（1）行筛选

# 行索单标签
df.loc['2013-01-02',]

# 行索引切片
df.loc['2013-01-01':'2013-12-01', :]

# 行索引列表
df.loc[['2020-01-01', '2021-01-01']]

# 布尔值
df.loc[df['a']>80]
df.loc[(df['b']>60) & (df['f']<90)]
df.loc[(df['b']>60) | (df['f']<90)]

（2）列筛选

# 选取单列
df.loc[:, 'A']

# 列索引的列表
df.loc[:, ['A', 'C']]

# 列索引的切片
df.loc[:, 'A':'C']

# 布尔值选取
df.loc[:, [True, False, False, True, Flase]]

（3）行列筛选

# 行为布尔筛选，列为切片筛选
df.loc[df['A']>0, 'A':'C']

# 行为布尔筛选，列为列表筛选
df.loc[(df['A']<80) | (df['C']>90), ['B','D','F']]

1.5.3 iloc

iloc只能通过索引的整数位置对数据筛选，通过切片筛选时，是前闭后开的。

（1）行筛选

# 单行
df.iloc[1]              # 选择第2行
df.iloc[-1]             # 选择最后一行

# 多行
df.iloc[0:3]            # 选择第1至3行

df.iloc[0]              # 返回一个Series
df.iloc[[0]]            # 返回一个DataFrame

（2）列筛选

# 单列
df.iloc[:,1]           # 选择第2列
df.iloc[:, -1]         # 选择最后一列

# 多列
df.iloc[:, 0:3]        # 选择1到3列

（3）行列筛选

df.iloc[[1,2],[3,4]]         # 选择第2/3行、3/4列
df.iloc[0:3, 2:4]            # 选择1-3行、3-5列

1.5.4 sample

# 固定数量
df.sample(n=2, random_state=0)

# 固定比例
df.sample(frac=0.1, random_state=0)

# 索引重置
df.sample(n=3, random_state=0. ignore_index=True)

# 有放回抽取（默认无放回）
df.sample(frac=1.5, replace=True, random_state=0)          # 有放回抽样，frac可以大于1，无放回必须小于1