Python---数据分析(Pandas八:二维数组DataFrame数据操作一： 数据清洗，数据转换)

一、 数据清洗

1.1、 isnull()

        用于检测 DataFrame 中的缺失值，它会返回一个相同形状的布尔型 DataFrame，其中每个元素表示原始 DataFrame 中相应位置的元素是否是缺失 值。

import pandas as pd
import numpy as np

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

# 打印原始DataFrame
print(df)

# 使用 isnull() 方法检测缺失值
missing_values = df.isnull()

print(missing_values)

1.2、dropna()

        用于删除 DataFrame 中的缺失值。

DataFrame.dropna(axis=0, how=any, thresh=_NoDefault.no_default, subset=None, inplace=False, ignore_index=False)

import pandas as pd
import numpy as np

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

# 打印原始DataFrame
print(df)

# 删除任何含有 NaN 值的行
df_cleaned = df.dropna(subset=['B'])

print(df_cleaned)

1.3、fillna()

        用于填充 DataFrame 中的缺失值。

DataFrame.fillna(value=None, *, method=None, axis=0, inplace=False, limit=None)

import pandas as pd
import numpy as np

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

# 打印原始DataFrame
print(df)

# 使用固定值填充缺失值
df_filled_value = df.fillna(value=0, limit=1, axis=1)
print(df_filled_value)

# 使用字典填充
data = {
    'A': 'a',
    'B': 'b',
    'C': 'c'
}
df_filled_dict = df.fillna(value=data)
print(df_filled_dict)

# 使用Series填充
data_series = pd.Series(['a', 'b', 'c'], ['A', 'B', 'C'])
df_filled_series = df.fillna(value=data_series)
print(df_filled_series)

# 使用前一个有效观测值填充缺失值
df_filled_ffill = df.fillna(method='ffill')
print(df_filled_ffill)

# 使用后一个有效观测值填充缺失值
df_filled_bfill = df.fillna(method='bfill', axis=1)
print(df_filled_bfill)

1.4、drop_duplicates()

        用于删除 DataFrame 中的重复行。

DataFrame.drop_duplicates(subset=None, keep='first', inplace=False, ignore_index=False)

import pandas as pd

# 创建一个包含重复行的 DataFrame
df = pd.DataFrame({
    'A': [1, 1, 2, 2, 3, 3],
    'B': [1, 1, 2, 3, 3, 3],
    'C': [1, 1, 2, 2, 3, 3]
})

# 打印原始DataFrame
print(df)

# 删除重复行，保留第一次出现的重复项
df_dedup_first = df.drop_duplicates(keep=False)
print(df_dedup_first)

# 根据指定列删除重复行
df_dedup_column = df.drop_duplicates(subset=['A'])
print(df_dedup_column)

# 删除重复行，保留最后一次出现的重复项
df_dedup_last = df.drop_duplicates(keep='last')
print(df_dedup_last)

# 删除所有重复行
df_dedup_all = df.drop_duplicates(keep=False)
print(df_dedup_all)

二、 数据转换

2.1、replace()

        用于替换 DataFrame 中的值。

DataFrame.replace(to_replace=None, value=_NoDefault.no_default, inplace=False, limit=None, regex=False, method=_NoDefault.no_default)

import pandas as pd

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

data = {
    1: 20
}

# 用数字 100 替换所有的 1
df_replaced = df.replace(to_replace=data)

# 用字符串 'z' 替换所有的 'a'
df_replaced = df.replace(to_replace='a', value='z')

# 使用字典替换多个值
df_replaced = df.replace({
    2: 200,
    'b': 'y'
})

# 使用正则表达式替换
df_replaced = df.replace(to_replace=r'^a$', value='z', regex=True)

2.2、pivot()

        用于改变表格形状格式。

DataFrame.pivot(columns, index=typing.Literal[<no_default>], values=typing.Literal[<no_default>])

import pandas as pd

# 创建一个DataFrame
df = pd.DataFrame({
    'foo': ['one', 'one', 'one', 'two', 'two', 'two'],
    'bar': ['A', 'B', 'C', 'A', 'B', 'C'],
    'baz': [1, 2, 3, 4, 5, 6],
    'zoo': ['x', 'y', 'z', 'q', 'w', 't']
})

# 打印原始DataFrame
print(df)

# 使用pivot方法对DataFrame进行重塑，其中foo作为行索引，bar作为列索引，baz作为值
res1 = df.pivot(index='foo', columns='bar', values='baz')

# # 打印重塑后的DataFrame
print(res1)

# 使用pivot方法对DataFrame进行重塑，其中foo作为行索引，bar作为列索引，baz、zoo作为值
res2 = df.pivot(index='foo', columns='bar', values=['baz', 'zoo'])
# 打印重塑后的DataFrame
print(res2)

2.3、melt()

        用于改变表格形状格式。

DataFrame.melt(id_vars=None, value_vars=None, var_name=None, value_name='value', col_level=None, ignore_index=True)

import pandas as pd

# 创建一个DataFrame
df = pd.DataFrame({
    'A': {0: 'a', 1: 'b', 2: 'c'},
    'B': {0: 1, 1: 3, 2: 5},
    'C': {0: 2, 1: 4, 2: 6}
})

# 打印原始DataFrame
print(df)

# 使用melt方法对DataFrame进行重塑
res1 = df.melt(id_vars=['A'], value_vars=['B'],)

# 打印重塑后的DataFrame
print(res1)

2.4、pivot_table()

        用于生成一个指定格式的数据透视表。

DataFrame.pivot_table(values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All', observed=False, sort=True)

import numpy as np
import pandas as pd

# 创建一个DataFrame
df = pd.DataFrame({
    "A": ["foo", "foo", "foo", "foo", "foo",
          "bar", "bar", "bar", "bar"],
    "B": ["one", "one", "one", "two", "two",
          "one", "one", "two", "two"],
    "C": ["small", "large", "large", "small",
          "small", "large", "small", "small",
          "large"],
    "D": [1, 2, 2, 3, 3, 4, 5, 6, 7],
    "E": [2, 4, 5, 5, 6, 6, 8, 9, 9]
})

# 打印原始DataFrame
print(df)

# 使用pivot_table方法创建一个数据透视表
table = df.pivot_table(values=['D', 'E'], index=['A',], columns=['C'], aggfunc=np.sum, fill_value='a', margins=True, margins_name='test')

# 打印数据透视表
print(table)

2.5、 astype()

        用于转换 DataFrame 中指定列的数据类型。

DataFrame.astype(dtype, copy=None, errors='raise')

import pandas as pd

# 创建一个示例 DataFrame
df = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4.5, 5.5, 6.5],
    'C': ['7', '8', '9']
})

# 打印原始DataFrame
print(df)

# 将列 'A' 转换为浮点数类型
df['A'] = df['A'].astype(float)

# 使用字典将多列转换为不同的数据类型
# 将列 'B' 转换为整数类型，列 'C' 也转换为整数类型
df = df.astype({
    'B': int,
    'C': int
})

# 打印转换后的DataFrame
print(df)

# 打印DataFrame中各列的数据类型
print(df.dtypes)