Python学习教程（三）——序列之字符串

1. 字符串概述

　　因为字符串也是一种序列类型，因此序列通用的操作对字符串同样适用，见《Python学习教程（二）——序列之列表和元组》中的一些例子。但是字符串是不可变的。比如在分片赋值时就是不可用的。

>>> str = 'hello'
>>> str[1:] = 'i'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

2. 字符串格式化操作符

　　字符串格式化操作符 %。
　　格式化字符串 % 希望被格式化的值

>>> "hello %s , %s enough for ya?" % ('world','Hot')
'hello world , Hot enough for ya?'

　　%s为转换说明符，标记了需要插入转换值的位置，s表示会被格式化为字符串（如果不是字符会用str将其转换为字符串）。

这里注意：只有元组和字典可以格式化一个以上的值，其他序列类型（列表等）会被解释为一个值。

>>> "hello %s enough for ya?" % ['world','Hot']
"hello ['world', 'Hot'] enough for ya?"

　　上面的例子中，转换说明符s表示字符串，但是格式化的值为列表，其实就是用了str将列表转为了字符串后进行的格式化，如下：

>>> str(['world', 'Hot'])
"['world', 'Hot']"

　　当格式化字符串中有%号时，应该用%%代替，以免程序认为是转换说明符。如下：

>>> "100%s test str %s !" % ("h")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: not enough arguments for format string
>>>
>>> "100%%s test str %s !" % ("h")
'100%s test str h !'

%%在格式化操作时会自行还原回%的状态，比如：

>>># 直接写字符串，会打印出两个%
>>> "100%%s"
'100%%s'
>>> #但是在格式化操作时会自动转为一个%
>>> "100%%s" % ()
'100%s'

　　对浮点数的格式化：

>>> pistr = "This is pi : %.3f"
>>> import math
>>> pistr % math.pi
'This is pi : 3.142'

%.3f：转换说明符。.3f表示精度，小数点保留3位的浮点数。因为格式化转换说明符总是以表示类型的字符结束，因此精度（.3）应该放在类型字符前面。

　　模板字符串：

>>> import string
>>> s = string.Template('$x , glorious $x !')
>>> s.substitute(x='slurm')
'slurm , glorious slurm !'

substitute这个模板方法，会用传递过来的关键字参数foo替换字符串中的$foo。

　　如果替换字段是单词的一部分：

>>> s = string.Template('$x , glorious $xab')
>>> s.substitute(x='slurm')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Python27\lib\string.py", line 176, in substitute
    return self.pattern.sub(convert, self.template)
  File "C:\Python27\lib\string.py", line 166, in convert
    val = mapping[named]
KeyError: 'xab'

发现报错了，因为后面的$x和ab连在了一起。需要用大括号括起来：

>>> s = string.Template('$x , glorious ${x}ab')
>>> s.substitute(x='slurm')
'slurm , glorious slurmab'

　　如果要插入美元符号$怎么办？

>>> s = string.Template('100$ abc $x')
>>> s.substitute(x='test')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Python27\lib\string.py", line 176, in substitute
    return self.pattern.sub(convert, self.template)
  File "C:\Python27\lib\string.py", line 173, in convert
    self._invalid(mo)
  File "C:\Python27\lib\string.py", line 146, in _invalid
    (lineno, colno))
ValueError: Invalid placeholder in string: line 1, col 4

发现报错了。原因是美元符号$在文中产生了歧义。
用$$转义了试试：

>>> s = string.Template('100$$ abc $x')
>>> s.substitute(x='test')
'100$ abc test'

成功显示。

　　除了上面的关键字参数之外，还可以使用字典变量提供值/名称对。

>>> s = string.Template('A $thing must never $action')
>>> d = {}
>>> d['thing'] = 'gentleman'
>>> d['action'] = 'show his socks'
>>> d
{'action': 'show his socks', 'thing': 'gentleman'}
>>> s.substitute(d)
'A gentleman must never show his socks'

　　safe_substitute方法不会因缺少或者不正确的使用$字符而出错：

>>> s = string.Template('A $thing must never $action')
>>> d = {}
>>> d['thing'] = 'gentleman'
>>> s.safe_substitute(d)
'A gentleman must never $action'

比如上面，即使缺少了一项也没有报错。有些用substitute报错的例子都可以用safe_substitute方法尝试看看效果。

3. 字符串格式化转换类型

　　在上面的内容中，我们已经谈到了字符串的格式化，在本节中我们将更深一步研究字符串格式化的有关内容。我们知道，格式化操作符%，%左边是格式化字符串，%右边是希望被格式化的值。 那么右边希望被格式化的值可以是任意类型。 Python支持的格式化转换类型如下表：

转换类型	含义
d. i	带符号的十进制整数
o	不带符号的八进制
u	不带符号的十进制
x	不带符号的十六进制（小写）
X	不带符号的十六进制（大写）
e	科学计数法表示的浮点数（小写）
E	科学计数法表示的浮点数（大写）
f. F	十进制浮点数
g	如果指数大于-4或者小于精度值则和e相同，其他情况与f相同
G	如果指数大于-4或者小于精度值则和E相同，其他情况则与F相同
C	单字符（接受整数或者单字符字符串）
r	字符串（使用repr转换任意Python对象）
s	字符串（使用str转换任意Python对象）

　　在上一节中我们已经涉及到了“转换说明符”的一些例子。比如：%s、%.3f等；基本的转换说明符包括以下部分：
　
注意顺序很重要：
1. %字符：标记转换说明符的开始；
2. 转换标志（可选）：- 表示左对齐；+ 表示在转换之前要加上正负号，“”（空白字符）表示正数之前保留空格；0表示转换值若位数不够则用0补充；
3. 最小字段宽度（可选）：转换后的字符串至少应该具有该值指定的宽度。如果是*，则宽度会从值元组中读出；
4. 点（.）后跟精度值（可选）：如果转换的是实数，精度值就表示出现在小数点后的位数。如果转换的是字符串，那么该数值就表示最大字段宽度。如果是*，那么精度将会从元组中读出。
5. 转换类型：参见表3-1；

以下看一个例子：

简单的转换：

>>> 'price of eggs : $%d' % 42
'price of eggs : $42'

字段的宽度和精度：
两个参数都得是整数，并且用.分割开，如果只写精度，也得把.加上。

>>> '%10f' % math.pi  #字段宽度10
'  3.141593'
>>> '%.2f' % math.pi  #精度2
'3.14'
>>> '%10.2f' % math.pi   #字段宽度10，精度2
'      3.14'
>>> '%.5s' % 'Guido van Rossum'    #字符串精度5，表示最大字段宽度
'Guido'
>>> '%.*s' % (5,'Guido van Rossum')    #*号匹配元组参数中的值
'Guido'

符号、对齐和用0填充：

　　在字段宽度和精度之前可以放置一个“标志”，零、加号、减号、空。
- 零（0）表示数字会用0进项填充：

>>> '%010.2f' % math.pi
'0000003.14'

• 减号（-）用来左对齐数值：

>>> '%-10.2f' % math.pi
'3.14      '

• 空（“”）表示在正数前加上空格，用来对齐负数的负号：

>>> print ('%5d' % 10) + '\n' + ('%5d' % -10)
   10
  -10

• 加号（+）表示不管是正数还是负数都标记出符号：

>>> print ('%+5d' % 10) + '\n' + ('%+5d' % -10)
  +10
  -10

4. 字符串常用的方法

　　由于字符串也是序列的一种，在前面讲序列和列表时，我们已经讲了很多有关字符串的方法。但字符串还从string模块中继承了一些方法。
　　字符串的方法有很多，这里只讲几个常用的，其他需要在实际使用时积累。

4.1. find

　　查找子字符串，返回最左端的索引。如果没有返回-1。

>>> 'yangliehui'.find('hui')
7
>>> 'yangliehui'.find('abc')
-1

这个方法还接受可选的起始点和结束点参数：

>>> 'yangliehui_yangliehui'.find('yang')
0
>>> 'yangliehui_yangliehui'.find('yang',1)
11
>>> 'yangliehui_yangliehui'.find('yang',1,10)
-1

注意：由起始点和结束点指定的范围包含第一个索引，但不包含第二个索引。这在Python中是个惯例。

4.2. join

　　连接序列中的元素，是split的逆向方法。

>>> seq = [1,2,3,4,5]
>>> sep = '+'
>>> sep.join(seq)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sequence item 0: expected string, int found
>>>
>>> seq = ['1','2','3','4','5']
>>> sep = '+'
>>> sep.join(seq)
'1+2+3+4+5'

我们看到被连接的序列元素必须是字符串。

>>> dirs = '','home','appusr','files'
>>> '/'.join(dirs)
'/home/appusr/files'
>>>
>>> print 'C:' + '\\'.join(dirs)
C:\home\appusr\files

4.3. lower

　　返回字符串的小写字母：

>>> 'YangLiehui'.lower()
'yangliehui'

与lower相关的两个方法：

>>> "that's all , folks".title()    #将字符串转换为标题，首字母大写，但是效果不是很好
"That'S All , Folks"
>>>
>>> import string
>>> string.capwords("that's all , folks")    # 效果比上面的好一些。
"That's All , Folks"

　　string.capwords(s[,sep])这是这个方法的实际的参数格式，其含义是使用split函数分割字符串s(以sep为分割符)，然后使用captitalize函数将分割得到的个单词首字母大写。并且使用join函数以sep分隔符将各单词连接起来。这就解释了上例中为什么效果比title方法效果好的原因。在上例中没有指定分隔符，默认的是空格分割符。

4.4. replace

　　返回某字符串的所有匹配项均被替换之后得到的字符串。

>>> 'yangliehui'.replace('hui','abc')
'yanglieabc'

4.5. split

　　将字符串分割为序列，join的逆向方法：

>>> '1+2+3+4'.split('+')
['1', '2', '3', '4']
>>> '/home/appusr/files'.split('/')
['', 'home', 'appusr', 'files']
>>> 'yang lie hui'.split()
['yang', 'lie', 'hui']

注意，如果不提供任何分隔符，程序会把所有空格作为分隔符（空格、制表符、换行等）。

4.6. strip

　　去除两侧空格（不含内部）：

>>> '        yangliehui                 '.strip()
'yangliehui'

该方法也可以去除指定的字符，将他们作为参数即可：

>>> '  ***yang**lie*hui!!** '.strip(' *!');
'yang**lie*hui'

我们看到，两侧的指定的字符已经去掉了。但内部的没有去掉。

4.7. translate

　　和replace方法一样，但不同的是translate只能处理单个字符。它的优势在于可以同时进行多个替换，有些时候比replace效率要高的多。具体用法如下：
假如我们有个需求是这样的，把字符串中[‘a’,’e’,’i’,’o’,’u’]替换为[‘1’,’2’,’3’,’4’,’5’]
首先我们需要一个转换表：

>>> trans_table = string.maketrans('aeiou','12345')

然后将它用作translate方法的参数：

>>> 'yangliehui'.translate(trans_table)
'y1ngl32h53'

translate方法还可以可选第二个参数，用来指定需要删除的字符：

>>> 'yangliehui'.translate(trans_table,'y')
'1ngl32h53'