数据分析和建模大部分时间都用在数据准备上，数据的准备过程包括：加载，清理，转换与重塑。
合并数据集
pandas对象中的数据可以通过一些内置方法来进行合并：
pandas.merge可根据一个或多个键将不同DataFrame中的行连接起来，实现类似于数据库中的连接操作。
pandas.cancat表示沿着一条轴将多个对象堆叠到一起。
实例方法combine_first可以将重复数据编接在一起，用一个对象中的值填充另一个对象的缺失值。
下面将进行分别讲解：
1、数据库风格的DateFrame合并
数据集的合并运算是通过一个或者多个键将行连接起来，主要使用的merge或者join方法。
>>> import pandas as pd
>>> from pandas import DataFrame
>>> import numpy as np
>>> df1=DataFrame({'key':['b','b','a','c','a','a','b'],'data1':range(7)})
>>> df2=DataFrame({'key':['a','b','d'],'data2':range(3)})
>>> pd.merge(df1,df2)
data1 key data2
0 0 b 1
1 1 b 1
2 6 b 1
3 2 a 0
4 4 a 0
5 5 a 0
#未显示指定用何列拼接，默认用重叠列的作为键，最好显示指定
>>> pd.merge(df1,df2,on='key')
data1 key data2
0 0 b 1
1 1 b 1
2 6 b 1
3 2 a 0
4 4 a 0
5 5 a 0
#当两个对象列明不同可以进行分别指定
>>> df3=DataFrame({'lkey':['b','b','a','c','a','a','b'],'data1':range(7)})
>>> df4=DataFrame({'rkey':['a','b','d'],'data2':range(3)})
>>> pd.merge(df3,df4,left_on='lkey',right_on='rkey')
data1 lkey data2 rkey
0 0 b 1 b
1 1 b 1 b
2 6 b 1 b
3 2 a 0 a
4 4 a 0 a
5 5 a 0 a
#默认情况下merge函数进行的是交集操作，可以指定how参数来实现左右连接与并集(outer)
#根据多个键进行合并，传入一个由列名组成的列表即可
>>> left=DataFrame({'key1':['foo','foo','bar'],'key2':['one','two','three'],'lval':[1,2,3]})
>>> right=DataFrame({'key1':['foo','foo','bar','bar'],'key2':['one','two','one','two'],'rval':[4,5,6,7]})
>>> pd.merge(left,right,on=['key1','key2'],how='outer')
key1 key2 lval rval
0 foo one 1 4
1 foo two 2 5
2 bar three 3 NaN
3 bar one NaN 6
4 bar two NaN 7
对于合并运算需要考虑的最后一个问题是对重复列名的处理，merge有一个suffixes选项，用于指定附加到左右两个DataFrame对象的重叠列名上的字符串：
>>> pd.merge(left,right,on='key1')
key1 key2_x lval key2_y rval
0 foo one 1 one 4
1 foo one 1 two 5
2 foo two 2 one 4
3 foo two 2 two 5
4 bar three 3 one 6
5 bar three 3 two 7
>>> pd.merge(left,right,on='key1',suffixes=('_left','_right'))
key1 key2_left lval key2_right rval
0 foo one 1 one 4
1 foo one 1 two 5
2 foo two 2 one 4
3 foo two 2 two 5
4 bar three 3 one 6
5 bar three 3 two 7
| merge函数的参数表 | |
| left | 参与合并的左侧DataFrame |
| right | 参与合并的右侧DataFrame |
| how | 选定参与合并的方式（inner，outer，left等） |
| on | 用于连接的列名 |
| left_on | 左侧DataFrame中用于连接的键 |
| right_on | 右侧DataFrame中用于连接的键 |
| sort | 根据连接键对合并后的数据进行排序，默认为True |
| suffixes |
字符串元组，用于追加到重叠列名的末尾 |
2、索引上的合并
有时，DataFrame中的连接位于其索引中，在此种情况下可以传入left_index=True或者right_index=True以说明索引应该被用作连接键：
>>> left1=DataFrame({'key':['a','b','a','a','b','c'],'value':range(6)})
>>> right1=DataFrame({'group':[3.5,7]},index=['a','b'])
>>> left1
key value
0 a 0
1 b 1
2 a 2
3 a 3
4 b 4
5 c 5
>>> right1
group
a 3.5
b 7.0
对于层次化索引数据，相对更为复杂些，在这种情况下，必须以列表的形式指明用作合并键的多个列
>>> lenth=DataFrame({'key1':['ohio','ohio','ohio','nevada','nevada'],'key2':[2000,2001,2002,2001,2002],'data':np.arange(5)})
>>> righth=DataFrame(np.arange(12).reshape((6,2)),index=[['neveda','neveda','ohio','ohio','ohio','ohio'],[2001,2000,2000,2000,2001,2002]],columns=['event1','event2'])
>>> lenth
data key1 key2
0 0 ohio 2000
1 1 ohio 2001
2 2 ohio 2002
3 3 nevada 2001
4 4 nevada 2002
>>> righth
event1 event2
neveda 2001 0 1
2000 2 3
ohio 2000 4 5
2000 6 7
2001 8 9
2002 10 11
>>> pd.merge(lenth,righth,left_on=['key1','key2'],right_index=True)
data key1 key2 event1 event2
0 0 ohio 2000 4 5
0 0 ohio 2000 6 7
1 1 ohio 2001 8 9
2 2 ohio 2002 10 11
DataFrame还有一个join实例方法，它可以更为方便的实现按索引合并，还可以合并多个带有相同或者相似索引的DataFrame对象，而不管其是否有重叠的列：
>>> left2=DataFrame([[1,2],[3,4],[5,6]],index=['a','c','e'],columns=['ohio','nevada'])
>>> left2
ohio nevada
a 1 2
c 3 4
e 5 6
>>> right2=DataFrame([[7,8],[9,10],[11,12],[13,14]],index=['b','c','d','e'],columns=['missouri','alambda'])
>>> right2
missouri alambda
b 7 8
c 9 10
d 11 12
e 13 14
>>> left2.join(right2,how='outer')
ohio nevada missouri alambda
a 1 2 NaN NaN
b NaN NaN 7 8
c 3 4 9 10
d NaN NaN 11 12
e 5 6 13 14
3、轴向连接
纵向上，numpy有一个用于合并原始numpy数组的concatenation函数：
>>> arr=np.arange(12).reshape((3,4))
>>> arr
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> np.concatenate([arr,arr],axis=1)
array([[ 0, 1, 2, 3, 0, 1, 2, 3],
[ 4, 5, 6, 7, 4, 5, 6, 7],
[ 8, 9, 10, 11, 8, 9, 10, 11]])
>>> np.concatenate([arr,arr],axis=0)
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
#pandas的concat函数提供了一种能够解决这些问题的可靠方式，默认情况下，concat在0轴上工作，
>>> 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'])
>>> pd.concat([s1,s2,s3])
a 0
b 1
c 2
d 3
e 4
f 5
g 6
dtype: int64
#axis=1时，得到一个DataFrame对象
>>> pd.concat([s1,s2,s3],axis=1)
0 1 2
a 0 NaN NaN
b 1 NaN NaN
c NaN 2 NaN
d NaN 3 NaN
e NaN 4 NaN
f NaN NaN 5
g NaN NaN 6
可以通过join_axes指定要在其他轴上使用的索引：
>>> s4=pd.concat([s1*5,s3])
>>> s4
a 0
b 5
f 5
g 6
dtype: int64
>>> pd.concat([s1,s4],axis=1,join_axes=[['a','c','b','e']])
0 1
a 0 0
c NaN NaN
b 1 5
e NaN NaN
当你需要区分参与连接的片段时，可以在连接轴上创建一个层次化索引，使用key参数可以达到这个目的
>>> result=pd.concat([s1,s2,s3],keys=['one','two','three'])
>>> result
one a 0
b 1
two c 2
d 3
e 4
three f 5
g 6
dtype: int64
#如果沿着axis=1对Series进行合并，则keys会变成合并后DataFrame的列头
>>> pd.concat([s1,s2,s3],keys=['one','two','three'],axis=1)
one two three
a 0 NaN NaN
b 1 NaN NaN
c NaN 2 NaN
d NaN 3 NaN
e NaN 4 NaN
f NaN NaN 5
g NaN NaN 6
最后一个需要考虑的问题是，跟当前分析无关的DataFrame索引，直接传入ignore_index=True即可：
>>> df1=DataFrame(np.random.randn(3,4),columns=['a','b','c','d'])
>>> df2=DataFrame(np.random.randn(2,3),columns=['b','d','a'])
>>> df1
a b c d
0 -1.928978 -1.202455 -0.180614 0.693538
1 -1.234482 0.664544 0.259534 0.429279
2 0.305255 0.133844 0.934637 0.243345
>>> df2
b d a
0 -1.582425 0.055378 0.288906
1 -0.381170 0.731310 -0.661805
>>> pd.concat([df1,df2],ignore_index=True)
a b c d
0 -1.928978 -1.202455 -0.180614 0.693538
1 -1.234482 0.664544 0.259534 0.429279
2 0.305255 0.133844 0.934637 0.243345
3 0.288906 -1.582425 NaN 0.055378
4 -0.661805 -0.381170 NaN 0.731310
#注意区分与下面区别
>>> pd.concat([df1,df2])
a b c d
0 -1.928978 -1.202455 -0.180614 0.693538
1 -1.234482 0.664544 0.259534 0.429279
2 0.305255 0.133844 0.934637 0.243345
0 0.288906 -1.582425 NaN 0.055378
1 -0.661805 -0.381170 NaN 0.731310
4、合并重叠数据
还有一种数据不能用简单的合并或者连接运算来处理比如你有可能索引全部或部分重叠的两个数据集：
>>> a=Series([np.nan,2.5,np.nan,3.5,4.5,np.nan],index=['f','e','d','c','b','a'])
>>> b=Series(np.arange(len(a),dtype=np.float64),index=['f','e','d','c','b','a'])
>>> a
f NaN
e 2.5
d NaN
c 3.5
b 4.5
a NaN
dtype: float64
>>> b
f 0
e 1
d 2
c 3
b 4
a 5
dtype: float64
>>> np.where(pd.isnull(a),b,a)
array([ 0. , 2.5, 2. , 3.5, 4.5, 5. ])
#可以看作用参数对象中的数据为调用者对象的缺失数据打补丁
也可用combine_first方法
>>> df1=DataFrame({'a':[1,np.nan,5,np.nan],'b':[np.nan,2,np.nan,6],'c':range(2,18,4)})
>>> df1
a b c
0 1 NaN 2
1 NaN 2 6
2 5 NaN 10
3 NaN 6 14
>>> df2=DataFrame({'a':[5,4,np.nan,3,7],'b':[np.nan,3,4,6,8]})
>>> df2
a b
0 5 NaN
1 4 3
2 NaN 4
3 3 6
4 7 8
>>> df1.combine_first(df2)
a b c
0 1 NaN 2
1 4 2 6
2 5 4 10
3 3 6 14
4 7 8 NaN
重塑和轴向旋转
1、重塑层次化索引
层次化索引技术为DataFrame数据重拍运算提供了一种具有良好一致性的方式，主要功能有二：
stack，将数据的列旋转为行
unstack，将数据的行旋转为列
>>> data=DataFrame(np.arange(6).reshape((2,3)),index=['ohio','colorado'],columns=['one','two','three'])
>>> data
one two three
ohio 0 1 2
colorado 3 4 5
>>> data.index
Index([u'ohio', u'colorado'], dtype='object')
>>> data.index.name='state'
>>> data.columns.name='number'
>>> 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
#将列转化为行，得到一个Series
#对于一个层次化索引的Series，可以用unstack将其重排为一个DataFrame
默认情况下unstack操作的是最内层的，可传入分层级别的编号和名称参数，即可对其他级别进行untack操作：
>>> result=data.stack()
>>> result
state number
ohio one 0
two 1
three 2
colorado one 3
two 4
three 5
dtype: int32
>>> result.unstack(0)
state ohio colorado
number
one 0 3
two 1 4
three 2 5
>>> result.unstack('state')
state ohio colorado
number
one 0 3
two 1 4
three 2 5
在对DataFrame，进行unset操作时，作为旋转轴的级别将会成为结果中的最低级别（即旋转轴索引将成为最内层索引）：
>>> df=DataFrame({'left':result,'right':result+5},columns=['left','right'])
>>> df.columns.name='side'
>>> df
side left right
state number
ohio one 0 5
two 1 6
three 2 7
colorado one 3 8
two 4 9
three 5 10
>>> df.unstack('state')
side left right
state ohio colorado ohio colorado
number
one 0 3 5 8
two 1 4 6 9
three 2 5 7 10
>>> df.unstack('state').stack('side')
state ohio colorado
number side
one left 0 3
right 5 8
two left 1 4
right 6 9
three left 2 5
right 7 10
数据转换
除了数据合并与重排之外，另一类重要的操作是过滤，清理。
1、移除重复数据
DataFrame的duplicated方法返回一个布尔型Series，表示各行是否为重复行
>>> data=DataFrame({'k1':['one']*3+['two']*4,'k2':[1,1,2,3,3,4,4]})
>>> data
k1 k2
0 one 1
1 one 1
2 one 2
3 two 3
4 two 3
5 two 4
6 two 4
>>> data.duplicated()
0 False
1 True
2 False
3 False
4 True
5 False
6 True
dtype: bool
#drop_duplicates方法用于返回一个移除了重复行的DataFrame，删除那些为True的行
>>> data.drop_duplicates()
k1 k2
0 one 1
2 one 2
3 two 3
5 two 4
#可以指定过滤重复列的项
>>> data.drop_duplicates(['k1'])
k1 k2
0 one 1
3 two 3
#以上两个方法默认保留第一个出现的组合值，传入take_last=True则可以保留最后一个
2、利用函数或映射进行数据转换
Series的map方法可以接受一个函数或含有映射关系的字典型对象
>>> data=DataFrame({'food':['bacon','pulled prok','bacon','pastrami','corned beef','bacon','pastrami','honey ham','nova lox'],'ounce':[4,3,12,6,7.5,8,3,5,6]})
>>> data
food ounce
0 bacon 4.0
1 pulled prok 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','honey ham':'pig','nova lox':'salmon'}
>>> data['animal']=data['food'].map(meat_to_animal)
>>> data
food ounce animal
0 bacon 4.0 pig
1 pulled prok 3.0 NaN
2 bacon 12.0 pig
3 pastrami 6.0 cow
4 corned beef 7.5 NaN
5 bacon 8.0 pig
6 pastrami 3.0 cow
7 honey ham 5.0 pig
8 nova lox 6.0 salmon
3、替换值
利用fillna方法填充缺失数据可以看作值替换的一种特殊情况,但是使用replace则提供了一种实现该功能更简单的方法：
>>> pd.Series([1,-999,2,-999,-1000,3])
0 1
1 -999
2 2
3 -999
4 -1000
5 3
dtype: int64
>>> data=pd.Series([1,-999,2,-999,-1000,3])
>>> data.replace(-999,np.nan)
0 1
1 NaN
2 2
3 NaN
4 -1000
5 3
dtype: float64
#如果想一次性替换多个值，可以传入一个由待替换值组成的列表以及一个替换值：
>>> data.replace([-999,-1000],np.nan)
0 1
1 NaN
2 2
3 NaN
4 NaN
5 3
dtype: float64
#如果希望对不同的值做不同的替换，则传入一个由替换关系组成的列表即可：
>>> data.replace([-999,-1000],[np.nan,0])
0 1
1 NaN
2 2
3 NaN
4 0
5 3
dtype: float64
#传入的参数也可以是字典形式：｛-999：np.nan,-1000:0｝
4、重命名轴索引
轴标签也可以通过函数或映射进行转换，从而得到一个新对象。轴也可以被修改，而无需创建一个新的数据结构。
轴标签也可以使用map方法
>>> df1=DataFrame(np.arange(12).reshape((3,4)),index=['ohio','colorado','new york'],columns=['one','two','three','four'])
>>> df1
one two three four
ohio 0 1 2 3
colorado 4 5 6 7
new york 8 9 10 11
>>> df1.index.map(str.upper)
array(['OHIO', 'COLORADO', 'NEW YORK'], dtype=object)
>>> df1.index=df1.index.map(str.upper)
>>> df1
one two three four
OHIO 0 1 2 3
COLORADO 4 5 6 7
NEW YORK 8 9 10 11
#如果不想修改原始数据可以创建数据的转换版
>>> df1.rename(columns=str.upper)
ONE TWO THREE FOUR
OHIO 0 1 2 3
COLORADO 4 5 6 7
NEW YORK 8 9 10 11
#rename也可以结合字典型对象实现对部分轴标签进行更新
>>> df1.rename(index={'OHIO':'INDIANA'},columns={'three':'peekaboo'})
one two peekaboo four
INDIANA 0 1 2 3
COLORADO 4 5 6 7
NEW YORK 8 9 10 11
5、离散化和面元划分
为了便于分析，连续数据常常需要被离散化或拆分为"面元"，此时需要使用pandas库中的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=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, object): [(18, 25] < (25, 35] < (35, 60] < (60, 100]]
#pandas返回的是一个特殊的categorcal对象，它含有一个表示不同分类名称的levels数组以及一个为年龄数据进行标号的labels属性
>>> cats.labels
array([0, 0, 0, 1, 0, 0, 2, 1, 3, 2, 2, 1], dtype=int8)
>>> cats.levels
Index([u'(18, 25]', u'(25, 35]', u'(35, 60]', u'(60, 100]'], dtype='object')
也可以设置自定义的面元名称，将labels选项设置为一个列表或元组即可：
>>> pd.cut(ages,bins,labels=['youth','youngadult','middleaged','senior'])
[youth, youth, youth, youngadult, youth, ..., youngadult, senior, middleaged, middleaged, youngadult]
Length: 12
Categories (4, object): [youth < youngadult < middleaged < senior]
如果cut传入的是面元的数量而不是确切的面元边界，则它会根据数据的最小值和最大值计算等长的面元，实现均分：
>>> data=np.random.randn(20)
>>> pd.cut(data,4,precision=2)
[(-1.018, 0.095], (-1.018, 0.095], (0.095, 1.21], (0.095, 1.21], (-1.018, 0.095], ..., (0.095, 1.21], (0.095, 1.21], (-1.018, 0.095], (0.095, 1.21], (-1.018, 0.095]]
Length: 20
Categories (4, object): [(-2.14, -1.018] < (-1.018, 0.095] < (0.095, 1.21] < (1.21, 2.32]]
qcut是一个类似与cut的函数，它可以根据样本分位数对数据进行面元划分：
>>> data=np.random.randn(1000)
>>> cats=pd.qcut(data,4) #按四分位数进行切割
>>> cats
[(0.644, 3.0404], (-0.00691, 0.644], (0.644, 3.0404], (-0.00691, 0.644], (0.644, 3.0404], ..., (-0.00691, 0.644], (-0.00691, 0.644], (0.644, 3.0404], [-3.753, -0.709], (-0.709, -0.00691]]
Length: 1000
Categories (4, object): [[-3.753, -0.709] < (-0.709, -0.00691] < (-0.00691, 0.644] < (0.644, 3.0404]]
>>> pd.value_counts(cats)
(0.644, 3.0404] 250
(-0.00691, 0.644] 250
(-0.709, -0.00691] 250
[-3.753, -0.709] 250
dtype: int64
6、检测和过滤异常值
异常值的过滤或变换运算在很大程度上就是数组运算：
>>> data=DataFrame(np.random.randn(1000,4))
>>> data.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
>>> col=data[3] #选取具体某列
>>> col[np.abs(col)>3]
97 3.927528
305 -3.399312
400 -3.745356
Name: 3, dtype: float64
#找出绝对值大小超过3的值
7、排列和随机抽样
利用numpy.random.permutation函数可以实现对Series或DataFrame的列的排列工作：
>>> df=DataFrame(np.arange(5*4).reshape(5,4))
>>> sapmler=np.random.permutation(5)
>>> 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(sapmler)
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
8、计算指标/哑变量
另一种常见的统计建模或机器学习的转换方式是将分类变量转换为哑变量矩阵，pandas有一个get_dummies函数可以实现该功能
>>> df=DataFrame({'key':['b','b','a','c','a','b'],'data1':range(6)})
>>> df
data1 key
0 0 b
1 1 b
2 2 a
3 3 c
4 4 a
5 5 b
>>> 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
有时候需要给DataFrame的列加上一个前缀，能够与其他的数据进行合并，get_dummies函数的prefix参数可以实现该功能
>>> dum=pd.get_dummies(df['key'],prefix='key')
>>> df_with_dummy=df[['data1']].join(dum)
>>> 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
结合cut与get_dummies离散化二元化数据：
>>> values=np.random.randn(10)
>>> values
array([ 0.04648638, -0.61044135, -0.39498189, 1.19991518, -0.45181441,
-0.15538512, -0.15351407, 0.01119376, -0.05055467, 0.42021107])
>>> bins=[0,0.2,0.4,0.6,0.8,1]
>>> pd.get_dummies(pd.cut(values,bins))
(0, 0.2] (0.2, 0.4] (0.4, 0.6] (0.6, 0.8] (0.8, 1]
0 1 0 0 0 0
1 0 0 0 0 0
2 0 0 0 0 0
3 0 0 0 0 0
4 0 0 0 0 0
5 0 0 0 0 0
6 0 0 0 0 0
7 1 0 0 0 0
8 0 0 0 0 0
9 0 0 1 0 0
字符串操作
python能够成为流行的数据处理语言，部分原因是其简单易用的字符串和文本处理功能。
1、字符串对象方法
以逗号分隔的字符串可以用split拆分为数段，split常常结合strip一起使用：
>>> val='a,b, guido'
>>> val.split(',')
['a', 'b', ' guido']
>>> pieces=[x.strip() for x in val.split(',')]
>>> pieces
['a', 'b', 'guido']
利用加法可以将子字符串以双冒号的形式连接起来，但是更简便的方式是使用字符串'::'的join方法传入一个元组或列表：
>>> first,second,third=pieces
>>> '::'.join(pieces)
'a::b::guido'
另一类方法关注的是子串定位，检测子串的最佳方式是利用python的in关键字（index与find同样适用）：
>>> 'guido'in val
True
>>> val.index(',')
1
>>> val.find(':')
-1
>>>
#如果找不到字符串，find返回一个-1，index会引发异常
此外，还有一个count函数，可返回指定子串的出现次数，replace用于将指定模式替换为另一个模式：
>>> val.count(',')
2
>>> val.replace(',',':')
'a:b: guido'
| python内置字符串说明列表 | |
| count | 返回子串在字符串中出现的次数 |
| endswith，startswith | 如果字符串以某个后缀结尾(开头)，返回ture |
| join | 将字符串用作连接其他字符串序列的分隔符 |
| index | 如果在字符串中找到子串，返回子串在字符串中的第一个字符所在的位置 |
| find | 如果在字符串中找到子串，返回子串在字符串中的第一个字符所在的位置，没找到则返回-1 |
| replace | 用一个字符串替换指定字符串 |
| strip，rstrip，lstrip | 去除空白符，包括换行符 |
| split | 通过指定的分隔符将字符串拆分为一组字符串 |
| lower，upper | 将字符串转换为小写或大写 |
2、正则表达式
正则表达式提供了一种灵活在文本中搜索或匹配字符串模式的方式。
re模块的函数可以分为三个大类：模式匹配，替换和拆分，这三个是相辅相成：
>>> text="foo bar\t baz \tqux"
>>> text
'foo bar\t baz \tqux'
>>> re.split('\s+',text)
['foo', 'bar', 'baz', 'qux']
一般可以用re.compile编译一个可重用的regrex对象，且针对许多字符串用同一正则表达式时，通过使用re.compile可以节省大量cpu计算时间：
>>> regrex=re.compile('\s+')
>>> regrex.split(text)
['foo', 'bar', 'baz', 'qux']
＃如果只希望得到regrex匹配的所有模式，可以使用findall方法
>>> regrex.findall(text)
[' ', '\t ', ' \t']
match功能和search功能跟findall功能类似，findall返回的是字符串中所有的匹配项，而search只返回第一个匹配项，match更加严格，它只匹配字符串的首部，sub方法会将匹配到的模式替换为指定字符串，并返回得到的字符串。
ps：想要用好正则表达式，需要大量的额外练习与使用
3、pandas中矢量化的字符串函数
清理待分析的散乱数据时，常常需要做一些字符串规整化的工作：
通过data.map,所有字符串和正则表达式方法都能被用于各个值，但传入na就会报错，Series提供了一些能够跳过NA值的字符串操作方法
>>> 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
Rob rob@gmail.com
Steve steve@gmail.com
Wes NaN
dtype: object
>>> data.isnull()
Dave False
Rob False
Steve False
Wes True
dtype: bool
>>> data.str.contains('gmail')
Dave False
Rob True
Steve True
Wes NaN
dtype: object
这里也可以通过正则表达式解决：
>>> data.str.findall(pattern,flags=re.IGNORECASE)
Dave [dave@google.com]
Rob [rob@gmail.com]
Steve [steve@gmail.com]
Wes NaN
dtype: object
有两个方法可以实现矢量化的元素获取操作:1）使用str.get，2）在str属性上使用索引