利用python进行数据分析-数据规整化3

最新推荐文章于 2024-04-19 18:55:03 发布

zhuhengv

最新推荐文章于 2024-04-19 18:55:03 发布

阅读量3k

点赞数 2

分类专栏： python 文章标签： python 数据分析

本文链接：https://blog.csdn.net/zhuhengv/article/details/51692002

版权

python 专栏收录该内容

55 篇文章 2 订阅

订阅专栏

1.离散化和面元划分

为了便于分析，连续数据常常被离散化或拆分为“面元”

有一组人员年龄数据，希望将这些数据划分为“18到25”,“26到35”,“36到60”,“60以上”几个面元

ages=[20,22,25,27,21,23,37,31,61,45,41,32]
bins=[18,25,35,60,100]
cats=pd.cut(ages,bins)
print 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, object): [(18, 25] < (25, 35] < (35, 60] < (60, 100]]

pandas返回的是一个特殊的Categorical对象。你可以将其看做一组表示面元名称的字符串。实际上，它含有一个表示不同分类名称的levels数组以及一个年龄数据进行标号的labels属性

print cats.labels
print cats.levels
print pd.value_counts(cats)

结果为：

[0 0 0 1 0 0 2 1 3 2 2 1]
Index([u'(18, 25]', u'(25, 35]', u'(35, 60]', u'(60, 100]'], dtype='object')
(18, 25]     5
(35, 60]     3
(25, 35]     3
(60, 100]    1
dtype: int64

跟“区间”的数学符号一样，圆括号表示开端，而方括号则表示闭端（包括）。哪边是闭端可以通过right=False进行修改

print 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, object): [[18, 26) < [26, 36) < [36, 61) < [61, 100)]

你也可以设置自己的面元名称，将labels选项设置为一个列表或数组即可

group_names=['Youth','YoungAdult','MiddleAged','Senior']
print 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)
print pd.cut(data,4,precision=2)

结果为：

[(0.0093, 0.26], (0.0093, 0.26], (0.26, 0.5], (0.0093, 0.26], (0.75, 0.99], ..., (0.0093, 0.26], (0.0093, 0.26], (0.0093, 0.26], (0.75, 0.99], (0.5, 0.75]]
Length: 20
Categories (4, object): [(0.0093, 0.26] < (0.26, 0.5] < (0.5, 0.75] < (0.75, 0.99]]

qcut是一个非常类似于cut的函数，它可以根据样本分位数对数据进行面元划分。根据数据的分布情况，cut可能无法使各个面元中含有相同数量的数据点。而qcut由于使用的是样本分位数，因此可以得到大小基本相等的面元

data1=np.random.randn(1000)#正太分布
cats=pd.qcut(data1,4)#按四分位数进行切割
print cats
print pd.value_counts(cats)

结果为：

[(0.674, 3.476], [-3.0413, -0.617], (-0.617, -0.00668], [-3.0413, -0.617], [-3.0413, -0.617], ..., (-0.00668, 0.674], (0.674, 3.476], (-0.617, -0.00668], (0.674, 3.476], (-0.617, -0.00668]]
Length: 1000
Categories (4, object): [[-3.0413, -0.617] < (-0.617, -0.00668] < (-0.00668, 0.674] < (0.674, 3.476]]
(0.674, 3.476]        250
(-0.00668, 0.674]     250
(-0.617, -0.00668]    250
[-3.0413, -0.617]     250
dtype: int64

跟cut一样，也可以设置自定义的分位数（0到1之间的数值，包含端点）

print pd.qcut(data1,[0,0.1,0.5,0.9,1])

结果为：

[(-1.332, -0.0241], (-1.332, -0.0241], (-0.0241, 1.266], [-3.0457, -1.332], (-0.0241, 1.266], ..., (-1.332, -0.0241], (1.266, 3.0939], (-0.0241, 1.266], (-0.0241, 1.266], [-3.0457, -1.332]]
Length: 1000
Categories (4, object): [[-3.0457, -1.332] < (-1.332, -0.0241] < (-0.0241, 1.266] < (1.266, 3.0939]]

2.检测和过滤异常值

np.random.seed(12345)
data2=DataFrame(np.random.randn(1000,4))
print data2.describe()

结果为：

                 0            1            2            3
count 1000.000000 1000.000000 1000.000000 1000.000000
mean     -0.067684     0.067924     0.025598    -0.002298
std       0.998035     0.992106     1.006835     0.996794
min      -3.428254    -3.548824    -3.184377    -3.745356
25%      -0.774890    -0.591841    -0.641675    -0.644144
50%      -0.116401     0.101143     0.002073    -0.013611
75%       0.616366     0.780282     0.680391     0.654328
max       3.366626     2.653656     3.260383     3.927528

假设你想要找出某列中绝大值大小超过3的值

col=data2[3]
print col[np.abs(col)>3]

结果为：

97     3.927528
305   -3.399312
400   -3.745356
Name: 3, dtype: float64

要选出全部含有“超过3或-3的值”的行，你可以利用布尔型DataFrame以及any方法

print data[(np.abs(data2)>3).any(1)]

根据这些条件，即可轻松地对值进行设置。下面的代码可以将值限制在区间-3到3以内

data2[np.abs(data2)>3]=np.sign(data2)*3
print data2.describe()

结果为：

                 0            1            2            3
count 1000.000000 1000.000000 1000.000000 1000.000000
mean     -0.067623     0.068473     0.025153    -0.00281
std       0.995485     0.990253     1.003977     0.989736
min      -3.000000    -3.000000    -3.000000    -3.000000
25%      -0.774890    -0.591841    -0.641675    -0.644144
50%      -0.116401     0.101143     0.002073    -0.013611
75%       0.616366     0.780282     0.680391     0.654328
max       3.000000     2.653656     3.000000     3.000000

np.sign这个ufunc返回的是一个由1和-1组成的数组，表示原始值的符号

3.排列和随机采样

df=DataFrame(np.arange(5*4).reshape(5,4))
sampler=np.random.permutation(5)
print sampler

结果为：

[1 0 2 3 4]

然后就可以在基于ix的索引操作或take函数中使用该数组了

print df
print df.take(sampler)

结果为：

    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
    0   1   2   3
1   4   5   6   7
0   0   1   2   3
2   8   9 10 11
3 12 13 14 15
4 16 17 18 19

如果不想用替换的方式选取随机子集，则可以使用permutation：从permutation返回的数组中切下前k个元素，其中k为期望的子集大小

print df.take(np.random.permutation(len(df))[:3])

结果为：

0 1 2 3
1 4 5 6 7
3 12 13 14 15
4 16 17 18 19

要通过替换的方式产生样本，最快的方式是通过np.random.randint得到一组随机整数

bag=np.array([5,7,-1,6,4])
sampler=np.random.randint(0,len(bag),size=10)
print sampler
draws=bag.take(sampler)
print draws

结果为：

[4 4 2 2 2 0 3 0 4 1]
[ 4 4 -1 -1 -1 5 6 5 4 7]

4.计算指标/哑变量

另一种常用于统计建模或机器学习的转换方式是：将分类变量转换为“哑变量矩阵”或“指标矩阵”。如果DataFrame的某一列中含有k个不同的值，则可以派生出一个k列矩阵或DataFrame（其值全为1或0）

df1=DataFrame({'key':['b','b','a','c','a','b'],
'data1':range(6)})
print df1
print pd.get_dummies(df1['key'])

结果为：

   data1 key
0      0   b
1      1   b
2      2   a
3      3   c
4      4   a
5      5   b
   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

你有可能想给DataFrame的列加上一个前缀，以便能够跟其他数据进行合并。get_dummies的perfix参数可以实现该功能

dummies=pd.get_dummies(df1['key'],prefix='key')
df_with_dummy=df1[['data1']].join(dummies)
print 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

如果DataFrame中的某行同属于多个分类，则事情就会有点复杂

mnames=['move_id','title','genres']
movies=pd.read_table('data/movies.dat',sep='::',header=None,names=mnames)
print movies[:10]

结果为：

   move_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值

genre_iter=(set(x.split('|')) for x in movies.genres)
genres=sorted(set.union(*genre_iter))

现在，我们从一个全零DataFrame开始构建指标DataFrame

dummies=DataFrame(np.zeros((len(movies),len(genres))),columns=genres)

接下来，迭代每一部电影并将dummies各行的项设为1

for i,gen in enumerate(movies.genres):
dummies.ix[i,gen.split('|')]=1

再将其与movies合并起来

movies_windic=movies.join(dummies.add_prefix('Genre_'))
print movies_windic.ix[0]

结果为：

move_id                                        1
title                           Toy Story (1995)
genres               Animation|Children's|Comedy
Genre_Action                                   0
Genre_Adventure                                0
Genre_Animation                                1
Genre_Children's                               1
Genre_Comedy                                   1
Genre_Crime                                    0
Genre_Documentary                              0
Genre_Drama                                    0
Genre_Fantasy                                  0
Genre_Film-Noir                                0
Genre_Horror                                   0
Genre_Musical                                  0
Genre_Mystery                                  0
Genre_Romance                                  0
Genre_Sci-Fi                                   0
Genre_Thriller                                 0
Genre_War                                      0
Genre_Western                                  0
Name: 0, dtype: object

一个对统计应用有用的秘诀是：结合get_dummies和诸如cut之类的离散化函数

values=np.random.rand(10)
bins=[0,0.2,0.4,0.6,0.8,1]
print values
print pd.get_dummies(pd.cut(values,bins))

结果为：

[ 0.75603383 0.90830844 0.96588737 0.17373658 0.87592824 0.75415641
0.163486    0.23784062 0.85564381 0.58743194]
   (0, 0.2] (0.2, 0.4] (0.4, 0.6] (0.6, 0.8] (0.8, 1]
0         0           0           0           1         0
1         0           0           0           0         1
2         0           0           0           0         1
3         1           0           0           0         0
4         0           0           0           0         1
5         0           0           0           1         0
6         1           0           0           0         0
7         0           1           0           0         0
8         0           0           0           0         1
9         0           0           1           0         0

5.字符串对象方法

val='a,b, guido'
print val.split(',')

结果为：

['a', 'b', ' guido']

split常常结合strip（用于修剪空白符（包括换行符））一起使用

pieces=[x.strip() for x in val.split(',')]
print pieces

结果为：

['a', 'b', 'guido']

利用加法，可以将这些子字符串以双冒号分隔符的形式连接起来

first,sencond,third=pieces
print first+'::'+sencond+'::'+third

结果为：

a::b::guido

但这种方式不实用。可以使用向字符串‘：：’的join方法传入一个列表或元组

print '::'.join(pieces)

结果为：

a::b::guido

另一类方法关注的是子串定位。检测子串的最佳方式是利用python的in关键字（当然还可以使用index和find）

print 'guido' in val
print val.index(',')
print val.find(':')

结果为：

True
1
-1

注意find和index的区别：如果找不到字符串，index将会引发一个异常，而不是返回-1

此外还有一个count函数，可以指定返回指定子串的出现次数

print val.count(',')

结果为：

replace用于指定模式替换为另一个模式。也常常用于删除模式：传入空字符串

print val.replace(',','::')
print val.replace(',','')

结果为：

a::b:: guido
ab guido

6.正则表达式

python内置的re模块负责对字符串应用正则表达式。re模块的函数可以分为三个大类：模式匹配、替换以及拆分。

import re

text='foo bar\t baz \tqux'
print re.split('\s+',text)

结果为：

['foo', 'bar', 'baz', 'qux']

你可以用re.compile自己编译regex以得到一个可重用的regex对象

regex=re.compile('\s+')
print regex.split(text)

结果为：

['foo', 'bar', 'baz', 'qux']

如果只希望得到匹配regex的所有模式，则可以使用findall方法

print regex.findall(text)

结果为：

[' ', '\t ', ' \t']

matc和search跟findall功能类似。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的作用是使正则表达式对大小写不敏感
regex=re.compile(pattern,flags=re.IGNORECASE)
print regex.findall(text)

结果为：

['dave@google.com', 'steve@gmail.com', 'rob@gmail.com', 'ryan@yahoo.com']

search返回的是文本中第一个电子邮件地址（以特殊的匹配对象形式返回）

print m
print text[m.start():m.end()]

结果为：

<_sre.SRE_Match object at 0x0000000009209B90>
dave@google.com

另外还有一个sub方法，它将会匹配到的模式替换为指定字符串，并返回所得到的新字符串

print regex.sub('REDACTDE',text)

Dave REDACTDE
Steve REDACTDE
Rob REDACTDE
Ryan REDACTDE

假设你不仅想要找出电子邮件地址，还想将各个地址分成3部分：用户名、域名以及域后缀

pattern1=r'([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})'
regex1=re.compile(pattern1,flags=re.IGNORECASE)
m=regex1.match('zhuheng@126.com')
print m.groups()

结果为：

('zhuheng', '126', 'com')

对于带有分组功能的模式，findall会返回一个元组列表

print regex1.findall(text)

结果为：

[('dave', 'google', 'com'), ('steve', 'gmail', 'com'), ('rob', 'gmail', 'com'), ('ryan', 'yahoo', 'com')]

sub还能通过诸如\1,\2之类的特殊符号访问各匹配项中的分组

print regex1.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

对上面那个电子邮件正则表达式做一点小改动：为各个匹配组加上一个名称

regex2=re.compile(r"""
    (?P<username>[A-Z0-9._%+-]+)
    @
    (?P<domain>[A-Z0-9.-]+)
    \.
    (?P<suffix>[A-Z]{2,4})""",flags=re.IGNORECASE|re.VERBOSE)
m=regex2.match('zhuheng@126.com')
print m.groupdict()

结果为：

{'username': 'zhuheng', 'domain': '126', 'suffix': 'com'}

7.pandas中矢量化的字符串函数

data4={'Dave':'dave@google.com','Steve':'steve@gmail.com',
'Rob':'rob@gmail.com','Wes':np.nan}
data4=Series(data4)
print data4
print data4.isnull()

结果为：

Dave     dave@google.com
Rob        rob@gmail.com
Steve    steve@gmail.com
Wes                  NaN
dtype: object
Dave     False
Rob      False
Steve    False
Wes       True
dtype: bool

print data4.str.contains('gmail')

结果为：

Dave     False
Rob       True
Steve     True
Wes        NaN
dtype: object

这里也可以使用正则表达式，还可以加上任意re选项

print pattern
print data4.str.findall(pattern1,flags=re.IGNORECASE)

结果为：

[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}
Dave     [(dave, google, com)]
Rob        [(rob, gmail, com)]
Steve    [(steve, gmail, com)]
Wes                        NaN
dtype: object

有两个办法可以实现矢量化的元素获取操作：要么使用str.get，要么在str属性上使用索引

matches=data4.str.match(pattern1,flags=re.IGNORECASE)
print matches
print matches.str.get(1)
print matches.str[0]

结果为：

Dave     (dave, google, com)
Rob        (rob, gmail, com)
Steve    (steve, gmail, com)
Wes                      NaN
dtype: object
Dave     google
Rob       gmail
Steve     gmail
Wes         NaN
dtype: object
Dave      dave
Rob        rob
Steve    steve
Wes        NaN
dtype: object

可以利用下面这种代码对字符串进行子串截取

print data4.str[:5]

结果为：

Dave     dave@
Rob      rob@g
Steve    steve
Wes        NaN
dtype: object