pandas之数据清洗实例大全

import pandas as pd
import numpy as np


# ============删除/填充 空值============
# 在许多情况下，如果你用 Pandas 来读取大量数据，往往会发现原始数据中会存在不完整的地方。
# 在 DataFrame 中缺少数据的位置， Pandas 会自动填入一个空值，比如 NaN或 Null 。
# 我们可以选择用 .dropna() 来丢弃这些自动填充的值;
#       或是用.fillna() 来自动给这些空值填充数据.
# -------删除--------
# 1、实例数据源（带有空值）
dt_01 = {'A':[1, np.nan, 3], 'B':[2,np.nan,np.nan], 'C':[4,5,6]}
my_datafarme_01 = pd.DataFrame(dt_01)
#print(my_datafarme_01)

# 2、当你使用 .dropna() 方法时，就是告诉 Pandas 删除掉存在一个或多个空值的行（或者列）。
# 删除行用的是 .dropna(axis=0) ，
# 删除列用的是 .dropna(axis=1) 。
# 请注意，如果你没有指定 axis 参数，默认是删除行。
#print(my_datafarme_01.dropna())
#print(my_datafarme_01.dropna(axis=0))
#print(my_datafarme_01.dropna(axis=1))

# ---------填充所有Nan--------
# 类似的，如果你使用 .fillna() 方法，Pandas 将对这个 DataFrame 里所有的空值位置填上你指定的默认值。
# 比如，将表中所有 NaN 替换成 20 ：
#print(my_datafarme_01.fillna('20'))

# ---------填充指定位置的Nan-----------
# 避免影响范围太大了，于是我们可以选择只对某些特定的行或者列进行 Nan值 填充
col = ['A','B']
my_datafarme_01[col] = my_datafarme_01[col].fillna('10')
#print(my_datafarme_01)

# 同理，.dropna() 和 .fillna() 并不会永久性改变你的数据，除非你传入了 inplace=True 参数。

# ===============分组统计===============
# Pandas 的分组统计功能：可以按某一列的内容对数据行进行分组，并对其应用统计函数，比如求和，平均数，中位数，标准差等等…
# 例：我们可以对下面这数据表用 .groupby() 方法，按 'Company' 列进行分组，并用 .mean() 求每组的平均值：
# -------数据表-------
dt_01 = {'Company':['GOOGLE','GOOGLE','ORACLE','ORACLE','TWITIER','TWITIER'],
      'Person':['Saa','Charlie','Amy','Vanessa','Carl','Sarah'],
      'Sales':[200, 120, 340, 124, 243, 350]
      }
my_datafarme_02 = pd.DataFrame(dt_01)
#print(my_datafarme_02)

# --------分组并求平均值--------
# 然后，调用 .groupby() 方法，并继续用 .mean() 求平均值：
#print(my_datafarme_02.groupby('Company').mean())

# 用 .count() 方法，能对 DataFrame 中的某个元素出现的次数进行计数。
#print(my_datafarme_02.groupby('Company').count())

# ==================数据描述==============
# Pandas 的 .describe() 方法将对 DataFrame 里的<<数据>>进行分析，(只会分析数据元素列)
#         并一次性生成多个描述性的统计指标，方便用户对数据有一个直观上的认识。
# 生成的指标，从左到右分别是：计数、平均数、标准差、最小值、(25% 50% 75%)分位数、最大值。
#print(my_datafarme_02.groupby('Company').describe())

# ---------转换显示样式（竖排）-----------
#print(my_datafarme_02.groupby('Company').describe().transpose())

# ---------指定索引的数据描述-------
#print(my_datafarme_02.groupby('Company').describe().transpose()['GOOGLE'])

# ==================堆叠(Concat)=============
# 堆叠:基本上就是简单地把多个 DataFrame 堆在一起，拼成一个更大的 DataFrame。
# 当你进行堆叠的时候，请务必注意你数据表的索引和列的延伸方向，堆叠的方向要和它一致。
# 1、---数据源----
#dt_02 = pd.DataFrame(np.array(['A0','B0','C0','D0','A1','B1','C1','D1','A2','B2','C2','D2','A3','B3','C3','D3']).reshape(4,4),[0,1,2,3],['A','B','C','D'])
#dt_03 = pd.DataFrame(np.array(['A4','B4','C4','D4','A5','B5','C5','D5','A6','B6','C6','D6','A7','B7','C7','D7']).reshape(4,4),[4,5,6,7],['A','B','C','D'])
#dt_04 = pd.DataFrame(np.array(['A8','B8','C8','D8','A9','B9','C9','D9','A10','B10','C10','D10','A11','B11','C11','D11']).reshape(4,4),[8,9,10,11],['A','B','C','D'])
#print(dt_02)
#print(dt_03)
#print(dt_04)
# 2、---默认堆叠（按行堆叠）-----
# 我们用 pd.concat() 将它堆叠成一个大的表：
#print(pd.concat([dt_02,dt_03,dt_04]))
# 3、---指定堆叠方向（按列堆叠）-----
#print(pd.concat([dt_02,dt_03,dt_04], axis=1))

# ===================归并（Merge）================(用于有较多共同列情况)（合并公共列）
# 使用 pd.merge() 函数，能将多个 DataFrame 归并在一起，它的合并方式类似合并 SQL 数据表的方式；
# 归并操作的基本语法是： pd.merge(left, right, how='inner', on='Key') 。
#        其中 left 参数代表放在左侧的 DataFrame，而 right 参数代表放在右边的 DataFrame；
#        how='inner' 指的是当左右两个 DataFrame 中存在不重合的 Key 时，取结果的方式：inner 代表交集；Outer 代表并集。
#        最后，on='Key' 代表需要合并的键值所在的列，最后整个表格会以该列为准进行归并。
# -------数据源--------
left_data_01 = pd.DataFrame({'KEY': ['K0','K1','K2','K3'],
                             'A': ['A0','A1','A2','A3'],
                             'B': ['B0','B1','B2','B3']
                             })
right_data_01 = pd.DataFrame({'KEY': ['K0','K1','K2','K3'],
                              'C': ['C0','C1','C2','C3'],
                              'D': ['D0','D1','D2','D3']
                              })
# -------两个 DataFrame 数据表归并-----  (相当于数据库中的内联接查询)
#print(pd.merge(left_data_01,right_data_01,how='inner',on='KEY'))

# --------多个 on 参数-------
left_data_02 = pd.DataFrame({'KEY1': ['K0','K0','K1','K2'],
                             'KEY2': ['K0','K1','K0','K1'],
                             'A': ['A0','A1','A2','A3'],
                             'B': ['B0','B1','B2','B3']
                             })
#print(left_data_02)
right_data_02 = pd.DataFrame({'KEY1': ['K0','K1','K1','K2'],
                              'KEY2': ['K0','K0','K0','K0'],
                              'C': ['C0','C1','C2','C3'],
                              'D': ['D0','D1','D2','D3']
                              })
#print(right_data_02)
#print(pd.merge(left_data_02,right_data_02, on='KEY1'))
#print(pd.merge(left_data_02,right_data_02, on='KEY2'))
#print(pd.merge(left_data_02,right_data_02, on=['KEY1','KEY2']))

# ==================连接（join）=================（用于没有太多共同列情况）（合并公共键）
# 和 .merge() 不同，连接采用索引作为公共的键，而不是某一列
# -------数据源-------
left_data_03 = pd.DataFrame({'A': ['A0','A1','A2'],
                             'B': ['B0','B1','B2']},
                            index=['K0','K1','K2'])
right_data_03 = pd.DataFrame({'C': ['C0','C2','C3'],
                              'D': ['D0','D2','D3']},
                            index=['K0','K2','K3'])
#print(left_data_03)
#print(right_data_03)
# -------连接---------(默认左连接)(以左表索引为基准)
#print(left_data_03.join(right_data_03))
# -------交集-------
#print(left_data_03.join(right_data_03, how='inner'))
# -------并集-------
#print(left_data_03.join(right_data_03, how='outer'))

# ==================查找不重复的值===============
# 不重复的值，在一个 DataFrame 里往往是独一无二，与众不同的。找到不重复的值，在数据分析中有助于避免样本偏差
# 在 Pandas 里，主要用到 3 种方法：
# ----1、首先是 .unique() 方法。比如在下面这个 DataFrame 里，查找 col2 列中所有不重复的值：
df = pd.DataFrame({'col1': [1,2,3,4],
                   'col2': [444,555,666,444],
                   'col3': ['abc','def','ghi','xyz']})
#print(df)
#print(df['col2'].unique())

# =================查找不重复的值的个数===========
# ----2、除了列出所有不重复的值，我们还能用 .nunique() 方法，获取所有不重复值的个数：
#print(df['col2'].nunique())

# =================查找不重复值及其个数===========
# ----3、此外，还可以用 .value_counts() 同时获得所有值和对应值的计数：
#print(df['col2'].value_counts())

# ==================自定义处理函数===============
# 用 .apply() 方法，可以对 DataFrame 中的数据应用自定义函数，进行数据处理。
#     例：比如，我们先定义一个 square() 函数，然后对表中的 col1 列应用这个函数：
def square(x):
    return x*x

#print(df['col1'].apply(square))

# ----使用内置函数-----
#print(df['col3'].apply(len))

# ----使用 lambda 表达式定义函数------
#print(df['col1'].apply(lambda x:x*x))
    
# ==================获取 DataFrame 的属性===========
# DataFrame 的属性：包括 列 和 索引 的名字
#print(df.columns)
#print(df.index)

# ==================排序=================
# 如果想要将整个表按某一列的值进行排序，可以用 .sort_values() ：
# 要注意的是，表格的索引 index 还是对应着排序前的行，并没有因为排序而丢失原来的索引数据。
#print(df.sort_values('col2'))

# ================查找空值===============
# 假如你有一个很大的数据集，你可以用 Pandas 的 .isnull() 方法，方便快捷地发现表中的空值：
# 这返回的是一个新的 DataFrame，里面用布尔值（True/False）表示原 DataFrame 中对应位置的数据是否是空值。
#print(df.isnull())
    
# ================数据透视表===============
# 数据透视表：是一种汇总统计表，它展现了原表格中数据的汇总统计结果。
# Pandas 的数据透视表能自动帮你对数据进行分组、切片、筛选、排序、计数、求和或取平均值，并将结果直观地显示出来。
# ----数据源--------
data_02 = {
        'A':['Dog', 'Dog', 'Dog', 'Goat', 'Goat', 'Goat'],
        'B':['Brown', 'Brown', 'Black', 'Black', 'Brown', 'Brown'],
        'C':['x', 'y', 'x', 'y', 'x', 'y'],
        'D':[1,3,2,5,4,1]
        }
df_02 = pd.DataFrame(data_02)
print(df_02)
# -----数据透视表----
# Pandas 数据透视表的语法是 .pivot_table(data, values='', index=[''], columns=['']) ，
#       其中 values 代表我们需要汇总统计的数据点所在的列，
#           index 表示按该列进行分组索引，
#         而 columns 则表示最后结果将按该列的数据进行分列。
#print(pd.pivot_table(df_02, values='D', index=['A','B'], columns=['C']))

# 上边是通过 pandas 调用此方法，也可以通过 DataFrame 对象直接调用此方法：
#print(df_02.pivot_table(values='D', index=['A','B'], columns=['C']))