Python基础与拾遗2：Python中的字符串与字符串格式化

本篇博文，讲解Python中常用的字符串与字符串格式化操作，下面开始干货。

常见的字符串常量与表达式

操作	解释
s = ‘’	空字符串
s = “spam’s”	普通字符串，单双引号相同
S = ‘s\np\ta\x00m’	转义序列
s = “”"…"""	三重引号字符串块
s = r’\temp\spam’	Raw字符串
S = b’spam’	Python 3.0及之后版本中的字节字符串
s = u’spam’	Python 2.6及之后版本使用的Unicode字符串
s1 + s2	合并
s * 3	重复
s[i]	索引
s[i:j]	分片
len(s)	求长度
“a %s parrot” % kind	字符串格式化表达式
“a {0} parrot”.format(kind)	Python 2.6及之后版本与Python 3.0及之后版本中的字符串格式化方法
a.find(‘pa’)	字符串方法调用：搜索
s.rstrip()	移除空格
s.replace(‘pa’, ‘xx’)	替换
s.split(’,’)	用展位符分隔
s.isdigit()	内容测试(这里是测试是否为数字组成的字符串)
s.lower()	大写转小写
S.endswith(‘spam’)	结束字符测试
‘spam’.join(strlist)	插入分隔符
S.encode(‘latin-1’)	编码
for x in S: print(x)	迭代
‘spam’ in S	成员关系判断
[c * 2 for c in S]	字符串解析
map(ord, S)	函数映射

1. 单双引号字符串相同。在Python中，没有像c语言一样的字符的概念，单引号与双引号表示一样的字符串。
2. 任意相邻的字符串会被合并。

a = "abcd"'efg' # 'abcdefg'

3. 在Python 2.6及之后的版本中，字符串前加u为Unicode字符串，表示宽Unicode文本；否则为str字符串，表示8位文本和二进制数据。
4. 在Python 3.0及之后的版本中，字符串前加b为Byte字符串，表示二进制数据，变体为bytearray；否则为Unicode文本。3和4中的两者，在普通的任务中较少使用。
5. 在上表中，仅列举了有限的字符串方法。若需查询所有的字符串方法，可以参阅Python手册。

字符串转义

‘\’后面的一个或多个字符，在最终的字符串中会被单个字符所替代。

转义	意义
\newline	\后面另起一行，表示连续
\	反斜杠(保留\字符)
’	单引号(保留‘字符)
"	双引号(保留"字符)
\a	响铃
\b	倒退
\f	换页
\n	新行(换行)
\r	返回
\t	水平制表符
\v	垂直制表符
\N{id}	Unicode数据库id
\uhhhh	Unicode 16位的十六进制值(必须有四个十六进制位h)
\uhhhhhhhh	Unicode 32位的十六进制值(必须有八个十六进制位h)
\xhh	十六进制值(必须有两个十六进制位h)
\ooo	八进制值(必须至少有一个八进制位o，至多三个)
\0	空字符(注意与空格不同)
\other	不转义(保留原字符)

1. \u后面必须接4个16进制位，\U后面必须接8个十六进制位。合起来是16进制值表示的一个字符。\u和\U只能用于Unicode常量之中。
2. \x后面必须接2个16进制位。合起来是16进制值表示的一个字符。

s = 'abc\xFF' # 'abcÿ'
s = 'abc\xF' # SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position 3-5: truncated \xXX escape

3. \后面可接至少一个8进制位，最多会查找至3个八进制位。合起来是8进制值表示的一个字符。
   注意，如果接的不是八进制位，那么\会自动转化成\，代表’'字符；\不能单独结尾。

s = 'abc\6' # 'abc\x06'
s = 'abc\11' # 'abc\t'
s = 'abc\555' # 'abcŭ'
s = 'abc\2222222' # 'abc\x9b333333''
s = 'abc\ABC' # 'abc\\ABC'
s = 'abc\' # SyntaxError: EOL while scanning string literal

5. \0与’ ‘(空格字符串)不相同。
6. r关闭转义

# 下述两个字符串相同
'C:\\MyFile\\'
r'C:\MyFile\'

6. 三重引号表示字符串块，常用于代码中大段注释。

索引和分片

1. 索引可为正也可为负。从左至右时，0为第一个元素；从右至左时，-1为第一个元素。
2. 分片操作会返回一个新的对象。
3. 分片操作有步进值。S[I:J:K]中，K就是步进值，可以为负数，不能为0。步进值表示每隔多少个元素提取一次。注意，步进值为负数时，I需大于J。分片操作中，[::-1]表示倒序，较常用。

a = 'abcdefghijklmn'
a[0:5] # 'abcde'
a[5:0] # ''
a[0:6:2] # 'ace'
a[9:5:-3] # 'jg'
a[::-1] # 'nmlkjihgfedcba'

原处修改字符串

1. replace()函数。
2. 先将字符串转换成列表，再修改列表，最后使用join方法进行合并。

S = 'abcdefg'
L = list(S)
L[0] = 'x'
L[1] = 'y'
S = ''.join(L) # 'xycdefg'

字符串格式化

格式化表达式

1. 在%操作符的左侧放置一个需要进行格式化的字符串，这个字符串带有一个或多个嵌入的转换目标，都以%开头。
2. 在%操作符右侧放置一个(或多个，嵌入到元祖中)对象，这些对象将会插入到左侧想让Python进行格式化字符串的一个(或多个)转换目标的位置上去。
3. 由于字符串的性质，格式化会返回新的字符串，而不是对原字符串进行修改。

代码	意义
s	字符串(或任何对象)
r	同s，但使用repr，而不是str
c	字符
d	十进制(整数)
i	整数
u	无号(整数)
o	八进制整数
x	十六进制整数
X	同x，但打印大写
e	浮点整数，使用科学计数法表示，默认保存小数点后六位
E	同e，但打印大写
f	浮点十进制，默认保存小数点后六位
F	浮点十进制，默认保存小数点后六位
g	浮点e或者f，根据数的大小决定(太小或太大就使用科学计数法，否则直接使用浮点数)
G	浮点E或者f，根据数的大小决定(太小或太大就使用科学计数法，否则直接使用浮点数)
%	常量%

4. 标准的表达式

%[(name)][flags][width][.precision]typecode

name放置一个字典的键。

'%(n)d | %(x)s' % {"n":1, "x":"spam"} # '1 | spam'

flags中“-”表示左对齐，"+"表示保留正负号，“0"表示补零，”#"后接o或者x表示八进制或者十六进制。

x = 1.23456789
'%-6.2f | %05.2f | %+06.1f' % (x, x, x) # '1.23   | 01.23 | +001.2'

x = 123456789
'%#o | %#x' % (x, x) # '0o726746425 | 0x75bcd15'

width和precision可编码为一个"*"，指定它们应该从输入值的下一项取值。

x = 1.23456789
 '%*.*f' % (7, 4, x) # ' 1.2346'

5. g和G的显示浮点数或科学计数法，取决于数据大小。

 '%g | %g | %g | %G | %G | %G' % (1.23456, 0.00000000000123456, 12345600000000, 1.23456, 0.00000000000123456, 12345600000000) # '1.23456 | 1.23456e-12 | 1.23456e+13 | 1.23456 | 1.23456E-12 | 1.23456E+13'

格式化调用方法

1. 在Python 2.6及之后的版本中与Python 3.0及之后的版本中，使用新的字符串对象的format方法，使用主体字符串作为模板，并且接受任意多个表示将要根据模板替换的值的参数。花括号通过位置指出替换的目标及将要插入的参数。

'{motto}, {0} and {food}'.format(32, motto=3.14 , food=[1,2]) # '3.14, 32 and [1, 2]'

2. 添加键，属性和偏移量。方括号指定字典键，点表示位置或关键字所引用的一项对象属性。

import sys
'My {1[spam]} runs {0.platform}'.format(sys, {'spam': 'laptop'}) # 'My laptop runs win32'

格式化字符串中的方括号可以指定列表(及其他序列)偏移量以执行索引，但注意只有单个的正的偏移才能在格式化字符串中的语法中有效。要指定负的偏移或分片，或者使用任意表达式，必须在格式化自身之外运行表达式。

somelist = list('SPAM')
'first={0[0]}, third={0[2]}'.format(somelist) # 'first=S, third=A'

'first={0}, last={1}'.format(somelist[0], somelist[-1]) # 'first=S, last=M'

parts = somelist[0],  somelist[-1],  somelist[1:3]
'first={0}, last={1}, middle={2}'.format(*parts) # "first=S, last=M, middle=['P', 'A']"

添加具体格式化

格式化标准格式

{format!conversionflag:formatspec}

fieldname是指定参数的一个数字或关键字，后面跟着可选的".name"或"[index]"成分引用。以上第2点的例子说明了这种情况。

conversionflag可以是r,s或者a，分别是在该值上对repr,str或ascii内置函数的一次调用，该点使用较少。

formatspec指定了如何表示该值，包括字符宽度，对齐方式，补零，小数点精度等细节，并且以一个可选的数据类型编码结束。组成形式上描述如下：

[[fill]align][sign][#][0][width][.precision][typecode]

align可能是<, >, =或^，分别表示左对齐，右对齐，一个标记字符后的补充或居中对齐。可以结合fill值进行填充。

'{0:<10.2f}'.format(1.234) # '1.23      '
'{0:>10.2f}'.format(1.234) # '      1.23'
'{0:^10.2f}'.format(1.234) # '   1.23   '
'{0:7<10.2f}'.format(1.234) # '1.23777777'
'{0:7>10.2f}'.format(1.234) # '7777771.23'
'{0:7^10.2f}'.format(1.234) # '7771.23777'
'{0:7=+10.2f}'.format(1.234) # '+777771.23'
'{0:7<+10.2f}'.format(1.234) # '+1.2377777'
'{0:7>+10.2f}'.format(1.234) # '77777+1.23'
'{0:7^+10.2f}'.format(1.234) # '77+1.23777'

formatspec也包含嵌套的，只带有{}的格式化字符串，它从参数列表动态地获取值(和格式化列表中的*很相似)。

比如，{0:10}意味着一个10字符宽的字段中的第一个位置参数，{1:<10}意味着第2个位置参数在一个10字符宽度字段中左对齐，{0.platform:>10}意味着第一个参数的platform属性在10字符宽度的字段中右对齐。

'{0:10} = {1:10}'.format('spam', 123.4567) # 'spam       =   123.4567'
'{0:>10} = {1:<10}'.format('spam', 123.4567) # '      spam = 123.4567  ''{0.platform:>10} = {1[item]:<10}'.format(sys, dict(item='laptop')) # '     win32 = laptop    '

在格式化方法调用中，浮点数支持与%表达式中相同的类型代码和格式化声明。例如{2:g}表示，第三个参数默认地根据’g’浮点数表示格式化，{1:.2f}指定了带有两个小数位的"f"浮点数格式，{2:06.2f}添加一个6字符宽度的字段并且在左边补充0。

'{0:e}, {1:.3e}, {2:g}'.format(3.14159, 3.14159, 3.14159) # '3.141590e+00, 3.142e+00, 3.14159'
'{0:f}, {1:.2f}, {2:06.2f}'.format(3.14159, 3.14159, 3.14159) # '3.141590, 3.14, 003.14'

格式化方法也支持十六进制，八进制与二进制格式。实际上，字符串格式化方法是把整数格式化为指定的进制的某些内置函数的替代方法。

'{0:X}, {1:o}, {2:b}'.format(255, 255, 255) # 'FF, 377, 11111111'

格式化参数可以在格式化字符串中硬编码，或者通过嵌套的格式化语法从参数列表动态地获取，后者很像是格式化表达式中的星号语法。

'{0:.2f}'.format(1 / 3.0) # '0.33'
'%.2f' % (1 / 3.0) # '0.33'
'{0:.{1}f}'.format(1 / 3.0, 4) # '0.3333'
'%.*f' % (4, 1 / 3.0) # '0.3333'

在Python 2.6及之后的版本中与Python 3.0及之后的版本中还提供了一种新的内置format函数，用来格式化一个单独的项，通过运行主体对象方法__format__实现。

'{0:.2f}'.format(1.2345) # '1.23'
'%.2f' % 1.2345 # '1.23'
format(1.2345, '.2f') # '1.23'

以上，欢迎各位读者朋友提出意见或建议。

欢迎阅读笔者后续博客，各位读者朋友的支持与鼓励是我最大的动力！

written by jiong
大道至简，知易行难。