一、字符串操作
Python内置的字符串操作和re正则模块可以解决很多场景下的字符串操作需求。但是在数据分析过程中，它们有时候比较尴尬，比如：
In [143]: dic= {'one':'feixue', 'two':np.nan, 'three':'tom', 'five':'jerry@film'} In [144]: s = pd.Series(dic) In [145]: s Out[145]: one feixue two NaN three tom five jerry@film dtype: object
现在想将s中的字母都大写，通过Python内置字符串方法，可能会这么设计：
In [159]: s.map(lambda x : x.upper()) --------------------------------------------------------------------------- AttributeError Traceback (most recent call last)
但是，弹出了异常，原因是数据有一个缺失值NaN，这个值不是字符串，没有upper方法。
那怎么办呢？Pandas为这一类整体性的操作，提供了专门的字符串函数，跳过缺失值等异常情况，对能够进行操作的每个元素进行处理：
In [160]: s.str.upper() Out[160]: one FEIXUE two NaN three TOM five JERRY@FILM dtype: object
这就是Series的str属性，在它的基础上甚至可以使用正则表达式的函数。
下面是部分可用的Series.str的字符串操作方法，名字基本和Python字符串内置方法相同：
- cat :粘合字符串
- contains：是否包含的判断
- count：计数
- extract：返回匹配的字符串组
- endswith：以xx结尾判断
- startswith：以xx开始判断
- findall：查找
- get：获取
- isalnum：类型判断
- isalpha：类型判断
- isdecimal：类型判断
- isdigit：类型判断
- islower：是否小写
- isnumeric：类型判断
- isupper：是否大写
- join：连接
- len：长度
- lower：小写
- upper：大写
- match：匹配
- pad：将空白加到字符串的左边、右边或者两边
- center：居中
- repeat：重复
- replace:替换
- slice：切片
- split：分割
- strip：脱除
- lstrip：左脱除
- rstrip：右脱除
二、合并连接
可以通过多种方式将Pandas对象联合到一起：
- pandas.merge: 根据一个或多个键进行连接。类似SQL的连接操作
- pandas.concat:使对象在轴向上进行粘合或者‘堆叠’
- combine_first:将重叠的数据拼接在一起，使用一个对象中的值填充另一个对象中的缺失值
1.merge连接
merge方法将两个pandas对象连接在一起，类似SQL的连接操作。默认情况下，它执行的是内连接，也就是两个对象的交集。通过参数how，还可以指定外连接、左连接和右连接。参数on指定在哪个键上连接，参数left_on和right_on分别指定左右对象的连接键。
- 外连接：并集
- 内连接：交集
- 左连接：左边对象全部保留
- 右连接：右边对象全部保留
In [23]: df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'], ...: 'data1': range(7)}) ...: In [24]: df2 = pd.DataFrame({'key': ['a', 'b', 'd'], ...: 'data2': range(3)}) ...: In [25]: df1 Out[25]: key data1 0 b 0 1 b 1
2 a 2
3 c 3
4 a 4
5 a 5
6 b 6 In [26]: df2 Out[26]: key data2 0 a 0 1 b 1
2 d 2 In [27]: pd.merge(df1,df2) # 默认内链接，并智能地查找连接的键
Out[27]: key data1 data2 0 b 0 1
1 b 1 1
2 b 6 1
3 a 2 0 4 a 4 0 5 a 5 0 In [28]: pd.merge(df1,df2,on='key') # 最好是显式地指定连接的键
Out[28]: key data1 data2 0 b 0 1
1 b 1 1
2 b 6 1
3 a 2 0 4 a 4 0 5 a 5 0 In [30]: pd.merge(df1, df2, how='outer') # 外连接
Out[30]: key data1 data2 0 b 0.0 1.0
1 b 1.0 1.0
2 b 6.0 1.0
3 a 2.0 0.0
4 a 4.0 0.0
5 a 5.0 0.0
6 c 3.0 NaN 7 d NaN 2.0 In [31]: pd.merge(df1, df2, how='left') # 左连接
Out[31]: key data1 data2 0 b 0 1.0
1 b 1 1.0
2 a 2 0.0
3 c 3 NaN 4 a 4 0.0
5 a 5 0.0
6 b 6 1.0 In [32]: pd.merge(df1, df2, how='right') #右连接
Out[32]: key data1 data2 0 b 0.0 1
1 b 1.0 1
2 b 6.0 1
3 a 2.0 0 4 a 4.0 0 5 a 5.0 0 6 d NaN 2 In [33]: df3 = pd.DataFrame({'lkey': ['b', 'b', 'a', 'c', 'a', 'a', 'b'], ...: 'data1': range(7)}) ...: In [34]: df4 = pd.DataFrame({'rkey': ['a', 'b', 'd'], ...: 'data2': range(3)}) ...: In [35]: pd.merge(df3, df4, left_on='lkey', right_on='rkey') # 指定两边的键
Out[35]: lkey data1 rkey data2 0 b 0 b 1
1 b 1 b 1
2 b 6 b 1
3 a 2 a 0 4 a 4 a 0 5 a 5 a 0
多对多的merge连接是行的笛卡儿积。比如左边如果有3个‘b’行，右边有2个‘b’行，那么结果是3x2，6个‘b’行。
也可以同时指定多个键进行连接：
In [36]: left = pd.DataFrame({'key1': ['foo', 'foo', 'bar'], ...: 'key2': ['one', 'two', 'one'], ...: 'lval': [1, 2, 3]}) In [37]: right = pd.DataFrame({'key1': ['foo', 'foo', 'bar', 'bar'], ...: 'key2': ['one', 'one', 'one', 'two'], ...: 'rval': [4, 5, 6, 7]}) In [38]: pd.merge(left, right, on=['key1', 'key2'], how='outer') Out[38]: key1 key2 lval rval 0 foo one 1.0 4.0
1 foo one 1.0 5.0
2 foo two 2.0 NaN 3 bar one 3.0 6.0
4 bar two NaN 7.0
merge操作中还有一个重叠列名的问题，比如上面的left和right两个数据，为此，我们可以使用suffixes参数，手动指定为重复的列名添加后缀：
In [41]: pd.merge(left, right, on='key1') Out[41]: key1 key2_x lval key2_y rval 0 foo one 1 one 4
1 foo one 1 one 5
2 foo two 2 one 4
3 foo two 2 one 5
4 bar one 3 one 6
5 bar one 3 two 7 In [42]: pd.merge(left, right, on='key1', suffixes=('_left', '_right')) Out[42]: key1 key2_left lval key2_right rval 0 foo one 1 one 4
1 foo one 1 one 5
2 foo two 2 one 4
3 foo two 2 one 5
4 bar one 3 one 6
5 bar one 3 two 7
有时候，用于merge合并的键可能是某个对象的行索引：
In [43]: left1 = pd.DataFrame({'key': ['a', 'b', 'a', 'a', 'b', 'c'], ...: 'value': range(6)}) ...: In [44]: right1 = pd.DataFrame({'group_val': [3.5, 7]}, index=['a', 'b']) In [45]: left1 Out[45]: key value 0 a 0 1 b 1
2 a 2
3 a 3
4 b 4
5 c 5 In [46]: right1 Out[46]: group_val a 3.5 b 7.0 In [47]: pd.merge(left1, right1, left_on='key', right_index=True) Out[47]: key value group_val 0 a 0 3.5
2 a 2 3.5
3 a 3 3.5
1 b 1 7.0
4 b 4 7.0 In [48]: pd.merge(left1, right1, left_on='key', right_index=True, how='outer') Out[48]: key value group_val 0 a 0 3.5
2 a 2 3.5
3 a 3 3.5
1 b 1 7.0
4 b 4 7.0
5 c 5 NaN
使用right_index=True参数显式地指出，右边的对象right1使用它的行索引作为连接的键。
事实上Pandas有一个join方法，可以帮助我们直接用行索引进行连接：
In [49]: left2 = pd.DataFrame([[1., 2.], [3., 4.], [5., 6.]], ...: index=['a', 'c', 'e'], ...: columns=['Ohio', 'Nevada']) ...: In [50]: right2 = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [13, 14]], ...: index=['b', 'c', 'd', 'e'], ...: columns=['Missouri', 'Alabama']) ...: In [51]: left2 Out[51]: Ohio Nevada a 1.0 2.0 c 3.0 4.0 e 5.0 6.0 In [52]: right2 Out[52]: Missouri Alabama b 7.0 8.0 c 9.0 10.0 d 11.0 12.0 e 13.0 14.0 In [53]: pd.merge(left2, right2, how='outer', left_index=True, right_index=True) Out[53]: 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 In [54]: left2.join(right2, how='outer') # 与上面的操作效果一样
Out[54]: 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.concat轴向连接
concat方法可以实现对象在轴向的的粘合或者堆叠。
In [55]: s1 = pd.Series([0, 1], index=['a', 'b']) In [56]: s2 = pd.Series([2, 3, 4], index=['c', 'd', 'e']) In [57]: s3 = pd.Series([5, 6], index=['f', 'g']) In [58]: pd.concat([s1, s2, s3]) # 要以列表的方式提供参数
Out[58]: a 0 b 1 c 2 d 3 e 4 f 5 g 6 dtype: int64 In [59]: pd.concat([s1, s2, s3], axis=1) # 横向堆叠，但出现警告信息
C:\ProgramData\Anaconda3\Scripts\ipython:1: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version of pandas will change to not sort by default. ...... Out[59]: 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 In [60]: pd.concat([s1, s2, s3], axis=1,sort=True) # 按人家的要求做
Out[60]: 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
对于DataFrame，默认情况下都是按行往下合并的，当然也可以设置axis参数：
In [66]: df1 = pd.DataFrame(np.arange(6).reshape(3, 2), index=['a', 'b', 'c'], ...: columns=['one', 'two']) ...: In [67]: df2 = pd.DataFrame(5 + np.arange(4).reshape(2, 2), index=['a', 'c'], ...: columns=['three', 'four']) ...: In [68]: df1 Out[68]: one two a 0 1 b 2 3 c 4 5 In [69]: df2 Out[69]: three four a 5 6 c 7 8 In [71]: pd.concat([df1, df2], sort=True) Out[71]: 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 In [72]: pd.concat([df1, df2], axis=1, sort=True) Out[72]: one two three four a 0 1 5.0 6.0 b 2 3 NaN NaN c 4 5 7.0 8.0
3.combine_first联合叠加
有这么种场景，某个对象里缺失的值，拿另外一个对象的相应位置的值来填补。在Numpy层面，可以这么做：
In [74]: a = pd.Series([np.nan, 2.5, 0, 3.5, 4.5, np.nan], ...: index=['f', 'e', 'd', 'c', 'b', 'a']) In [75]: b = pd.Series([0, np.nan, 2.1, np.nan, np.nan, 5], index=list('abcdef')) In [76]: a Out[76]: f NaN e 2.5 d 0.0 c 3.5 b 4.5 a NaN dtype: float64 In [77]: b Out[77]: a 0.0 b NaN c 2.1 d NaN e NaN f 5.0 dtype: float64 In [78]: np.where(pd.isnull(a), b, a) Out[78]: array([0. , 2.5, 0. , 3.5, 4.5, 5. ])
np.where(pd.isnull(a), b, a)，这一句里，首先去pd.isnull(a)种判断元素，如果是True，从b里拿数据，否则从a里拿，得到最终结果。
实际上，Pandas为这种场景提供了一个专门的combine_first方法：
In [80]: b.combine_first(a) Out[80]: a 0.0 b 4.5 c 2.1 d 0.0 e 2.5 f 5.0 dtype: float64
对于DataFrame对象，combine_first逐列做相同的操作，因此你可以认为它是根据你传入的对象来‘修补’调用对象的缺失值。
In [81]: df1 = pd.DataFrame({'a': [1., np.nan, 5., np.nan], ...: 'b': [np.nan, 2., np.nan, 6.], ...: 'c': range(2, 18, 4)}) ...: In [82]: df2 = pd.DataFrame({'a': [5., 4., np.nan, 3., 7.], ...: 'b': [np.nan, 3., 4., 6., 8.]}) ...: In [83]: df1 Out[83]: a b c 0 1.0 NaN 2
1 NaN 2.0 6
2 5.0 NaN 10
3 NaN 6.0 14 In [84]: df2 Out[84]: 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 In [85]: df1.combine_first(df2) Out[85]: 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
三、重塑
对表格型数据进行重新排列的操作，被称作重塑。
使用多层索引进行重塑主要有stack和unstack操作，前面有介绍过。
In [93]: df = pd.DataFrame(np.arange(6).reshape(2,3), ...: index=pd.Index(['河南','山西'], name='省份'), ...: columns=pd.Index(['one','two','three'],name='number')) In [94]: df Out[94]: number one two three 省份 河南 0 1 2 山西 3 4 5 In [95]: result = df.stack() In [96]: result Out[96]: 省份 number 河南 one 0 two 1 three 2 山西 one 3 two 4 three 5 dtype: int32 In [97]: result.unstack() Out[97]: number one two three 省份 河南 0 1 2 山西 3 4 5
stack操作使得df的所有列都变成了分层行索引，产生了一个新的Series。
unstack默认情况下拆分最内层索引，然后将数据放入一个DataFrame中。可以传入一个层级序号或名称来拆分不同的层级。
In [98]: result.unstack(0) Out[98]: 省份 河南 山西 number one 0 3 two 1 4 three 2 5 In [99]: result.unstack('省份') Out[99]: 省份 河南 山西 number one 0 3 two 1 4 three 2 5
如果层级中的所有值并未有包含于每个子分组中，拆分可能会导致缺失值的产生：
In [100]: s1 = pd.Series([0, 1, 2, 3], index=['a', 'b', 'c', 'd']) In [101]: s2 = pd.Series([4, 5, 6], index=['c', 'd', 'e']) In [102]: data2 = pd.concat([s1, s2], keys=['one', 'two']) In [103]: data2 # 注意concat的结果是一个分层索引
Out[103]: one a 0 b 1 c 2 d 3 two c 4 d 5 e 6 dtype: int64 In [104]: data2.unstack() Out[104]: a b c d e one 0.0 1.0 2.0 3.0 NaN two NaN NaN 4.0 5.0 6.0 In [105]: data2.unstack().stack() # 结果是可逆的
Out[105]: one a 0.0 b 1.0 c 2.0 d 3.0 two c 4.0 d 5.0 e 6.0 dtype: float64 In [106]: data2.unstack().stack(dropna=False) # 保留缺失值
Out[106]: one a 0.0 b 1.0 c 2.0 d 3.0 e NaN two a NaN b NaN c 4.0 d 5.0 e 6.0 dtype: float64
而在DataFrame对象拆堆时，被拆的层级会变成结果中最低的层级：
In [107]: df = pd.DataFrame({'left': result, 'right': result + 5}, ...: columns=pd.Index(['left', 'right'], name='side')) ...: In [108]: df Out[108]: side left right 省份 number 河南 one 0 5 two 1 6 three 2 7 山西 one 3 8 two 4 9 three 5 10 In [109]: df.unstack('省份') # 因为作死引入了中文，所以版式不太对齐
Out[109]: side left right 省份 河南 山西 河南 山西 number one 0 3 5 8 two 1 4 6 9 three 2 5 7 10