Python字符串方法详解

Python字符串方法详解
字符串
由0个或多个字符组成的有序字符序列

• 由一对单引号或双引号表示
• 由一对三单引号或三双引号表示，可表示多行字符串
  但是python在输出字符串的时候，总是倾向于使用单引号，除非字符串中包含了单引号。

字符串类型的格式化

字符串格式化用于解决字符串和变 量同时输出时的格式安排

format()方法的基本使用

基本语法是通过 {} 和 : 来代替以前的 %
字符串format()方法的基本使用格式是： <模板字符串>.format(<逗号分隔的参数>)
• <模板字符串>由一系列的槽组成，用来控制修改字符串中嵌入值出现 的位置，其基本思想是将format()方法的<逗号分隔的参数>中的参数按照 序号关系替换到<模板字符串>的槽中。槽用大括号{}表示，如果大括 号中没有序号，则按照出现顺序替换

• 如果大括号中指定了使用参数的序号，按照序号对应参数替换，调 用format()方法后会返回一个新的字符串，参数从0开始编号。

"{ }：计算机{ }的CPU占有率为{ } %.".format("2016-12-31","python",10)
'2016-12-31:计算机python的CPU占有率为10%.'

• format()方法可以非常方便地连接不同类型的变量或内容，如果需 要输出大括号，采用{{表示{，}}表示}，例如：

"{ } { } { }".format("圆周率是",3.1415926，"...")
'圆周率是3.1415926...'

format()方法的格式控制

• format()方法中<模板字符串>的槽除了包括参数序号，还可以包括格式 控制信息。此时，槽的内部样式如下：
  {<参数序号>: <格式控制标记>} • 其中，<格式控制标记>用来控制参数显示时的格式，格式内容如下：
• <格式控制标记>包括：<填充><对齐><宽度>,<.精度><类型>6个字段 ，这些字段都是可选的，可以组合使用，这里按照使用方式逐一介绍 ：
  <填充>、<对齐>和<宽度>是3个相关字段。
  • **<宽度>**指当前槽的设定输出字符宽度，如果该槽对应的format()参 数长度比<宽度>设定值大，则使用参数实际长度。如果该值的实际位 数小于指定宽度，则位数将被默认以空格字符补充。
  format()方法的格式控制
  • **<对齐>**指参数在<宽度>内输出时的对齐方式，分别使用<、>和^三 个符号表示左对齐、右对齐和居中对齐。
  • **<填充>**指<宽度>内除了参数外的字符采用什么方式表示，默认采用 空格，可以通过<填充>更换。
• **<.精度>**表示两个含义，由小数点（.）开头。对于浮点数，精度表 示输出的有效位数。对于字符串，精度表示输出的最大长度

"{0:.4}".format("python")
'pyth'

**<类型>**表示输出整数和浮点数类型的格式规则。
➢ b: 输出整数的二进制方式；
➢ c: 输出整数对应的Unicode字符；
➢ d: 输出整数的十进制方式；
➢ o: 输出整数的八进制方式；
➢ x: 输出整数的小写十六进制方式；
➢ X: 输出整数的大写十六进制方式；

对于浮点数类型，输出格式包括4种：
➢ e: 输出浮点数对应的小写字母e的指数形式；
➢ E: 输出浮点数对应的大写字母E的指数形式；
➢ f: 输出浮点数的标准浮点形式；
➢ %: 输出浮点数的百分形式。
• 浮点数输出时尽量使用<.精度>表示小数部分的宽度，有助于更好控 制输出格式。

字符串的特殊字符

转义符
——“这里有个双引号（”)"
这里有个双引号(")
——转义符形成一些组合，表达一些不可打印的含义
“\b”——回退
“\n”——换行
“\r”——回车

字符串方法

(string)方法整理

python中字符串是不可变对象，所以所有修改和生成字符串的操作的实现方法都是另一个内存片段中新生成一个字符串对象。

大小写转换

• S.lower() 返回S字符串的小写格式

>>> print('ab XY'.lower())
ab xy

• S.upper() 返回S字符串的大写格式

>>> print('ab XY'.upper())
AB XY

• S.title() 返回S字符串中所有单词首字母大写且其他字母小写的格式

print('ab XY'.title())
Ab Xy

• S.capitalize() 返回首字母大写、其他字母全部小写的新字符串

print('abc DE'.capitalize())
Abc de

• S.swapcase() 对S中的所有字符串做大小写转换(大写–>小写，小写–>大写)。

print('abc XYZ'.swapcase())
ABC xyz

isXXX判断

• S.isdigit() 、S.isdecimal() 、S.isnumeric() 测试字符串S是否是数字

 print('34'.isdigit())
True

• S.isalpha() 测试字符串S是否是字母

print('abc'.isalpha())
True

• S.isalnum() 测试字符串S是否是字母或数字

print('a34'.isalnum())
True

• S.islower() 判断是否小写。要求S中至少要包含一个字符串字符，否则直接返回False。例如不能是纯数字

print('a34'.islower())
True

S.isupper() 判断是否大写。要求S中至少要包含一个字符串字符，否则直接返回False。例如不能是纯数字。

print('AB'.isupper())
True
 print('Aa'.isupper())
False

S.istitle() 判断是否首字母大写。要求S中至少要包含一个字符串字符，否则直接返回False。例如不能是纯数字。

>>>print('Aa Bc'.istitle())
True
>>> print('Aa_Bc'.istitle())
True
>>> print('Aa bc'.istitle())
False
>>> print('Aa_bc'.istitle())
False
>>>print('Aa BC'.istitle())
False

• S.isspace()判断字符串是否是空白(空格、制表符、换行符等)字符

>>> print(' '.isspace())
True
>>> print(' \t'.isspace())
True
>>> print('\n'.isspace())
True
>>> print(''.isspace())
False
>>> print('Aa BC'.isspace())
False

• S.isprintable()判断是否是可打印字符(例如制表符、换行符就不是可打印字符，但空格是)

>>> print('\n'.isprintable())
False
>>> print('\t'.isprintable())
False
>>> print('acd'.isprintable())
True
>>> print(' '.isprintable())
True
>>> print(''.isprintable())
True

• S.isidentifier()判断是否满足标识符定义规则。

>>> print('abc'.isidentifier())
True
>>> print('2abc'.isidentifier())
False
>>> print('abc2'.isidentifier())
True
>>> print('_abc2'.isidentifier())
True
>>> print('_abc_2'.isidentifier())
True
>>> print('_Abc_2'.isidentifier())
True
>>> print('Abc_2'.isidentifier())
True

填充

• S.center(width[, fillchar])将字符串居中，左右两边使用fillchar进行填充，使得整个字符串的长度为width。fillchar默认为空格。如果width小于字符串的长度，则无法填充直接返回字符串本身(不会创建新字符串对象)。

>>> print('ab'.center(4,'_'))
_ab_
>>> print('ab'.center(5,'_'))
__ab_
>>> print('ab'.center(4))
 ab 
>>> print(len('ab'.center(4)))
4
>>> print('abcde'.center(3))
abcde

• S.ljust(width[, fillchar])使用fillchar填充在字符串S的右边，使得整体长度为width。

>>> print('xyz'.ljust(5,'_'))
xyz__

• S.rjust(width[, fillchar])填充在左边

>>> print('xyz'.rjust(5,'_'))
__xyz

• S.zfill(width)用0填充在字符串S的左边使其长度为width。如果S前有正负号+/-，则0填充在这两个符号的后面，且符号也算入长度。
  如果width小于或等于S的长度，则无法填充，直接返回S本身(不会创建新字符串对象)。

>>> print('abc'.zfill(5))
00abc

>>> print('-abc'.zfill(5))
-0abc

>>> print('+abc'.zfill(5))
+0abc

>>> print('42'.zfill(5))
00042

>>> print('-42'.zfill(5))
-0042

>>> print('+42'.zfill(5))
+0042

子串搜索

• S.count(sub[, start[, end]])返回字符串S中子串sub出现的次数，可以指定从哪里开始计算(start)以及计算到哪里结束(end)，索引从0开始计算，不包括end边界。

>>> print('xyabxyxy'.count('xy'))
3

# 次数2，因为从index=1算起，即从'y'开始查找，查找的范围为'yabxyxy'
>>> print('xyabxyxy'.count('xy',1))
2

# 次数1，因为不包括end，所以查找的范围为'yabxyx'
>>> print('xyabxyxy'.count('xy',1,7))
1

# 次数2，因为查找的范围为'yabxyxy'
>>> print('xyabxyxy'.count('xy',1,8))
2

• S.endswith(suffix[, start[, end]])检查字符串S是否以suffix结尾，返回布尔值的True和False。suffix可以是一个元组(tuple)。可以指定起始start和结尾end的搜索边界。

>>> print('abcxyz'.endswith('xyz'))
True
　
# False，因为搜索范围为'yz'
>>> print('abcxyz'.endswith('xyz',4))
False
　
# False，因为搜索范围为'abcxy'
>>> print('abcxyz'.endswith('xyz',0,5))
False
>>> print('abcxyz'.endswith('xyz',0,6))
True

• S.startswith(prefix[, start[, end]])判断字符串S是否是以prefix开头。

• S.find(sub[, start[, end]])搜索字符串S中是否包含子串sub，如果包含，则返回sub的索引位置，否则返回"-1"。可以指定起始start和结束end的搜索位置。

>>> print('abcxyzXY'.find('xy'))
3
>>> print('abcxyzXY'.find('Xy'))
-1
>>> print('abcxyzXY'.find('xy',4))
-1

>>> print('xyzabcabc'.find('bc'))
4

• S.rfind(sub[, start[, end]])¶返回搜索到的最右边子串的位置，如果只搜索到一个或没有搜索到子串，则和find()是等价的。

>>> print('xyzabcabc'.rfind('bc'))
7

>>> print('xyzabcabc'.rindex('bcd'))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

S.index(sub[, start[, end]])

S.rindex(sub[, start[, end]])

替换

• S.replace(old, new[, count])将字符串中的子串old替换为new字符串，如果给定count，则表示只替换前count个old子串。如果S中搜索不到子串old，则无法替换，直接返回字符串S(不创建新字符串对象)。

>>> print('abcxyzoxy'.replace('xy','XY'))
abcXYzoXY
>>> print('abcxyzoxy'.replace('xy','XY',1))
abcXYzoxy
>>> print('abcxyzoxy'.replace('mn','XY',1))
abcxyzoxy

• S.expandtabs(N)将字符串S中的\t替换为一定数量的空格

>>> '01\t012\t0123\t01234'.expandtabs(4)
'01  012 0123    01234'          --> 2个空格、1个空格、4个空格

>>> '01\t012\t0123\t01234'.expandtabs(8)
'01      012     0123    01234'  --> 6个空格、5个空格、4个空格

>>> '01\t012\t0123\t01234'.expandtabs(7)
'01     012    0123   01234'     --> 5个空格、4个空格、3个空格

>>> print('012\t0123\n01234'.expandtabs(7))
012    0123        --> 4个空格
01234

• S.translate(table)
  static str.maketrans(x[, y[, z]])

分割

• S.partition(sep) 从左边第一个sep进行分割

  S.rpartition(sep) 从右边第一个sep进行分割

# 只搜索到一个sep时，两者结果相同
>>> print('abcxyzopq'.partition('xy'))
('abc', 'xy', 'zopq')
>>> print('abcxyzopq'.rpartition('xy'))
('abc', 'xy', 'zopq')

# 搜索到多个sep时，分别从左第一个、右第一个sep分割
>>> print('abcxyzxyopq'.partition('xy'))
('abc', 'xy', 'zxyopq')
>>> print('abcxyzxyopq'.rpartition('xy'))
('abcxyz', 'xy', 'opq')

# 搜索不到sep
>>> print('abcxyzxyopq'.partition('xyc'))
('abcxyzxyopq', '', '')
>>> print('abcxyzxyopq'.rpartition('xyc'))
('', '', 'abcxyzxyopq')

• S.split(sep=None, maxsplit=-1)

  S.rsplit(sep=None, maxsplit=-1)
  根据sep对S进行分割，maxsplit用于指定分割次数，如果不指定maxsplit或者给定值为"-1"，则会从左向右搜索并且每遇到sep一次就分割直到搜索完字符串。如果不指定sep或者指定为None，则改变分割算法：以空格为分隔符，且将连续的空白压缩为一个空格。

# sep为单个字符时
>>> '1,2,3'.split(',')
['1', '2', '3']

>>> '1,2,3'.split(',',1)
['1', '2,3']    # 只分割了一次

>>> '1,2,,3'.split(',')
['1', '2', '', '3']  # 不会压缩连续的分隔符

>>> '<hello><><world>'.split('<')
['', 'hello>', '>', 'world>']

# sep为多个字符时
>>> '<hello><><world>'.split('<>')
['<hello>', '<world>']

# 不指定sep时
>>> '1 2 3'.split()
['1', '2', '3']

>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']

>>> '   1    2   3   '.split()
['1', '2', '3']

>>> '   1    2   3  \n'.split()
['1', '2', '3']

# 显式指定sep为空格、制表符、换行符时
>>> ' 1  2  3  \n'.split(' ')
['', '1', '', '2', '', '3', '', '\n']

>>> ' 1  2  3  \n'.split('\t')
[' 1  2  3  \n']

>>> ' 1 2\n3 \n'.split('\n')
[' 1 2', '3 ', '']  # 注意列表的最后一项''

>>> ''.split('\n')
['']

S.splitlines([keepends=True]) 专门用来分割换行符

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

.join

S.join(iterable)
将可迭代对象(iterable)中的元素使用S连接起来。注意，iterable中必须全部是字符串类型，否则报错。

# 字符串
>>> L='python'
>>> '_'.join(L)
'p_y_t_h_o_n'
# 元组
>>> L1=('1','2','3')
>>> '_'.join(L1)
'1_2_3'
# 集合。注意，集合无序。
>>> L2={'p','y','t','h','o','n'}
>>> '_'.join(L2)
'n_o_p_h_y_t'
# 列表
>>> L2=['py','th','o','n']
>>> '_'.join(L2)
'py_th_o_n'
# 字典
>>> L3={'name':"malongshuai",'gender':'male','from':'China','age':18}
>>> '_'.join(L3)
'name_gender_from_age'
# iterable参与迭代的每个元素必须是字符串类型，不能包含数字或其他类型。
>>> L1=(1,2,3)
>>> '_'.join(L1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sequence item 0: expected str instance, int found

修剪：strip、lstrip和rstrip

S.strip([chars])

S.lstrip([chars])

S.rstrip([chars])

分别是移除左右两边、左边、右边的字符char。如果不指定chars或者指定为None，则默认移除空白(空格、制表符、换行符)。
唯一需要注意的是，chars可以是多个字符序列。在移除时，只要是这个序列中的字符，都会被移除。

>>> 'spacious   '.lstrip('s')
'pacious   '
　
>>> 'spacious'.rstrip('s')
'spaciou'