Pandas快速教程(3)-处理文本数据

Series和Index(不包括Dataframe)有很多处理文本数据的方法.而且这些方法自动排除了缺失值.这些方法通过访问str属性获得,与python内置的文本处理函数非常相似.

[code]s = pd.Series(['A',  np.nan, 'cat'])

s
Out[149]:
0      A
1    NaN
2    cat
dtype: object

s.str.upper()
Out[150]:
0      A
1    NaN
2    CAT
dtype: object

dex=pd.Index([' dog ','   cat'])

dex.str.strip()
Out[153]: Index(['dog', 'cat'], dtype='object')

这样的字符处理功能对于处理DataFrame对象的columns中的字符非常便捷.

[code]df = pd.DataFrame(np.random.randn(3, 2), columns=['     Column A ', ' Column B '],index=range(3))

df
Out[168]:
Column A    Column B
0        0.551199   -0.252916
1       -2.074720   -0.742020
2       -1.655261   -0.235225

df.columns = df.columns.str.strip().str.lower().str.replace(' ', '_')

df
Out[170]:
column_a  column_b
0  0.551199 -0.252916
1 -2.074720 -0.742020
2 -1.655261 -0.235225

split()函数不仅可以分离字符,在分割后的结果进行切片操作,还可以将结果以DataFrame的形式返回,只需要指定expand参数即可(n表示要分割为多少列)

[code]s2 = pd.Series(['a_b_c', 'c_d_e', np.nan, 'f_g_h'])

s2
Out[10]:
0    a_b_c
1    c_d_e
2      NaN
3    f_g_h
dtype: object

s2.str.split('_').str[1]
Out[11]:
0      b
1      d
2    NaN
3      g
dtype: object

s2.str.split('_',expand=True,n=2)
Out[12]:
0    1    2
0    a    b    c
1    c    d    e
2  NaN  NaN  NaN
3    f    g    h

下面再介绍一个使用频率很高的函数.

replace

(pat, repl, n=-1, case=None, flags=0, regex=True)

regex:表示是否启用正则匹配,设置为False则仅使用文本匹配

pat:要被替换数据的正则表达式或者文本

repl:替换的目标内容

n:-1表示全部,也可指定替换数量

case:bool值,代表大小写敏感

flags:与re的flags一致

需要注意的是,如果pat是一个被compile的表达,则case和flags参数不起作用.

[code]s2.str.replace('_','&',regex=False)
Out[5]:
0    a&b&c
1    c&d&e
2      NaN
3    f&g&h
dtype: object

s2.str.replace('[a-z]{1,3}','AA',regex=True)
Out[8]:
0    AA_AA_AA
1    AA_AA_AA
2         NaN
3    AA_AA_AA
dtype: object

在Series或者Index中字符的串联都是基于cat()函数实现的.

cat

(others=None, sep=None, na_rep=None, join=None)

other:代表要串联的其他数据,可以值Series,Index,Dataframe,或者list-like,但合并的对象的长度必须一致.

sep:默认为' ',表示连串符号

na_rep:缺失值的表示符号

join:‘left’, ‘right’, ‘outer’, ‘inner’,代表串联的方式,不指定的话,默认的None会不启用对齐功能,但在以后的新版本中,该设置会被移除或者做修改,官网的表述是以后会默认设置为left,并代表不启用对齐.

[code]s = pd.Series(['a', 'b', np.nan, 'd'])

s.str.cat()
Out[13]: 'abd'

s.str.cat(sep='_',na_rep='NaN')
Out[14]: 'a_b_NaN_d'

与其他list-like类型的数据串联

[code]s.str.cat(['A', 'B', 'C', 'D'])
Out[15]:
0     aA
1     bB
2    NaN
3     dD
dtype: object

s1=s.str.cat(['A', 'B', 'C', 'D'])

s1
Out[17]:
0     aA
1     bB
2    NaN
3     dD
dtype: object

s.str.cat(s1,na_rep='NaN')
Out[19]:
0       aaA
1       bbB
2    NaNNaN
3       ddD
dtype: object

''other''参数的对象也可以是DataFrame.

[code]
s2
Out[24]:
0  1
0  a  b
1  a  b
2  a  b
3  a  b

s.str.cat(s2,na_rep='1')
Out[26]:
0    aab
1    bab
2    1ab
3    dab
dtype: object

如果设置了join参数的话,目前版本来说,就代表启动了数据对齐功能,那么连串的数据会自动的进行Index对齐,也就说串联的数据的长度可以不一致了.

如果与带Index的对象连串,目前0.23版本的pandas也会有相应的提示.

以下例子为例说明:

left:表示以s的index为连串标准

right:表示以u的index为串联标准

[code]u = pd.Series(['z', 'w', 'x', 'y'], index=[1, 3, 0, 2])

s.str.cat(u,join='left')
Out[39]:
0     ax
1     bz
2    NaN
3     dw
dtype: object

s.str.cat(u,join='right')
Out[40]:
1     bz
3     dw
0     ax
2    NaN
dtype: object

启动了join参数,就启用了自动对齐功能,所以即使串联的数据长度不一致,也是可以的.最终的结果,就需要看join的参数是对齐哪个对象的Index了.

[code]v = pd.Series(['z', 'a', 'b', 'd', 'e'], index=[-1, 0, 1, 3, 4])

s.str.cat(v,join='left')
Out[43]:
0     aa
1     bb
2    NaN
3     dd
dtype: object

s.str.cat(v,join='right')
Out[44]:
-1    NaN
0     aa
1     bb
3     dd
4    NaN
dtype: object

同样,串联的也可以是多维的其他数据,比如DataFrame.

[code] s2
Out[47]:
0  1
2  a  b
3  a  b
4  a  b
5  a  b

s1.str.cat(s2,join='left')
Out[49]:
0     NaN
1     NaN
2     NaN
3    dDab
dtype: object

s1.str.cat(s2,join='right')
Out[50]:
2     NaN
3    dDab
4     NaN
5     NaN
dtype: object

还可以同时串联多个不同的对象(Index,Series,list-like).

但需要注意一点是,如果list-like对象不含Index索引的话,那么长度必须与要串联的对象长度一致.

[code]
s1
Out[78]:
0     aA
1     bB
2    NaN
3     dD
dtype: object

u
Out[79]:
1    z
3    w
0    x
2    y
dtype: object

v
Out[80]:
-1    z
0    a
1    b
3    d
4    e
dtype: object

s.str.cat([s1,u,v,list('xxxx')], join='outer', na_rep='-')
Out[81]:
-1     ---z-
0    aaAxax
1    bbBzbx
2     --y-x
3    ddDwdx
4     ---e-
dtype: object

s.str.cat([s1,u,v,list('xxxxyyy')], join='outer', na_rep='-')
Traceback (most recent call last):

File "<ipython-input-82-d894fc954f72>", line 1, in <module>
s.str.cat([s1,u,v,list('xxxxyyy')], join='outer', na_rep='-')

File "D:\Anaconda\lib\site-packages\pandas\core\strings.py", line 2294, in cat
raise ValueError('If `others` contains arrays or lists (or '

ValueError: If `others` contains arrays or lists (or other list-likes without an index), these must all be of the same length as the calling Series/Index.

Index对象的str属性

对应一个有Index'属性的Series对象,也可直接对str属性使用[ ]符号进行对象提取,如果指定的位置超出了对象str的长度范围,则返回缺失值:

[code]s.str[0]
Out[83]:
0      a
1      b
2    NaN
3      d
dtype: object

s.str[1]
Out[84]:
0   NaN
1   NaN
2   NaN
3   NaN
dtype: float64

提取子字符串的话可以使用extract()函数

extract

(pat, flags=0, expand=True)

pat:表示re正则表达式

flags:与正则的flags相同

expand:若设置为True,则返回值总是DataFrame,若为False,则根据提取的结果来确定返回数据的类型(可是是Series,可能是DF)

[code]t=pd.Series(['a1', 'b2', 'c3']).str.extract('([ab])', expand=False)

type(t)
Out[90]: pandas.core.series.Series

t=pd.Series(['a1', 'b2', 'c3']).str.extract('([ab])', expand=True)

type(t)
Out[92]: pandas.core.frame.DataFrame

子字符的提取,总是根据正则表达式来返回结果,总的来说是一类一行 (with one column per group),正则表达的规则决定了该column是否被命名,如:

[code]pd.Series(['a1', 'b2', 'c3']).str.extract('([abc])?(\d)', expand=False)
Out[95]:
0  1
0  a  1
1  b  2
2  c  3

pd.Series(['a1', 'b2', 'c3']).str.extract('(?P<letter>[abc])(?P<digit>\d)', expand=False)
Out[96]:
letter digit
0      a     1
1      b     2
2      c     3

match和contains的区别类似于re.match和re.search

对应缺失值,na参数可以指定缺失值的判断结果.

[code]pattern = r'[a-zA-Z]'

s4 = pd.Series(['A', '2Aaba', np.nan, '2CABA', '33AB',np.nan])

s4.str.match(pattern,na=False)
Out[102]:
0     True
1    False
2    False
3    False
4    False
5    False
dtype: bool

s4.str.contains(pattern,na=False)
Out[103]:
0     True
1     True
2    False
3     True
4     True
5    False
dtype: bool

s4.str.contains(pattern,na=True)
Out[104]:
0    True
1    True
2    True
3    True
4    True
5    True
dtype: bool

小结

关于对文本数据的处理,还有很多的方法和函数可以使用.

但是,注意一点,这些方法和函数仅对Series和Index有效,对DataFrame是不使用的.

还有很多未介绍到的方法和函数,可以查阅官网:

http://pandas.pydata.org/pandas-docs/stable/text.html

 

阅读更多