pandas之基本的数据处理

基本功能

判断样本数量和特征数量、各个特征类型、是否有缺失值

展开部分数据

head(n)可以显示前n个样本
tail(n)显示末尾n个样本
sample(n)则从数据中随机采样得到n个样本。n默认为5。
建议采用sample（）来进行展开

查看数据类型

dtypes属性，我们可以得到各个特征的数据
astype()方法可以对数据类型进行转换，在默认情况下会产生对象转换后的一个副本。

df['G'] = df['G'].astype('int32')

对多列进行转换，那么我们可以通过向astype()方法传入一个字典来实现。字典中的键值对格式为列名：目标数据类型。

df = df.astype({'B':'int8', 'G':'int32'})
df.dtypes

select_dtypes()只包含两个参数，include和exclude，前者代表筛选时选取的数据类型，后者代表筛选时剔除的数据类型。

df.select_dtypes(include=['number'])

统计型函数

这些函数都将axis作为其参数，默认axis=0表示对索引index进行操作，axis=1表示对列columns进行操作
df.mean(0)
count非缺失样本（NA）的数量
sum加和
mean均值
mad平均绝对偏差（Mean absolute deviation）
median中位数
min最小值
max最大值
mode众数
abs绝对值
prod乘积
stdBessel-corrected标准差
var无偏方差
sem平均标准误差
skew偏度 (三阶矩)
kurt峰度 (四阶矩)
quantile分位数
cumsum累和
cumprod累积
cummax累积最大值
cummin累积最小值
corr()相关系数是通过
cov()协方差
info()各列数据的类型、非空值数量和总体样本数，计算占用的内存空间
describe()
方法能够自动计算Series对象和DataFrame对象各特征的均值、标准差、最小值、最大值以及分位数。
可以通过percentiles参数设置显示哪几个分位数

df.describe(percentiles=[.05, .5, .95])

describe()也可以对非数值型数据进行统计
如果一个DataFrame对象既包括了数值型特征又包括了非数值型特征，那么describe()方法将默认只对数值型特征进行汇总统计
可以通过include和exclude分别指定包括哪些类型的特征和排除哪些类型的特征
all表示对所有特征进行汇总统计。

算数运算型函数

+-*\进行二元运算外，Pandas对象包含了二元运算方法
add()、sub()、mul()和div()分别表示加减乘除（注意乘法是对应元素相乘，而不是矩阵乘法）并且可以使用axis参数指定沿行还是沿列进行计算。
在 Pandas 中，df.sub(row, axis=1) 方法用于将 DataFrame 的每一列减去指定的行。其中，row 是一个 Series 对象或列表，代表需要从 DataFrame 的每一列中减去的值；axis=1 表示按列方向进行操作。

import pandas as pd

# 创建 DataFrame
df = pd.DataFrame({
    'A': [1, 4, 7],
    'B': [2, 5, 8],
    'C': [3, 6, 9]
})

# 减去第二行的数据
row = df.iloc[1]
result = df.sub(row, axis=1)

print(result)

输出：

   A  B  C
0 -3 -3 -3
1  0  0  0
2  3  3  3

sub() 方法不会修改原始 DataFrame，而是返回一个新的 DataFrame。如果我们想要更新原始 DataFrame，可以将结果赋值给原始变量 df，即 df = df.sub(row, axis=1)

算数运算的对齐问题

会按照标签进行运算
s1.sub(s2)
算术运算默认axis=1，表示与每一行进行操作，这与之前df.sum()等描述性统计方法默认的axis=0不同。算术运算中的axis的轴号表示希望匹配的轴。可以使用axis参数指定沿行还是沿列进行计算。

丢弃数据

DataFrame.drop(axis=0, how=‘any’, thresh=None, subset=None, inplace=False)

• axis：默认为 0，表示逢空值剔除整行，如果设置参数 axis＝1 表示逢空值去掉整列。
• how：默认为 ‘any’ 如果一行（或一列）里任何一个数据有出现 NA 就去掉整行，如果设置 how=‘all’ 一行（或列）都是 NA 才去掉这整行。
• thresh：设置需要多少非空值的数据才可以保留下来的。
• subset：设置想要检查的列。如果是多个列，可以使用列名的 list 作为参数。
• inplace：如果设置 True，将计算得到的值直接覆盖之前的值并返回 None，修改的是源数据。
  我们可以通过 isnull() 判断各个单元格是否为空。

drop()

根据标签丢弃数据

• labels，单个或者多个标签，传入类列表值（列表、array等）
• axis，丢弃行（0，默认）或者丢弃列（1）
• inplace，是否用结果替换原Pandas对象（默认为False）

drop_duplicates()

丢弃重复数据，默认会判断全部列，通过参数指定
duplicated() 方法用于判断 DataFrame 中的每一行是否为重复行。如果某一行与前面的某一行完全相同，则该方法返回 True；否则返回 False。如果指定了 keep='first' 参数（默认情况下），则保留第一个出现的行，而将其余重复的行标记为 True；如果指定了 keep='last' 参数，则保留最后一个出现的行。

dropna()

丢弃缺失数据

• axis，丢弃缺失值所在行（0，默认）或者所在行（1）
• how，"any"表示只要存在缺失值即丢弃（默认），"all"表示所有值为缺失值才丢弃
• subset，考虑部分行和列
• inplace，替换原来的对象

缺失值

判断缺失值

isnull()可以对Pandas对象中的所有数值进行逐一判断，然后返回一个同样大小的Pandas对象，如果是NaN标识的缺失值，则结果True，否则为False。

import pandas as pd
import numpy as np

# 创建包含缺失值的 DataFrame
df = pd.DataFrame({
    'A': [1, 2, np.nan, 4],
    'B': [5, np.nan, 7, 8],
    'C': [9, 10, 11, np.nan]
})

# 检查每个元素是否为缺失值
print(df.isnull())

# 检查每列中是否存在缺失值
print(df.isnull().any())

# 检查每行中是否存在缺失值
print(df.isnull().any(axis=1))

# 统计每列中缺失值的数量
print(df.isnull().sum())

输出：

       A      B      C
0  False  False  False
1  False   True  False
2   True  False  False
3  False  False   True

A     True
B     True
C     True
dtype: bool

0    False
1     True
2     True
3     True
dtype: bool

A    1
B    1
C    1
dtype: int64

填补缺失值

import pandas as pd
import numpy as np

# 创建包含缺失值的 DataFrame
df = pd.DataFrame({
    'A': [1, 2, np.nan, 4],
    'B': [5, np.nan, 7, np.nan],
    'C': [9, 10, 11, np.nan]
})

# 将缺失值填充为指定值
print(df.fillna(0))

# 将缺失值填充为前一行的值
print(df.fillna(method='ffill'))

# 将缺失值填充为后一行的值
print(df.fillna(method='bfill'))

# 将每列的缺失值填充为该列的平均值
print(df.fillna(df.mean()))

# 将每列的缺失值填充为该列的中位数

# 对每列分别填补缺失值 fill_values = {'A': df['A'].mean(), 'B': df['B'].median(), 'C': 0} print(df.fillna(fill_values))

输出：

     A    B     C
0  1.0  5.0   9.0
1  2.0  0.0  10.0
2  0.0  7.0  11.0
3  4.0  0.0   0.0

     A    B     C
0  1.0  5.0   9.0
1  2.0  5.0  10.0
2  2.0  7.0  11.0
3  4.0  7.0  11.0

     A    B     C
0  1.0  5.0   9.0
1  2.0  7.0  10.0
2  4.0  7.0  11.0
3  4.0  NaN   NaN

     A    B     C
0  1.0  5.0   9.0
1  2.0  6.0  10.0
2  2.333333  7.0  11.0
3  4.0  6.0   10.0

     A    B     C
0  1.0  5.0   9.0
1  2.0  6.0  10.0
2  2.0  7.0  11.0
3  4.0  6.0  10.0

     A    B     C
0  1.0  5.0   9.0
1  2.0  6.0  10.0
2  2.333333  7.0  11.0
3  4.0  6.0   0.0

bfill 方法将缺失值填充为该列后面一行的值,也就是下面的补充上面的

修改索引

reindex（）

# 直接修改
df.index = ['a', 'b', 'c']

# 重新索引并得到一个新的Pandas对象
df.reindex(['b', 'c', 'e'])

# 对列进行索引并得到一个新的Pandas对象
df.reindex(columns=['two', 'three', 'four'])

# 用某一列作为索引并得到一个新的Pandas对象
set_index()

import pandas as pd

# 创建 DataFrame
df = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
}, index=['a', 'b', 'c'])

# 对行进行重新索引
print(df.reindex(['a', 'b', 'd']))

# 对列进行重新索引
print(df.reindex(columns=['A', 'C']))

输出：

     A    B
a  1.0  4.0
b  2.0  5.0
d  NaN  NaN

   A   C
a  1 NaN
b  2 NaN
c  3 NaN

在上述代码中，我们使用 reindex() 方法重新索引 DataFrame 或 Series。例如，df.reindex(['a', 'b', 'd']) 表示对 DataFrame 的行进行重新索引，将原来的索引 [‘a’, ‘b’, ‘c’] 转变为 [‘a’, ‘b’, ‘d’]；由于没有索引为 ‘d’ 的行，所以新的 DataFrame 在该位置添加了一行缺失值。另外，df.reindex(columns=['A', 'C']) 表示对 DataFrame 的列进行重新索引，将原来的列名 [‘A’, ‘B’] 转变为 [‘A’, ‘C’]；由于没有列名为 ‘C’ 的列，所以新的 DataFrame 在该位置添加了一列缺失值。需要注意的是，reindex() 方法返回一个新的对象，并不会就地修改原始对象。

修改标签

df.rename({‘a’:‘A’, ‘b’:‘B’, ‘c’:‘C’})

层次化索引

import pandas as pd

# 使用 MultiIndex.from_tuples() 方法创建层次化索引
index1 = pd.MultiIndex.from_tuples([('A', 'a'), ('A', 'b'), ('B', 'a'), ('B', 'b')])
data1 = pd.Series([1, 2, 3, 4], index=index1)
print(data1)

# 使用 MultiIndex.from_arrays() 方法创建层次化索引
index2 = pd.MultiIndex.from_arrays([['A', 'A', 'B', 'B'], ['a', 'b', 'a', 'b']])
data2 = pd.Series([1, 2, 3, 4], index=index2)
print(data2)

# 使用 MultiIndex.from_product() 方法创建层次化索引
index3 = pd.MultiIndex.from_product([['A', 'B'], ['a', 'b']])
data3 = pd.Series([1, 2, 3, 4], index=index3)
print(data3)

输出：

A  a    1
   b    2
B  a    3
   b    4
dtype: int64

A  a    1
   b    2
B  a    3
   b    4
dtype: int64

A  a    1
   b    2
B  a    3
   b    4
dtype: int64

交换一级二级索引顺序

import pandas as pd

# 创建 DataFrame，并设置层次化列索引
data = {'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]}
df = pd.DataFrame(data, columns=[['L1', 'L2', 'L2'], ['B', 'A', 'B']])
print(df)

# 对层次化列索引进行交换
df_swapped = df.swaplevel(0, 1, axis=1)
print(df_swapped)

输出：

  L1 L2   
   B  A  B
0  1  4  7
1  2  5  8
2  3  6  9

   B  A  B
  L1 L2 L2
0  1  4  7
1  2  5  8
2  3  6  9

其中第一个参数 0 和第二个参数 1 表示需要交换的层级在原索引中的位置，第三个参数 axis=1 表示该操作是针对 DataFrame 的列进行的
swaplevel() 方法返回的是一个新的 DataFrame 对象，原始的 DataFrame 对象并没有被修改。
也可以用df.reorder_levels([1, 0], axis=1)