本节来讲一下文本处理相关的库
str
字符串定义：
在 Python 中处理文本数据是使用 str 对象，也称为 字符串。 字符串是由 Unicode 码位构成的不可变序列。
字符串字面值有多种不同的写法：
单引号: '允许包含有 "双" 引号’
双引号: "允许包含有 '单' 引号”
三重引号: '''三重单引号''', """三重双引号"""
使用三重引号的字符串可以跨越多行 —— 其中所有的空白字符都将包含在该字符串字面值中。
class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')
返回 object 的 字符串 版本。 如果未提供 object 则返回空字符串。 在其他情况下 str() 的行为取决于 encoding 或 errors 是否有给出。
-r 表示字符串中所有的字符表示其本身，比如，反斜杠就是反斜杠，不是用来转义的，'\n' 表示换行符，是一个字符，而 r'\n' 则是两个字符：一个反斜杠、一个小写n。
-u 表示字符串是Unicode字符串，在Python 3中保留是为了兼容Python 2，而Python 3中的字符串默认都是Unicode字符串，在Python 3中，不需要添加，而且不能和 r 一起使用。
字符串方法：
str.capitalize()
返回原字符串的副本，其首个字符大写，其余为小写。
示例：
print(str.capitalize('a我是个字符串’))
输出：
A我是个字符串
str.casefold()
返回原字符串消除大小写的副本。 消除大小写的字符串可用于忽略大小写的匹配。
消除大小写类似于转为小写，但是更加彻底一些，因为它会移除字符串中的所有大小写变化形式。
例如，德语小写字母 'ß' 相当于 "ss"。 由于它已经是小写了，lower() 不会对 'ß' 做任何改变；而 casefold() 则会将其转换为 "ss"。
示例：
print(str.casefold('ABGQ我是个字符串'))
输出：
abgq我是个字符串
str.center(width[, fillchar])
返回长度为 width 的字符串，原字符串在其正中。
使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。 如果 width 小于等于 len(s) 则返回原字符串的副本。
示例：
test_str = str('ABGQ我是个字符串')
print(test_str.center(20, 'M'))
输出：
MMMMMABGQ我是个字符串MMMMM
str.count(sub[, start[, end]])
反回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法。
示例：
test_str = str('ABGQ我是个字符串ABGQ')
print(test_str.count('A’)) # 统计A在test_str中出现的次数
print(test_str[0:5]) # 0到5位置的字符串是“ABGQ我”
print(test_str.count('A', 0, 5)) # 统计A在test_str字符串，[0,5]范围内出现的次数，[0,5]范围是‘ABGQ我’，所以统计出来的个数是1个
输出：
2
ABGQ我
1
str.encode(encoding="utf-8", errors="strict")
返回原字符串编码为字节串对象的版本。 默认编码为 'utf-8’。
可以给出 errors 来设置不同的错误处理方案。 errors 的默认值为 'strict'，表示编码错误会引发 UnicodeError。
其他可用的值为 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及任何其他通过 codecs.register_error() 注册的值。
示例：
test_str = str('ABGQ我是个字符串ABGQ')
print(test_str.encode()) # 默认编码 ‘utf-8’
print(test_str) # 说明encode操作不会改变test_str
输出：
b'ABGQ\xe6\x88\x91\xe6\x98\xaf\xe4\xb8\xaa\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2ABGQ'
ABGQ我是个字符串ABGQ
str.endswith(suffix[, start[, end]])
如果字符串以指定的 suffix 结束返回 True，否则返回 False。 suffix 也可以为由多个供查找的后缀构成的元组。
如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。
示例：
test_str = str('ABGQ我是个字符串ABGQ')
print(test_str.endswith('BGQ'))
print(test_str.endswith('BG'))
print(test_str.endswith('BGQ', 0, 4)) #比较[0:4]就是‘ABGQ’字符串的结尾是否是’BGQ’，所以这里是True
print(test_str.endswith('BGQ', 0, 5)) #比较[0:5]就是’ABGQ我’字符串的结尾是否是’BGQ’，所以这里是False
输出：
True
False
True
False
str.expandtabs(tabsize=8)
返回字符串的副本，其中所有的制表符会由一个或多个空格替换，具体取决于当前列位置和给定的制表符宽度。 每 tabsize 个字符设为一个制表位（默认值 8 时设定的制表位在列 0, 8, 16 依次类推）。 要展开字符串，当前列将被设为零并逐一检查字符串中的每个字符。 如果字符为制表符 (\t)，则会在结果中插入一个或多个空格符，直到当前列等于下一个制表位。 （制表符本身不会被复制。） 如果字符为换行符 (\n) 或回车符 (\r)，它会被复制并将当前列重设为零。 任何其他字符会被不加修改地复制并将当前列加一，不论该字符在被打印时会如何显示。
>>> '01\t012\t0123\t01234'.expandtabs()
'01 012 0123 01234'
>>> '01\t012\t0123\t01234'.expandtabs(4)
'01 012 0123 01234'
str.find(sub[, start[, end]])
返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。 可选参数 start 与 end 会被解读为切片表示法。 如果 sub 未被找到则返回 -1。
示例：
test_str = str('ABGQ我是个字符串ABGQ')
print(test_str.find('A’)) # 从头开始找第一个A所在的位置索引，所以是0
print(test_str.find('Q’)) # 从头开始找第一个Q所在的位置索引，所以是3
print(test_str.find('个’)) # 从头开始找第一个“个”所在的位置索引，所以是6
print(test_str.find('B', 5)) # 从位置索引是5的地方开始找第一个B所在的位置索引，所以是11
print(test_str.find('K’)) # 从头开始找第一个K所在的位置索引，因为没找到，所以返回-1
输出：
0
3
6
11
-1
str.format(*args, **kwargs)
执行字符串格式化操作。
调用此方法的字符串可以包含字符串字面值或者以花括号 {} 括起来的替换域。
每个替换域可以包含一个位置参数的数字索引，或者一个关键字参数的名称。
返回的字符串副本中每个替换域都会被替换为对应参数的字符串值。
示例：
addend1 = 3
addend2 = 6
sum = addend1 + addend2
# format 以位置参数做替换域
print('the sum is {0} + {1} = {2}'.format(addend1, addend2, sum))
# format 以关键字参数做替换域
print('the sum is {addend1_name} + {addend2_name} = {sum_name}'.format(addend1_name=addend1, addend2_name=addend2, sum_name=sum))
输出：
the sum is 3 + 6 = 9
the sum is 3 + 6 = 9
str.index(sub[, start[, end]])
类似于 find()，但在找不到子类时会引发 ValueError。
示例：
test_str = str('ABGQ我是个字符串ABGQ')
test_str.index('H’)
输出：
test_str.index('H')
ValueError: substring not found
str.isalnum()
如果字符串中的所有字符都是字母数字，并且至少有一个字符，则返回true，否则为false。
如果下面其中一个返回True，则字符c是字母数字:c.isalpha()、c.isdecimal()、c.isdigit()或c.isnumeric()。
示例：
test_str1 = str('99ABGQ我是个字符串ABGQ33')
print(test_str1.isalnum())
test_str2 = str('#99ABGQ我是个字符串ABGQ33%')
print(test_str2.isalnum())
输出：
True
False
str.isalpha()
如果字符串中的所有字符都是字母顺序的，并且至少有一个字符，则返回true，否则返回false。
字母字符是在Unicode字符数据库中定义为“字母”的字符，即，一般类别属性为“Lm”、“Lt”、“Lu”、“Ll”或“Lo”的。
注意，这与Unicode标准中定义的“Alphabetic”属性不同。
示例：
test_str1 = str('99ABGQ我是个字符串ABGQ33’) #包含数字，所以返回False
print(test_str1.isalpha())
test_str2 = str('ABGQ我是个字符串ABGQ’) #纯Unicode字符，所以返回True。中文汉字也是Unicode字符。
print(test_str2.isalpha())
输出：
False
True
str.isdecimal()
如果字符串中的所有字符都是十进制字符，并且至少有一个字符，则返回true，否则返回false。
十进制字符是那些可以用来形成以10为基数的数字的字符，例如U+0660，阿拉伯-印度数字0。在形式上，十进制字符是Unicode通用类别“Nd”中的字符。
示例：
test_str1 = str('99ABGQ我是个字符串ABGQ33')
print(test_str1.isdecimal())
test_str2 = str('01234567890’) #十进制基数的字符“0123456789”
print(test_str2.isdecimal())
输出：
False
True
str.isdigit()
如果字符串中的所有字符都是数字，并且至少有一个字符，则返回true，否则返回false。
数字包括十进制字符和需要特殊处理的数字，如兼容性上标数字。这包括不能用于以10为基数形成数字的数字，如Kharosthi数字。
在形式上，数字是具有属性值Numeric_Type= digit或Numeric_Type=Decimal的字符。
str.isidentifier()
如果字符串是一个有效的标识符，则返回true，否则返回false。
示例：
test_str = str('school’) # 有效的标识符
print(test_str.isidentifier())
test_str = str('1school’) # 无效的标识符，因为是数字开头的字符串
print(test_str.isidentifier())
输出：
True
False
str.islower()
如果字符串中都是小写字母，并且至少有一个字符，则返回true，否则返回false。
示例：
test_str = str('99school我@#￥’) #都是小写字母，返回true
print(test_str.islower())
test_str = str('99我是谁@#￥’) #没有字母，返回false
print(test_str.islower())
test_str = str('Who am I?’) #包含大写字母，返回false
print(test_str.islower())
输出：
True
False
False
str.isupper()
如果字符串中都是大写字母，并且至少有一个字符，则返回true，否则返回false。
示例：
test_str = str('i am shanhai')
print(test_str.isupper()) #包含了小写字母，所以返回false
test_str = str('I Am Shanhai')
print(test_str.isupper()) #包含了小写字母，所以返回false
test_str = str('I AM SHANHAI')
print(test_str.isupper()) #全部是大写字母，所以返回true
输出：
False
False
True
str.isnumeric()
如果字符串中的所有字符都是数字字符，并且至少有一个字符，则返回true，否则为false。
数字字符包括数字字符，以及所有具有Unicode数值属性的字符。
在形式上，数字字符是那些具有属性值Numeric_Type=Digit、Numeric_Type=Decimal或Numeric_Type= numeric的字符。
str.isprintable()
如果字符串中的所有字符都可打印或字符串为空，则返回true，否则返回false。
不可打印字符是Unicode字符数据库中定义为“其他”或“分隔符”的字符，ASCII空格(0x20)除外，它被认为是可打印的。
注意，在这个上下文中，可打印字符是在字符串上调用repr()时不应该转义的字符。它与向sys写入的字符串的处理无关。stdout或sys.stderr。
str.isspace()
如果字符串中只有空白字符并且至少有一个字符，则返回true，否则返回false。
空白字符是Unicode字符数据库中定义为“其他”或“分隔符”的字符，而具有双向属性的字符是“WS”、“B”或“S”之一。
str.istitle()
如果字符串是有标题的字符串，并且至少有一个字符，则返回true。
例如大写字符只能跟在无大小写字符后面，小写字符只能跟在大小写字符后面。否则返回假。
str.join(iterable)
返回一个由 iterable 中的字符串拼接而成的字符串。
如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError。 调用该方法的字符串将作为元素之间的分隔。
str.ljust(width[, fillchar])
返回长度为 width 的字符串，原字符串在其中靠左对齐。
使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。
str.rjust(width[, fillchar])
返回长度为 width 的字符串，原字符串在其中靠右对齐。
使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。
str.lstrip([chars])
返回原字符串的副本，移除其中的前导字符。 chars 参数为指定要移除字符的字符串。
如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀；而是会移除参数值的所有组合。
str.rstrip([chars])
返回原字符串的副本，移除其中的末尾字符。 chars 参数为指定要移除字符的字符串。
如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个后缀；而是会移除参数值的所有组合。
str.partition(sep)
在 sep 首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。
如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串。
str.replace(old, new[, count])
返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。
str.rfind(sub[, start[, end]])
返回子字符串 sub 在字符串内被找到的最大（最右）索引，这样 sub 将包含在 s[start:end] 当中。
可选参数 start 与 end 会被解读为切片表示法。 如果未找到则返回 -1。
str.rindex(sub[, start[, end]])
类似于 rfind()，但在子字符串 sub 未找到时会引发 ValueError。
str.rpartition(sep)
在 sep 最后一次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。
如果分隔符未找到，则返回的 3 元组中包含两个空字符串以及字符串本身。
str.rsplit(sep=None, maxsplit=-1)
返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分，从 最右边 开始。
如果 sep 未指定或为 None，任何空白字符串都会被作为分隔符。 除了从右边开始拆分，rsplit() 的其他行为都类似于下文所述的 split()。
str.split(sep=None, maxsplit=-1)
返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。
如果给出了 maxsplit，则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）。
如果 maxsplit 未指定或为 -1，则不限制拆分次数（进行所有可能的拆分）。
如果给出了 sep，则连续的分隔符不会被组合在一起而是被视为分隔空字符串 (例如 '1,,2'.split(',') 将返回 ['1', '', '2'])。
sep 参数可能由多个字符组成 (例如 '1<>2<>3'.split('<>') 将返回 ['1', '2', '3'])。 使用指定的分隔符拆分空字符串将返回 ['']。
str.splitlines([keepends])
返回由原字符串中各行组成的列表，在行边界的位置拆分。 结果列表中不包含行边界，除非给出了 keepends 且为真值。
此方法会以下列行边界进行拆分。 特别地，行边界是 universal newlines 的一个超集。
str.startswith(prefix[, start[, end]])
如果字符串以指定的 prefix 开始则返回 True，否则返回 False。 prefix 也可以为由多个供查找的前缀构成的元组。
如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。
str.strip([chars])
返回原字符串的副本，移除其中的前导和末尾字符。 chars 参数为指定要移除字符的字符串。
如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀或后缀；而是会移除参数值的所有组合。
示例：
test_str = str(' i am shanhai ')
print(test_str.strip()) #移除了字符串前后的空格符
test_str = str('i am shanhai')
print(test_str.strip('i’)) #移除字符串前后的’i’
输出：
i am shanhai
am shanha
str.swapcase()
返回原字符串的副本，其中大写字符转换为小写，反之亦然。
请注意 s.swapcase().swapcase() == s 并不一定为真值。
示例：
test_str = str('I Am Shanhai')
print(test_str.swapcase())
输出：
i aM sHANHAI
str.title()
返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。
示例：
test_str = str('i am shanhai')
print(test_str.title())
输出：
I Am Shanhai
static str.maketrans(x[, y[, z]])
此静态方法返回一个可供 str.translate() 使用的转换对照表。
如果只有一个参数，则它必须是一个将 Unicode 码位序号（整数）或字符（长度为 1 的字符串）映射到 Unicode 码位序号、（任意长度的）字符串或 None 的字典。
字符键将会被转换为码位序号。
如果有两个参数，则它们必须是两个长度相等的字符串，并且在结果字典中，x 中每个字符将被映射到 y 中相同位置的字符。
如果有第三个参数，它必须是一个字符串，其中的字符将在结果中被映射到 None。
str.translate(table)
返回原字符串的副本，其中每个字符按给定的转换表进行映射。 转换表必须是一个使用 __getitem__() 来实现索引操作的对象，通常为 mapping 或 sequence。
当以 Unicode 码位序号（整数）为索引时，转换表对象可以做以下任何一种操作：返回 Unicode 序号或字符串，将字符映射为一个或多个字符；
返回 None，将字符从结果字符串中删除；或引发 LookupError 异常，将字符映射为其自身。
你可以使用 str.maketrans() 基于不同格式的字符到字符映射来创建一个转换映射表。
示例：
transverter_before = 'abcde'
transverter_after = '12345'
transverter_table = str.maketrans(transverter_before, transverter_after) # 建立转换表
test_str = str('+@AB我是个字符串abgq')
print(test_str.translate(transverter_table)) #把’abcde'用'12345’替换，所以这里a替换成1，b替换成2，其他字符不变。
输出：
+@AB我是个字符串12gq
str.lower()
返回原字符串的副本，其所有区分大小写的字符均转换为小写。
示例：
test_str = str('ABGQ我是个字符串ABGQ')
print(test_str.lower())
输出：
abgq我是个字符串abgq
str.upper()
返回原字符串的副本，其中所有区分大小写的字符 4 均转换为大写。
请注意如果 s 包含不区分大小写的字符或者如果结果字符的 Unicode 类别不是 “Lu” (Letter, uppercase) 而是 “Lt” (Letter, titlecase) 则 s.upper().isupper() 有可能为 False。
示例：
test_str = str('+@AB我是个字符串abgq')
print(test_str.upper())
输出：
+@AB我是个字符串ABGQ
str.zfill(width)
返回原字符串的副本，在左边填充 ASCII '0' 数码使其长度变为 width。 正负值前缀 ('+'/'-') 的处理方式是在正负符号 之后 填充而非在之前。
如果 width 小于等于 len(s) 则返回原字符串的副本。
示例：
test_str = str('ABGQ我是个字符串ABGQ')
print(test_str.zfill(5))
print(test_str.zfill(25)) # 左边补0
test_str = str('+ABGQ我是个字符串ABGQ’) # 在+之后填充0
print(test_str.zfill(25))
test_str = str('-ABGQ我是个字符串ABGQ’) # 在-之后填充0
print(test_str.zfill(25))
输出：
ABGQ我是个字符串ABGQ
00000000000ABGQ我是个字符串ABGQ
+0000000000ABGQ我是个字符串ABGQ
-0000000000ABGQ我是个字符串ABGQ
网友评论