Python 之 Pandas 处理字符串和apply() 函数、applymap() 函数、map() 函数详解

一、处理字符串

• 当我们遇到一个超级大的 DataFrame，里面有一列类型为字符串，要将每一行的字符串都用同一方式进行处理， 一般会想到遍历整合 DataFrame。
• 但是如果直接这样做的话将会耗费很长时间，有时几个小时都处理不完。 因此我们将学习 pandas 快速处理字符串方法。

1. 向量化字符串操作简介

• 量化操作简化了纯数值的数组操作语法，我们不需要再担心数组的长度或维度，只需要把中心放在操作上面。
• 而对字符串的向量化需要工具包的支持，如 Numpy 就没办法直接对字符串进行向量化操作，只能通过繁琐的循环来实现。 Pandas 则可以很好的处理这类问题。

2. str 方法的简介

• Python 会处理字符串起来会很容易，作为工具包的 Pandas 同样可以简单快速的处理字符串，几乎把 Python 内置的字符串方法都给复制过来了，这种方法就是 Pandas 内置的 str 方法。
• 通俗来说就可以将 series 和 index 对象中包含字符串的部分简单看作单个字符串处理，达到批量简单快速处理的目的，str 方法有如下函数可供我们使用。

函数	含义
lower()	将的字符串转换为小写
upper()	将的字符串转换为大写
len()	得出字符串的长度
strip()	去除字符串两边的空格（包含换行符）
split()	用指定的分割符分割字符串
cat(sep=“”)	用给定的分隔符连接字符串元素
contains(pattern)	如果子字符串包含在元素中，则为每个元素返回一个布尔值 True，否则为 False
replace(a,b)	将值 a 替换为值 b
count(pattern)	返回每个字符串元素出现的次数
startswith(pattern)	如果 Series 中的元素以指定的字符串开头，则返回 True
endswith(pattern)	如果 Series 中的元素以指定的字符串结尾，则返回 True
findall(pattern)	以列表的形式返出现的字符串
find(pattern)	返回字符串第一次出现的索引位置

• 这里需要注意的是，上述所有字符串函数全部适用于 DataFrame 对象，同时也可以与 Python 内置的字符串函数一起使用，这些函数在处理 Series/DataFrame 对象的时候会自动忽略缺失值数据（NaN）。
• 首先，我们导入需要的 numpy 和 pandas 库。

import pandas as pd
import numpy as np

• （1） lower() 函数可以将的字符串转换为小写。

s = pd.Series(['C', 'Python', 'java', 'go', np.nan, '1125','javascript'])
s.str.lower()
0             c
1        python
2          java
3            go
4           NaN
5          1125
6    javascript
dtype: object

• （2） upper() 将的字符串转换为大写。

s = pd.Series(['C', 'Python', 'java', 'go', np.nan, '1125','javascript'])
s.str.upper()
#0             C
#1        PYTHON
#2          JAVA
#3            GO
#4           NaN
#5          1125
#6    JAVASCRIPT
#dtype: object

• （3） len() 得出字符串的长度。

s = pd.Series(['C', 'Python', 'java', 'go', np.nan, '1125','javascript'])
s.str.len()
#0     1.0
#1     6.0
#2     4.0
#3     2.0
#4     NaN
#5     4.0
#6    10.0
#dtype: float64

• （4） strip() 去除字符串两边的空格（包含换行符）。

s = pd.Series(['C ', ' Python\t     \n', '    java     ', 'go\t', np.nan, '\t1125 ','\tjavascript'])
s_strip = s.str.strip(" ")
s_strip
#0                  C
#1    Python\t     \n
#2               java
#3               go\t
#4                NaN
#5             \t1125
#6       \tjavascript
#dtype: object

• （5） split() 用指定的分割符分割字符串。

s = pd.Series(['Zhang hua',' Py thon\n','   java   ','go','11 25 ','javascript'])
print(s.str.split(" "))
#0          [Zhang, hua]
#1        [, Py, thon\n]
#2    [, , , java, , , ]
#3                  [go]
#4            [11, 25, ]
#5          [javascript]
#dtype: object

• 如果不带参数,会先执行 strip()，再默认以空格分割。

print(s.str.split())
#0    [Zhang, hua]
#1      [Py, thon]
#2          [java]
#3            [go]
#4        [11, 25]
#5    [javascript]
#dtype: object

• 我们也可以对 strip() 的参数进行设置。

print(s.str.strip().str.split(" "))
#0    [Zhang, hua]
#1      [Py, thon]
#2          [java]
#3            [go]
#4        [11, 25]
#5    [javascript]
#dtype: object

• （6） cat(sep=“”) 用给定的分隔符连接字符串元素。
• cat(sep=“”) 函数会自动忽略 NaN。

s = pd.Series(['C', 'Python', 'java', 'go', np.nan, '1125','javascript'])
s_cat = s.str.cat(sep="_")
s_cat
#'C_Python_java_go_1125_javascript'

• （7） contains(pattern) 如果子字符串包含在元素中，则为每个元素返回一个布尔值 True，否则为 False。
• 我们可以取出 s 中包含空格的元素。

s = pd.Series(['C ',' Python','java','go','1125 ','javascript'])
s.str.contains(" ")
#0     True
#1     True
#2    False
#3    False
#4     True
#5    False
#dtype: bool

• 也可以将 True 返回原数据。

s[s.str.contains(" ")]
#0         C 
#1     Python
#4      1125 
#dtype: object

• （8） replace(a,b) 将值 a 替换为值 b。

s = pd.Series(['C ',' Python','java','go','1125 ','javascript'])
s.str.replace("java","python")
#0              C 
#1          Python
#2          python
#3              go
#4           1125 
#5    pythonscript
#dtype: object

• （9） count(pattern) 返回每个字符串元素出现的次数。

s = pd.Series(['C ','Python Python','Python','go','1125 ','javascript'])
s.str.count("Python")
#0    0
#1    2
#2    1
#3    0
#4    0
#5    0
#dtype: int64

• （10） startswith(pattern) 如果 Series 中的元素以指定的字符串开头，则返回 True。
• （11） endswith(pattern) 如果 Series 中的元素以指定的字符串结尾，则返回 True。
• 若以指定的 j 开头的字符串，则返回 True。

s = pd.Series(['C ',' Python','java','go','1125 ','javascript'])
print(s.str.startswith("j"))​
#0    False
#1    False
#2     True
#3    False
#4    False
#5     True
#dtype: bool

• （12） repeat(value) 以指定的次数重复每个元素。

s = pd.Series(['C ',' Python','java','go','1125 ','javascript'])
print(s.str.repeat(3))
#0                            C C C 
#1              Python Python Python
#2                      javajavajava
#3                            gogogo
#4                   1125 1125 1125 
#5    javascriptjavascriptjavascript
#dtype: object

• （13） find(pattern) 返回字符串第一次出现的索引位置。
• 这里如果返回 -1 表示该字符串中没有出现指定的字符。

s = pd.Series(['C ',' Python','java','go','1125 ','javascript'])
print(s.str.find("a"))
#0   -1
#1   -1
#2    1
#3   -1
#4   -1
#5    1
#dtype: int64

• （14） findall(pattern) 以列表的形式返出现的字符串。

s = pd.Series(['C ',' Python','java','go','1125 ','javascript'])
print(s.str.findall("a"))
#0        []
#1        []
#2    [a, a]
#3        []
#4        []
#5    [a, a]
#dtype: object

二、apply() 函数详解

• 在日常的数据处理中，经常会对一个 DataFrame 进行逐行、逐列和逐元素的操作，对应这些操作，Pandas 中的 map()、apply() 和 applymap() 可以解决绝大部分这样的数据处理需求。
• 三种方法的使用和区别如下：
• apply() 函数应用在 DataFrame 的行或列中。
• applymap() 函数应用在 DataFrame 的每个元素中。
• map() 函数应用在单独一列（Series）的每个元素中。
• 前面也说了 apply() 函数是一般性的“拆分-应用-合并”方法。 apply() 将一个函数作用于 DataFrame 中的每个行或者列，它既可以得到一个经过广播的标量值，也可以得到一个相同大小的结果数组。
• 我们先来看下函数形式：

df.apply(func, axis=0, raw=False, result_type=None, args=(), **kwds)

• 其参数含义如下：
• func 表示函数应用于每一列或每一行。
• axis 有 0 和 1 或者索引和列两种取值， 0 或“索引”表示将函数应用于每一列；1或“行”表示将函数应用于每一行。
• 我们先生成初始数据，并将列标签设置为 A 和 B。

df = pd.DataFrame([[4, 9]] * 3, columns=['A', 'B'])
df
A	B
0	4	9
1	4	9
2	4	9

• 可以使用 apply() 函数对 A、B 两列进行求和（axis 参数默认为 0）。

df.apply(np.sum)
#A    12
#B    27
#dtype: int64

• 我们将 axis 参数设置为 1，表示对每一行进行求和。

df.apply(np.sum, axis=1)
#0    13
#1    13
#2    13
#dtype: int64

• 或者我们使用 lambda 函数做简单的运算。

df.apply(lambda x: x + 1)
#   A	 B
#0	5	10
#1	5	10
#2	5	10

• 但是这样使用起来非常不方便，每次都要定义 lambda 函数。因此可以通过 def 定义一个函数，然后再调用该函数，在实际处理中都是定义自己所需要的函数完成操作：

def cal_result(df, x, y):df['C'] = (df['A'] + df['B']) * xdf['D'] = (df['A'] + df['B']) * yreturn df

• 我们使用自定义的函数进行计算，并生成 C、D 两列。

df.apply(cal_result, x=3, y=8, axis=1)
#   A	B	C	D
#0	4	9	39	104
#1	4	9	39	104
#2	4	9	39	104

• 在这里我们先定义了一个 cal_result 函数，它的作用是计算 A，B 列和的 x 倍和 y 倍添加到 C，D 列中。
• 这里有三种方式可以完成参数的赋值：
• （1） 第一种方式直接通过关键字参数赋值，指定参数的值。
• （2） 第二种方式是使用 args 关键字参数传入一个包含参数的元组。
• （3） 第三种方式传入通过 ** 传入包含参数和值的字典。
• apply() 函数的使用是很灵活的，再举一个例子，配合 loc 方法我们能够在最后一行得到一个总和：

df.loc[2] = df.apply(np.sum)
df
#   A	B
#0	4	9
#1	4	9
#2	12	27

三、applymap() 函数详解

• applymap() 函数针对 DataFrame中 的元素进行操作，还是使用这个数据：df.applymap(func)。

df
#   A	B
#0	4	9
#1	4	9
#2	12	27

• 我们使用 lambda 函数将其变为浮点型。

df.applymap(lambda x: '%.2f'%x)
#      A	   B
#0	4.00	9.00
#1	4.00	9.00
#2	4.00	9.00

• 在这里可以看到 applymap() 函数操作的是其中的元素，并且是对整个 DataFrame 进行了格式化，我们也可以选择行或列中的元素。
• 对行进行选取。

df[['A']]
#   A
#0	4
#1	4
#2	4

• 对列进行选取。

df[['A']].applymap(lambda x: '%.2f'%x)
#      A
#0	4.00
#1	4.00
#2	4.00

• 需要注意的是这里必须使用 df[[‘A’]] ，表示这是一个 DataFrame，而不是一个 Series，如果使用 df[‘A’] 就会报错。同样从行取元素也要将它先转成 DataFrame。

df['A'].applymap(lambda x: '%.2f'%x)  # 异常 
#---------------------------------------------------------------------------
#AttributeError                            Traceback (most recent call last)
#<ipython-input-11-585649caf30e> in <module>()
#----> 1 df['A'].applymap(lambda x: '%.2f'%x)  # 异常
#
#E:\Anaconda\lib\site-packages\pandas\core\generic.py in __getattr__(self, name)
#   5139             if self._info_axis._can_hold_identifiers_and_holds_name(name):
#   5140                 return self[name]
#-> 5141             return object.__getattribute__(self, name)
#   5142 
#   5143     def __setattr__(self, name: str, value) -> None:
#
#AttributeError: 'Series' object has no attribute 'applymap'

• 还需要注意 apply() 函数和 applymap() 函数的区别：
• apply() 函数操作的是行或列的运算，而不是元素的运算，比如在这里使用格式化操作就会报错。
• applymap() 函数操作的是元素，因此没有诸如 axis 这样的参数，它只接受函数传入。

四、map() 函数详解

• 如果对 applymap() 函数搞清楚了，那么map() 函数就很简单，说白了 map() 函数是应用在 Series 中的，还是举上面的例子。

df['A'].map(lambda x: '%.2f'%x)
#0    4.00
#1    4.00
#2    4.00
#Name: A, dtype: object

• 需要注意的是，Series 没有 applymap() 函数。

df[['A']].applymap(lambda x: '%.2f'%x)
#---------------------------------------------------------------------------
#AttributeError                            Traceback (most recent call last)
#<ipython-input-11-585649caf30e> in <module>()
#----> 1 df[['A']].applymap(lambda x: '%.2f'%x)  # 异常
#
#E:\Anaconda\lib\site-packages\pandas\core\generic.py in __getattr__(self, name)
#   5139             if self._info_axis._can_hold_identifiers_and_holds_name(name):
#   5140                 return self[name]
#-> 5141             return object.__getattribute__(self, name)
#   5142 
#   5143     def __setattr__(self, name: str, value) -> None:
#
#AttributeError: 'Series' object has no attribute 'applymap'