利用Python进行数据分析之数据清洗

在进行数据分析和建模的过程中，数据的清洗和准备是后续工作能够顺利开展的保障，包括数据加载、清理、转换和重新排列，可能占分析师80%以上的时间。数据清洗的过程中需要掌握对缺失值、重复值、字符串的操作，并掌握其他分析数据转换的工具。

处理缺失值

缺失数据在很多数据分析应用中出现，当清洗数据用于分析时，对缺失数据进行分析以确定数据收集问题或数据丢失导致的数据偏差通常也很重要。

pandas中对缺失值的处理方法归纳如下：

函数名 描述
dropna 根据参数丢弃缺失值所在的行/列
fillna 用某些值填充缺失的数据或插值(如：’ffill’或’bfill’)
isnull 返回表明哪些值是缺失值
notnull isnull的反函数

过滤缺失值

过滤缺失值的方法有很多种，常用的如下：

  1. 使用pd.isnull和布尔值索引过滤缺失值

    1
    2
    3
    4
    5
    6
    import numpy as np
    import pandas as pd

    data = pd.Series([1, np.nan, 3.5, np.nan, 7])
    cleaned = data[data.notnull()]
    print(cleaned)

  2. 使用pd.dropna过滤缺失值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    import numpy as np
    import pandas as pd

    data = pd.DataFrame([[1., 6.5, 3.], [1., np.nan, np.nan], [
                        np.nan, np.nan, np.nan], [np.nan, 6.5, 3.]])
    # 默认删除包含NA值的行
    cleaned = data.dropna()
    print(cleaned)

    # 删除所有值都是NA的行
    cleaned = data.dropna(how='all')
    print(cleaned)

    # 删除包含NA的列
    cleaned = data.dropna(axis=1,how='all')
    print(cleaned)

    # 删除NA值，剩余数值的数量大于等于n
    cleaned = data.dropna(thresh=1)
    print(cleaned)

补全缺失值

主要使用fillna方法补全缺失值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np
import pandas as pd

data = pd.DataFrame([[1., 6.5, 3.], [1., np.nan, np.nan], [
                    np.nan, np.nan, np.nan], [np.nan, 6.5, 3.]])
# 使用常数填充缺失值
data1 = data.fillna(0)
print(data1)

# 使用字典为不同列设定不同的填充值
data2 = data.fillna({0:0,1:1,2:2})
print(data2)

# 用插值方法填充缺失值
data3 = data.fillna(method='ffill')
print(data3)

# 用函数值填充缺失值
data4 = data.fillna(data.mean())
print(data4)

fillna函数参数整理：

参数 描述
value 标量值或字典对象，用于填充缺失值
method 插值方法，默认是’ffill’
axis 填充的轴，默认是axis=0
inplace 修改被调用的对象，默认是False
limit 用于前向或后向填充时，最大的填充范围

数据转换

数据转换是数据过滤、清洗中的重要操作。

删除重复值

duplicated方法返回一个布尔值Series，反映每个行是否存在重复，drop_duplicates方法返回DataFrame，内容是duplicated方法返回数组中的False部分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import numpy as np
import pandas as pd

def prints(a):
    print(a)
    print('='*30)

data = pd.DataFrame(
    {'k1': ['one', 'two']*3 + ['two'], 'k2': [1, 1, 2, 3, 3, 4, 4]})
prints(data)

# 检查是否有重复值
prints(data.duplicated())

# 默认按照全列数据判断重复
prints(data.drop_duplicates())

data['v1'] = range(7)
prints(data)
# 按照指定列判断重复
prints(data.drop_duplicates(['k1']))

使用函数或映射进行数据转换

基于DataFrame中的数组、列或列中的数值进行一些转换，可以利用map函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 给每种水果加上分类数据
import numpy as np
import pandas as pd

def prints(a):
    print(a)
    print('='*30)

data = pd.DataFrame({'food': ['Apple', 'banana', 'orange',
                    'apple', 'mango', 'tomato'], 'price': [4, 3, 3.5, 6, 12, 3]})
prints(data)

# 利用映射/字典
meat = {'apple': 'fruit', 'banana': 'fruit',
        'orange': 'fruit', 'mango': 'fruit', 'tomato': 'vagetable'}

# 全部改为小写字母
low = data['food'].str.lower()

# 映射，类似于vlookup
data['class'] = low.map(meat)
prints(data)

# 利用函数
data['class1'] = data['food'].map(lambda x: meat[x.lower()])
prints(data)

替代值

当数据中包含异常值，如数值偏离大部分其他数据，为方便数据分析，可以使用replace函数将异常值替换成其他正常值或空值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import numpy as np
import pandas as pd

def prints(a):
    print(a)
    print('='*30)

data = pd.Series([1, -999, 2, -1000, 3, -999, -999])
prints(data)

# 替换单个异常值
prints(data.replace(-999, np.nan))

# 修改多个异常值
prints(data.replace([-999, -1000], np.nan))

# 用列表的方式修改多个异常值为不同值
prints(data.replace([-999, -1000], [np.nan, 0]))

# 用字典的方式修改多个异常值为不同值
prints(data.replace({-999: np.nan, -1000: 0}))

重命名轴索引

数据清洗过程中可能需要对轴标签进行转换，轴索引也有一个map方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import numpy as np
import pandas as pd

def prints(a):
    print(a)
    print('='*30)

data = pd.DataFrame(np.arange(12).reshape((3, 4)), 
                    index=['Beijing', 'Tokyo', 'New York'], 
                    columns=['one', 'two', 'three', 'four'])
prints(data)

# 重新索引 reindex
prints(data.reindex(['Beijing', 'New York', 'Tokyo']))

# index.map 在原有的数据集上修改
def tran(x): return x[:].upper()

data.index = data.index.map(tran)
prints(data)

# rename 不修改原有的数据集
prints(data.rename(index=str.title, columns=str.upper))
prints(data.rename(index={'BEIJING': 'Beij', 'TOKYO': 'Toky', 'NEW YORK': 'Newy'}, 
                   columns={'one': '1', 'two': '2', 'three': '3', 'four': '4'}))

离散化和分箱

连续值经常需要离散化，或者分离成“箱子”进行分析。

假设有某项研究中的一组人群数据，需要将他们进行分组，放入离散的年龄框中，为实现这个，可以使用cut函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import numpy as np
import pandas as pd

def prints(a):
    print(a)
    print('='*30)

# 用户的年龄数据
ages = [20,22,25,27,21,23,37,31,61,45,41,32]
# 需要成的组
bins = [18,25,35,60,100]
# 进行分箱操作，注意'[]'表示闭区间，'()'表示开区间
cats = pd.cut(ages,bins)
prints(cats)
prints(cats.codes)
prints(cats.categories)
# 分组计数
prints(pd.value_counts(cats))
# 给每个组设定名称
names = ['青年','壮年','中年','老年']
cats = pd.cut(ages,bins,labels=names)
# 分组计数
prints(pd.value_counts(cats))

# 正态分布样本
data = np.random.rand(20)
# 从最小值到最大值等长分成4组,保留2位小数
cats1 = pd.cut(data,4,precision=2)
prints(pd.value_counts(cats1))

# qcut函数
data1 = np.random.rand(1000)
# 按照数量相等，均分成4组
cats2 = pd.qcut(data1,4)
prints(pd.value_counts(cats2))
# 按照步长，分组
cats3 = pd.qcut(data1,[0,0.1,0.5,0.9,1])
prints(pd.value_counts(cats3))

检测和过滤异常值

过滤和转换异常值可以使用any函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import numpy as np
import pandas as pd

def prints(a):
    print(a)
    print('='*30)

data = pd.DataFrame(np.random.randn(1000,4))
# 1000行数据全部取出来
prints(data[(np.abs(data)>3)]) 
# 仅取出含有绝对值大于3的行
prints(data[(np.abs(data)>3).any(1)])
# 将绝对值大于3的值都修改成3
data[np.abs(data)>3] = 3
prints(data.describe())

置换和随机抽样

置换可使用np.random.permutation对DataFrame中的Series或行进行操作(随机重排序)。利用np.random.permutation生成的随机数组要与想要排序的轴长度相等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import numpy as np
import pandas as pd

def prints(a):
    print(a)
    print('='*30)

# 创建有规律的df
df = pd.DataFrame(np.arange(20).reshape((5,4)))
prints(df)
# 定义随机数组
sam = np.random.permutation(5)
prints(sam)
# 按照随机数组，随机排列
prints(df.take(sam))

# 从df中随机选取3行样本，且顺序随机
prints(df.sample(n=3))

ch = pd.Series([5,7,1,6,3])
prints(ch)
prints(ch.sample(n=10,replace=True)) # 允许重复选择

计算指标/虚拟变量

将分类变量转换为“虚拟”或“指标”矩阵是一种用于统计建模或机器学习的转换操作。如果DataFrame中的一列有k个不同的值，则可以衍生出一个k列的值为0和1的矩阵，利用get_dummies函数实现这个功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
import numpy as np
import pandas as pd

# 定义一个df
df = pd.DataFrame({'key':['b','b','a','c','a','b'],'data1':[range(6)]})
print(df)
print(pd.get_dummies(df['key']))

# 在指标矩阵的列上加入前缀
dummies = pd.get_dummies(df['key'],prefix='key')
# 与原数据集合并
df_with_dummy = df[['data1']].join(dummies)
print(df_with_dummy)

将get_dummies与cut等离散化函数结合使用时统计应用等一个常用办法：

1
2
3
4
5
6
7
8
9
10
11
12
import numpy as np
import pandas as pd

# 生成一个随机种子
np.random.seed(12345)
# 生成随机数
values = np.random.rand(10)
print(values)
# 设定离散分组
bins = [0,0.2,0.4,0.6,0.8,1]
# 结合使用，统计在不同区间内数据的散落情况
print(pd.get_dummies(pd.cut(values,bins)))

字符串操作

字符串对象的内建方法使得大部分文本操作非常简单。pandas允许将字符串和正则表达式简洁地应用到整个数据数组上，此外还能处理数据缺失带来的困扰。

字符串对象方法

很多字符串处理和脚本应用中，内建的字符串方法是足够的：

  • 一个逗号分隔的字符串可以使用split方法拆成多块
  • split常和strip一起使用，用于清除空格和换行符
  • 字符串可以使用加号连接在一起，但着并不是一个通用方法。在字符串’::’的join方法中传入一个列表或元组是一种更快速且更加Pythonic的方法
  • 使用Python的in关键字检测子字符串的最佳方法
  • index在字符串没有找到是会抛出异常，而find则返回-1
  • count返回某个特定子字符串在字符串中出现的次数
  • replace用一种模式替代另一种模式，通常也可以传入空字符串来删除某个模式

Python内建字符串方法汇总：

函数名 描述
count 返回子字符串在字符串中非重叠出现次数
endswith 如果字符串以后缀结尾则返回True
startswith 如果字符串以前缀开始则返回True
join 使用字符串作为间隔符，用于粘合其他字符串
index 如果在字符串中找到，则返回子字符串中第一个字符的位置；如果找不到则引发ValueError
find 如果在字符串中找到，则返回子字符串中第一个字符的位置；如果找不到则返回-1
rfind 如果在字符串中找到，则返回子字符串中第一个字符最后出现的位置；如果找不到则返回-1
replace 使用一个字符串替代另一个字符串
strip, strip, lstrip 修剪空白，包括换行符；相当于对每个元素进行x.strip()
split 使用分隔符将字符串拆分为子字符串的列表
lower 将大写字母转换为小写字母
upper 将小写字母转换为大写字母
casefold 将字符转换为小写，并将任何特定于区域的变量字符组合转换为常见的可比较形式
ljust, rjust 左对齐或右对齐；用空格(其他字符)填充字符串的相反侧，以返回具有最小宽度的字符串

正则表达式

正则表达式提供了一种在文本中灵活查找或匹配字符串模式的方法。Python中内建的re模块是用于将正则表达式应用到字符串上的库。re模块主要有三个主题：模式匹配、替代、拆分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import numpy as np
import pandas as pd
import re

def prints(a):
    print(a)
    print('='*30)

text = "foo bar\t bat \tqq"
prints(text)
prints(re.split('\s+',text))

# 编译正则表达式对象，形成一个可复用的正则表达式对象
# 这样做有利于节约CPU周期
res = re.compile('\s+')
prints(res.split(text))

reg = re.split(res,text)
prints(reg)

# 查找匹配
prints(res.findall(text))
prints(re.findall(res,text))

# 替换
prints(re.sub(res,'9',text))

t1 = re.match('f',text)
prints(t1)
# group方法返回的是模式组件的元组
prints(t1.group())

prints(re.search('b',text).group())

正则表达式的方法如下：

函数名 描述
findall 将字符串中所有的非重叠匹配模式以列表形式返回
finditer 与findall类似，但返回的是迭代器
match 在字符串起始位置匹配，也可以将模式组建匹配到分组中；如果模式匹配上了，返回一个匹配对象，否则返回None
search 扫描字符串的匹配模式，如果扫描到了返回匹配对象，与match方法不同的是，search方法的匹配可以是字符串的任意位置，而不仅仅是字符串开头
split 根据模式，将字符串拆分为多个部分
sub, subn 用替换表达式替换字符串中所有的匹配(sub)或第n个出现的匹配串(subn)

正则表达式模式字符串使用特殊的语法来表示一个正则表达式：

字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。

多数字母和数字前加一个反斜杠时会拥有不同的含义。

标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。

反斜杠本身需要使用反斜杠转义。

由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r’\t’，等价于 ‘\t’)匹配相应的特殊字符。

下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。

模式 描述
^ 匹配字符串的开头
$ 匹配字符串的末尾。
. 匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[…] 用来表示一组字符,单独列出：[amk] 匹配 ‘a’，’m’或’k’
[^…] 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re* 匹配0个或多个的表达式。
re+ 匹配1个或多个的表达式。
re? 匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n} 精确匹配 n 个前面表达式。例如， o{2} 不能匹配 “Bob” 中的 “o”，但是能匹配 “food” 中的两个 o。
re{ n,} 匹配 n 个前面表达式。例如， o{2,} 不能匹配”Bob”中的”o”，但能匹配 “foooood”中的所有 o。”o{1,}” 等价于 “o+”。”o{0,}” 则等价于 “o*”。
re{ n, m} 匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a| b 匹配a或b
(re) 对正则表达式分组并记住匹配的文本
(?imx) 正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx) 正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re) 类似 (…), 但是不表示一个组
(?imx: re) 在括号中使用i, m, 或 x 可选标志
(?-imx: re) 在括号中不使用i, m, 或 x 可选标志
(?#…) 注释.
(?= re) 前向肯定界定符。如果所含正则表达式，以 … 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re) 前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re) 匹配的独立模式，省去回溯。
\w 匹配字母数字及下划线
\W 匹配非字母数字及下划线
\s 匹配任意空白字符，等价于 **[ \t\n\r\f]**。
\S 匹配任意非空字符
\d 匹配任意数字，等价于 [0-9].
\D 匹配任意非数字
\A 匹配字符串开始
\Z 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
\z 匹配字符串结束
\G 匹配最后匹配完成的位置。
\b 匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配”never” 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。
\B 匹配非单词边界。’er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。
\n, \t, 等. 匹配一个换行符。匹配一个制表符。等
\1…\9 匹配第n个分组的内容。
\10 匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

向量化字符串函数

清理杂乱的数据集用于分析时，通常需要大量的字符串处理和正则化，可以使用pd.map方法将字符串和有效的正则表达式方法应用到每个值上，但是在NA值上会失败，为了解决这个问题，Series有面向数组的方法用于跳过NA值的字符串操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import numpy as np
import pandas as pd

def prints(a):
    print(a)
    print('='*30)

data = {'a':'dave@qq.com','b':'steve@gmail.com','c':'sam@gmail.com','d':np.nan}
prints(data)
data = pd.Series(data)
prints(data)
prints(data.isnull())
prints(data.str.contains('gmail'))
prints(data.str.split('@'))
prints(data.str.findall('@'))
prints(data.str[:5])

# 直接运行以下代码会报错
# data.map(lambda x :x.split('@'))

部分向量化字符串方法的列表：

函数名 描述
cat 根据可选的分隔符按元素黏合字符串
contains 返回是否含有某个模式/正则表达式的布尔值数组
count 模式出现次数的计数
extract 使用正则表达式从字符串Series中分组抽取一个或多个字符串；返回的结果是每个分组形成一列的DataFrame
endswith 等价于对每个元素使用x.endwith(模式)
startswith 等价于对每个元素使用x.startwith(模式)
findall 找出字符串中所有的模式/正则表达式匹配项，以列表返回
get 对每个元素进行索引(获得第i个元素)
isalnum 等价于内建的str.alnum
isalhpa 等价于内建的str.isalhpa
isdecimal 等价于内建的str.isdecimal
isdigit 等价于内建的str.isdigit
islower 等价于内建的str.islower
isnumeric 等价于内建的str.isnumeric
isupper 等价于内建的str.isupper
join 根据传递的分隔符，将Series中的字符串联合
len 计算每个字符串的长度
lower, upper 转换大小写；等价于对每个元素进行x.lower()/x.upper()
match 使用re.match将正则表达式应用到每个元素上，将匹配分组以列表形式返回
pad 将空白加到字符串的左边、右边或两边
center 等价于pad(side=’both’)
repeat 重复值(例如s.str.repeat(3)等价于对每个字符串进行x*3)
replace 以其他字符串替代模式/正则表达式的匹配项
slice 对Series中的字符串进行切片
split 以分隔符或正则表达式对字符串进行拆分
strip 对字符串两边空白进行消除，包括换行符
rstrip 消除字符串右边的空白
lstrip 消除字符串左边的空白

关于正则表达式的其他基础学习可以查看菜鸟教程-正则表达式。

赏

谢谢你请我吃糖果

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

萌新伊始<br><br>把这里作为记录学习和成长的平台<br><br>如果您觉得不错<br><br>可以请我喝杯咖啡☕️<br>