Data Cleaning and Preparation 数据清洗和准备
修改之后,增加代码,注释
xiaoyao
# 导入package
import numpy as np
import pandas as pd
# 设置数据显示行数
PREVIOUS_MAX_ROWS = pd.options.display.max_rows
pd.options.display.max_rows = 20
# 生成随机数种子
np.random.seed(12345)
import matplotlib.pyplot as plt
plt.rc('figure', figsize=(10, 6))
np.set_printoptions(precision=4, suppress=True)# 忽略警告
import warnings
warnings.filterwarnings('ignore')
Handling Missing Data 处理缺失数据
pandas对象的所有描述性统计默认都不包括缺失数据。pandas使用浮点值NaN(Not a Number)表示缺失数据。
string_data = pd.Series(['aardvark', 'artichoke', np.nan, 'avocado'])
string_data
0 aardvark
1 artichoke
2 NaN
3 avocado
dtype: object
# values为null,则结果为True
string_data.isnull()
0 False
1 False
2 True
3 False
dtype: bool
在pandas中,采用的是R语言中的惯用法,将缺失值表示为NA,他表示不可用not available.在统计应用中,NA数据可能是不存在的数据或者虽然存在,但是没有观察到(例如,数据采集中发生了问题)。
- 当进行数据清洗以进行分析的时候,最好直接对缺失数据进行分析,从而判断数据采集的问题或者缺失数据可能导致的偏差。
- python内置的None值在对象数组中也可以作为NA
string_data
0 aardvark
1 artichoke
2 NaN
3 avocado
dtype: object
string_data.isnull()
0 False
1 False
2 True
3 False
dtype: bool
# 这里,None值也可以作为NA
string_data[0] = None
string_data.isnull()
0 True
1 False
2 True
3 False
dtype: bool
一些关于缺失数据处理的函数
方法
|
说明
|
dropna
|
根据各标签的值中是否存在缺失数据对轴标签进行过滤,可以通过阈值调节对缺失值的容忍度
|
fillna
|
用指定值或者插值方法(如ffill或者bfill)填充确实数据
|
isnull
|
返回一个含有布尔值的对象,这些布尔值表示哪些值为缺失值NA,该对象的类型与源类型一样
|
notnull
|
这个是isnull的否定形式
|
Filtering Out Missing Data 滤除缺失数据
过滤掉缺失数据的方式有很多种。可以通过pandas.isnull或者布尔索引的方式,但dropna可能会更加实用。对于一个Series,dropna返回一个仅仅含有非空数据和索引值的Series:
from numpy import nan as NA
data = pd.Series([1, NA, 3.5, NA, 7])
data.dropna()
0 1.0
2 3.5
4 7.0
dtype: float64
# 上述操作等价于,采用布尔索引
data[data.notnull()]
0 1.0
2 3.5
4 7.0
dtype: float64
对于DataFrame对象,事情变得不一样。他这里默认丢弃任何含有缺失值的行。
data = pd.DataFrame([[1., 6.5, 3.], [1., NA, NA],[NA, NA, NA], [NA, 6.5, 3.]])
cleaned = data.dropna()
data
|
0
|
1
|
2
|
0
|
1.0
|
6.5
|
3.0
|
1
|
1.0
|
NaN
|
NaN
|
2
|
NaN
|
NaN
|
NaN
|
3
|
NaN
|
6.5
|
3.0
|
cleaned
# 传入how='all'将仅仅丢弃全部都是NA的那些行
data.dropna(how='all')
|
0
|
1
|
2
|
0
|
1.0
|
6.5
|
3.0
|
1
|
1.0
|
NaN
|
NaN
|
3
|
NaN
|
6.5
|
3.0
|
data
|
0
|
1
|
2
|
0
|
1.0
|
6.5
|
3.0
|
1
|
1.0
|
NaN
|
NaN
|
2
|
NaN
|
NaN
|
NaN
|
3
|
NaN
|
6.5
|
3.0
|
# 采用这种方式丢弃列,只需要传入axis=1就可以了
data[4] = NA
data
|
0
|
1
|
2
|
4
|
0
|
1.0
|
6.5
|
3.0
|
NaN
|
1
|
1.0
|
NaN
|
NaN
|
NaN
|
2
|
NaN
|
NaN
|
NaN
|
NaN
|
3
|
NaN
|
6.5
|
3.0
|
NaN
|
# 删除全为NaN的列
data.dropna(axis=1, how='all')
|
0
|
1
|
2
|
0
|
1.0
|
6.5
|
3.0
|
1
|
1.0
|
NaN
|
NaN
|
2
|
NaN
|
NaN
|
NaN
|
3
|
NaN
|
6.5
|
3.0
|
另外一个滤除DataFrame行的问题所涉及时间序列数据。加入我只想留下一部分观测数据,可以采用thresh参数实现此目的。
df = pd.DataFrame(np.random.randn(7, 3))
df
|
0
|
1
|
2
|
0
|
0.476985
|
3.248944
|
-1.021228
|
1
|
-0.577087
|
0.124121
|
0.302614
|
2
|
0.523772
|
0.000940
|
1.343810
|
3
|
-0.713544
|
-0.831154
|
-2.370232
|
4
|
-1.860761
|
-0.860757
|
0.560145
|
5
|
-1.265934
|
0.119827
|
-1.063512
|
6
|
0.332883
|
-2.359419
|
-0.199543
|
df[0]
0 0.476985
1 -0.577087
2 0.523772
3 -0.713544
4 -1.860761
5 -1.265934
6 0.332883
Name: 0, dtype: float64
df.iloc[:4, 1] = NA
df.iloc[:2, 2] = NA
df
|
0
|
1
|
2
|
0
|
0.476985
|
NaN
|
NaN
|
1
|
-0.577087
|
NaN
|
NaN
|
2
|
0.523772
|
NaN
|
1.343810
|
3
|
-0.713544
|
NaN
|
-2.370232
|
4
|
-1.860761
|
-0.860757
|
0.560145
|
5
|
-1.265934
|
0.119827
|
-1.063512
|
6
|
0.332883
|
-2.359419
|
-0.199543
|
# 默认还是删除,任何含有NaN的行
df.dropna()
|
0
|
1
|
2
|
0
|
0.476985
|
3.248944
|
-1.021228
|
1
|
-0.577087
|
0.124121
|
0.302614
|
2
|
0.523772
|
0.000940
|
1.343810
|
3
|
-0.713544
|
-0.831154
|
-2.370232
|
4
|
-1.860761
|
-0.860757
|
0.560145
|
5
|
-1.265934
|
0.119827
|
-1.063512
|
6
|
0.332883
|
-2.359419
|
-0.199543
|
df.dropna(thresh=2)
|
0
|
1
|
2
|
0
|
0.476985
|
3.248944
|
-1.021228
|
1
|
-0.577087
|
0.124121
|
0.302614
|
2
|
0.523772
|
0.000940
|
1.343810
|
3
|
-0.713544
|
-0.831154
|
-2.370232
|
4
|
-1.860761
|
-0.860757
|
0.560145
|
5
|
-1.265934
|
0.119827
|
-1.063512
|
6
|
0.332883
|
-2.359419
|
-0.199543
|
Filling In Missing Data 填充缺失数据
不滤除缺失数据,我希望通过其他的方法来填补这些“空洞”,对于大多数情况而言,fillna方法是主要的函数。通过一个常数
调用fillna就会将缺失值替换为那个常数值:
df
|
0
|
1
|
2
|
0
|
0.476985
|
NaN
|
NaN
|
1
|
-0.577087
|
NaN
|
NaN
|
2
|
0.523772
|
NaN
|
1.343810
|
3
|
-0.713544
|
NaN
|
-2.370232
|
4
|
-1.860761
|
-0.860757
|
0.560145
|
5
|
-1.265934
|
0.119827
|
-1.063512
|
6
|
0.332883
|
-2.359419
|
-0.199543
|
df.fillna(0)
|
0
|
1
|
2
|
0
|
0.476985
|
0.000000
|
0.000000
|
1
|
-0.577087
|
0.000000
|
0.000000
|
2
|
0.523772
|
0.000000
|
1.343810
|
3
|
-0.713544
|
0.000000
|
-2.370232
|
4
|
-1.860761
|
-0.860757
|
0.560145
|
5
|
-1.265934
|
0.119827
|
-1.063512
|
6
|
0.332883
|
-2.359419
|
-0.199543
|
# 若是通过一个字典调用fillna,就可以实现对不同列填充不同的值:
df.fillna({1: 0.5, 2: 0})
|
0
|
1
|
2
|
0
|
0.476985
|
0.500000
|
0.000000
|
1
|
-0.577087
|
0.500000
|
0.000000
|
2
|
0.523772
|
0.500000
|
1.343810
|
3
|
-0.713544
|
0.500000
|
-2.370232
|
4
|
-1.860761
|
-0.860757
|
0.560145
|
5
|
-1.265934
|
0.119827
|
-1.063512
|
6
|
0.332883
|
-2.359419
|
-0.199543
|
fillna默认会返回新对象,但是也可以实现对现有的对象进行就地修改
_ = df.fillna(0, inplace=True)
df
|
0
|
1
|
2
|
0
|
0.476985
|
0.000000
|
0.000000
|
1
|
-0.577087
|
0.000000
|
0.000000
|
2
|
0.523772
|
0.000000
|
1.343810
|
3
|
-0.713544
|
0.000000
|
-2.370232
|
4
|
-1.860761
|
-0.860757
|
0.560145
|
5
|
-1.265934
|
0.119827
|
-1.063512
|
6
|
0.332883
|
-2.359419
|
-0.199543
|
# 对reindexing有效的那些插值方法也可以用于fillna
df = pd.DataFrame(np.random.randn(6, 3))
df
|
0
|
1
|
2
|
0
|
0.862580
|
-0.010032
|
0.050009
|
1
|
0.670216
|
0.852965
|
-0.955869
|
2
|
-0.023493
|
-2.304234
|
-0.652469
|
3
|
-1.218302
|
-1.332610
|
1.074623
|
4
|
0.723642
|
0.690002
|
1.001543
|
5
|
-0.503087
|
-0.622274
|
-0.921169
|
df.iloc[2:, 1] = NA
df.iloc[4:, 2] = NA
df
|
0
|
1
|
2
|
0
|
0.862580
|
-0.010032
|
0.050009
|
1
|
0.670216
|
0.852965
|
-0.955869
|
2
|
-0.023493
|
NaN
|
-0.652469
|
3
|
-1.218302
|
NaN
|
1.074623
|
4
|
0.723642
|
NaN
|
NaN
|
5
|
-0.503087
|
NaN
|
NaN
|
# 传入Series的平均值或者中位数
data = pd.Series([1., NA, 3.5, NA, 7])
data.mean() # 对应于11.5/3
3.8333333333333335
# 将缺失值填充为均值
data.fillna(data.mean())
0 1.000000
1 3.833333
2 3.500000
3 3.833333
4 7.000000
dtype: float64
关于fillna参数的说明
|
|
value
|
用于填充缺失值的标量值或者字典对象
|
method
|
插值方式,如果函数调用时候没有进行指定,则默认为“ffill”
|
axis
|
待填充的轴,默认为axis=0
|
inplace
|
修改调用者对象而不产生副本,就地修改
|
limit
|
(对于前向和后向填充)可以连续填充的最大数量
|
Data Transformation 数据转换
到此之前都是进行的为:数据的重排,另一类重要的操作为:通过过滤,清理以及其他的转换工作。
Removing Duplicates 移除重复的数据
# DataFrame中设置出现重复的行# ‘k1’,'k2'为列索引,其中,‘k1’对应的值为:“one, two ”,同时重复三次,最后加上一个'two'
data = pd.DataFrame({'k1': ['one', 'two'] * 3 + ['two'],'k2': [1, 1, 2, 3, 3, 4, 4]})
data
|
k1
|
k2
|
0
|
one
|
1
|
1
|
two
|
1
|
2
|
one
|
2
|
3
|
two
|
3
|
4
|
one
|
3
|
5
|
two
|
4
|
6
|
two
|
4
|
# DataFrame的duplicated方法返回一个布尔型的Series,表示各行是否为重复行(之前是否出现过)
data.duplicated()
0 False
1 False
2 False
3 False
4 False
5 False
6 True
dtype: bool
# 与此对应的为:drop_duplicates方法,他会返回一个DataFrame,重复的数组会被标成False
data.drop_duplicates()
|
k1
|
k2
|
0
|
one
|
1
|
1
|
two
|
1
|
2
|
one
|
2
|
3
|
two
|
3
|
4
|
one
|
3
|
5
|
two
|
4
|
data
|
k1
|
k2
|
0
|
one
|
1
|
1
|
two
|
1
|
2
|
one
|
2
|
3
|
two
|
3
|
4
|
one
|
3
|
5
|
two
|
4
|
6
|
two
|
4
|
# 这两个方法默认会判断全部列,这里可以指定部分列进行重复项进行判断。# 假设现有一列值,且只希望根据k1列过滤重复项data['v1'] = range(7)
data
|
k1
|
k2
|
v1
|
0
|
one
|
1
|
0
|
1
|
two
|
1
|
1
|
2
|
one
|
2
|
2
|
3
|
two
|
3
|
3
|
4
|
one
|
3
|
4
|
5
|
two
|
4
|
5
|
6
|
two
|
4
|
6
|
data.drop_duplicates(['k1'])
|
k1
|
k2
|
v1
|
0
|
one
|
1
|
0
|
1
|
two
|
1
|
1
|
# duplicated和drop_duplicates默认保留的是第一个出现的值组合,这里传入keep = 'last'则默认保留最后一个:
data.drop_duplicates(['k1', 'k2'], keep='last')
|
k1
|
k2
|
v1
|
0
|
one
|
1
|
0
|
1
|
two
|
1
|
1
|
2
|
one
|
2
|
2
|
3
|
two
|
3
|
3
|
4
|
one
|
3
|
4
|
6
|
two
|
4
|
6
|
Transforming Data Using a Function or Mapping
利用函数或者映射进行数据转换
对于许多数据集,可能希望根据数组、Series或者DataFrame列中的值来实现转换工作,我们接下来:
data = pd.DataFrame({'food': ['bacon', 'pulled pork', 'bacon','Pastrami', 'corned beef', 'Bacon','pastrami', 'honey ham', 'nova lox'],'ounces': [4, 3, 12, 6, 7.5, 8, 3, 5, 6]})
data
|
food
|
ounces
|
0
|
bacon
|
4.0
|
1
|
pulled pork
|
3.0
|
2
|
bacon
|
12.0
|
3
|
Pastrami
|
6.0
|
4
|
corned beef
|
7.5
|
5
|
Bacon
|
8.0
|
6
|
pastrami
|
3.0
|
7
|
honey ham
|
5.0
|
8
|
nova lox
|
6.0
|
# 假设要添加一列表示该肉类食物来源的动物类型,先编写一个不同肉类到动物的映射
meat_to_animal = {'bacon': 'pig','pulled pork': 'pig','pastrami': 'cow','corned beef': 'cow','honey ham': 'pig','nova lox': 'salmon'
}
# Series的map方法可以接受一个函数或者含有映射关系的字典型对象,但是这里的问题是:
"""
有些肉类的首字母大写了,而另一些没有,因此,首先调用Series的str.lower方法,将各个值转换为小写:
"""
lowercased = data['food'].str.lower()
lowercased
0 bacon
1 pulled pork
2 bacon
3 pastrami
4 corned beef
5 bacon
6 pastrami
7 honey ham
8 nova lox
Name: food, dtype: object
data['animal'] = lowercased.map(meat_to_animal)
data
|
food
|
ounces
|
animal
|
0
|
bacon
|
4.0
|
pig
|
1
|
pulled pork
|
3.0
|
pig
|
2
|
bacon
|
12.0
|
pig
|
3
|
Pastrami
|
6.0
|
cow
|
4
|
corned beef
|
7.5
|
cow
|
5
|
Bacon
|
8.0
|
pig
|
6
|
pastrami
|
3.0
|
cow
|
7
|
honey ham
|
5.0
|
pig
|
8
|
nova lox
|
6.0
|
salmon
|
也可以传入一个可以完成全部工作的函数,这里使用匿名函数
data['food'].map(lambda x: meat_to_animal[x.lower()])
0 pig
1 pig
2 pig
3 cow
4 cow
5 pig
6 cow
7 pig
8 salmon
Name: food, dtype: object
data
|
food
|
ounces
|
animal
|
0
|
bacon
|
4.0
|
pig
|
1
|
pulled pork
|
3.0
|
pig
|
2
|
bacon
|
12.0
|
pig
|
3
|
Pastrami
|
6.0
|
cow
|
4
|
corned beef
|
7.5
|
cow
|
5
|
Bacon
|
8.0
|
pig
|
6
|
pastrami
|
3.0
|
cow
|
7
|
honey ham
|
5.0
|
pig
|
8
|
nova lox
|
6.0
|
salmon
|
Replacing Values 替换值
利用fillna方法填充缺失数据可以看作是替换值的一种特殊方法。前面已经看到,map可以用于修改对象的数据子集。
而replace则提供了以中国实现该功能的更加简单、灵活的方式。
data = pd.Series([1., -999., 2., -999., -1000., 3.])
data
0 1.0
1 -999.0
2 2.0
3 -999.0
4 -1000.0
5 3.0
dtype: float64
# 这里的-999可以看作是一个表示缺失数据的标记值。将其替换为pandas可以理解的NA值。# 通过使用replace来产生一个崭新的Series(除非传入:inplace=True)
data.replace(-999, np.nan)
0 1.0
1 NaN
2 2.0
3 NaN
4 -1000.0
5 3.0
dtype: float64
# 如果希望一次性替换多个值,可以传入一个由待替换值组成的列表以及一个替代值
data.replace([-999, -1000], np.nan)
0 1.0
1 NaN
2 2.0
3 NaN
4 NaN
5 3.0
dtype: float64
data
0 1.0
1 -999.0
2 2.0
3 -999.0
4 -1000.0
5 3.0
dtype: float64
# 要让每个值有不同的替换值,可以传递一个替换列表
data.replace([-999, -1000], [np.nan, 0])
0 1.0
1 NaN
2 2.0
3 NaN
4 0.0
5 3.0
dtype: float64
# 传入的参数也可以是字典
data.replace({-999: np.nan, -1000: 0})
0 1.0
1 NaN
2 2.0
3 NaN
4 0.0
5 3.0
dtype: float64
data.replace方法与data.str.replace不同,后者做的是字符串的元素级替换,
Renaming Axis Indexes 重命名轴索引
data = pd.DataFrame(np.arange(12).reshape((3, 4)),index=['Ohio', 'Colorado', 'New York'],columns=['one', 'two', 'three', 'four'])
跟Series中的值一样,轴标签也可以通过函数或者映射进行转换,从而得到一个新的不同标签的对象。轴还可以被就地修改,而无需新建一个数据结构。
data
|
one
|
two
|
three
|
four
|
Ohio
|
0
|
1
|
2
|
3
|
Colorado
|
4
|
5
|
6
|
7
|
New York
|
8
|
9
|
10
|
11
|
transform = lambda x: x[:4].upper()
data.index.map(transform)
Index(['OHIO', 'COLO', 'NEW '], dtype='object')
# 可以将其赋值给index,这样子就可以实现对DataFrame进行就地修改
data.index = data.index.map(transform)
data
|
one
|
two
|
three
|
four
|
OHIO
|
0
|
1
|
2
|
3
|
COLO
|
4
|
5
|
6
|
7
|
NEW
|
8
|
9
|
10
|
11
|
# 如果想要要创建数据集的转换版(而不是修改原始数据),比较实用的方法是使用:rename方法
data.rename(index=str.title, columns=str.upper)
|
ONE
|
TWO
|
THREE
|
FOUR
|
Ohio
|
0
|
1
|
2
|
3
|
Colo
|
4
|
5
|
6
|
7
|
New
|
8
|
9
|
10
|
11
|
data.rename(index={'OHIO': 'INDIANA'},columns={'three': 'peekaboo'})
|
one
|
two
|
peekaboo
|
four
|
INDIANA
|
0
|
1
|
2
|
3
|
COLO
|
4
|
5
|
6
|
7
|
NEW
|
8
|
9
|
10
|
11
|
# rename可以实现复制DataFrame并对其索引和列标签进行赋值。# 如果希望就地修改某个数据集,传入inplace=True就可以
data.rename(index={'OHIO': 'INDIANA'}, inplace=True)
data
|
one
|
two
|
three
|
four
|
INDIANA
|
0
|
1
|
2
|
3
|
COLO
|
4
|
5
|
6
|
7
|
NEW
|
8
|
9
|
10
|
11
|
Discretization and Binning 离散化和面元划分
为了便于分析,连续的数据常常被离散化或者拆分为"面元(bin)".
如下:假设有一组人员数据,希望将其划分为不同的年龄组:
ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]
# 接下来将这些数据划分为:18-25, 26-35, ...
bins = [18, 25, 35, 60, 100]
cats = pd.cut(ages, bins)
cats
[(18, 25], (18, 25], (18, 25], (25, 35], (18, 25], ..., (25, 35], (60, 100], (35, 60], (35, 60], (25, 35]]
Length: 12
Categories (4, interval[int64]): [(18, 25] < (25, 35] < (35, 60] < (60, 100]]
pandas返回的是一个特殊的Categorical对象。结果展示了pandas.cut划分的面元。可以将其看作一组表示面元名称的字符串。
它的底层含有一个表示不同分类名称的类型数组,以及一个codes属性中的年龄数据的标签。
cats.codes
array([0, 0, 0, 1, 0, 0, 2, 1, 3, 2, 2, 1], dtype=int8)
cats.categories
IntervalIndex([(18, 25], (25, 35], (35, 60], (60, 100]],closed='right',dtype='interval[int64]')
pd.value_counts(cats)
(18, 25] 5
(35, 60] 3
(25, 35] 3
(60, 100] 1
dtype: int64
# 类似于数学符号一样,圆括号表示开区间,方括号表示闭区间。# 具体那一边表示闭,可以通过right = False
pd.cut(ages, [18, 26, 36, 61, 100], right=False)
[[18, 26), [18, 26), [18, 26), [26, 36), [18, 26), ..., [26, 36), [61, 100), [36, 61), [36, 61), [26, 36)]
Length: 12
Categories (4, interval[int64]): [[18, 26) < [26, 36) < [36, 61) < [61, 100)]
# 可以传递一个列表或者数组到labels,设置自己的面元名称。
group_names = ['Youth', 'YoungAdult', 'MiddleAged', 'Senior']
pd.cut(ages, bins, labels=group_names)
[Youth, Youth, Youth, YoungAdult, Youth, ..., YoungAdult, Senior, MiddleAged, MiddleAged, YoungAdult]
Length: 12
Categories (4, object): [Youth < YoungAdult < MiddleAged < Senior]
# 如果向cut传入的是面源的额数量而不是确切的面元边界,则他会根据数据的最小值和最大值计算等长的面元。
data = np.random.rand(20)
pd.cut(data, 4, precision=2)
[(0.49, 0.72], (0.02, 0.26], (0.02, 0.26], (0.49, 0.72], (0.49, 0.72], ..., (0.49, 0.72], (0.49, 0.72], (0.26, 0.49], (0.72, 0.96], (0.49, 0.72]]
Length: 20
Categories (4, interval[float64]): [(0.02, 0.26] < (0.26, 0.49] < (0.49, 0.72] < (0.72, 0.96]]
这里的选项precision=2,限定小数只有两位
# qcut是一个非常类似于cut的函数,它可以根据样本分位数对数据进行面元划分。根据数据的分布情况,# cut可能无法使各个面元中含有相同数量的数据点。# 而qcut由于使用的是样本分位数,因此可以得到大小基本相同的面元data = np.random.randn(1000) # Normally distributed
cats = pd.qcut(data, 4) # Cut into quartiles
cats
[(-0.0453, 0.604], (-2.9499999999999997, -0.686], (-0.0453, 0.604], (-0.0453, 0.604], (-2.9499999999999997, -0.686], ..., (-0.686, -0.0453], (0.604, 3.928], (0.604, 3.928], (-0.0453, 0.604], (-0.686, -0.0453]]
Length: 1000
Categories (4, interval[float64]): [(-2.9499999999999997, -0.686] < (-0.686, -0.0453] < (-0.0453, 0.604] < (0.604, 3.928]]
pd.value_counts(cats)
(0.604, 3.928] 250
(-0.0453, 0.604] 250
(-0.686, -0.0453] 250
(-2.9499999999999997, -0.686] 250
dtype: int64
# 类似于cut,可以自定义分位数,从零到壹,包含端点
pd.qcut(data, [0, 0.1, 0.5, 0.9, 1.])
[(-0.0453, 1.289], (-1.191, -0.0453], (-0.0453, 1.289], (-0.0453, 1.289], (-2.9499999999999997, -1.191], ..., (-1.191, -0.0453], (1.289, 3.928], (1.289, 3.928], (-0.0453, 1.289], (-1.191, -0.0453]]
Length: 1000
Categories (4, interval[float64]): [(-2.9499999999999997, -1.191] < (-1.191, -0.0453] < (-0.0453, 1.289] < (1.289, 3.928]]
Detecting and Filtering Outliers 检测和过滤异常值
data = pd.DataFrame(np.random.randn(1000, 4))
data.describe()
|
0
|
1
|
2
|
3
|
count
|
1000.000000
|
1000.000000
|
1000.000000
|
1000.000000
|
mean
|
-0.043288
|
0.046433
|
0.026352
|
-0.010204
|
std
|
0.998391
|
0.999185
|
1.010005
|
0.992779
|
min
|
-3.428254
|
-3.645860
|
-3.184377
|
-3.745356
|
25%
|
-0.740152
|
-0.599807
|
-0.612162
|
-0.699863
|
50%
|
-0.085000
|
0.043663
|
-0.008168
|
-0.031732
|
75%
|
0.625698
|
0.746527
|
0.690847
|
0.692355
|
max
|
3.366626
|
2.653656
|
3.525865
|
2.735527
|
# 假设要找出某一列中绝对值超过3的值;
col = data[2]
col[np.abs(col) > 3]
50 3.260383
225 -3.056990
312 -3.184377
772 3.525865
Name: 2, dtype: float64
# 要选出全部含有"超过3或者-3的值的行",可以在布尔型DataFrame中使用any方法:
data[(np.abs(data) > 3).any(1)]
|
0
|
1
|
2
|
3
|
31
|
-2.315555
|
0.457246
|
-0.025907
|
-3.399312
|
50
|
0.050188
|
1.951312
|
3.260383
|
0.963301
|
126
|
0.146326
|
0.508391
|
-0.196713
|
-3.745356
|
225
|
-0.293333
|
-0.242459
|
-3.056990
|
1.918403
|
249
|
-3.428254
|
-0.296336
|
-0.439938
|
-0.867165
|
312
|
0.275144
|
1.179227
|
-3.184377
|
1.369891
|
534
|
-0.362528
|
-3.548824
|
1.553205
|
-2.186301
|
626
|
3.366626
|
-2.372214
|
0.851010
|
1.332846
|
772
|
-0.658090
|
-0.207434
|
3.525865
|
0.283070
|
793
|
0.599947
|
-3.645860
|
0.255475
|
-0.549574
|
# 通过使用符号函数,实现将值限制在±3之间
data[np.abs(data) > 3] = np.sign(data) * 3
data.describe()
|
0
|
1
|
2
|
3
|
count
|
1000.000000
|
1000.000000
|
1000.000000
|
1000.000000
|
mean
|
-0.043227
|
0.047628
|
0.025807
|
-0.009059
|
std
|
0.995841
|
0.995170
|
1.006769
|
0.988960
|
min
|
-3.000000
|
-3.000000
|
-3.000000
|
-3.000000
|
25%
|
-0.740152
|
-0.599807
|
-0.612162
|
-0.699863
|
50%
|
-0.085000
|
0.043663
|
-0.008168
|
-0.031732
|
75%
|
0.625698
|
0.746527
|
0.690847
|
0.692355
|
max
|
3.000000
|
2.653656
|
3.000000
|
2.735527
|
# 根据数据的值是正还是负,np.sign(data)可以生成1和-1
np.sign(data).head()
|
0
|
1
|
2
|
3
|
0
|
-1.0
|
-1.0
|
-1.0
|
-1.0
|
1
|
-1.0
|
1.0
|
-1.0
|
-1.0
|
2
|
1.0
|
-1.0
|
-1.0
|
1.0
|
3
|
1.0
|
1.0
|
1.0
|
-1.0
|
4
|
1.0
|
1.0
|
1.0
|
1.0
|
Permutation and Random Sampling 排列和随机采样
利用numpy.random.permutation函数可以轻松实现对Series或者DataFrame的列的排列工作(permuting,随机重排序)。通过对需要排列的轴的长度调用permutation,可以产生一个表示新顺序的整数数组。
df = pd.DataFrame(np.arange(5 * 4).reshape((5, 4)))
sampler = np.random.permutation(5)
sampler
array([2, 0, 3, 4, 1])
df
|
0
|
1
|
2
|
3
|
0
|
0
|
1
|
2
|
3
|
1
|
4
|
5
|
6
|
7
|
2
|
8
|
9
|
10
|
11
|
3
|
12
|
13
|
14
|
15
|
4
|
16
|
17
|
18
|
19
|
df.take(sampler)
|
0
|
1
|
2
|
3
|
2
|
8
|
9
|
10
|
11
|
0
|
0
|
1
|
2
|
3
|
3
|
12
|
13
|
14
|
15
|
4
|
16
|
17
|
18
|
19
|
1
|
4
|
5
|
6
|
7
|
# 如果不想用替换的方式选取随机子集,可以在Series和DataFrame上使用sample方法:
df.sample(n=3)
|
0
|
1
|
2
|
3
|
2
|
8
|
9
|
10
|
11
|
1
|
4
|
5
|
6
|
7
|
0
|
0
|
1
|
2
|
3
|
# 要通过替换的方式产生样本(允许重复选择),可以传递replace = True到sample
choices = pd.Series([5, 7, -1, 6, 4])
draws = choices.sample(n=10, replace=True)
draws
4 4
4 4
1 7
3 6
4 4
3 6
4 4
4 4
3 6
2 -1
dtype: int64
Computing Indicator/Dummy Variables 计算指标/哑变量
另一种常用于统计建模或机器学习的转换方式是:将分类变量(类别型变量)转换为"哑变量"或者"指标矩阵"
df = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],'data1': range(6)})
pd.get_dummies(df['key'])
|
a
|
b
|
c
|
0
|
0
|
1
|
0
|
1
|
0
|
1
|
0
|
2
|
1
|
0
|
0
|
3
|
0
|
0
|
1
|
4
|
1
|
0
|
0
|
5
|
0
|
1
|
0
|
df
|
key
|
data1
|
0
|
b
|
0
|
1
|
b
|
1
|
2
|
a
|
2
|
3
|
c
|
3
|
4
|
a
|
4
|
5
|
b
|
5
|
如果,DataFrame的某一列中含有k各不同的值,则可以派生出一个k列的矩阵或者DataFrame(其值全为1和0)
"""
有时候,可能想给指标DataFrame的列加上一个前缀,以便于能够跟其他的数据进行合并。get_dummies的prefix参数可以实现该功能。
"""
dummies = pd.get_dummies(df['key'], prefix='key')
df_with_dummy = df[['data1']].join(dummies)
df_with_dummy
|
data1
|
key_a
|
key_b
|
key_c
|
0
|
0
|
0
|
1
|
0
|
1
|
1
|
0
|
1
|
0
|
2
|
2
|
1
|
0
|
0
|
3
|
3
|
0
|
0
|
1
|
4
|
4
|
1
|
0
|
0
|
5
|
5
|
0
|
1
|
0
|
mnames = ['movie_id', 'title', 'genres']
movies = pd.read_table('datasets/movielens/movies.dat', sep='::',header=None, names=mnames)
movies[:10]
|
movie_id
|
title
|
genres
|
0
|
1
|
Toy Story (1995)
|
Animation|Children's|Comedy
|
1
|
2
|
Jumanji (1995)
|
Adventure|Children's|Fantasy
|
2
|
3
|
Grumpier Old Men (1995)
|
Comedy|Romance
|
3
|
4
|
Waiting to Exhale (1995)
|
Comedy|Drama
|
4
|
5
|
Father of the Bride Part II (1995)
|
Comedy
|
5
|
6
|
Heat (1995)
|
Action|Crime|Thriller
|
6
|
7
|
Sabrina (1995)
|
Comedy|Romance
|
7
|
8
|
Tom and Huck (1995)
|
Adventure|Children's
|
8
|
9
|
Sudden Death (1995)
|
Action
|
9
|
10
|
GoldenEye (1995)
|
Action|Adventure|Thriller
|
# 要为每个genre添加指标变量就需要做一些数据规整操作。首先,我们从数据集中抽取不同的genre值:
all_genres = []for x in movies.genres:all_genres.extend(x.split('|'))
genres = pd.unique(all_genres)
genres
array(['Animation', "Children's", 'Comedy', 'Adventure', 'Fantasy','Romance', 'Drama', 'Action', 'Crime', 'Thriller', 'Horror','Sci-Fi', 'Documentary', 'War', 'Musical', 'Mystery', 'Film-Noir','Western'], dtype=object)
zero_matrix = np.zeros((len(movies), len(genres)))
dummies = pd.DataFrame(zero_matrix, columns=genres)
gen = movies.genres[0]
gen.split('|')
dummies.columns.get_indexer(gen.split('|'))
array([0, 1, 2], dtype=int64)
for i, gen in enumerate(movies.genres):indices = dummies.columns.get_indexer(gen.split('|'))dummies.iloc[i, indices] = 1
movies_windic = movies.join(dummies.add_prefix('Genre_'))
movies_windic.iloc[0]
movie_id 1
title Toy Story (1995)
genres Animation|Children's|Comedy
Genre_Animation 1
Genre_Children's 1...
Genre_War 0
Genre_Musical 0
Genre_Mystery 0
Genre_Film-Noir 0
Genre_Western 0
Name: 0, Length: 21, dtype: object
对于很大的数据,用这种方法构建多成员指标变量就会变得非常慢,最好使用更加低级的函数,将其写入到Numpy数组,然后将结果包装在DataFrame中。
np.random.seed(12345)
values = np.random.rand(10)
values
array([0.9296, 0.3164, 0.1839, 0.2046, 0.5677, 0.5955, 0.9645, 0.6532,0.7489, 0.6536])
bins = [0, 0.2, 0.4, 0.6, 0.8, 1]
pd.get_dummies(pd.cut(values, bins))
|
(0.0, 0.2]
|
(0.2, 0.4]
|
(0.4, 0.6]
|
(0.6, 0.8]
|
(0.8, 1.0]
|
0
|
0
|
0
|
0
|
0
|
1
|
1
|
0
|
1
|
0
|
0
|
0
|
2
|
1
|
0
|
0
|
0
|
0
|
3
|
0
|
1
|
0
|
0
|
0
|
4
|
0
|
0
|
1
|
0
|
0
|
5
|
0
|
0
|
1
|
0
|
0
|
6
|
0
|
0
|
0
|
0
|
1
|
7
|
0
|
0
|
0
|
1
|
0
|
8
|
0
|
0
|
0
|
1
|
0
|
9
|
0
|
0
|
0
|
1
|
0
|
String Manipulation 字符串操纵
python本身能够处理字符串和文本,对于更加复杂的模式匹配和文本操作,就需要使用到正则表达式。pandas对此进行了加强,可以实现对:整租数据应用字符串表达式和正则表达式,而且可以处理烦人的缺失数据。
String Object Methods 字符串对象方法
# 根据逗号分隔,使用split函数进行字符串拆分
val = 'a,b, guido'
val.split(',')
['a', 'b', ' guido']
# split通常和strip一起使用,从而实现去除空白符(包括换行符)
pieces = [x.strip() for x in val.split(',')]
pieces
['a', 'b', 'guido']
# 利用加法,可以实现将字符串以双冒号分隔符的形式连接起来,
first, second, third = pieces
first + '::' + second + '::' + third
'a::b::guido'
# 一种更加实用的方法是,向字符串"::"的join方法传入一个列表或者元组;
'::'.join(pieces)
'a::b::guido'
# 实现字串定位
'guido' in val
True
val.index(',')
1
val.find(':')
-1
find和index的区别是;如果找不到字符串,index将会引发一个异常,而不是返回-1
# 如下操作会产生异常
val.index(':')
---------------------------------------------------------------------------ValueError Traceback (most recent call last)<ipython-input-108-2c016e7367ac> in <module>
----> 1 val.index(':')ValueError: substring not found
# count可以返回指定字串的出现次数
val.count(',')
2
# replace用于将指定模式替换为另一个模式。通过传入空字符串,他也常常用于删除模式
val.replace(',', '::')
'a::b:: guido'
val.replace(',', '')
'ab guido'
python内置的字符串方法
方法
|
说明
|
count
|
返回字串在字符串中出现的次数(非重叠)
|
endswith
|
字符串是否以某个后缀结尾,是则返回True
|
startswith
|
字符串是否以某个前缀开头,是则返回True
|
find, rfind
|
如果在字符串中找到字串,则返回第一次出现的位置,没有发现则返回-1,,后者返回最后一个发现的位置
|
Regular Expressions 正则表达式
re模块的函数可以分为三个大类:模式匹配,替换以及拆分
# 描述一个或者多个空白符的regex是:"\s+"
import re
text = "foo bar\t baz \tqux"
re.split('\s+', text)
['foo', 'bar', 'baz', 'qux']
调用re.split(’\s+’,text)的时候,正则表达式会先被编译,然后会在text上调用其split方法。
regex = re.compile('\s+')
regex.split(text)
['foo', 'bar', 'baz', 'qux']
# 如果只希望匹配得到regex的所有模式,则可以使用findall发方法
regex.findall(text)
[' ', '\t ', ' \t']
如果想避免正则表达式中不需要的转移 (\),则可以使用原始字符串字面量如:
r’C:\x’
如果打算对许多字符串应用同一条正则表达式,建议通过re.compile创建regex对象。这样子可以节省大量的cpu时间
findall返回的是:字符串中所有的匹配项,而search则只返回第一个匹配项。match则更加严格,仅仅匹配字符串的首部。
text = """Dave dave@google.com
Steve steve@gmail.com
Rob rob@gmail.com
Ryan ryan@yahoo.com
"""
pattern = r'[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}'# re.IGNORECASE makes the regex case-insensitive
regex = re.compile(pattern, flags=re.IGNORECASE)
regex.findall(text)
['dave@google.com', 'steve@gmail.com', 'rob@gmail.com', 'ryan@yahoo.com']
m = regex.search(text)
m
<re.Match object; span=(5, 20), match='dave@google.com'>
text[m.start():m.end()]
'dave@google.com'
# 下面将返回None,因为他只匹配出现在字符串开头的模式:
print(regex.match(text))
None
# sub方法可以将匹配到的模式替换为指定的字符串,且返回所得到的新字符串
print(regex.sub('REDACTED', text))
Dave REDACTED
Steve REDACTED
Rob REDACTED
Ryan REDACTED
# 分别找出,用户名,域名,域后缀,将模式的各个部分使用圆括号包起来。
pattern = r'([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})'
regex = re.compile(pattern, flags=re.IGNORECASE)
m = regex.match('wesm@bright.net')
m.groups()
('wesm', 'bright', 'net')
regex.findall(text)
[('dave', 'google', 'com'),('steve', 'gmail', 'com'),('rob', 'gmail', 'com'),('ryan', 'yahoo', 'com')]
print(regex.sub(r'Username: \1, Domain: \2, Suffix: \3', text))
Dave Username: dave, Domain: google, Suffix: com
Steve Username: steve, Domain: gmail, Suffix: com
Rob Username: rob, Domain: gmail, Suffix: com
Ryan Username: ryan, Domain: yahoo, Suffix: com
Vectorized String Functions in pandas pandas的矢量化字符串函数
data = {'Dave': 'dave@google.com', 'Steve': 'steve@gmail.com','Rob': 'rob@gmail.com', 'Wes': np.nan}
data = pd.Series(data)
data
Dave dave@google.com
Steve steve@gmail.com
Rob rob@gmail.com
Wes NaN
dtype: object
data.isnull()
Dave False
Steve False
Rob False
Wes True
dtype: bool
# 可以通过str.sontains检查各个电子邮件是否含有"gmail"
data.str.contains('gmail')
Dave False
Steve True
Rob True
Wes NaN
dtype: object
pattern
data.str.findall(pattern, flags=re.IGNORECASE)
Dave [(dave, google, com)]
Steve [(steve, gmail, com)]
Rob [(rob, gmail, com)]
Wes NaN
dtype: object
# 有两个办法可以实现矢量化的元素获取操作,要么使用:str.get, 要么在str属性上使用索引
matches = data.str.match(pattern, flags=re.IGNORECASE)
matches
Dave True
Steve True
Rob True
Wes NaN
dtype: object
matches.str[0]
data.str[:5]
pd.options.display.max_rows = PREVIOUS_MAX_ROWS
Conclusion
数据分析----数据清洗和准备相关推荐
- 大数据分析数据清洗的价值和意义
在这个由物联网(IoT),社交媒体,边缘计算以及越来越多的计算能力(如量子计算)支持的数字时代,数据可能是任何企业最有价值的资产之一.正确(或不正确)的数据管理将对企业的成功产生巨大影响.换句话说,它 ...
- 数据分析--数据清洗详解流程
无论是做机器学习还是做数据分析,都离不开获取数据后的第一步-数据清洗工作.据统计,数据清洗工作占据整个工作时间百分之50左右,有的甚至能达到百分之70.下面我将介绍我进行数据清洗得思路流程. 数据清洗 ...
- 动手学数据分析 | 数据清洗及特征处理(二)
接上篇动手学数据分析 | 数据基础操作(一),下面代码为本篇内容的基本代码准备工作. import numpy as np import pandas as pddf = pd.read_csv('t ...
- 3_数据分析—数据清洗及特征处理
文章目录 一.数据导入 二.数据清洗简述 2.1 缺失值-观察与处理 2.1.1 缺失值观察(2种方法) 2.1.2 对缺失值进行处理 2.1.3 对缺失值进行填充 2.2 重复值-观察与处理 2.2 ...
- 数据分析----数据清洗
一.导入数据 import pandas as pd import numpy as np from pandas import Series,DataFrame import xlrd df = D ...
- 旅游网站大数据分析 - 数据清洗
第1关:清洗HTML文档中无意义数据 将获取到携程网的城市酒店的HTML数据(包含了所有元素)进行清洗,得到我们需要的标签数据. package step1;import java.io.File; ...
- 数据分析——数据清洗之文字特征编码
在对数据进行预处理时,有时会面临特征值是字符串类型的时候,这时候就需要对特征值进行编码处理,主要分为一下两类: 各个特征值之间没有任何关联,如['red', 'green', 'blue']. 各个特 ...
- python数据清理的实践总结_Python数据清洗实践
原标题:Python数据清洗实践 DATA CLEANING WITH PYTHON 作者 | Balogun Omobolaji 翻译 | 酱番梨.祝弟弟基督教 校对 | Pita 审核 | 约翰逊 ...
- pandas用众数填充缺失值_python数据分析包|Pandas-02之缺失值(NA)处理
本篇详解pandas中缺失值(Missing data handling)处理常用操作. 缺失值处理常用于数据分析数据清洗阶段:Pandas中将如下类型定义为缺失值: NaN: '', '#N/A', ...
- dataframe 一列的不同值_python数据分析包|Pandas-02之缺失值(NA)处理
本篇详解pandas中缺失值(Missing data handling)处理常用操作. 缺失值处理常用于数据分析数据清洗阶段:Pandas中将如下类型定义为缺失值: NaN: '', '#N/A', ...
最新文章
- C# Idioms: Safely方法
- 如何同时展现不同粒度的度量
- git——从远程库克隆
- java8 CompletableFuture异步编程
- HDU 5131 Song Jiang's rank list
- easyui数据请求两个url_easyui使用是调用两次后台请求(解决)
- Codeforces VK Cup 2015 A.And Yet Another Bracket Sequence(后缀数组+平衡树+字符串)
- ASP.NET Core 集成测试中模拟登录用户的一种姿势
- contiki cooja仿真
- 云服务器怎么把软件装上去_服务器:云服务器怎么设置301
- shell脚本相关指令
- java求立方体表面积和体积_有关正方体、长方体表面积和体积的计算题
- JavaScript TypeScript 学习总结
- 【生活中的逻辑谬误】止于分析和简化主义
- “蔚小理”想挑战特斯拉?先干过比亚迪再说
- Linux环境下利用perl脚本批量筛选VCF文件指定样本
- android 五种存储方式,android数据五种存储
- 肝进ICU,万字真言点化八大排序——我奶奶都看得懂的算法详解
- pytorch优化器详解:Adam
- Java的字符串连接符(+)
热门文章
- (转)Oracle数据库资料收藏
- 聚类分析 距离 matlab,用MATLAB做聚类分析
- 汇编语言 XCHG指令
- UA PHYS515A 电磁理论IV 时变电磁场理论4 电磁场的动量与麦克斯韦压缩能张量
- java实现快递单信息识别
- 搜c语言题答案软件下载,C语言二级题库软件下载-C语言二级题库官方版下载v1.01-乐游网安卓下载...
- Wifi密码破解(rtl8818linux驱动安装)
- H3CSE认证网络工程师视频课程-广域网-宋文峰-专题视频课程
- HDU2157 How many ways??(可达矩阵+矩阵快速幂)
- 六大免费网站数据采集器对比(火车头,海纳,云采集,ET,三人行,狂人采集)