机器学习-文本处理

机器学习-文本处理

Pandas 处理文本字符串

官网学习链接：https://www.pypandas.cn/docs/user_guide/text.html#%E6%8B%86%E5%88%86%E5%92%8C%E6%9B%BF%E6%8D%A2%E5%AD%97%E7%AC%A6%E4%B8%B2

大小写转换、计算字符串长度

s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'])
s.str.lower() #将字符串转换为小写，自动跳过NAN
s.str.upper() #将字符串转换为大写
s.str.len()   #每个字符串的长度，如‘A’的长度为1.0

删除字符串中的空格

idx = pd.Index([' jack', 'jill ', ' jesse ', 'frank'])
idx.str.strip() 	#删除字符串中的空格
idx.str.lstrip()	#截掉字符串左边的空格或指定字符
idx.str.rstrip()	#截掉字符串右边的空格或指定字符

拆分字符串

s2 = pd.Series(['a_b_c', 'c_d_e', np.nan, 'f_g_h'])
s2.str.split('_')	#将字符串根据‘-’拆分
s2.str.split('_', expand=True)	#使用expand方法可以轻易地将这种返回展开为一个数据表
s2.str.split('_', expand=True, n=1)	#限制切分的次数(从0开始数)
s2.str.split('_').str.get(1)	#切分后的列表中的元素可以通过 get 方法或者 [] 方法进行读取
s2.str.split('_').str[1] 
s2.str.rsplit('_', expand=True, n=1)	#rsplit与split相似，不同的是，这个切分的方向是反的。即，从字串的尾端向首段切分

替换字符串

s3 = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca',
                 '', np.nan, 'CABA', 'dog', 'cat'])
s3.str.replace('^.a|dog', 'XX-XX ', case=False) #把所有以a结尾的或者是dog的字符串替换成XX-XX。replace方法默认使用正则表达式
dollars.str.replace('-$', '-', regex=False)	#replace替换包含'$'符号时这样写

pat = r'[a-z]+'
def repl(m):
    return m.group(0)[::-1]
pd.Series(['foo 123', 'bar baz', np.nan]).str.replace(pat, repl)	#replace的方便用法

拼接字符串

s = pd.Series(['a', 'b', 'c', 'd'])
s.str.cat(sep=',')	#将单个序列拼接为一个完整字符串，sep 即分隔符默认为空字串，即sep=''
t.str.cat(sep=',', na_rep='-')	#默认情况下，缺失值会被忽略。使用na_rep参数，可以对缺失值进行赋值
s.str.cat(['A', 'B', 'C', 'D'])	#拼接序列和其他类列表型对象为新的序列，cat() 的第一个参数为类列表对象，但必须要确保长度与序列或索引相同
s.str.cat(t, na_rep='-')	#任何一端的缺失值都会导致之中结果为缺失值，除非使用na_rep
s.str.cat(u, join='left')	#对齐操作。join的选项为（'left', 'outer', 'inner', 'right'）中的一个。特别的，对齐操作使得两个对象可以是不同的长度。只要禁用对齐join=None，那么序列或索引就可以是任意长度
d = pd.concat([t, s], axis=1)

字符串索引

s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan,
                 'CABA', 'dog', 'cat'])
s.str[0]	#返回每个字符串的第一个元素，如果你的索引超过了字符串的结尾，将返回NaN

提取子字符串

pd.Series(['a1', 'b2', 'c3']).str.extract(r'([ab])(\d)', expand=False)#提取第一个匹配的对象。没有成功匹配的元素将会返回一行NaN
#extract拥有了expand 参数。当 expand=False时， 将返回一个序列，索引或者数据表， 这取决于原对象和正则表达式（之前的版本也是如此）。当 expand=True时，它则总是返回一个DataFrame
------------------------------------------------------------------------------
s = pd.Series(["a1a2", "b1", "c1"], index=["A", "B", "C"])
two_groups = '(?P<letter>[a-z])(?P<digit>[0-9])'
s.str.extract(two_groups, expand=True)	#提取所有的匹配 

测试匹配或包含模式的字符串

pattern = r'[0-9][a-z]'
pd.Series(['1', '2', '3a', '3b', '03c']).str.contains(pattern)	#你可以检查是否一个元素包含一个可以匹配到的正则表达式
s4.str.contains('A', na=False)	#是否元素完整匹配一个正则表达式,返回True或False
pd.Series(['1', '2', '3a', '3b', '03c']).str.match(pattern)	#是否元素完整匹配一个正则表达式,返回True或False

建立一个指示变量

s = pd.Series(['a', 'a|b', np.nan, 'a|c'])
s.str.get_dummies(sep='|')	#你从字符串列可以抽出一个哑变量。例如，是否他们由|分割

方法总览

方法	描述
cat()	拼接字符串
split()	基于分隔符切分字符串
rsplit()	基于分隔符，逆向切分字符串
get()	索引每一个元素（返回第i个元素）
join()	使用传入的分隔符依次拼接每一个元素
get_dummies()	用分隔符切分字符串，并返回一个含有哑变量的数据表
contains()	返回一个布尔矩阵表明是每个元素包含字符串或正则表达式
replace()	将匹配到的子串或正则表达式替换为另外的字符串，或者一个可调用对象的返回值
repeat()	值复制（s.str.repeat(3)等价于x * 3）
pad()	将白空格插入到字符串的左、右或者两端
center()	等价于str.center
ljust()	等价于str.ljust
rjust()	等价于str.rjust
zfill()	等价于str.zfill
wrap()	将长字符串转换为不长于给定长度的行
slice()	将序列中的每一个字符串切片
slice_replace()	用传入的值替换每一个字串中的切片
count()	对出现符合的规则进行计数
startswith()	等价于str.startswith(pat)
endswith()	等价于 str.endswith(pat)
findall()	返回每一个字串中出现的所有满足样式或正则的匹配
match()	素调用 re.match，并以列表形式返回匹配到的组
extract()	Call 对每一个元素调用 re.search, 并以数据表的形式返回。行对应原有的一个元素，列对应所有捕获的组
extractall()	一个元素调用 re.findall, 并以数据表的形式返回。行对应原有的一个元素，列对应所有捕获的组
len()	计算字符串长度
strip()	等价于str.strip
rstrip()	等价于str.rstrip
lstrip()	等价于str.lstrip
partition()	等价于 str.partition
rpartition()	等价于 str.rpartition
lower()	等价于 str.lower
casefold()	等价于 str.casefold
upper()	等价于 str.upper
find()	等价于str.find
rfind()	等价于 str.rfind
index()	等价于 str.index
rindex()	等价于 str.rindex
capitalize()	等价于 str.capitalize
swapcase()	等价于 str.swapcase
normalize()	返回Unicode 标注格式。等价于 unicodedata.normalize
translate()	等价于 str.translate
isalnum()	等价于 str.isalnum
isalpha()	等价于 str.isalpha
isdigit()	等价于 str.isdigit
isspace()	等价于 str.isspace
islower()	等价于 str.islower
isupper()	等价于 str.isupper
istitle()	等价于 str.istitle
isnumeric()	等价于 str.isnumeric
isdecimal()	等价于 str.isdecimal

正则表达式

re模块常用的函数

函数	描述
match(pattern,string,flags=0)	根据pattern从string的头部开始匹配字符串，只返回第一次匹配成功的对象；否则，返回None
findall(pattern,string,flags=0)	根据pattern在string中匹配字符串。如果匹配成功，返回匹配结果的列表；否则，返回空列表。当pattern中有分组时，返回包含多个元组的列表，每个元组对应1个分组。flags表示规则选项，规则选项用于辅助匹配。
sub(pattern,repl,string,count=0)	根据指定的正则表达式，替换源字符串中的子串。pattern是一个正则表达式,repl是用于替换的字符串,string是源字符串。如果count等于0，则返回string中匹配的所有结果；如果count大于0，则返回count个匹配的结果。
subn(pattern,repl,string,count=0)	作用和sub()相同，返回一个二元的元组。第一个元素是替换结果，第二个元素是替换的次数。
search(pattern,string,flags=0)	根据pattern在string中匹配字符串，只返回第一次匹配成功的对象。如果匹配失败，返回None
compile(pattern,flags=0)	编译正则表达式pattern，返回1个pattern的对象
split(pattern,string,maxsplit=0)	根据pattern分割string，maxsplit表示最大的分割数
escape(pattern)	匹配字符串中的特殊字符，如*、+、？等

match方法

​ re.match尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回None。语法格式如下：

re.match(pattern,string,flags=0)

函数参数说明如下：

match函数参数说明

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串
flags	标志位，用于空值正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。如下表列出正则表达式修饰符-可选标志

正则表达式修饰符-可选标志

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地识别（locale-aware）匹配
re.M	多行匹配，影响^和$
re.S	使.匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符，这个标志影响\w,\W,\b,\B
	该标志通过给予你更灵活的格式以便你将正则表达式写的更易于理解

​ 匹配字符串是正则表达式中最常用的一类应用。也就是设定一个文本模式,然后判断另外一个字符串是否符合这个文本模式。

​ 如果文本模式只是一个普通的字符串,那么待匹配的字符串和文本模式字符串在完全相等的情况下, match方法会认为匹配成功。如果匹配成功,则match方法返回匹配的对象,然后可以调用对象中的group方法获取匹配成功的字符串,如果文本模式就是一个普通的字符串,那么group方法返回的就是文本模式字符串本身。

实例

import re 
s='hello python'
pattern='hello'
o=re.match(pattern,s,re.I) #re.I不区分大小写
print(o)
print(dir(o))
print(o.group) #返回匹配的字符串

常用匹配符

正则表达式中常用的字符

符号	描述
.	匹配任意一个字符（除了\n）
[]	匹配列表中的字符
\w	匹配字母、数字、下划线，即a-z,A-Z,0-9,_
\W	匹配不是字母、数字、下划线
\s	匹配空白字符，即空格（\n,\t）
\S	匹配不是空白的字符
\d	匹配数字，即0-9
\D	匹配非数字的字符

实例

import re
print('------.的使用------')
s='a'
s='A'
s='8'
s='_'
pattern='.'
o=re.match(pattern,s)
print(o)
print('------\d的使用------') #数字
print('------\s的使用------')

表示数量（匹配多个字符）

实例

import re
pattern='\d\d\d\d\d\d\d\d\d' #匹配手机号
pattern='1[135789]\d\d\d\d\d\d\d'
s='13456788765'
o=re.match(pattern,s)
print(o)
#电话号码 区号-座机号 010-3762266 0342-8776262

正则表达式中常用的限定符

符号	描述	符号	描述
*	匹配零次或多次	{m}	重复m次
+	匹配一次或多次	{m,n}	重复m到n次，其中n可以省略，表示m到任意次
？	匹配一次或零次	{m,}	至少m次

利用{}可以空值符号重复的次数

实例

import re
print('------*的使用------')
s='123qwe'
pattern='\d*'
o=re.match(pattern,s)
print(o)
print('------+的使用------') 
print('------?的使用------')