2.pandas 的数据清洗及特征处理

最新推荐文章于 2024-05-06 23:56:21 发布

qwerqwer233sjjss

最新推荐文章于 2024-05-06 23:56:21 发布

阅读量695

点赞数 23

文章标签： pandas

本文链接：https://blog.csdn.net/qwerqwer233sjjss/article/details/136677538

版权

2.1缺失值观察与处理

缺失值：我们拿到的数据通常是不干净的，所谓的不干净，就是数据中有缺失值，有一些异常点等，需要经过一定的处理才能继续做后面的分析或建模，所以拿到数据的第一步是进行数据清洗，即缺失值、重复值、字符串和数据转换等操作，将数据清洗成可以分析或建模的样子。

2.1.1缺失值观察

isnull()函数

isnull 是 DataFrame.isna 的别名。

返回一个布尔大小相同的对象，指示值是否为 NA。 NA 值（如 None 或）映射到 True 值。其他所有内容都映射到 False 值。

创建dataframe

df = pd.DataFrame(dict(age=[5, 6, np.nan],
                       born=[pd.NaT, pd.Timestamp('1939-05-27'),
                             pd.Timestamp('1940-04-25')],
                       name=['Alfred', 'Batman', ''],
                       toy=[None, 'Batmobile', 'Joker']))


df
   age       born    name        toy
0  5.0        NaT  Alfred       None
1  6.0 1939-05-27  Batman  Batmobile
2  NaN 1940-04-25              Joker

调用isnull()函数：返回显示 DataFrame 中的哪些条目是 NA

df.isna()

     age   born   name    toy
0  False   True  False   True
1  False  False  False  False
2   True  False  False  False

查看age列特征缺失值个数：

df['age'].isna()

     toy
0   True
1   False
2   False

isnull()相关函数：

DataFrame.notna（）
isna 的布尔逆。

DataFrame.dropna（）
省略缺少值的行标签。

2.1.2对缺失值进行处理

函数：

DataFrame.fillna(value=None, , method=None, axis=None, inplace=False, limit=None, downcast=_NoDefault.no_default*)

参数：

值标量、字典、系列或数据帧

用于填充孔的值（例如 0），或者 dict/Series/DataFrame 的值，指定要使用的值每个索引（对于 Series）或列（对于 DataFrame）。值不在 dict/Series/DataFrame 中不会被填充。此值不能是一个列表。

method{'backfill'， 'bfill'， 'ffill'， None}，默认 None

用于填充重新索引系列中的孔的方法：

ffill：将最后一个有效观测值转发到下一个有效观测值。

回填/填充：使用下一个有效观测值来填充间隙。

axis{0 或 'index'} 表示 Series，{0 或 'index'， 1 或 'columns'} 表示 DataFrame

沿其填充缺失值的轴。对于 Series，此参数未使用，默认为 0。

inplacebool，默认值 False

如果为 True，则就地填写。注意：这将修改任何此对象的其他视图（例如，A 中的列的无复制切片） DataFrame）。

limitint，默认 None

如果指定了 method，则这是最大连续数 NaN 值向前/向后填充。换句话说，如果有超过此连续 NaN 数的差距，它只会部分填充。如果未指定 method，则为沿 NaN 所在的整个轴的最大条目数㿙。如果不是 None，则必须大于 0。

downcastdict，默认值为 None

如果可能的话，要放下什么的 item->dtype 的字典，或字符串“infer”，它将尝试向下转换为适当的相等类型（例如，如果可能，则将 float64 更改为 int64）。

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

参数：

axis{0 or 'index'， 1 or 'columns'}，默认 0

确定包含缺失值的行或列是否为删除。

0 或 'index' ：删除包含缺失值的行。

1 或“columns”：删除包含缺失值的列。

只允许使用一个轴。

how{'any'， 'all'}，默认 'any'

确定是否从 DataFrame 中删除行或列，当我们有至少一个 NA 或所有 NA。

'any' ：如果存在任何 NA 值，请删除该行或列。

'all' ：如果所有值都是 NA，则删除该行或该列。

threshint，可选

需要许多非 NA 值。不能与如何结合。

子集列标签或标签序列，可选

要考虑的其他轴上的标签，例如，如果您要删除行这些将是要包含的列列表。

inplacebool，默认值 False

是否修改 DataFrame 而不是创建新 DataFrame。

ignore_index布尔值，默认

如果，则生成的轴将被标记为 0， 1， ...， n - 1。True

例子：fillna()

建立列表

df = pd.DataFrame([[np.nan, 2, np.nan, 0],
                   [3, 4, np.nan, 1],
                   [np.nan, np.nan, np.nan, np.nan],
                   [np.nan, 3, np.nan, 4]],
                  columns=list("ABCD"))

df
     A    B   C    D
0  NaN  2.0 NaN  0.0
1  3.0  4.0 NaN  1.0
2  NaN  NaN NaN  NaN
3  NaN  3.0 NaN  4.0

将所有 NaN 元素替换为 0

df.fillna(0)

     A    B    C    D
0  0.0  2.0  0.0  0.0
1  3.0  4.0  0.0  1.0
2  0.0  0.0  0.0  0.0
3  0.0  3.0  0.0  4.0

将“A”、“B”、“C”和“D”列中的所有 NaN 元素替换为 0，1， 2 ， 3。

values = {"A": 0, "B": 1, "C": 2, "D": 3}
df.fillna(value=values)
     A    B    C    D

0  0.0  2.0  2.0  0.0
1  3.0  4.0  2.0  1.0
2  0.0  1.0  2.0  3.0
3  0.0  3.0  2.0  4.0

用缺失值前面的有效值来从前往后填充：

df.fillna(method='ffilll')

例子:dropna()

df = pd.DataFrame({"name": ['Alfred', 'Batman', 'Catwoman'],
                   "toy": [np.nan, 'Batmobile', 'Bullwhip'],
                   "born": [pd.NaT, pd.Timestamp("1940-04-25"),
                            pd.NaT]})

df
       name        toy       born
0    Alfred        NaN        NaT
1    Batman  Batmobile 1940-04-25
2  Catwoman   Bullwhip        NaT

删除缺少至少一个元素的行

df.dropna()

     name        toy       born
1  Batman  Batmobile 1940-04-25

删除缺少至少一个元素的列

df.dropna(axis='columns')

       name
0    Alfred
1    Batman
2  Catwoman

或者是axis=1

删除缺少所有元素的行（how参数默认是any，即有NaN就删除该行）

df.dropna(how='all')

       name        toy       born
0    Alfred        NaN        NaT
1    Batman  Batmobile 1940-04-25
2  Catwoman   Bullwhip        NaT

仅保留至少具有 2 个非 NA 值的行

df.dropna(thresh=2)

       name        toy       born
1    Batman  Batmobile 1940-04-25
2  Catwoman   Bullwhip        NaT

2.2 重复值观察与处理

2.2.1查看数据中的重复值

函数：

duplicated（subset=None， keep='first'）

子集列标签或标签序列，可选

仅考虑某些列来识别重复项，通过默认使用所有列。

保持{'first'， 'last'， False}，默认为 'first'

确定要标记的重复项（如果有）。

first：将重复项标记为除第一次出现项外。True

last：将重复项标记为除上次出现项外。True

False ：将所有重复项标记为。True

df.duplicated(keep=False) （设置为 False，则所有重复项均为 True。）

df = pd.DataFrame({
    'brand': ['Yum Yum', 'Yum Yum', 'Indomie', 'Indomie', 'Indomie'],
    'style': ['cup', 'cup', 'cup', 'pack', 'pack'],
    'rating': [4, 4, 3.5, 15, 5]
})
df
    brand style  rating
0  Yum Yum   cup     4.0
1  Yum Yum   cup     4.0
2  Indomie   cup     3.5
3  Indomie  pack    15.0

df.duplicated(keep=False)
0     True
1     True
2    False
3    False
dtype: bool

df.duplicated(keep='last') （每组重复值的最后一次出现 设置为 False，所有其他设置为 True。）

df.duplicated(keep='last')

0     True
1    False
2    False
3    False
4    False
dtype: bool

df.duplicated(subset=['brand']) （查找特定列的重复项）

df.duplicated(subset=['brand'])

0    False
1     True
2    False
3     True
4     True
dtype: bool

2.2.2对重复项进行处理

函数：

drop_duplicates（*， keep='first'， inplace=False， ignore_index=False)

参数：

keep{'first'， 'last'， }，默认 'first'

处理删除重复项的方法：

'first' ：删除除第一次出现之外的重复项。

'last' ：删除除上次出现项之外的重复项。

False：删除所有重复项。

就地布尔，默认

如果，则就地执行操作并返回 None。True

ignore_index布尔值，默认

如果，则生成的轴将被标记为 0， 1， ...， n - 1。True

可以使用data.drop_duplicates(subset='label'）指定去除某一列的重复值

data.drop_duplicates(subset='label')

Out[20]: 
  label  num
0     a    1
2     b    1

s.drop_duplicates(keep=False) (参数“keep”的值将丢弃所有 重复的条目)

s.drop_duplicates(keep=False)


1       cow
3    beetle
5     hippo
Name: animal, dtype: object

2.3特征值的观察与处理

2.3.1分箱操作

分箱是一种常见的数据预处理技术，有时也被称为 分桶或 离散化，可用于将连续数据的间隔分组到“箱”或“桶”中，也就是将连续数据进行离散化。

函数：

pandas.cut(x, bins, right=True, labels=None, retbins=False, precision=3, include_lowest=False, duplicates='raise', ordered=True) (其中x为类似列阵)

等宽法：离散化后的每个区间的差值相等。

将数组分为三个部分：并用变量表示区间离散化处理（）

pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3)


[(0.994, 3.0], (5.0, 7.0], (3.0, 5.0], (3.0, 5.0], (5.0, 7.0], ...
Categories (3, interval[float64, right]): [(0.994, 3.0] < (3.0, 5.0] ...

将数据以变量区间形式离散化表示：

Age = tcs['Age']
Age

0      22.0
1      38.0
2      26.0
3      35.0
4      35.0
       ... 
886    27.0
887    19.0
888     NaN
889    26.0
890    32.0
Name: Age, Length: 891, dtype: float64

pd.cut(Age,[0,5,15,30,50,80],[1,2,3,4,5])

0      (15.0, 30.0]
1      (30.0, 50.0]
2      (15.0, 30.0]
3      (30.0, 50.0]
4      (30.0, 50.0]
           ...     
886    (15.0, 30.0]
887    (15.0, 30.0]
888             NaN
889    (15.0, 30.0]
890    (30.0, 50.0]
Name: Age, Length: 891, dtype: category
Categories (5, interval[int64, right]): [(0, 5] < (5, 15] < (15, 30] < (30, 50] < (50, 80]]

函数：

qcut
用处：
根据秩或样本分位数将变量离散到大小相等的桶中
q= 分位数，整数（10 十分位数）小数（0.25四分位数）

#将连续变量Age按10% 30% 50% 70% 90%五个年龄段，并用分类变量12345表示

qcut = pd.qcut(Age,[0,0.1,0.3,0.5,0.7,0.9],[1,2,3,4,5])#写入代码
qcut

0        2
1        5
2        3
3        4
4        4
      ... 
886      3
887      2
888    NaN
889      3
890      4
Name: Age, Length: 891, dtype: category
Categories (5, int64): [1 < 2 < 3 < 4 < 5]

2.3.2对文本变量进行转换

数据有两种类型，文本类型和数值类型，数值型特征一般可以直接用于模型的训练，文本型特征往往需要转换成数值型特征才能用于建模分析。

方法一：replace

series.replace([代替换值],[替换值])

方法二：one-hot

pandas.get_dummies(data, prefix=None, prefix_sep='_', dummy_na=False, columns=None, sparse=False, drop_first=False, dtype=None)

s = pd.Series(list('abca'))  
pd.get_dummies(s)

       a      b      c
0   True  False  False
1  False   True  False
2  False  False   True

qwerqwer233sjjss

关注

23
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
2.pandas 的数据清洗及特征处理

缺失值：我们拿到的数据通常是不干净的，所谓的不干净，就是数据中有缺失值，有一些异常点等，需要经过一定的处理才能继续做后面的分析或建模，所以拿到数据的第一步是进行数据清洗，即缺失值、重复值、字符串和数据转换等操作，将数据清洗成可以分析或建模的样子。如果可能的话，要放下什么的 item->dtype 的字典，或字符串“infer”，它将尝试向下转换为适当的相等类型（例如，如果可能，则将 float64 更改为 int64）。如果，则生成的轴将被标记为 0， 1， ...， n - 1。
复制链接

扫一扫