Python程序设计2——列表和元组

　　数据结构：更好的说法是从数据角度来说，结构化数据，就是说数据并不是随便摆放的，而是有一定结构的，这种特别的结构会带来某些算法上的性能优势，比如排序、查找等。
　　在Python中，最基本的数据结构是序列(sequence)。序列中的每个元素被分配一个序号————即元素的位置，这个序号也被称为索引。第一个索引从0开始。
　　本章先介绍序列，然后介绍针对序列(包括元组和列表)都通用的操作，这些操作也适用于字符串。

1 序列概览

　　Python包含6种内建的序列，本章重点讨论最常用的两种类型:列表和元组。其他的内建序列类型有字符串、Unicode字符串、buffer对象和xrange对象。
　　列表和元组的主要区别在于，列表可以修改，元组不能。一般来说，在几乎所有的情况下列表都可以替代元组。不过需要注意的是：使用元组作为字典的键，这种情况下，键不可以改，所以不能使用列表。
　　在需要操作一组数组的时候，序列很好用，可以用序列表示数据库中一个人的信息————第1个元素是姓名，第二个是年龄，根据上述内容编写一个列表，如下所示:

>>> ed = ['Edward',23]
>>> ed
['Edward', 23]

　　ed相当于一个记录，可以将记录房子更大的一个包中。

>>> john = ['John',24]
>>> database=[ed,john]
>>> database
[['Edward', 23], ['John', 24]]

　　上面的database是一种容器。Python之中还有一种名为容器的数据结构。容器基本是包含其他对象的任意对象。序列(例如列表和元组)和映射(例如字典)是两类主要容器。序列中的每个元素都有自己的编号，而映射中的每个元素则有一个名字(也称为键)。

2 通用序列操作

　　所有序列类型都可以进行某些特定的操作，这些操作包括:索引、分片、加、乘以及检查某个元素是否属于序列的成员，除此之外，Python还有计算序列长度、找出最大元素和最小元素的内建函数。
　　另外还有一个重要操作:迭代。对序列进行迭代的意思是:依次对序列中的每个元素重复执行某些操作。

2.1 索引

　　序列中的所有元素都是有编号的————从0开始，这些元素可以通过编号分别访问。并且Python是允许从末尾开始访问数据的，也就是把-1当作倒数第一个，把-2当作第二个

示例1：正向索引第一个元素

>>> greet = 'hello'
>>> greet[0]
'h'

示例2：反向索引第一个元素

>>> greet = 'hello'
>>> greet[-1]
'o'

示例3：通过字符串值直接使用索引

>>> 'hello'[-2]
'l'

示例4:如果一个函数调用返回一个序列，那么可以直接对返回结果进行索引操作。例如，假设你只对用户输入年份的第4个数字感兴趣，那么可以如下操作:

>>> fourth = raw_input("Year:")[3]
Year:2013
>>> fourth
''

分析：raw_input返回的是一个字符串序列，输入的是2013，再进行索引4号元素，即3

代码示例:
下面是一个示例程序，它要求输入年、月、日，然后按照如下格式打印：August 16th.1974

2.2 分片

　　与使用索引来访问单个元素类似，可以使用分片操作来访问一定范围内的元素。分片通过冒号相隔的两个索引来实现：

tag = 'http://www.cnblogs.com/people/p/3230193.html'
>>> tag[7:22]
'www.cnblogs.com'

　　分片操作对于提取序列的一部分是很有用的。编号在这里显得尤为重要，第1个索引是需要提取部分的第一个元素编号，第二个索引是最终的编号，但是不包含这个编号。例如

numbers = [1,2,3,4]
numbers[0:1]
[1]

　　也就是只有一个元素

简而言之：分片操作的实现需要提供两个索引作为边界，第一个索引的元素是包含在分片内的，而第二个则不包含在分片内，两个索引之间用冒号隔开。正向边界和反向边界都可以，从哪边计算方便就从哪边看。

2.2.1 优雅的捷径

假设需要访问最后3个元素，可以进行如下操作

>>> numbers=[1,2,3,4,5,6]
>>> numbers[-3:]
[4, 5, 6]

同样适用于序列开始的元素

>>> numbers[:3]
[1, 2, 3]

如果完全都不写

>>> numbers[:]
[1, 2, 3, 4, 5, 6]

下面这个程序用于提取一个URL，假设URL形式为http://www.somedomainname.com

url = raw_input('Please enter the URL: ')
domain = url[11:-4]
print "Domain name: " + domain
运行：Please enter the URL: http://www.python.com
Domain name: python

2.3 更大的步长

　　进行分片的时候，分片的开始和结束点需要进行指定，而另外一个参数——步长通常是隐式设置的。在普通的分片中，步长是1———分片操作就是按照这个步长逐个遍历序列的元素，然后返回开始和结束之间的所有元素。

>>> numbers[1:10:2]
[2, 4, 6, 8, 10]
>>> numbers[1:10:1]
[2, 3, 4, 5, 6, 7, 8, 9, 10]

步长可以为负数，表示从右到左提取元素，但是起始元素也要从右往左，否则无法返回元素。也就是说如果以负数为步长，那么开始点要大于结束点。

>>> numbers[9:1:-1]
[10, 9, 8, 7, 6, 5, 4, 3]
>>> numbers[1:10:-2]
[]

2.4 序列相加

　　通过使用加号可以进行序列的连接操作。

>>> [1,2] + [3,4]
[1, 2, 3, 4]
>>> 'Hello' + ' World'
'Hello World'

　　同类才可以相连，列表和字符串是不可以相连的

>>> [1,2] + 'Hello'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate list (not "str") to list

2.5 乘法

　　用数字x乘以一个序列会生成新的序列或字符串，在新的序列或字符串中，原来的序列将被重复x次。

>>> 'python'*5
'pythonpythonpythonpythonpython'
>>> [1,2]*5
[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]

2.6 空列表与None

　　空列表可以简单地通过两个中括号进行标示([])——里面什么东西都没有。但是，如果想创建一个占用十个元素空间，却不包含任何有用内容的列表，可以使用None来表示。None是Python的内建值，表示这里什么都没有，代表空值。

>>> none_sequence = [None]*10
>>> none_sequence
[None, None, None, None, None, None, None, None, None, None]

　　程序示例：要打印如下图形

+-----------------------+
|                                  |
|   He's a naughty boy!  |
|                                  |
+-----------------------+
代码如下：

#!/usr/bin/python
sentence = raw_input("Sentence: ")
screen_width = 80
text_width = len(sentence)
box_width = text_width + 6
left_margin = (screen_width - box_width)//2

print
print ' '*left_margin + '+' + '-'*(box_width - 2) + '+'
print ' '*left_margin + '|' + ' '*text_width + ' |'
print ' '*left_margin + '| ' + sentence + ' |'
print ' '*left_margin + '|' + ' '*text_width + ' |'
print ' '*left_margin + '+' + '-'*(box_width - 2) + '+'

2.7 成员资格

　　为了检查一个值是否在序列中，可以使用in运算。该运算符和之前已经讨论过的(例如+、*运算符)有一点不同。这个运算符检查某个条件是否为真，然后返回相应的值:条件为真返回True，条件为假返回False。这样的运算符叫做布尔运算符，而真值则叫做布尔值。

>>> permissions = 'rw'
>>> 'r' in permissions
True

>>> users = ['hello','world']
>>> raw_input('Enter your name: ') in users
Enter your name: hell
False
>>> raw_input('Enter your name: ') in users
Enter your name: hello
True

　　我们可以利用这个关键字来进行用户名输入和密码的检查。如果用户名/PIN码这一数值对存在于数据库中，那么就在屏幕上打印通过。

#!/usr/bin/python
#check account and password
database = [
['albert',''],
['jack',''],
['Amy','abc']
]
username = raw_input('Enter your name: ')
passwd = raw_input('Enter your password: ')
if[username,passwd] in database:print 'Access granted'
输出结果：
Enter your name: jack
Enter your password: 123
Access granted

2.8 长度、最小值和最大值

　　内建函数len、min和max非常有用。len函数返回序列中所包含元素的数量，min函数和max函数则分别返回序列中最大和最小的元素。

>>> numbers = [1,3,9]
>>> len(numbers)
3
>>> max(numbers)
9
>>> min(numbers)
1

3 列表:Python的'苦力'

　　在前面的例子中已经用了很多次列表，它的强大之处不言而喻。本节讨论列表不同于元组和字符串的地方:列表是可变的(mutable)——可以改变列表的内容，并且列表有许多有用的、专门的方法。

3.1 list函数

　　因为字符串不能像列表一样被修改，所以有时候根据字符串创建列表会很有用，list函数可以实现这个操作。

>>> list('hello')
['h', 'e', 'l', 'l', 'o']

3.2 基本的列表操作

　　列表可以使用所有适用于序列的标准操作，例如索引、分片、连接和乘法。有趣的是，列表是可以修改的。本节介绍一些可以改变列表的方法:元素赋值、元素删除、分片赋值以及列表方法(请注意：并不是所有的列表方法都真正地改变列表)
1.改变列表:元素赋值
改变列表很容易，只需要使用普通的赋值语句即可。

>>> x = [1,1,1]
>>> x[1] = 2
>>> x
[1, 2, 1]

注意：不能为一个位置不存在的元素进行赋值。如果列表长度为2，那么索引为100显然就会超出范围。

删除元素

从列表中删除元素很容易，使用del语句来实现。

>>> del x[1]
>>> x
[1, 1]

分片赋值

　　分片是一个非常强大的特性，分片赋值操作则更强大

>>> name = list('Perl')
>>> name
['P', 'e', 'r', 'l']
>>> name[2:] = list('ar')
>>> name
['P', 'e', 'a', 'r']

分片赋值语句可以在不需要替换任何原有元素的情况下插入新的元素。

>>> numbers = [1,5]
>>> numbers[1:1] = [2,3,4]
>>> numbers
[1, 2, 3, 4, 5]

这个程序只是替换了一个空的切片，因此实际的操作是插入了一个序列，依次类推，通过分片赋值来删除元素也是可行的。

>>> numbers[1:4] = []
>>> numbers
[1, 5]

3.3 列表方法

　　python是面向对象的，因此，可以通过对象来调用python的方法。
1.append
append方法用于在列表末尾追加新的对象，会修改掉原来的列表。注意append只能接受一个参数

>>> lst = [2,4,5]
>>> lst.append(4)
>>> lst
[2, 4, 5, 4]
>>> lst.append(4,5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: append() takes exactly one argument (2 given)

2.count

count方法统计某个元素在列表中出现的次数:

>>> lst.count(4)
2
>>> ['i','want','to','to'].count('to')
2
>>> x = [[1,2],1,1,[1,2,3]]
>>> x.count(1)
2
>>> x.count([1,2])
1

3.extend

　　extend方法可以在列表的末尾一次性追加另一个序列的多个值，换句话说，可以用新列表扩展原有的列表。

>>> a = [1,2,3]
>>> b = [2,4,6]
>>> a.extend(b)
>>> a
[1, 2, 3, 2, 4, 6]
>>> b.extend(a)
>>> b
[2, 4, 6, 1, 2, 3, 2, 4, 6]

　　这个操作看起来很像连接操作，两者最主要的区别在于:extend方法修改了被扩展的序列。而原始的连接操作则不然，它返回的还是原有的列表。

>>> a = [1,2,3]
>>> b = [2,4,6]
>>> a + b
[1, 2, 3, 2, 4, 6]
>>> a
[1, 2, 3]

　　当然也可以用赋值的方式实现extend的功能，但是效率会比较低

>>> a = a + b
>>> a
[1, 2, 3, 2, 4, 6]
4.index

　　index方法用于从列表中找出某个值第一个匹配项的索引位置

>>> a
[1, 2, 3, 2, 4, 6]
>>> a.index(2)
1

如果有多个，只索引第一个

5.insert
insert方法用于将对象插入到列表中:

>>> a.insert(2,7)
>>> a
[1, 2, 7, 3, 2, 4, 6]

6.pop

　　pop方法会移除列表中的一个元素(默认是最后一个)，并返回该元素的值

>>> a.pop()
2
>>> a
[1, 2, '', 7, 3]

　　pop方法是唯一一个集能修改列表又返回元素值的列表方法。

　　使用pop方法可以实现一种常见的数据结构——栈。栈的原理就像堆放盘子一样，只能在顶部放一个盘子，同样也只能从顶部拿走一个盘子。最后被放入栈的最先被移除，也就是后进先出。python没有提供入栈的方法，但是可以用append方法来代替。pop方法和append方法的操作结果刚好相反。如果入栈刚刚出栈的值，最后得到的结果还是原来的栈。

>>> qq = [2,7,27]
>>> qq.append(qq.pop())
>>> qq
[2, 7, 27]

7.remove方法

　　remove方法用于移除列表中某个值的第一个匹配项，注意是第一个，该方法没有返回值

>>> x = ['to','be','or','not','to','be']
>>> x
['to', 'be', 'or', 'not', 'to', 'be']
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']

8.reverse

reverse方法将列表中的元素反向存放，也就是逆序

>>> x
['to', 'or', 'not', 'to', 'be']
>>> x.reverse()
>>> x
['be', 'to', 'not', 'or', 'to']

9.sort

sort方法用于对列表进行排序，会修改列表本身

>>> x = [3,4,2]
>>> x.sort()
>>> x
[2, 3, 4]

　　如果需要只是修改列表的副本并保存，而原始的不改变，需要使用分片[:],想使用赋值的方式来产生副本是不可以的。因为本身列表是一个对象，x和y只是一个指针，它们指向同一个对象，所以改掉其中一个另一个也会改变。

>>> x = [3,4,2]
#通过赋值
>>> y = x
>>> y.sort()
>>> y
[2, 3, 4]
#此方法不行，x的也会改变
>>> x
[2, 3, 4]
正确的方式：
>>> x = [3,4,2]
>>> y = x[:]
>>> y.sort()
>>> y
[2, 3, 4]
>>> x
[3, 4, 2]

　　另一种获取已排序的列表副本的方法是，使用sorted函数

>>> x = [3,4,2]
>>> y = sorted(x)
>>> y
[2, 3, 4]
>>> x
[3, 4, 2]
sorted函数可以用于任何序列
>>> sorted('Python')
['P', 'h', 'n', 'o', 't', 'y']

10.高级排序

　　如果希望元素能按照特定的方式进行排序(而不是sort函数默认的方式，即根据Python的默认排序规则按升序排列元素)，那么可以通过compare(x,y)的形式自定义比较函数。compare(x,y)函数会在x < y时返回负数，在x > y时返回正数，如果x = y则返回0。定义好该函数之后，就可以根据该sort方法作为参数了。内建函数cmp提供了比较函数的默认实现方式。

>>> cmp(32,45)
-1
>>> cmp(32,25)
1
>>> cmp(32,32)
0
>>> nubers = [5,2,9,7]
>>> nubers.sort(cmp)
>>> nubers
[2, 5, 7, 9]

　　sort方法有另外两个可选的参数——key和reverse。如果要使用它们，那么就要通过名字来指定。参数key和参数cmp类似，必须提供一个在排序过程中使用的函数。然而，该函数并不是直接用来确定对象的大小，而是为每个元素创建一个键，然后所有元素根据键来排序。因此，如果要根据元素的长度进行排序，那么可以使用len作为键函数，就是说排序会按照元素的长度作为标准来进行排序

>>> x = ['hello','a','this','is']
>>> x.sort(key = len)
>>> x
['a', 'is', 'this', 'hello']

　　另一个关键字参数reverse是简单的布尔值(True或者False)用来指明列表是否要进行反向排序。

>>> x.sort(reverse = True)
>>> x
['this', 'is', 'hello', 'a']

　　cmp、key、reverse参数都可以用于sorted函数，在多数情况下，为cmp或key提供自定义函数是很有用的。

4 元组:不可变序列

　　元组和列表一样，也是一种序列，唯一不同的是元组不能修改(字符串也是不可修改的)，创建元组的语法很简单，用逗号分隔一些值

>>> 1,23,3
(1, 23, 3)

元组是用括号包起来的。

当然最好是输入时候也用括号包起来

>>> (1,23,3)
(1, 23, 3)

空元组可以用没有包含内容的两个括号来表示

>>> ()
()
对于单个元素组成的元组，必须要有逗号

>>> (42，)
(42，)

逗号很重要，它决定了一个元素组成是否是元组，如下

>>> 3*(40+2)
126
>>> 3*(40+2,)
(42, 42, 42)

第一个根本就不是元组，而是一个普通的数学表达式

tuple函数

　　tuple函数的功能与list函数基本是一样的:以一个序列作为参数并把它转换为元组。如果参数就是元组，那么该参数就会被原样返回。

>>> tuple([1,3,5])
(1, 3, 5)
>>> tuple((1,3,5))
(1, 3, 5)

4.1 基本元组操作

　　元组没有需要多少操作，除了创建和访问之外，因为元组是不可变的，所有少了修改、增加等操作。

>>> x = 1,2,3
>>> x
(1, 2, 3)
>>> x[1]
2
>>> x[1:2]
(2,)
>>> x[1:3]
(2, 3)

元组的分片和列表一样

小结：
本节讨论了如下重要内容
1.序列。序列是一种数据结构，它对包含的元素进行了编号，典型的序列包括列表、字符串和元组，列表是可变的，元组和字符串不可变(长度和值都无法修改)。通过分片操作可以访问序列的一部分。
2.成员资格 in操作符可以检查一个值是否存在于序列中
3.方法。列表和字符串都提供了很多函数来处理

5 使用字符串

　　所有标准的序列操作(索引、分片、乘法、判断成员资格、求长度、取最小值和最大值)对字符串同样适用，请注意字符串是不可变的，类似分片赋值是不合法的。

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

5.1 字符串格式化 :精简版

　　字符串格式化使用字符串格式化操作符即百分号%来实现的。当然%也可以当做模运算(求余)操作符。

>>> format = "Hello,%s,%s enough for ya"
>>> value = ('Hello','World')
>>> print format % value
Hello,Hello,World enough for ya

　　格式化字符串的%s被称为替换符号，它标记了需要插入转换值的位置。s表示值会被格式化为字符串——如果不是字符串，则会用str将其转换为字符串。这个方法对大多数值都有效。

　　如果要格式化浮点数，可以使用f，同时提供所需要的精度:一个句点再加上希望保留的小数位数。因为格式化说明符总是以表示类型的字符结束，所以精度应该放在类型字符前面。

>>> format = 'Pi with three decimals: %.3f'
>>> from math import pi
>>> print format % pi
Pi with three decimals: 3.142

5.2 字符串格式化:完整版

　　格式化操作符的右操作数可以是任何东西，如果是元组或者映射类型如字典，那么字符串格式化将会有所不同。
　　如果右操作数是元组的话，则其中的每一个元素都会被单独格式化，每个值都需要一个对应的转换说明符。
　　如果需要转换的元组作为转换表达式的一部分存在，那么必须讲她用圆括号括起来，以避免出错。

>>> '%s plus %s equals %s' % (1,2,3)
'1 plus 2 equals 3'

　　基本的转换说明符包括如下部分:注意这些项的顺序是至关重要的

1.%字符:标记转换说明符的开始
2.转换标志(可选):-表示左对齐;+表示在转换值之前要加上正负号，空白字符表示正数之前保留空格，0表示转换值若位数不够则用0填充
3.最小字段宽度:转换后的字符串至少应该具有该值指定的宽度，如果是*，则宽度会从值元组中读出
4.点后跟精度值:如果转换的是实数，精度值就表示出现在小数点后的位数。如果转换的是字符串，那么该数字就表示最大字段宽度。如果是*，那么精度将会从元组中读出。
5.转换类型
PS:字符串格式化转换类型
转换类型　　　　含义
d,i 　　　　     带符号的十进制整数
0 　　　　　　 无符号八进制
u 　　　　　　 无符号十进制
x 　　　　　　 无符号十六进制小写
X　　　　　　  无符号十六进制大写
e 　　　　　　 科学计数法表示的小写浮点数
E 　　　　      科学计数法表示的浮点数大写
f，F 　　　　  十进制浮点数
g                  如果指数大于-4或者小于精度值，则和e相同，其他情况与f相同
G                  如果指数大于-4或者小于精度值，则和E相同，其他情况与F相同
C                  单字符(接受整数或者单字符字符串)
r                   字符串(使用repr转换任意Python对象)
s                  字符串(使用str转换任意Python对象)

5.3 简单转换

简单的转换只需要写出转换类型，使用起来很简单:

#!/usr/bin/python
print 'Price of eggs $%d:' % 27
print 'Hexadecimal of eggs $%x:' %27
from math import pi
print 'Pi:%f...' % pi
print 'Using str:%s' % 27L
print 'Using repr:%r'% 27L
编译运行
Price of eggs $27:
Hexadecimal of eggs $1b:
Pi:3.141593...
Using str:27
Using repr:27L

5.4 字段宽度和精度

　　转换说明符可以包括字段宽度和精度。字段宽度是转换后的值所保留的最小字符个数，精度(对于数字转换来说)则是结果中应该包含的小数位数，或者(对于字符串转换来说)是转换后的值所能包含的最大字符个数。
　　这两个参数都是整数(首先是字段宽度，然后是精度)，通过点号分隔。虽然两个都是可选参数，但如果只给出精度，就必须包含点号。
先要满足宽度，再满足精度

>>> from math import pi
#字段宽10
>>> '%10f' % pi
' 3.141593'
#字段宽10，精度2
>>> '%10.2f' % pi
' 3.14'
#精度2
>>> '%.2f' % pi
'3.14'

　　可以使用*(星号)作为字段宽度或者精度(或者两者都使用*),此时数值会从元组参数中读出

>>> '%.*s' % (5,'HelloWorld')
'Hello'

5.5 符号、对齐和0填充

　　在字段宽度和精度值之前还可以放置一个标表，该标表可以是0、加号、减号或空格。0表示数字将会用0进行填充

>>> '%010.2f' % pi
'0000003.14'

　　010表示字段宽度为10，并且用0进行填充空位而不是说字段宽度为8

减号-用来表示左对齐数值

>>> '%-010.2f' % pi
'3.14 '

　　由于宽度是10，所以右边多了几个空格

而空白意味着在正数前面加上空格

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

加号：表示不管是正数还是负数都标出符号

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

字符串格式化示例

#使用给定的宽度打印格式化后的价格列表
#!/usr/bin/python
width = input('Please enter the width: ')

price_width = 10
item_width = width - price_width

header_format = '%-*s%*s'
format = '%-*s%*.2f'
print '='*width
print header_format % (item_width,'Item',price_width,'Price')
print '-'*width
print format % (item_width,'Apple',price_width,0.4)
print format % (item_width,'Orange',price_width,0.5)
print format % (item_width,'Pear',price_width,0.9)

运行结果:

Please enter the width: 35
===================================
　　　　　　　　　　Item　　　　　　　　　　　　　Price
　　　　　　　　　　-----------------------------------
　　　　　　　　　　Apple 　　　　　　　　　　　　 0.40
　　　　　　　　　　Orange 　　　　　　　　　　　 0.50
　　　　　　　　　　Pear                                     0.90

　　前面介绍了很多列表的方法，字符串的方法要丰富得多。这是因为字符串从string模块中获取了很多方法。 find find方法可以在一个较长的字符串中查找子字符串。它返回子串所在位置的最左端索引。如果没有找到，则返回-1

>>> text = 'I am 27 years old'

>>> text 'I am 27 years old'

>>> text.find('am') 2

5.6 join

　　join方法是很重要的方法，它是split方法的逆方法，用来在队列中添加元素。注意：序列里面的元素一定是字符串，不能是数字。

>>> seq = [1,2,3,4]

>>> sep = '+' #用+来连接元素

>>> sep.join(seq) Traceback (most recent call last):   File "<pyshell#7>", line 1, in <module>    

sep.join(seq) TypeError: sequence item 0: expected str instance, int found

正确做法：

>>> seq = ['','','','']

>>> sep.join(seq) '1+2+3+4'

>>> dirs = 'usr','bin','python'

>>> print('C:' + '\\'.join(dirs)) C:usr\bin\python

lower lower方法返回字符串的小写字母形式

>>> 'Hello World'.lower() 'hello world'

　　标题转换方法：title方法和capwords函数 这两个函数会将单词的首个字母转换成大写，而其他字母转成小写

>>> 'hello world'.title() 'Hello World'

>>> string.capwords('hello world') 'Hello World'

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

>>> 'this is a test'.replace('is','at')

'that at a test'

　　split 这是一个非常重要的字符串方法，它是join的逆方法，用来将字符串分割成序列

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

>>> 'Using the default'.split() ['Using', 'the', 'default']

5.7 strip

　　strip方法返回去除两侧(不包括内部)空格的字符串，也就是清洗空格

>>> '      internal white space is kept    '.strip()

'internal white space is kept'

　　可以看到字符串两边的空格被去掉了 也可以指定需要去除的字符，将它们列为参数即可。注意：只会去除两侧的，中间的不会去掉。

>>> '***!!internal* white* space is kept*'.strip('*!')

'internal* white* space is kept'

translate

　　translate方法和replace方法一样，可以替换字符串中的某些部分，但是和前者不同的是，translate方法之处理单个字符。它的优势在于可以同时进行多个替换，有些时候比replace效率高得多。假设我们要把c替换成k，把s替换成z 使用translate转换之前，需要先完成一张转换表，转换表中是以某字符替换某字符的对应关系。因为这个表(事实上是字符串)有多达256个项目，我们还是不要自己写了，使用string模块里面的maketrans函数即可。 maketrans函数接受两个参数：两个等长的字符串，表示第一个字符串中的每个字符都用第二个字符串中相同位置的字符替换。

>>> from  string import maketrans

>>> table = maketrans('cs','kz')

>>> table '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abkdefghijklmnopqrztuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'

　　创建这个表后，可以用它来当作translate方法的参数，进行字符串转换如下：

>>> 'this is an incredible test'.translate(table)

'thiz iz an inkredible tezt'

　　另外translate的第二个参数可选的，这个参数用来删除指定的字符。例如删除空格：

>>> 'this is an incredible test'.translate(table,' ')

'thizizaninkredibletezt'

6 小结

　　 本章介绍了字符串的两种非常重要的使用方式 1.字符串格式化：求模操作符(%)可以用来将其他值转换为包含转换标志的字符串，例如%s。它还能用来对值进行不同方式的格式化，包括左右对齐、设定字段宽度以及精度值，增加符号(正负号)或者左填充数字0 2.字符串方法：字符串有很多方法。有些非常有用，比如split和join