Python数据处理学习笔记 - pandas数据合并、重塑和转换篇

这是我阅读《用Python进行数据分析》一书的笔记、实验和总结。本篇文章主要讲解pandas包Series和DataFrame这两大数据结构的以下内容:单个数据集的值检测与处理,多个数据集的合并、重塑、以及包括映射、替换、离散、排列、取样、哑变量等数据转换方法,最后介绍了包括正则在内的对于字符串的处理方法。

第一篇文章主要介绍numpy的ndarray这一多维数组对象,这是Python进行数据分析的基石,也是保证大量数据处理速度的必要条件。第二篇文章主要讲解DataFrame和Series这两个对象本身的使用方法。而本篇文章则着重介绍单个数据集的值检测与处理,多个数据集的合并、重塑、以及包括映射、替换、离散、排列、取样、哑变量等数据转换方法,最后介绍了包括正则在内的对于字符串的处理方法。

对于不同导入格式(CSV、JSON、HDF5、Pickle、Excel、SQL/NoSQL)的导入方法,本文及以后亦不会做详细介绍,请直接翻阅pandas和numpy的I/O部分,所有方法的使用在使用手册中都说明的很详细。其中对JSON的读取效率高于python json模块,但是读取为DataFrame之后,往往不能够很高效的对其进行进一步分析处理,因此还是推荐使用json模块将json对象转化成为Python的字典,然后按需构造DataFrame。至于Excel,pandas使用的是xlrd。如果是大数据集,推荐使用二进制格式,最好是HDF5(适用于多次读一次写)和分块读,效率很高。而频繁写入,最好还是使用SQL/NoSQL数据库。groupby、aggregate、透视、交叉等聚合技术将会在之后逐步介绍。

本文主要内容:从单个数据集导入后的第一步——处理缺失值开始,然后到多个数据集的合并、转置和数据转换。把“单个数据集的值检测和缺失值处理”放在开头而不是和“数据转换”放在一起的原因是,缺失值的优先级很高,并且其属于单个数据集数据剔除、过滤和修剪部分,而不属于数据变换,格式改变等数据转换部分。

约定俗成的,引入numpy、matplotlib和pandas包中DataFrame和Series结构。

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)
%matplotlib inline

1. 单个数据集的值统计和缺失值处理

1.1 存在、唯一和计数

isin([list]) 用来判断存在;unique() 用来生成所有唯一值;value_counts() 用来计数,这个方法也是pandas全局方法,pd.value_counts(obj.values,xxx)

obj = pd.Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])
print(obj.unique().sort()) # 错误,sort不会返回新数据
un = obj.unique();print(un);un.sort();print(un)
None
['c' 'a' 'd' 'b']
['a' 'b' 'c' 'd']
obj.value_counts() #等同于下述
pd.value_counts(obj.values, sort=True)
a    3
c    3
b    2
d    1
dtype: int64
print(obj)
mask = obj.isin(['b', 'c']) 
#isin接受一个list作为判断,返回一个bool型索引,
# 可以根据此索引作为切片生成新的数组
print(mask) # 其本质类似于obj[(obj == "b") | (obj == "c")]
print(obj[mask])
print(obj[(obj == "b") | (obj == "c")])
0    c
1    a
2    d
3    a
4    a
5    b
6    b
7    c
8    c
dtype: object
0     True
1    False
2    False
3    False
4    False
5     True
6     True
7     True
8     True
dtype: bool
0    c
5    b
6    b
7    c
8    c
dtype: object
0    c
5    b
6    b
7    c
8    c
dtype: object

value_counts()只适用于Series


>> baby_name.head(3)

	Unnamed: 0	Id	Name	Year	Gender	State	Count
0	11349	11350	Emma	2004	F	AK	62
1	11350	11351	Madison	2004	F	AK	48
2	11351	11352	Hannah	2004	F	AK	46

>> baby_name["Gender"].value_counts()["F"] # Returns 558846

value_count返回所有的value分类结果,而其实我们可以指定返回某些特定值的结果,只需要将这些值的列表转换成index,使用get_indexer来和对象进行比较。【存疑】

to_match = pd.Series(['c', 'a', 'b', 'b', 'c', 'a','e','q'])
unique_vals = pd.Series(['c', 'b', 'a'])
#print(returns.tail())
#print(pd.Index(pd.Series(["0.007846"])).get_indexer(returns.tail()))
print(to_match,unique_vals,pd.Index(unique_vals))
pd.Index(unique_vals).get_indexer(to_match) 
#index.get_indexer(obj) 传入一个需要比较的对象,返回这个对象的value和标准index比较后的结果。
                AAPL      GOOG       IBM      MSFT
Date                                              
2016-10-17 -0.000680  0.001837  0.002072 -0.003483
2016-10-18 -0.000681  0.019616 -0.026168  0.007690
2016-10-19 -0.002979  0.007846  0.003583 -0.002255
2016-10-20 -0.000512 -0.005652  0.001719 -0.004867
2016-10-21 -0.003930  0.003011 -0.012474  0.042096

[-1 -1 -1 -1 -1]

0    c
1    a
2    b
3    b
4    c
5    a
6    e
7    q
dtype: object 0
    c

1    b
2    a

dtype: object Index(['c', 'b', 'a'], dtype='object')

array([ 0,  2,  1,  1,  0,  2, -1, -1], dtype=int64)
data = pd.DataFrame({'Qu1': [1, 3, 4, 3, 4],
                     'Qu2': [2, 3, 1, 2, 3],
                     'Qu3': [1, 5, 2, 4, 4]})
data


    Qu1	Qu2	Qu3
    0	1	2	1
    1	3	3	5
    2	4	1	2
    3	3	2	4
    4	4	3	4



result = data.apply(pd.value_counts).fillna(0)
result


        Qu1	Qu2	Qu3
    1	1.0	1.0	1.0
    2	0.0	2.0	1.0
    3	2.0	2.0	0.0
    4	2.0	0.0	2.0
    5	0.0	0.0	1.0

1.2 缺失值处理

缺失值在numpy和pandas中被看作nan,在Python中被看作None,大概有四个方法可以进行缺失值的处理

1.2.1 检测缺失值

检测缺失值需要使用isnull()/isna()/notnull()等函数,一个比较方便的方法,可以快速查看当前列的缺失值情况的是:

df.info() 在这里会看到各个列的索引,还有是否列有缺失值

df.isnull().sum() 可以按照列快速统计缺失值数量。
#需要注意,不能使用df.isnull().count() 这个会统计所有的玩意,包括T和F

#这其实是个谬论,当你越来越了解特殊的、好用的函数,
#你对一个工具了解就越深,但是越容易被束缚,一个通用解决方案是:

for item in df.column:
    getattr(df,item)[getattr(df,item).isnull().any(axis=0)].count()
    #上面这种方法的一个关键在于.any()函数,没有这个参数则不会被过滤。
    #或者 getattr(df,item).isnull().value_counts()[False]

1.2.2 缺失值的丢弃

isnull() or notnull() ; dropna() or fillna()

from numpy import nan as NA
temp = Series([1,23,34,NA,2,31,None]);print(temp)
temp2 = temp.dropna(); #需要注意,dropna()生成一个新的Series。
temp3 = temp[temp.notnull()];print(temp3) #利用boolindex也可以去除缺失值
0     1.0
1    23.0
2    34.0
3     NaN
4     2.0
5    31.0
6     NaN
dtype: float64

0     1.0
1    23.0
2    34.0
4     2.0
5    31.0
dtype: float64

对于DataFrame来说,指定轴axis和how方式可以进行更为细致的处理,比如how=”all”,axis=”index”可以处理全为NA的行。how的值还可以为any

还有一个参数为trash,此参数针对时间序列数据,rows必须包含trash个非NA数据,否则将被去除

temp = DataFrame([[None,None,None,None,None],[None,1,2,3,4],[None,2,3,4,12]]);temp
0	1	2	3	4
0	None	NaN	NaN	NaN	NaN
1	None	1.0	2.0	3.0	4.0
2	None	2.0	3.0	4.0	12.0
print(temp.dropna(axis="index",how="all")) 
#temp.dropna(axis=0,how="all")也可以 默认按照行处理
print(temp.dropna(axis=1,how="all"))
print(temp.dropna(how="all").dropna(axis=1))
      0    1    2    3     4
1  None  1.0  2.0  3.0   4.0
2  None  2.0  3.0  4.0  12.0
     1    2    3     4
0  NaN  NaN  NaN   NaN
1  1.0  2.0  3.0   4.0
2  2.0  3.0  4.0  12.0
     1    2    3     4
1  1.0  2.0  3.0   4.0
2  2.0  3.0  4.0  12.0
print(temp.dropna(thresh=5))
print(temp.dropna(thresh=4))
Empty DataFrame
Columns: [0, 1, 2, 3, 4]
Index: []
      0    1    2    3     4
1  None  1.0  2.0  3.0   4.0
2  None  2.0  3.0  4.0  12.0

1.2.3 缺失值的填充

填充缺失数据可以使用fillna() DataFrame.fillna(value=None, method=None, axis=None, inplace=False,limit=None)

传入参数为填充值、填充方法(向前,向后),轴、就地替换,填充多少

frame = DataFrame([[1,2,3],[2,NA,3],[1,NA,NA]]);frame
0	1	2
0	1	2.0	3.0
1	2	NaN	3.0
2	1	NaN	NaN
frame.fillna(0) # 需要注意,不能同时指定 method="ffill"和value,
# 如果指定method,使用limit限制填充数目。
frame.fillna({1:666,2:888}) #不仅仅可以填充标量,还可以填充字典,
# 默认使用column填充不同数值
    0	1	2
0	1	2.0	3.0
1	2	666.0	3.0
2	1	666.0	888.0
frame = DataFrame(np.random.randn(5,5),index=list("12345"),columns=list("abcde"))
frame.iloc[:2,3] = NA;frame.iloc[:4,1]=NA
frame.fillna(method="bfill",limit=3)
    a	b	c	d	e
1	0.373929	NaN 0.230848	1.131250	-0.598619
2	-0.688854	1.356393	2.109390	1.131250	0.293097
3	-0.271625	1.356393	0.549346	1.131250	0.780131
4	0.013845	1.356393	-0.873472	-1.028130	-1.961575
5	-0.302951	1.356393	-0.060635	-1.108226	-0.593790

1.2.4 丢弃指定轴上的项

一般而言,drop可以针对index和column,如果不指定则针对index,如果指定轴为1和指定column是一样的效果。使用inplace可以原地替换。除了drop之外,还可以使用 del df["some column index name"]

obj = DataFrame(np.random.randint(0,100,size=25).reshape(5,5),
columns=["A","B","C","D","E"]);
print(obj)
newobj = obj.drop(0)
newobj_2 = obj.drop([0,1])
newobj_3 = obj.drop(columns=["D"])
newobj_4 = obj.drop(["E"],axis=1,inplace=True) #可以就地替换
print(newobj,newobj_2,newobj_3,obj,sep="\n\n")
    A   B   C   D   E
0  34  23  41  97  49
1  61  15  78  38  56
2  95   1  91  84   8
3  11  19   1  13  93
4  87  25  96  87  72

    A   B   C   D   E
1  61  15  78  38  56
2  95   1  91  84   8
3  11  19   1  13  93
4  87  25  96  87  72

    A   B   C   D   E
2  95   1  91  84   8
3  11  19   1  13  93
4  87  25  96  87  72

    A   B   C   E
0  34  23  41  49
1  61  15  78  56
2  95   1  91   8
3  11  19   1  93
4  87  25  96  72

    A   B   C   D
0  34  23  41  97
1  61  15  78  38
2  95   1  91  84
3  11  19   1  13
4  87  25  96  87


2. 合并数据集

2.1 merge/join:横轴的合并

使用 pd.merge(on,left_on,right_on,how,copy,suffiex) 进行数据集的合并。

2.1.1 简单轴的合并

需要注意,on如果不指定,则默认按照共同的轴来合并。推荐指定一个轴进行合并

from pandas import DataFrame ,Series
df1 = DataFrame(np.random.randn(10).reshape(5,2),columns=["data","s1"]);
df1["nov"]=[1,2,3,4,5];
df1 = df1.reindex(columns=["nov","data","s1"])

df2 = DataFrame(np.random.randn(10).reshape(5,2),columns=["data","s2"]);
df2["nov"]=[1,2,3,4,5];
df2 = df2.reindex(columns=["nov","data","s2"])
print(df1)
print(df2)
   nov      data        s1
0    1 -0.204708  0.478943
1    2 -0.519439 -0.555730
2    3  1.965781  1.393406
3    4  0.092908  0.281746
4    5  0.769023  1.246435

   nov      data        s2
0    1  1.007189 -1.296221
1    2  0.274992  0.228913
2    3  1.352917  0.886429
3    4 -2.001637 -0.371843
4    5  1.669025 -0.438570

On参数的使用:

pd.merge(df1,df2) #默认会按照所有相同的列来合并
print(pd.merge(df1,df2,on="nov",suffixes=("_1","_2")))
#on可以指定需要参考合并的column,重复的数据会添加_x,_y标签,使用suffixes指定duple。
   nov    data_1        s1    data_2        s2
0    1 -0.204708  0.478943  1.007189 -1.296221
1    2 -0.519439 -0.555730  0.274992  0.228913
2    3  1.965781  1.393406  1.352917  0.886429
3    4  0.092908  0.281746 -2.001637 -0.371843
4    5  0.769023  1.246435  1.669025 -0.438570

how参数的使用:

df1 = df1.loc[:3];print(df1)
df2 = df2.loc[[0,1,2,4]];print(df2)

pd.merge(df1,df2,on="nov",how="inner")
pd.merge(df1,df2,on="nov",how="left").fillna("NA")

print(pd.merge(df1,df2,on="nov",how="outer").fillna("NA")) 
//#how的作用是取交集、并集、以左边为准、以右边为准
print(pd.merge(df1,df2,left_on="nov",right_on="nov",how="left").fillna("NA")) 
//#其中left_on是指定左边需要比较的column,有时候left_on和
//#right_on不同,需要这样写,而不是使用一个on
   nov      data        s1
0    1 -0.204708  0.478943
1    2 -0.519439 -0.555730
2    3  1.965781  1.393406
3    4  0.092908  0.281746
   nov      data        s2
0    1  1.007189 -1.296221
1    2  0.274992  0.228913
2    3  1.352917  0.886429
4    5  1.669025 -0.438570
   nov     data_x        s1    data_y        s2
0    1  -0.204708  0.478943   1.00719  -1.29622
1    2  -0.519439  -0.55573  0.274992  0.228913
2    3    1.96578   1.39341   1.35292  0.886429
3    4  0.0929079  0.281746        NA        NA
4    5         NA        NA   1.66903  -0.43857
   nov    data_x        s1    data_y        s2
0    1 -0.204708  0.478943   1.00719  -1.29622
1    2 -0.519439 -0.555730  0.274992  0.228913
2    3  1.965781  1.393406   1.35292  0.886429
3    4  0.092908  0.281746        NA        NA

2.1.2 简单索引的合并

首先构造一个简单索引。

df1["new_index"] = list("aabc");
df1 = df1.set_index("new_index");
df1.index.name = "num";
print(df1)
df2 = DataFrame([23,213,43,12],index=list("accb"),columns=["data"]);
print(df2)
     nov      data        s1
num                         
a      1 -0.204708  0.478943
a      2 -0.519439 -0.555730
b      3  1.965781  1.393406
c      4  0.092908  0.281746
   data
a    23
c   213
c    43
b    12

简单索引的合并依旧使用merge函数,不过需要声明index参数而不是on参数。

index参数的使用:

print(pd.merge(df1,df2,left_index=True,right_index=True,how="inner"))
#简单索引需要声明left_index和right_index,如果左边的并非索引,而不需要
# 声明left_index,而需要声明left_on
   nov    data_x        s1  data_y
a    1 -0.204708  0.478943      23
a    2 -0.519439 -0.555730      23
b    3  1.965781  1.393406      12
c    4  0.092908  0.281746     213
c    4  0.092908  0.281746      43

2.1.3 层次化索引的合并

和简单索引类似,区别是,如果是column labels和index进行合并,则xx_on需要传递一个包含label name的列表。除此之外,也可以实现index和index的合并。

lefth = pd.DataFrame({'key1': ['Ohio', 'Ohio', 'Ohio',
                               'Nevada', 'Nevada'],
                      'key2': [2000, 2001, 2002, 2001, 2002],
                      'data': np.arange(5.)})
righth = pd.DataFrame(np.arange(12).reshape((6, 2)),
                      index=[['Nevada', 'Nevada', 'Ohio', 'Ohio',
                              'Ohio', 'Ohio'],
                             [2001, 2000, 2000, 2000, 2001, 2002]],
                      columns=['event1', 'event2'])
print(lefth)
print(righth)
   data    key1  key2
0   0.0    Ohio  2000
1   1.0    Ohio  2001
2   2.0    Ohio  2002
3   3.0  Nevada  2001
4   4.0  Nevada  2002
             event1  event2
Nevada 2001       0       1
       2000       2       3
Ohio   2000       4       5
       2000       6       7
       2001       8       9
       2002      10      11
abc = pd.merge(lefth,righth,left_on=["key1","key2"],right_index=True,how="outer")
print(abc)
   data    key1  key2  event1  event2
0   0.0    Ohio  2000     4.0     5.0
0   0.0    Ohio  2000     6.0     7.0
1   1.0    Ohio  2001     8.0     9.0
2   2.0    Ohio  2002    10.0    11.0
3   3.0  Nevada  2001     0.0     1.0
4   4.0  Nevada  2002     NaN     NaN
4   NaN  Nevada  2000     2.0     3.0
left2 = pd.DataFrame([[1., 2.], [3., 4.], [5., 6.]],
                     index=['a', 'c', 'e'],
                     columns=['Ohio', 'Nevada'])
right2 = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [13, 14]],
                      index=['b', 'c', 'd', 'e'],
                      columns=['Missouri', 'Alabama'])
abd = pd.merge(left2,right2,left_index=True,right_index=True,how="outer").fillna(0)
print(abd)
   Ohio  Nevada  Missouri  Alabama
a   1.0     2.0       0.0      0.0
b   0.0     0.0       7.0      8.0
c   3.0     4.0       9.0     10.0
d   0.0     0.0      11.0     12.0
e   5.0     6.0      13.0     14.0

join方法

除了使用merge外,其实还可以使用join方法。和merge类似,其也有how、on参数,但是join有lsuffix和rsuffix代替suffixes选项。join可以传入一组DataFrame以连接多个(少用),不过concat也可以。

Join columns with other DataFrame either on index or on a key column

作为比较而言,merge可以连接index和column,更为通用。但是后者可以完全重新制定column名,而不仅仅是添加一个后缀。并且,后者更面向对象一些。

abe = left2.join(right2,how="outer") 
print(abe)
   Ohio  Nevada  Missouri  Alabama
a   1.0     2.0       NaN      NaN
b   NaN     NaN       7.0      8.0
c   3.0     4.0       9.0     10.0
d   NaN     NaN      11.0     12.0
e   5.0     6.0      13.0     14.0

2.2 concat:横纵轴的合并

区分与横轴合并使用merge(面向过程)和join(面向对象)方法,Concat连接多用于时间序列等纵轴的合并,虽然concat也是面向过程函数,但是其功能更加强大,可以指定轴,这意味着其也可以完成merge和join的大部分工作。

pandas.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True)

参数含义解释:

  • axis轴默认为0,也可以设置为1,类似于merge
  • join和merge中的how是一个意思
  • join_axes是join的高级版,可以更加精细的从纵向选取某些列
  • keys可以区分不同数据集的concat,如果axis为1的话,keys即columns。指定keys后会形成多层索引,如果不指定keys,则默认合并相同轴,形成简单索引。
  • ignore_index 丢弃连接轴上的索引并生成新的索引
  • levels 定义keys在多层索引的级别.

Series的Concat

s1 = pd.Series([0, 1], index=['a', 'b'])
s2 = pd.Series([2, 3, 4], index=['c', 'd', 'e'])
s3 = pd.Series([5, 6], index=['f', 'g'])

print(pd.concat([s1,s2,s3])) 
//#一般而言,轴默认为0,如果设置为1,则成为DataFrame。
print(pd.concat([s1,s2,s3],axis=0,join="outer"))
print(pd.concat([s1,s2,s3],axis=0,keys=["A","B","C"]))
print(pd.concat([s1,s2,s3],axis=1))
print(pd.concat([s1,s2,s3],axis=1,join_axes=[["a","c","e"]])) 
//#join_axes可以指定选取某些列,其必须为花式索引,axis不能为0. 
print(pd.concat([s1,s2,s3],axis=1,keys=["A","B","C"]))
a    0
b    1
c    2
d    3
e    4
f    5
g    6
dtype: int64
a    0
b    1
c    2
d    3
e    4
f    5
g    6
dtype: int64
A  a    0
b    1
B  c    2
d    3
e    4
C  f    5
g    6
dtype: int64
    0    1    2
a  0.0  NaN  NaN
b  1.0  NaN  NaN
c  NaN  2.0  NaN
d  NaN  3.0  NaN
e  NaN  4.0  NaN
f  NaN  NaN  5.0
g  NaN  NaN  6.0
    0    1   2
a  0.0  NaN NaN
c  NaN  2.0 NaN
e  NaN  4.0 NaN
    A    B    C
a  0.0  NaN  NaN
b  1.0  NaN  NaN
c  NaN  2.0  NaN
d  NaN  3.0  NaN
e  NaN  4.0  NaN
f  NaN  NaN  5.0
g  NaN  NaN  6.0

DataFrame的concat

和Series类似,区别是,其默认的join方法为outer,多了一个names参数来定义索引标签名称,如果axis为1,keys为level0的索引。

此外,可以使用ignore_index来丢弃连接轴上的索引并生成新的索引。使用levels指定索引级别。

df1 = pd.DataFrame(np.arange(6).reshape(3, 2), index=['a', 'b', 'c'],
                   columns=['one', 'two'])
df2 = pd.DataFrame(5 + np.arange(4).reshape(2, 2), index=['a', 'c'],
                   columns=['three', 'four'])
print(df1)
print(df2)
   one  two
a    0    1
b    2    3
c    4    5
   three  four
a      5     6
c      7     8

如果不指定axis,默认是纵轴连接,会有四个column,分别是one、two、three和four。而df1和df2的纵轴不会合并。如果指定axis为1,则为横轴连接,也会有四个column,但是纵轴会自动合并,和merge类似。

key参数类似于: fa = pd.concat({"S1":df1,"S2":df2},axis=1,names=["Level0","Level1"]),也可以使用词典key来充当Column Level0 Index Name

level参数类似于:swaplevel("Level0","Level1",axis=1)

print(pd.concat([df1,df2]))
print(pd.concat([df1,df2],axis=0,keys=["A","B"]))
print(pd.concat([df1,df2],axis=1))
print(pd.concat([df1,df2],axis=1,keys=["A","B"]))
four  one  three  two
a   NaN  0.0    NaN  1.0
b   NaN  2.0    NaN  3.0
c   NaN  4.0    NaN  5.0
a   6.0  NaN    5.0  NaN
c   8.0  NaN    7.0  NaN

    four  one  three  two
A   a   NaN  0.0    NaN  1.0
    b   NaN  2.0    NaN  3.0
    c   NaN  4.0    NaN  5.0
B   a   6.0  NaN    5.0  NaN
    c   8.0  NaN    7.0  NaN

one  two  three  four
a    0    1    5.0   6.0
b    2    3    NaN   NaN
c    4    5    7.0   8.0

    A         B     
one two three four
a   0   1   5.0  6.0
b   2   3   NaN  NaN
c   4   5   7.0  8.0

2.3 combin_first:重叠数据的合并

一般而言,对于两份几乎一样的数据集,一份作为主要数据集,而这份数据集存在数据缺失,想要从副数据集中提取数据进行填充合并,可以使用 np.where 或者 pandas.combin_first 进行操作。

a = pd.Series([np.nan, 2.5, np.nan, 3.5, 4.5, np.nan],
              index=['f', 'e', 'd', 'c', 'b', 'a'])
b = pd.Series(np.arange(len(a), dtype=np.float64),
              index=['f', 'e', 'd', 'c', 'b', 'a'])
print(a,b)
f    NaN
e    2.5
d    NaN
c    3.5
b    4.5
a    NaN
dtype: float64 f    

0.0

e    1.0
d    2.0
c    3.0
b    4.0
a    5.0
dtype: float64
b[-1]=np.nan;b
f    0.0
e    1.0
d    2.0
c    3.0
b    4.0
a    NaN
dtype: float64
np.where(pd.isna(a),b,a) #使用np.where可以自动数据对其并且进行数据合并
array([0. , 2.5, 2. , 3.5, 4.5, nan])

此外,对于pandas来说,可以使用 combine_first

a.combine_first(b) #对于Series,会自动进行数据补齐
f    0.0
e    2.5
d    2.0
c    3.5
b    4.5
a    NaN
dtype: float64
df1 = pd.DataFrame({'a': [1., np.nan, 5., np.nan],
                    'b': [np.nan, 2., np.nan, 6.],
                    'c': range(2, 18, 4)})
df2 = pd.DataFrame({'a': [5., 4., np.nan, 3., 7.],
                    'b': [np.nan, 3., 4., 6., 8.]})
print(df1)
print(df2)
print(df1.combine_first(df2)) 
//#对于DataFrame而言,会对每个单元格进行修正
     a    b   c
0  1.0  NaN   2
1  NaN  2.0   6
2  5.0  NaN  10
3  NaN  6.0  14

     a    b
0  5.0  NaN
1  4.0  3.0
2  NaN  4.0
3  3.0  6.0
4  7.0  8.0

     a    b     c
0  1.0  NaN   2.0
1  4.0  2.0   6.0
2  5.0  4.0  10.0
3  3.0  6.0  14.0
4  7.0  8.0   NaN

3. 重塑和轴向旋转

3.1 stack堆叠

reshape和pivot。轴向旋转主要使用的函数是stack()和unstack(),以及一个快捷方式:pivote()。

stack和unstack:其中stack可以将列转换成行(也就是生成一个层次化索引的Series)。unstack可以在DataFrame和层次化索引的Series之间进行转换。

data = pd.DataFrame(np.arange(6).reshape((2, 3)),
                    index=pd.Index(['Ohio', 'Colorado'], name='state'),
                    columns=pd.Index(['one', 'two', 'three'],
                    name='number'))
print(data)
number    one  two  three
state                    
Ohio        0    1      2
Colorado    3    4      5
data.stack()
state     number
Ohio      one       0
          two       1
          three     2
Colorado  one       3
          two       4
          three     5
dtype: int32
print(data.stack().unstack())
number    one  two  three
state                    
Ohio        0    1      2
Colorado    3    4      5

stack轴选择

stack中有一个关键参数叫做dropna=bool,stack/unstack中的一个关键参数是操作轴,默认而言,是操作最内层进行堆叠,自然,也可以手动指定。

data = pd.DataFrame(np.arange(6).reshape((2, 3)),
                    index=pd.Index(['Ohio', 'Colorado'], name='state'),
                    columns=[["A","B","C"],['one', 'two', 'three']])
data.columns.names = ["Outer","Inner"]
print(data)
Outer      A   B     C
Inner    one two three
state                 
Ohio       0   1     2
Colorado   3   4     5
print(data.stack("Outer",dropna=False))
print(data.stack("Inner",dropna=True))
Inner           one  three  two
state    Outer                 
Ohio     A      0.0    NaN  NaN
         B      NaN    NaN  1.0
         C      NaN    2.0  NaN
Colorado A      3.0    NaN  NaN
         B      NaN    NaN  4.0
         C      NaN    5.0  NaN
Outer             A    B    C
state    Inner               
Ohio     one    0.0  NaN  NaN
         three  NaN  NaN  2.0
         two    NaN  1.0  NaN
Colorado one    3.0  NaN  NaN
         three  NaN  NaN  5.0
         two    NaN  4.0  NaN

3.2 pivot转换

pivote用于将long/stacked长格式转化成为unstacked宽格式。其实其本质相当于unstack,对stack后的数据使用set_index设置索引,使用unstack进行反向堆叠,然后re_index重新设置索引的过程。

pivote有三个参数,分别是index(按照某个column列作为基准,转换后成为新的row index)、column(某个column列,转换后成为新的column index),value(如果不指定,其余的列会形成符合索引,可以使用re_index设置)。

data = pd.read_csv('examples/macrodata.csv')
print(data.head(3))
     year  quarter   realgdp  realcons  realinv  realgovt  realdpi    cpi  \
0  1959.0      1.0  2710.349    1707.4  286.898   470.045   1886.9  28.98   
1  1959.0      2.0  2778.801    1733.7  310.859   481.301   1919.7  29.15   
2  1959.0      3.0  2775.488    1751.8  289.226   491.260   1916.4  29.35   

      m1  tbilrate  unemp      pop  infl  realint  
0  139.7      2.82    5.8  177.146  0.00     0.00  
1  141.7      3.08    5.1  177.830  2.34     0.74  
2  140.5      3.82    5.3  178.657  2.74     1.09  
periods = pd.PeriodIndex(year=data.year, quarter=data.quarter,
                         name='date') 
print(periods) #生成一个特殊的Q DEC索引,名称叫做name
columns = pd.Index(['realgdp', 'infl', 'unemp'], name='item')
print(columns) #column索引
PeriodIndex(['1959Q1', '1959Q2', '1959Q3', '1959Q4', '1960Q1', '1960Q2',
             '1960Q3', '1960Q4', '1961Q1', '1961Q2',
             ...
             '2007Q2', '2007Q3', '2007Q4', '2008Q1', '2008Q2', '2008Q3',
             '2008Q4', '2009Q1', '2009Q2', '2009Q3'],
            dtype='period[Q-DEC]', name='date', length=203, freq='Q-DEC')
Index(['realgdp', 'infl', 'unemp'], dtype='object', name='item')
data = data.reindex(columns=columns)
data.index = periods.to_timestamp('D', 'end')
print(data[:4])
ldata = data.stack().reset_index().rename(columns={0:"value"})
print(ldata[:4])
item         realgdp  infl  unemp
date                             
1959-03-31  2710.349  0.00    5.8
1959-06-30  2778.801  2.34    5.1
1959-09-30  2775.488  2.74    5.3
1959-12-31  2785.204  0.27    5.6
        date     item     value
0 1959-03-31  realgdp  2710.349
1 1959-03-31     infl     0.000
2 1959-03-31    unemp     5.800
3 1959-06-30  realgdp  2778.801
ldata["value2"] = np.random.randn(len(ldata))
print(ldata[:4])
pivot = ldata.pivot(index="date",columns="item",values="value");
pivot2 = ldata.pivot(index="date",columns="item");
print(pivot[:4]) 
#pivot执行的是和unstack类似的ldata反向操作,需要指定一个index,column的来源。
# 如果含有其余多个列,不指定value的话,则会
#默认生成层次化column索引,否则则抛弃未指定的值。
print(pivot2[:4])
        date     item     value    value2
0 1959-03-31  realgdp  2710.349  0.887204
1 1959-03-31     infl     0.000  0.014331
2 1959-03-31    unemp     5.800 -0.074155
3 1959-06-30  realgdp  2778.801 -0.048565

item        infl   realgdp  unemp
date                             
1959-03-31  0.00  2710.349    5.8
1959-06-30  2.34  2778.801    5.1
1959-09-30  2.74  2775.488    5.3
1959-12-31  0.27  2785.204    5.6

           value                    value2                    
item        infl   realgdp unemp      infl   realgdp     unemp
date                                                          
1959-03-31  0.00  2710.349   5.8  0.014331  0.887204 -0.074155
1959-06-30  2.34  2778.801   5.1  1.235021 -0.048565 -0.433295
1959-09-30  2.74  2775.488   5.3  0.820211  1.391035 -0.247423
1959-12-31  0.27  2785.204   5.6  0.543980  0.302271 -0.942369

pivot其实就是set_index和unstack的一个快捷方式。对于多余的value2,可以使用层次化索引的reindex进行重新指定。

pivot_like = ldata.set_index(["date","item"]).unstack("item");
pivot_like2 = ldata.set_index(["date","item"]).unstack("item")
.reindex(["value"],level=0,axis=1);

newindex = pd.MultiIndex.from_arrays([["value","value","value","value2","value2"],["infl","unemp","realgdp","unemp","realgdp"]])
print(newindex)

pivot_like3 = ldata.set_index(["date","item"]).unstack("item")
.reindex(newindex,axis=1); #不用写,level=(0,1)了。

pivot_like4 = ldata.set_index(["date","item"]).unstack("item")
.reindex([["value","value","value","value2"],
["infl","unemp","realgdp","unemp"]],axis=1); 
#如果声明一个mutipiindex后,不能写,level=(0,1)

print(pivot_like[:3])
print(pivot_like2[:3])
print(pivot_like3[:3]) 
//#Mutipiindex使用from_array和from_tuple必须在level0级别内分别制定level1的数目
print(pivot_like4[:3])
MultiIndex(levels=[['value', 'value2'], ['infl', 'realgdp', 'unemp']],
           labels=[[0, 0, 0, 1, 1], [0, 2, 1, 2, 1]])

           value                    value2                    
item        infl   realgdp unemp      infl   realgdp     unemp
date                                                          
1959-03-31  0.00  2710.349   5.8  0.014331  0.887204 -0.074155
1959-06-30  2.34  2778.801   5.1  1.235021 -0.048565 -0.433295
1959-09-30  2.74  2775.488   5.3  0.820211  1.391035 -0.247423

           value                
item        infl   realgdp unemp
date                            
1959-03-31  0.00  2710.349   5.8
1959-06-30  2.34  2778.801   5.1
1959-09-30  2.74  2775.488   5.3

           value                    value2          
            infl unemp   realgdp     unemp   realgdp
date                                                
1959-03-31  0.00   5.8  2710.349 -0.074155  0.887204
1959-06-30  2.34   5.1  2778.801 -0.433295 -0.048565
1959-09-30  2.74   5.3  2775.488 -0.247423  1.391035

           value                    value2
item        infl unemp   realgdp     unemp
date                                      
1959-03-31  0.00   5.8  2710.349 -0.074155
1959-06-30  2.34   5.1  2778.801 -0.433295
1959-09-30  2.74   5.3  2775.488 -0.247423
arrays = [[1, 1, 2, 2], ['red', 'blue', 'red', 'blue']]
pd.MultiIndex.from_arrays(arrays, names=('number', 'color'))
MultiIndex(levels=[[1, 2], ['blue', 'red']],
           labels=[[0, 0, 1, 1], [1, 0, 1, 0]],
           names=['number', 'color'])

4. 数据剔除、转换和抽取

常见的数据转换主要分为以下几类: 重复数据和缺失值的检测、过滤和替换,map、applymap数据操纵和变换,不同数据形式的转换(离散分组、分类统计、抽样等)。

4.1 值异常:检测和过滤

本质上来说,异常值的过滤是数组运算。一些常用的np函数有any(),abs()和sign()以及describe()。使用bool型索引对其进行过滤。

一个可能的流程是:对于分类数据,可以使用value_counts()和unique()以及isin()进行异常判断;对于连续数据,还可以在此基础上使用describe()和std()(如果我们将大于多少标准差的值看作异常),最后使用bool型索引进行过滤。

需要注意,在过滤数据的时候,DF.any()这个函数很有帮助,bool型索引生成一个ndarray/dataframe,但是是对于每一个元素进行判断的,使用any可以保证对于一行/列,甚至一个level进行判断,如果在这个范围内任意元素出现异常,标记所有行/列/level为异常。然后就可以对其进行过滤。

DataFrame.any(axis=None, bool_only=None, skipna=None, level=None, **kwargs)

data=...
drop data[(np.abs(data)>data.std()*3).any(1)]
# 这个可以对大于三个标准差的数据进行处理
data = pd.DataFrame(np.random.randn(1000, 4))
print(data.describe())
                 0            1            2            3
count  1000.000000  1000.000000  1000.000000  1000.000000
mean      0.042343    -0.044058    -0.029533     0.003557
std       0.990727     0.978300     0.993268     1.025561
min      -3.333767    -2.901831    -3.108915    -3.645860
25%      -0.628630    -0.739475    -0.745047    -0.692099
50%       0.028040    -0.070391    -0.076246     0.028360
75%       0.690847     0.664260     0.634823     0.722198
max       3.525865     2.611678     3.366626     2.763474
data[(np.abs(data) > 3).any(1)] = np.sign(data)*3
print(data.describe())
                 0            1            2            3
count  1000.000000  1000.000000  1000.000000  1000.000000
mean      0.042814    -0.048896    -0.031920     0.008760
std       1.013954     1.015776     1.020521     1.039471
min      -3.000000    -3.000000    -3.000000    -3.000000
25%      -0.654179    -0.751791    -0.748308    -0.694262
50%       0.028040    -0.071723    -0.076246     0.028360
75%       0.713593     0.666408     0.638751     0.725255
max       3.000000     3.000000     3.000000     3.000000

4.3 行列异常:duplicate重复行列移除

duplicate()和drop_duplicate()可以用来查看和删除重复行。其中,如果不指定参数,其默认选取和删除不是第一个的重复值,如果需要反过来,则使用keep=”last/first”参数。此外,默认这两者都是根据行的全部列判断重复, 可以传入一个column name的list以用于在这些列判断行是否重复。

data = pd.DataFrame({'k1': ['one', 'two'] * 3 + ['two'],
                     'k2': [1, 1, 2, 3, 3, 4, 4]})
print(data)
    k1  k2
0  one   1
1  two   1
2  one   2
3  two   3
4  one   3
5  two   4
6  two   4
print(data.duplicated())
data.drop_duplicates()
print(data.drop_duplicates(["k2"],keep="last"))
0    False
1    False
2    False
3    False
4    False
5    False
6     True
dtype: bool
    k1  k2
1  two   1
2  one   2
4  one   3
6  two   4

4.3 函数映射转换 map/applymap

映射关系指的是创建一个映射关系列表,然后把元素和一个特定标签或者字符串或者应用函数绑定起来。最常用的映射关系定义一般采用dict,如下:

map = {
    "label1":"value1",
    "label2":"value2"
}

对于元素、行列和索引都可以进行映射,对于值来说,我们用replace函数进行映射替换,对于行列来说,我们用map/applymap进行映射替换,对于索引来说,使用rename进行映射替换。

4.3.1 值处理:replace替换元素

可以使用replace进行替换,第一个参数为需要替换的对象,第二个参数为替换后的对象,可以传递标量和标量、列表和标量、列表和列表,以及字典

data = pd.Series([1., -999., 2., -999., -1000., 3.])
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.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

4.3.2 行列处理:map映射

使用map可以将本来已经有的一行/列元素进行替换,也可以创建新的行/列。更灵活的,不仅仅可以使用字典对映射关系进行界定,还可以使用函数,对各个元素进行变换。

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]})
print(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.str.xxx 等同于str.xxx(),对字符串进行的操作。

map可以接受一个函数或者是字典对象,然后生成其对应的序列。

animal = data["food"].str.lower().map(meat_to_animal)
animal = data["food"].map(str.lower).map(meat_to_animal) 
#和上述等同,map用来对一连串序列进行函数化操作
animal = data["food"].map(lambda x:meat_to_animal[x.lower()]) #一个更加紧凑的形式
data["animal"] = animal;
print(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

我们也可以同时使用函数和字典,比如这样:

map = {
    "a":"A",
    "b":"B"
}

def myfunc(g):
    return map.get(g,g)

grouped.map(myufunc)

# 同时使用字典和函数可以保证在字典中的映射可以得以改变,而不在字典中的映射则保持原样。

4.3.3 索引处理:rename重命名

rename可以对所有索引进行更改,可以使用column和index,也可以使用axis。可以传入字典对部分索引更改,使用inplace可以进行原地替换。可以不传入参数,而是传入一个mapper,比如str.upper等。

data = pd.DataFrame(np.arange(12).reshape((3, 4)),
                    index=['Ohio', 'Colorado', 'New York'],
                    columns=['one', 'two', 'three', 'four'])
data.rename({"four":"fff"},axis=1,inplace=False)
#data.rename([["A","B","C"]],axis=1,inplace=False) #不能传递list
# 此外,可以针对index、columns进行参数选择,而不是使用axis,更可以传入一个函数:
print(data.rename(columns=str.upper,inplace=False))
          ONE  TWO  THREE  FOUR
Ohio        0    1      2     3
Colorado    4    5      6     7
New York    8    9     10    11

有时候我们需要将数据的性质进行变换,比如,对于连续型数据,我们需要对其处理以变换成为描述型数据,或者是需要从总体中抽取部分样本做分析,这就需要用到下面的知识:面元划分、计算哑变量和随机抽样。

4.4 离散化和面元划分: (q)cut

对于需要进行分割的数据,使用pd.cut即可。第一个参数为实际数据,第二个参数为分隔段/段数,cut会生成一个categories对象,此对象的codes和categories方法返回原始数据的区分index和categories分段标准本身。一个非常实用的方法是pd.value_counts(categories obj),可以统计在不同段的分别的数值。

cut可以手动传入点列表来分段,也可以自动划分等长的段落,可以指定分段精度以及分段名称,区间闭合选项等。

ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]
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]]
print(cats.codes)
print(cats.categories)
pd.value_counts(cats)
[0 0 0 1 0 0 2 1 3 2 2 1]
IntervalIndex([(18, 25], (25, 35], (35, 60], (60, 100]]
              closed='right',
              dtype='interval[int64]')

(18, 25]     5
(35, 60]     3
(25, 35]     3
(60, 100]    1
dtype: int64
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)]
group_names = ['Youth', 'YoungAdult', 'MiddleAged', 'Senior']
#还可以设置labels name,用来区分不同分段
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]
data = np.random.rand(20)
pd.cut(data, 5, precision=2) #此外,还可以传递分段数而不是分段点来自动分段
#precision定义精度
[(0.57, 0.76], (0.0027, 0.19], (0.38, 0.57], (0.0027, 0.19], (0.57, 0.76], 
..., (0.0027, 0.19], (0.57, 0.76], (0.57, 0.76], (0.0027, 0.19], (0.0027, 0.19]]
Length: 20
Categories (5, interval[float64]): 
[(0.0027, 0.19] < (0.19, 0.38] < (0.38, 0.57] < (0.57, 0.76] < (0.76, 0.95]]

qcut()和cut类似,不过其可以保证分段的个数均等,其按照分位数进行分割:

10 for deciles, 4 for quartiles, etc. Alternately array of quantiles, e.g. [0, .25, .5, .75, 1.] for quartiles

data = np.random.randn(1000)  # Normally distributed
cats = pd.qcut(data, 4)  # Cut into quartiles
print(cats)
print(pd.value_counts(cats))
[(0.035, 0.717], (0.035, 0.717], (-0.6, 0.035], (0.717, 3.26], (-0.6, 0.035], ..., 
(-3.746, -0.6], (-0.6, 0.035], (0.717, 3.26], (0.035, 0.717], (0.717, 3.26]]
Length: 1000
Categories (4, interval[float64]): 
[(-3.746, -0.6] < (-0.6, 0.035] < (0.035, 0.717] < (0.717, 3.26]]
(0.717, 3.26]     250
(0.035, 0.717]    250
(-0.6, 0.035]     250
(-3.746, -0.6]    250
dtype: int64
pd.qcut(data, [0, 0.1, 0.5, 0.9, 1.],precision=2)
[(0.035, 1.32], (0.035, 1.32], (-1.31, 0.035], (0.035, 1.32], (-1.31, 0.035], ..., 
(-1.31, 0.035], (-1.31, 0.035], (0.035, 1.32], (0.035, 1.32], (0.035, 1.32]]
Length: 1000
Categories (4, interval[float64]): 
[(-3.76, -1.31] < (-1.31, 0.035] < (0.035, 1.32] < (1.32, 3.26]]

4.5 计算指标/哑变量 get_dummies

dummy/indicator variables 叫做指标变量或者哑变量,可以对分类变量使用get_dummies()进行处理。传入一个Series或者DF的某一列,生成一个统计其量值的DataFrame,可以使用join连接原本的列。类似于unstack和value_count的合体。

df = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],
                   'data1': range(6)});print(df)
print(pd.get_dummies(df['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
dummies = pd.get_dummies(df['key'], prefix='key')
#prefix为前缀字符串,一般使用指标变量计算时传入Series或者DF的某一列。
print(dummies,type(dummies))
df_with_dummy = df[['data1']].join(dummies) #使用join将一个DF和DF连接起来。
print(df_with_dummy)

# 一个需要注意的点是:
print(type(df[['data1']]),type(df['data1'])) 
# 使用一般切片切取的是column某一列,其实Series,而是用花式索引切取的是DataFrame。
   key_a  key_b  key_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 

<class 'pandas.core.frame.DataFrame'>

   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

<class 'pandas.core.frame.DataFrame'> 

<class 'pandas.core.series.Series'>
mnames = ['movie_id', 'title', 'genres']
movies = pd.read_table('datasets/movielens/movies.dat', sep='::',
                       header=None, names=mnames)
print(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
all_genres = []
for x in movies.genres:
    all_genres.extend(x.split('|')) #两个list相连使用extend而不是append
genres = pd.unique(all_genres) #使用unique统计唯一值
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)


```python
zero_matrix = np.zeros((len(movies), len(genres)))
dummies = pd.DataFrame(zero_matrix, columns=genres);
#print(dummies[:10])
gen = movies.genres[0];print(gen)
gen.split('|')
dummies.columns.get_indexer(gen.split('|'))#获取索引所在位置,这里正好是前三个0,1,2
Animation|Children's|Comedy

array([0, 1, 2], dtype=int64)
#第几行就写入第几行的数据,比如i=1,则写入第一行的0,1,2列数据为1
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][:5]
movie_id                                      1
title                          Toy Story (1995)
genres              Animation|Children's|Comedy
Genre_Animation                               1
Genre_Children's                              1
Name: 0, dtype: object

结合分段的哑变量统计使用非常方便

values = np.random.rand(10)
print(values)
bins = [0, 0.2, 0.4, 0.6, 0.8, 1]
print(pd.cut(values,bins))
print(pd.get_dummies(pd.cut(values, bins).categories))
[0.9296 0.3164 0.1839 0.2046 0.5677 0.5955 0.9645 0.6532 0.7489 0.6536]

[(0.8, 1.0], (0.2, 0.4], (0.0, 0.2], (0.2, 0.4], (0.4, 0.6], (0.4, 0.6], 
(0.8, 1.0], (0.6, 0.8], (0.6, 0.8], (0.6, 0.8]]

Categories (5, interval[float64]): 
[(0.0, 0.2] < (0.2, 0.4] < (0.4, 0.6] < (0.6, 0.8] < (0.8, 1.0]]

   (0.0, 0.2]  (0.2, 0.4]  (0.4, 0.6]  (0.6, 0.8]  (0.8, 1.0]
0           1           0           0           0           0
1           0           1           0           0           0
2           0           0           1           0           0
3           0           0           0           1           0
4           0           0           0           0           1

4.6 排列和随机取样 sample/permut..

numpy.random.permutation 用于随机化,类似于ramdom.choice().其一是传入标量调用arange(n),其二是传入list,随机list的元素值.

此外,还可以使用simple(n,widght,axis)来直接从Series或者DataFrame进行取样

np.random.permutation(10)
array([1, 3, 9, 6, 5, 0, 4, 2, 7, 8])
np.random.permutation(["A","B","C","D","E","F","G"])
array(['B', 'F', 'E', 'C', 'G', 'D', 'A'], dtype='<U1')
df = pd.DataFrame(np.arange(5 * 4).reshape((5, 4)))
print(df)
df.take(np.random.permutation(5)[:3],axis=0).take(np.random.permutation(4),axis=1)
#随机化轴的索引顺序,
#Return the elements in the given positional indices along an axis.
#在随机化轴顺序时take还可以限制只取一部分样
    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
print(df.sample(n=3,axis=0).sample(n=3,axis=1))
print(df.sample(n=3,axis=0).sample(frac=0.5,axis=1))  
#此外,还可以按照比率进行取值而不仅仅是指定数目大小,n和frac不能同时使用。
    1   3   0
0   1   3   0
3  13  15  12
4  17  19  16

    3   2
3  15  14
2  11  10
1   7   6

5. 字符串处理

5.1 Python原生字符串处理方法

val = 'a,b,  guido'
val.split(',')
pieces = [x.strip() for x in val.split(',')]
pieces
first, second, third = pieces
first + '::' + second + '::' + third
'::'.join(pieces)
'guido' in val
val.index(',')
val.find(':')
val.index(':')
val.count(',')
val.replace(',', '::')
val.replace(',', '')

5.2 Python正则表达式

Python正则表达式需要使用 regex=re.compile("rules") 先创建一个规则,然后使用findall寻找所有匹配,使用match匹配开头,使用search匹配一个,使用split进行分割,使用sub进行替换。

import re
regex = re.compile('\s+')
regex.split("foo bar baz \nqux")
['foo', 'bar', 'baz', 'qux']
regex.findall("foo bar baz \nqux")
[' ', ' ', ' \n']
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
text[m.start():m.end()]
'dave@google.com'
print(regex.match(text))
print(regex.sub('REDACTED', text))
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()
regex.findall(text)
print(regex.sub(r'Username: \1, Domain: \2, Suffix: \3', text))

5.3 矢量化字符串处理方法

按理来说,可以直接使用正则和Python自带的字符串方法对多维数组进行操作,但是一个问题是NaN的问题,map函数会出错,因此DataFrame.str内置了很多字符串处理方法。

比如普通Python字符串的in方法(使用contains),正则表达式的findall和match。

data = {'Dave': 'dave@google.com', 'Steve': 'steve@gmail.com',
        'Rob': 'rob@gmail.com', 'Wes': np.nan}
data = pd.Series(data)
print(data)
data.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
data.str.contains('gmail')
Dave     False
Rob       True
Steve     True
Wes        NaN
dtype: object
pattern
data.str.findall(pattern, flags=re.IGNORECASE)
Dave     [dave@google.com]
Rob        [rob@gmail.com]
Steve    [steve@gmail.com]
Wes                    NaN
dtype: object
matches = data.str.match(pattern, flags=re.IGNORECASE) #对各个元素执行re.match。
matches
Dave     True
Rob      True
Steve    True
Wes       NaN
dtype: object
data.str[:5] #此外,str还支持slice、split、replace、strip等常用字符串方法。
Dave     dave@
Rob      rob@g
Steve    steve
Wes        NaN
dtype: object

6. 示例:USDA食品数据库.json

data = pd.read_json("datasets/usda_food/database.json");
index = ["description","group","id","manufacturer"]
info = DataFrame(data,columns=index);
print(info[:5])
                          description                   group    id  \
0                     Cheese, caraway  Dairy and Egg Products  1008   
1                     Cheese, cheddar  Dairy and Egg Products  1009   
2                        Cheese, edam  Dairy and Egg Products  1018   
3                        Cheese, feta  Dairy and Egg Products  1019   
4  Cheese, mozzarella, part skim milk  Dairy and Egg Products  1028   

  manufacturer  
0               
1               
2               
3               
4               
info.group.value_counts()
Vegetables and Vegetable Products    812
Beef Products                        618
Baked Products                       496
Breakfast Cereals                    403
Legumes and Legume Products          365
Fast Foods                           365
Lamb, Veal, and Game Products        345
Sweets                               341
Fruits and Fruit Juices              328
Pork Products                        328
                                    ... 
Ethnic Foods                         165
Snacks                               162
Nut and Seed Products                128
Poultry Products                     116
Sausages and Luncheon Meats          111
Dairy and Egg Products               107
Fats and Oils                         97
Meals, Entrees, and Sidedishes        57
Restaurant Foods                      51
Spices and Herbs                      41
Name: group, Length: 25, dtype: int64
import json
ndata = json.loads(open("datasets/usda_food/database.json").read())
nutrients = ndata[0]["nutrients"];
nutrients = DataFrame(nutrients)
print(nutrients.head(5))
                   description        group units   value
0                      Protein  Composition     g   25.18
1            Total lipid (fat)  Composition     g   29.20
2  Carbohydrate, by difference  Composition     g    3.06
3                          Ash        Other     g    3.28
4                       Energy       Energy  kcal  376.00
print(nutrients.duplicated().sum())
a = nutrients.drop_duplicates()
108
nindex = ["description","group","id","manufacturer"]
info = DataFrame(ndata,columns=nindex);
print(info.head())
                          description                   group    id  \
0                     Cheese, caraway  Dairy and Egg Products  1008   
1                     Cheese, cheddar  Dairy and Egg Products  1009   
2                        Cheese, edam  Dairy and Egg Products  1018   
3                        Cheese, feta  Dairy and Egg Products  1019   
4  Cheese, mozzarella, part skim milk  Dairy and Egg Products  1028   

  manufacturer  
0               
1               
2               
3               
4               
nutrients = []
for item in ndata:
    itemdf = DataFrame(item["nutrients"])
    itemdf["id"] = item["id"]
    nutrients.append(itemdf)
nutrients = pd.concat(nutrients,ignore_index=True)
nutrients = nutrients.rename({"group":"nutgroup","description":"nutrient"},copy=False,axis=1)
info = info.rename({"group":"fgroup","description":"food"},copy=False,axis=1)
ndata = pd.merge(info,nutrients,on="id",how="outer")
print(ndata.head())
              food                  fgroup    id manufacturer  \
0  Cheese, caraway  Dairy and Egg Products  1008                
1  Cheese, caraway  Dairy and Egg Products  1008                
2  Cheese, caraway  Dairy and Egg Products  1008                
3  Cheese, caraway  Dairy and Egg Products  1008                
4  Cheese, caraway  Dairy and Egg Products  1008                

                      nutrient     nutgroup units   value  
0                      Protein  Composition     g   25.18  
1            Total lipid (fat)  Composition     g   29.20  
2  Carbohydrate, by difference  Composition     g    3.06  
3                          Ash        Other     g    3.28  
4                       Energy       Energy  kcal  376.00  
result = ndata.groupby(["nutrient","fgroup"])["value"].quantile(0.5)
result
nutrient          fgroup                           
Adjusted Protein  Sweets                               12.900
                  Vegetables and Vegetable Products     2.180
Alanine           Baby Foods                            0.107
                  Baked Products                        0.248
                  Beef Products                         1.550
                  Beverages                             0.003
                  Breakfast Cereals                     0.311
                  Cereal Grains and Pasta               0.373
                  Dairy and Egg Products                0.273
                  Ethnic Foods                          1.290
                                                        ...  
Zinc, Zn          Nut and Seed Products                 3.290
                  Pork Products                         2.320
                  Poultry Products                      2.500
                  Restaurant Foods                      0.800
                  Sausages and Luncheon Meats           2.130
                  Snacks                                1.470
                  Soups, Sauces, and Gravies            0.200
                  Spices and Herbs                      2.750
                  Sweets                                0.360
                  Vegetables and Vegetable Products     0.330
Name: value, Length: 2246, dtype: float64
result["Zinc, Zn"].plot(kind="barh")
<matplotlib.axes._subplots.AxesSubplot at 0x4912cc5cf8>

png

————————————————————————————————————

更新日志

2018-02-27 完成《利用Python进行数据分析》阅读和笔记

2018-03-25 完成笔记补充和目录整理

2018-03-28 na值处理的笔记补充,添加了StringIO读写的说明。

搜索

    Post Directory