第3单元容器 通常，容器（container）是指用来包装或装载物品的器件（如箱、罐、坛）。
在计算机程序中，容器是用来存储和组织对象的对象，可以在容器中存储基本类型或任何类类型的对象。
根据容器的存储特点、操作方式，容器可以分为不同的类型。
如表1.1所示，Python提供了三大类内置的容器：序列（sequence）、字典（dictionary）和集合（set）。
表3.1为它们的粗略比较。
容器名称列表 序元组 列字符串 字典 集合 表3.1序列、字典和集合的粗略比较 边界符 元素形式类型标识符可变性元素分隔符元素互异性元素有序性 […] 对象 (…) 对象 '…'/"…"/'''…'''/"""…"""字符 {…} 键-值对 {…} 对象 listtuplestr dict setfrozenset 可变， 不可变 不可变 无 位置无 有序 键不可变,(元素间) 键唯
一 值可变 :(键-值间) 无 可变 , 有 不可变 3.1序列容器 Python有元组（tuple）、列表（list）和字符串（string）3种内置序列容器。
3.1.1序列对象的构建 列表、元组和字符串都可以用如下两种方式构建对象：使用字面量直接构建和用构造函数构建。

1.使用字面量构建 不管是元组，还是列表或字符串，它们创建对象的方法相似且非常简单，只要用边界符将序列元素括起来，就成为序列对象。
当一个序列有多个元素时，元素之间应使用合法的分隔符分隔。
代码3-1创建合法的字符串对象。
>>>'abcd1234''abcd1234' #创建一个普通字符串对象 ·100· >>>"""abcdefghijklmnop"krs"w'123'""" #含有单撇号和双撇号的多行字符串,用三撇号做边界符 'abcdefghijk\nlmnop"krs"w\'123\'' >>>'' #一个空字符串对象 '' 说明：
（1）Python字符串是由单个字符为元素组成的序列。
这些单个字符是键盘上可以打出的任何字符，也可以是转义字符。

（2）三撇号字符串与单撇号字符串和双撇号字符串的区别在于，它可以使多行的、可以直接包含换行，也可以直接包含单撇号和双撇号。
代码3-2创建合法的列表对象。
>>>['ABCDE','Hello',"ok",'''Python''',123]['ABCDE','Hello','ok','Python',123] #创建一个列表对象 代码3-3创建合法的元组对象。
>>>('ABCDE','Hello',"ok",'''Python''',123)('ABCDE','Hello','ok','Python',123) >>>(123,)123>>>1,2,3(123,) #创建一个元组对象#要创建只有一个元素的元组，最后要加一个分隔符#圆括号可以省略 非但如此，还可以用变量指向这些用符号常量构建的序列对象。
代码3-4用变量指向序列对象。
>>>str1='abcd1234' #一个普通字符串对象,并用变量str1指向它 >>>lIst1=['ABCDE','Hello',"ok",'''Python''',123]#创建一个列表对象，并用变量list1指向它 >>>tup1=('ABCDE','Hello',"ok",'''Python''',123)#创建一个元组对象,并用变量tup1指向它
2.用构造方法构建序列对象 用构造方法构建序列对象的语法如下。
list(iterable)tuple(iterable)str(字符串字面量) #用可枚举对象iterable构造一个列表对象#用可枚举对象iterable构造一个元组对象#用可枚举对象iterable构造一个字符串对象 当参数缺省时，构建的是一个空序列对象。
代码3-5用构造方法构建序列对象示例。
>>>list1=list()>>>list1[]>>>list2=list("IlikePython,2017")>>>list2 #构造一个空列表对象#用字符串（可枚举）对象构造一个空列表对象 ·101· ['I','','l','i','k','e','','P','y','t','h','o','n',',','2','0','1','7'] >>>list3=list(range(1,20,3)) #用range()函数返回的递增整数序列构造一个列表对象 >>>list3 [1,4,7,10,13,16,19] >>>>>>t1=tuple('a','b','c',1,2,3) #错误，不能用多个参数 Traceback(mostrecentcalllast): File"",line1,in ti=tuple('a','b','c',1,2,3) TypeError:tuple()takesatmost1argument(6given) >>>t1=tuple(['a','b','c',1,2,3]) #正确 >>>t1 ('a','b','c',1,2,3)>>>t2=tuple(range(1,20,3)) #用range()函数返回的递增整数序列构造一个元组对象 >>>t2 (1,4,7,10,13,16,19)>>>type(list1) #测试类型 >>>list2=list('Hello,Python') #将字符串用函数list()转换为列表 >>>list2 ['H','e','l','l','o',',','P','y','t','h','o','n'] 3.1.2序列通用操作 不管是哪种序列对象，都可以使用下列操作符进行操作。

1.序列对象的元素索引与切片 序列的基本特征是有序，即序列中的元素包含了一个从左到右的顺序，这个顺序用元素在序列中的位置偏移量表示。
这个位置偏移量，也称为序列号或下标（index，索引），可以分为如图3.1所示的正向和反向两个体系。
图3.1序列的正向索引与反向索引 注意：正向下标最左端为
0，向右按1递增；反向下标最右端为
1，向左按-1递减。
使用索引/切片操作符（[]）可以对序列进行索引/切片操作。
1）索引索引（index）是快捷获取信息的手段。
在序列容器中，索引一个元素的操作由索引操作符（[]，也称为下标操作符）和下标进行。
代码3-6序列索引举例。
>>>list1=['ABCDE','Hello',"ok",'''Python''',123]>>>list1[3] ·102· 'Python'>>>s1='abcd1234'>>>s1[-3]'2'>>>t1=('ABCDE','Hello',"ok",'''Python''',123)>>>t1[-5]'ABCDE' 2）切片切片操作的格式如下。
序列对象变量[起始下标:终止下标:步长] 说明：
（1）切片就是在序列中划定一个区间[起始下标:终止下标)，并按步长选取元素，但不包括终止下标指示的元素。

（2）步长的默认值为
1，即不指定步长，就是获取指定区间中的每个元素，但不包括终止下标指示的元素。

（3）起始下标和终止下标缺省或表示为None，分别默认为起点和终点。

（4）起始在左、终止在右时，步长应为正；起始在右、终止在左时，步长应为负。
否则切片为空。
代码3-7序列切片举例。
>>>list1=['ABCDE','Hello',"ok",'''Python''',123] >>>list1[:] #起始、终止、步长都缺省 ['ABCDE','Hello','ok','Python',123] >>>list1[None:] #起始为None，其他缺省 ['ABCDE','Hello','ok','Python',123] >>>list1[::2] #起始、终止缺省，步长为
2 ['ABCDE','ok',123]>>>list1[1:3] #步长缺省，起始、终止分别为1、
3 ['Hello','ok']>>>list1[-5:-2] #反向索引：起始在左，步长为正 ['ABCDE','Hello','ok']>>>list1[2:2] #起始与终止相同，取空 [] >>>list1[2:3] ['ok'] >>>s1="ABCDEFGHIJK123">>>s1[-2:-10:2] #反向索引：起始在右，步长为正，将得空序列 ''>>>s1[-2:-11:-2] #反向索引：起始在右，步长为负 '2KIGE'>>>s1[11:2:-2] #正向索引：起始在右，步长为负 '1JHFD' ·103·
2.序列对象连接与重复操作 Python用连接操作符（+）和重复操作符（*）进行序列的连接和重复操作，格式如下。
序列1+序列
2 序列*重复次数 代码3-8序列连接与重复举例。
>>>list1=['ABCDE','Hello',"ok",'''Python''',123]>>>list2=['xyz',567]>>>list1+list2['ABCDE','Hello','ok','Python',123,'xyz',567]>>>list2*3['xyz',567,'xyz',567,'xyz',567]>>>s1="ABCDEFGHIJK123">>>s2='abcdfg'>>>s1+s2'ABCDEFGHIJK123abcdfg'>>>s2*3'abcdfgabcdfgabcdfg'
3.序列对象判定操作 序列对象的判定操作包括如下5类，它们均得到bool值：True或False。

（1）对象值比较操作符：>、>=、<、<=、==和!
=。

（2）对象身份判定操作符：is和isnot。

（3）成员属于判定操作符：in和notin。

（4）布尔操作符：not、and和or。

（5）判定序列对象的元素是否全部或部分为True的内置函数：all()和any()。
代码3-9对序列进行判定操作举例。
>>>list1=['ABCDE','Hello',"ok",'''Python''',123];list2=['xyz',567]>>>list1==list2False>>>list1!
=list2True>>>list1>list2False>>>list1>>'ABCDE'inlist1True>>>['xyz',567]islist2False>>>list3=['xyz',567];list3==list2True ·104· >>>list3islist2False>>>t1=(1,2,3);t2=(1,2,3);t3=(1,2,0)>>>t1==t2True>>>t1ist2False>>>t1=t2;t1ist2True>>>all(t3)False>>>any(t3)True 说明：
（1）相等比较（==）与是否比较（is）的不同在于，相等比较的是值，是否比较的是id（地址）。

（2）序列对象不是按照值存储的，即值相等，不一定是同一对象。

（3）字符串之间的比较，是按正向下标，从0开始，以对应字符的码值（如ASCII码值）作为依据进行的，直到对应字符不同，或所有字符都相同，才能决定大小，或是否相等。

4.获取序列对象的长度、最大值、最小值与和 下面4个Python内置函数，用于获取序列的有关数据。
len(obj)：返回对象obj的元素个数。
max(s)：返回序列s的最大值（仅限字符串或数值序列）。
min(s)：返回序列s的最小值（仅限字符串或数值序列）。
sum(s)：返回序列s的元素之和（仅限数值序列）。
代码3-10对序列求元素个数、最大元素、最小元素与和。
>>>list1=['ABCDE','Hello',"ok",'''Python''',123];s1='qwertyuiop';t1=(1.23,3.1416,1.414) >>>len(list1) 5>>>max(list1) #错误，非数值序列、非字符串求最大值 Traceback(mostrecentcalllast): File"",line1,in max(list1) TypeError:'>'notsupportedbetweeninstancesof'int'and'str' >>>max(s1) 'y'>>>sum(s1) #错误，非数值序列求和 Traceback(mostrecentcalllast): File"",line1,in sum(s1) ·105· TypeError:unsupportedoperandtype(s)for+:'int'and'str'>>>sum(t1)5.7856
5.序列元素排序可以用内置函数sorted()返回一个序列元素排序后的列表。
该函数的格式如下。
sorted(序列对象[,key=排序属性][,reverse=False/True]) 说明：
（1）排序的前提是元素间可以相互比较，用术语iterable（可迭代）表示。
若一个序列中有不可相互比较的元素，就不可排序。

（2）一个序列中的元素对象可以有许多属性，要用key指定按照哪个属性排序。
例如对字符串可以指定str.lower。
通常，对于字符串元素以及数值型元素对象，key项可以缺省，默认按照数值排序。
对于字符串对象，按照编码值（如ASCII码值）排序。
（3）sorted()函数默认按照升序排序，但可以用reverse的取值为True/False，决定是否反转。
（4）sorted()返回一个列表。
代码3-11序列元素排序。
>>>list1=['ABCDE','Hello',"ok",'''Python'''] >>>s1='qwertyuiop' >>>t1=(1.23,3.1416,1.414);t2=('a','y',1,
2,'n') >>>sorted(list1,key=str.lower) ['ABCDE','Hello','ok','Python'] >>>sorted(s1) ['e','i','o','p','q','r','t','u','w','y'] >>>sorted(s1,reverse=True) ['y','w','u','t','r','q','p','o','i','e'] >>>sorted(t1) [1.23,1.414,3.1416]>>>sorted(t2) #错误，t2中含不可比较元素 Traceback(mostrecentcalllast): File"",line1,in sorted(t2) TypeError:'<'notsupportedbetweeninstancesof'int'and'str' 说明：产生一个错误的原因是无法对不可相互比较的序列元素排序。

6.序列拆分 一个序列可以按照元素数量被拆分。
下面分3种情形讨论。
1）变量数与元素数一致当变量数与元素数一致时，将为每个变量按顺序分配一个元素。
代码3-12变量数与元素数一致时的序列拆分示例。
·106· >>>t1=("zhang",'male',20,puter",
3,(70,80,90,65,95))>>>name,sex,age,major,year,grade=t1>>>name'zhang'>>>sex'male'>>>age20>>>majorputer'>>>year3>>>grade(70,80,90,65,95) 2）变量数少于元素数变量数与元素数不一致，将导致ValueError。
但是，用比序列元素个数少的变量拆分一个序列，可以获取一个子序列。
办法是，在欲获取子序列的变量前加一个星号。
代码3-13在序列中获取一个子序列的拆分示例。
>>>grade=(70,80,90,65,95)>>>first,*middles,last=sorted(grade)>>>sum(middles)/len(middles)80.0 #用middles获取数据排序后,再去掉两头的最高和最低成绩#计算中间段的平均成绩 3）仅获取关心的元素为了仅获取关心的元素，可以用匿名变量（_）进行虚读。
代码3-14在序列中安排部分虚读示例。
>>>t1=("zhang",'male',20,puter",
3,(70,80,90,65,95)) >>>name,_,_,*learningStatus=t1 #嵌入虚读的匿名变量 >>>name 'zhang' >>>learningStatus [puter',
3,(70,80,90,65,95)]
7.序列遍历 遍历（traversal）是指按某条路径巡访容器中的元素，使每个元素均被访问一次，而且仅被访问一次。
遍历的关键是设计巡访路径。
对于序列这样的线性容器来说，最容易理解的遍历路径列表是通过对象值的迭代，形成一条遍历路径。
为此可以使用如下3种for循环。

（1）用len()函数计算出序列长度，用range()函数产生一个索引序列控制for循环。

（2）隐匿列表长度，利用本身的序列控制for循环。

（3）用内置的enumerate()将序列转换为索引序列控制for循环。
代码3-15遍历序列的3种办法示例。
·107· >>>t1=('one','two','three')#办法1：利用len()和range()控制for循环>>>foriinrange(0,len(t1)): print(i,t1[i])0one1two2three#办法2：直接用t1序列控制for循环>>>foriint1: print(i)onetwothree#办法3：用enumerate()控制for循环>>>fori,elementinenumerate(t1): print(i,t1[i])0one1two2three 3.1.3列表的个性化操作 列表的基本特征是有序和可变。
有序是序列容器的共性。
体现这个共性的操作已经介绍。
表3.2是体现其可变性的操作函数。
这些函数仅属于列表这个类型，是列表容器的另一方面属性。
为体现类（类型）的属性，这种函数都被特别称为方法（method），并且要用圆点（.）操作符（也称为分量操作符）进行访问。
可以看出，内置的序列操作函数，是将所操作对象作为参数，而列表个性化操作方法是作为操作对象的分量调用。
方法名aList.append(obj)aList.clear() aList.copy() aList.count(obj)aList.extend(seq)aList.index(obj)aList.insert(index,obj)aList.pop(index)aList.remove(obj)aList.reverse()aList.sort() 表3.2列表个性化操作的主要方法（设aList=[3,5,7,5]） 功能 参数示例 将对象obj追加到列表末尾清空列表aList obj='a' 复制列表aList 统计元素obj在列表中出现的次数把序列seq一次性追加到列表末尾返回obj首个位置索引值；若无obj，则抛出异常将对象obj插入列表中下标index位置移除index指定元素（默认尾元素），返回其值移除列表中obj的第一个匹配项列表中元素进行原地反转 bList=aList.copy()id(aList)id(bList)obj=5seq=['a',8,9]obj=5index=2,obj=8index=3obj=
5 对原列表进行原地排序 执行结果aList：[3,5,7,
5,'a']aList：[]bList：[3,5,7,5]204906125152820490612510162aList：[3,5,
7,'a',8,9] 1aList：[3,5,8,7,5]5,aList：[3,5,7]aList：[3,7,5]aList：[5,7,5,3]aList：[3,5,5,7] ·108· 下面从应用的角度，讨论列表的几种个性化操作。

1.向列表增添元素 向列表增添元素，有如下5种办法。

（1）利用加号（+）。
代码3-16利用加号向序列添加元素。
>>>aList=[3,5,9,7];bList=['a','b']>>>aList+=bList>>>aList[3,5,9,
7,'a','b']
（2）利用乘号（*）。
代码3-17利用乘号向序列添加元素。
>>>aList=[3,5,9,7]>>>aList*3[3,5,9,7,3,5,9,7,3,5,9,7]
（3）用append()方法向列表尾部添加一个对象。
代码3-18用append()方法向列表尾部添加一个对象。
>>>aList=[3,5,9,7];bList=['a','b']>>>aList.append(bList)>>>aList[3,5,9,
7,['a','b']]>>>aList.append(True)>>>aList[3,5,9,
7,['a','b'],True]
（4）用extend()方法向列表尾部添加一个列表。
代码3-19用extend()方法向列表尾部添加一个对象。
>>>aList=[3,5,9,7];bList=['a','b'] >>>aList.extend(bList) >>>aList[3,5,9,
7,'a','b'] #将这个结果与代码3-17的结果比较
（5）用insert()方法将一个对象插入到指定位置。
代码3-20用insert()方法将一个对象插入到指定位置。
>>>aList=[3,5,9,7];bList=['a','b']>>>aList.insert(2,bList)>>>aList[3,
5,['a','b'],9,7]>>>aList.insert(4,2)>>>aList[3,
5,['a','b'],9,2,7] ·109· 这5种办法有各有特色，但也有异曲同工之效。

2.从列表中删除元素 从列表中删除元素，Python有del、remove、pop三种操作。
它们的区别如下。
（1）del是根据索引（元素所在位置）来删除的。
（2）remove是删除首个符合条件的元素。
（3）pop返回的是弹出的那个数值。
代码3-21在列表中删除元素示例。
>>>aList=[3,5,7,9,8,6,2,5,7,1]>>>delaList[3]>>>aList[3,5,7,8,6,2,5,7,1]>>>aList.remove
(7)>>>aList[3,5,8,6,2,5,7,1]>>>aList.remove(10)Traceback(mostrecentcalllast): File"",line1,inaList.remove(10) ValueError:list.remove(x):xnotinlist>>>aList.pop(3)6>>>aList[3,5,8,2,5,7,1] 使用时要根据具体需求选用合适的方法。

3.赋值（=）与复制（copy()）
（1）赋值（=）只是对象的引用赋值，让另一个变量指向同一个对象。

（2）复制（copy()）是创建另一个同值对象。
代码3-22赋值（=）与复制（copy()）异同示例。
>>aList=[3,5,7,9]>>>bList=aList>>>bList[3,5,7,9]>>>id(aList),id(bList)(2788871571976,2788871571976)>>>cList=aList.copy()>>>cList[3,5,7,9]>>>id(aList),id(cList)(2788871571976,2788871570312) ·110· 3.1.4字符串的个性化操作
1．Python的驻留机制 字符串的一个重要特征是其内存驻留机制，简称字符串驻留（stringinterning）机制。
意思就是，为每个取值相同的字符串，在内存中只保留一个副本。
但这种驻留是有条件的。

（1）仅限数字、大小写拉丁字母和下画线组成的字符串可以驻留。
代码3-23对字符串组成字符的限制。
>>>a='a5678912345'>>>b='a5678912345'>>>aisbTrue>>>a='qwertyuiop[]asdfghjklzxcvbnm,./'>>>b='qwertyuiop[]asdfghjklzxcvbnm,./'>>>aisbFalse>>>a="王";b="王";aisbFalse #含非规定字符#含非规定字符
（2）编译期间就确定的字符串——静态字符串，采用驻留机制，但是，仅限于规定字符。
代码3-24静态字符串驻留示例。
>>>a='abcdef'>>>b='abc'+'def'>>>c=''.join(['abc','def'])>>>a,b,c('abcdef','abcdef','abcdef')>>>aisb,aisc(True,False) #静态字符串#静态字符串#动态字符串
（3）字符串不能太长，特别是通过乘法运算符得到的字符串，长度必须小于20。
代码3-25长度限制示例。
>>>a='abc5678912345abcdefaabc5678912345abcdefef' >>>b='abc5678912345abcdefaabc5678912345abcdefef' >>>aisb True >>>a='abc5678912345abcdefaabc5678912345abcdefefaabc0123 912345abcdefaabc5678912345abcdefef' #长字符串 >>>b='abc5678912345abcdefaabc5678912345abcdefefaabc0123 912345abcdefaabc5678912345abcdefef' #长字符串 >>>aisb False>>>b='abcde'*4;a='abcde'*4;aisb #长度为20 True>>>b='abcde'*4+'a';a='abcde'*4+'a';aisb #长度为21 False ·111·
（4）Python的sys模块提供的intern()方法可以强制两个取值相同的变量指向同一个对象。
代码3-26intern()应用示例。
>>>importsys>>>a='abcdef!
';b='abcdef!
';aisbFalse>>>a=sys.intern(b);aisbTrue
2.字符串搜索与测试 1）字符串搜索字符串搜索是在给定的区间[beg，end]搜索指定字符串，默认的搜索区间是整个字符串。
Python字符串的搜索方法如表3.3所示。
表3.3Python字符串的搜索方法 方法s.count(str,beg=0,end=len(s))s.endswith(obj,beg=0,end=len(s))s.find(str,beg=0,end=len(s))s.index(str,beg=0,end=len(s))s.rfind(str,beg=0,end=len(s))s.rindex(str,beg=0,end=len(s))s.startswith(obj,beg=0,end=len(s)) 功能返回区间内str出现的次数在区间内，检查字符串是否以obj结尾：是，则返回True；否则返回False在区间内，检查str是否包含在s中：是，则返回开始的索引值；否则返回-1跟find()方法一样，只不过如果str不在s中会报一个异常类似于find()函数，不过是从右边开始查找类似于index()，不过是从右边开始在区间内，若以obj开头，返回True；否则返回False 2）字符串测试字符串测试是判断字符串元素的特征，Python字符串不划分区间的检查统计类操作方法如表3.4所示。
表3.4Python字符串不划分区间的检查统计类操作方法 方法s.isalnum()s.isalpha()s.isdecimal()s.isdigit()s.islower()s.isnumeric()s.isspace()s.istitle()s.isupper()s.isdecimal() 功能如果s非空且所有字符都是字母或数字则返回True，否则返回False如果s至少有一个字符并且所有字符都是字母则返回True，否则返回False如果s只包含十进制数字则返回True，否则返回False如果s只包含数字则返回True，否则返回False如果s中包含有区分大小写的字符，并且它们都是小写，则返回True，否则返回False如果s中只包含数字字符则返回True，否则返回False如果s中只包含空格则返回True，否则返回False如果s是标题化的（见title()）则返回True，否则返回False如果s中包含有区分大小写字符，并且它们都是大写，则返回True，否则返回False检查字符串是否只包含十进制字符，只用于Unicode对象 ·112· 这些方法都比较简单，就不举例说明了。

3.字符串修改 应当注意，字符串对象是不可变（immutable）序列对象。
这种不可变意味着一旦创建就不可改变，不可在同一个位置进行赋值。
但是，这并不妨碍创建一个新的字符串，而用原来字符串的变量指向它，就好像是把原来的字符串进行了改变似的。
表3.5列出了Python字符串的修改操作方法。
表3.5Python字符串的修改操作方法 方法s.capitalize()s.center(width)s.expandtabs(tabsize=8)s.ljust(width)s.lower()s.lstrip()s.rstrip()s.strip([obj])s.maketrans(intab,outtab)s.replace(str1,str2,num=s.count(str1))s.rjust(width)s.swapcase()s.title()s.translate(table,del="")s.upper()s.zfill(width) 功能把字符串s的第一个字符大写返回一个原字符串居中并使用空格填充至长度width的新字符串把字符串s中的tab符号转为空格，tab符号默认的空格数是8返回一个原字符串左对齐，并使用空格填充至长度width的新字符串转换s中所有大写字符为小写删除s首部的空格删除s末尾的空格删除s首尾空格创建字符映射转换表。
intab表示需要转换的字符串；outtab为转换的目标字符串把s中的str1替换成str2，若指定num，则替换不超过num次返回一个原字符串右对齐，并使用空格填充至长度width的新字符串翻转s中的大小写返回“标题化”的s，即所有单词都以大写开始，其余字母均为小写（见istitle()）根据table给出的翻译表转换s的字符，要过滤掉的字符放到del参数中转换s中的小写字母为大写返回长度为width的字符串，原字符串s右对齐，前面填充
0 这些方法的使用比较简单，就不举例说明了。

4.字符串分隔与连接 表3.6给出Python字符串分隔和连接的方法。
表3.6Python字符串分隔和连接的方法 方法s.split(str="",num=s.count(str))s.splitlines()s.partition(str) s.rpartition(str)str.join(seq) 功能返回以str为分隔符将s分隔为num个子字符串组成的列表，num为str个数返回在每个行终结处进行分隔所产生的行列表，并剥离所有行终结符返回第一个str分隔的三个字符串元组：(s_pre_str,str,s_post_str)。
若s中不含str，则s_pre_str==s类似于partition()，不过是从右边开始查找以str作为连接符，将seq中各元素（的字符串表示）连接为一个新的字符串 ·113· 代码3-27字符串分隔与连接示例。
>>>s1="red/yellow/blue/white/black">>>list1=s1.split('/') #返回用每个'/'分隔子串列表 >>>list1 ['red','yellow','blue','white','black'] >>>>>>s1.partition('/') #返回用第一个'/'分隔为3个子串的元组 ('red','/','yellow/blue/white/black')>>>s1.rpartition('/') #返回用最后一个'/'分隔为3个子串的元组 ('red/yellow/blue/white','/','black') >>> >>>s2='''red yellow blue white black'''>>>s2.splitlines() #返回按行分隔的列表 ['red','yellow','blue','white','black'] >>>'#'.join(list1)'red#yellow#blue#white#black' #用#连接各子串 3.1.5字符串编码与解码
1.有关概念 在计算机底层，任何数据都是用0、1表示的。
为了能用0、1表示文字，并且能共享，一些标准化组织制定了一些编码标准。
下面介绍与Python字符串编码相关的概念。
1）ASCII编码ASCII（AmericanStandardCodeforInformationInterchange，美国标准信息交换代码）由美国国家标准学会（AmericanNationalStandardInstitute，ANSI）制定，后被国际标准化组织（InternationalOrganizationforStandardization，ISO）定为国际标准。
它使用7位或8位二进制数组合来表示基于拉丁字母的语言文字符号，形成128或256种可能的字符，包括大写和小写拉丁字母、数字0~
9、标点符号、非打印字符（换行符、制表符等4个）以及控制字符（退格、响铃等）。
这种字符在全世界范围内的应用是极为有限的。
2）Unicode与UTFUnicode（统一码、万国码、单一码）是一种2字节计算机字符编码，为欧洲、非洲、中东、亚洲大部分国家文字的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换与处理的要求。
1990年开始研发，1994年正式公布。
它比ASCII占用大一倍的空间，可以用ASCII表示的字符使用Unicode就是浪费。
为了解决这个问题，出现了一些中间格式的字符集，被称为通用转换格式（UnicodeTransformationFormat，UTF）。
3）UTF-8UTF-8（8-bitUnicodeTransformationFormat）是多种UTF格式中的一种，是一种变长 ·114· 编码。
例如，对于ASCII字符集中的字符，UTF-8只使用1B，并且与ASCII字符表示一样，而其他的Unicode字符转化成UTF-8需要至少2B。
4）GBKGBK（国标扩展）码是《汉字内码扩展规范》（ChineseInternalCodeSpecification）的简称，中华人民共和国全国信息技术标准化技术委员会1995年12月1日制定。
由于IBM在编写CodePage的时候将GBK放在第936页，所以也叫CP936。
5）字节序列为了便于存储和传输，Python内置了两种基本的二进制序列——字节序列：Python3引入的不可变bytes类型和Python2.6添加的可变bytearray类型，对应的构造函数为bytes()和bytearray()。
它们的对象都是以8b为单位组织，每个元素x（0≤x<256）为整数。
为与字符串区别，在字面量之前要加个字符b。
例如，b'abc'、b'abc\'x"、b'abc"x'''、b"xyz"、b"""等。

2.字符串编码与解码操作 简单地说，把字节序列变成人类可读的文本字符串就是解码，而把字符串变成用于存储或传输的字节序列就是编码。
在Python3中，字符串不再区分ASCII编码和Unicode编码，默认采用UTF-
8，并允许创建字符串时指定编码方式。
表3.7为字符串编码与解码有关的方法。
表3.7字符串编码与解码有关的方法 （s：字符串变量；b：字节码变量；object：序列对象；encoding：编码格式；errors：错误控制） 方法str(object=b".encoding='UTF-8',='strict')b.decode(encoding='UTF-8',='strict')s.encode(encoding='UTF-8',errors='strict') 功能构造函数解码字节码b为相应的字符串对象将s编码为字节码对象 说明 如果出错默认报一个ValueError异常，除非errors指定的是'ignore'或者'replace' 代码3-28字符串的编码与解码示例。
>>>s1='我喜欢Python!
'>>>b1=s1.encode(encoding='CP936')>>>b1b'\xce\xd2\xcf\xb2\xbb\xb6Python!
'>>>b1.decode(encoding='CP936')'我喜欢Python!
' #将s1按CP936格式编码为字节码#将b1按CP936格式解码
3．字符串中的汉字 严格地说，str其实是字节串，它是Unicode经过编码后的字节组成的序列。
对UTF-8编码的str'汉'使用len()函数时，结果是
3，实际上，UTF-8编码的'汉'=='\xE6\xB1\x89'。
Unicode才是真正意义上的字符串，对字节串str使用正确的字符编码进行解码后获得，并且len(u'汉')==
1。

4．字符编码声明 在Python源代码文件中，如果要用到非ASCII字符，则需要在文件头部进行字符编码·115· 的声明。
字符编码声明的语法如下。
#coding:编码名称 例如，采用UTF-
8，可以声明为 #coding:UTF-
8 也可以写成 #*****coding:UTF-8***** 因为Python只检查#、coding和编码代号，其他字符都不影响Python的判断。
另外，Python中可用的字符编码很多，并且还有许多别名，还不区分大小写，例如，UTF-8可以写成u8。
另外需要注意的是，声明的编码必须与文件实际保存时用的编码一致，否则很大几率会出现代码解析异常。
3.1.6字符串格式化与format()方法
1.字符串格式化表达式 1.5.2节介绍了print()函数的格式控制。
由于print()的输出就是创建字符流的过程，所以print()的输出格式控制，就是字符串的格式控制。
下面较深入地讨论字符串的格式化控制，对于理解print()的输出格式控制会有深刻的体会。
Python的格式化表达式主要进行格式化操作，由字符串格式化操作符（%）连接两个表达式组成，格式如下。
格式化字符串%被格式化对象
（1）格式化字符串由格式化字段和一些可缺省字符组成。
格式字段（也称为格式指令），用于指示被格式化对象在字符流中的格式，其一般结构如下。
%[flag][width][.precision]typecode ①flag：可以为+（右对齐）、-（左对齐）、0（0填充）、"（空格）。
②width：宽度。
③precision：小数点后的精度（仅对浮点类型有用）。
④typecode：格式化对象类型。

（2）被格式化对象可以是一个值（如一个字符串、一个数值等），也可以是由多个值组成的元组。

（3）格式化字符串中的格式化字段数目，与被格式化对象要一致，并且在类型上相对应。

（4）格式化字符串中可以包括其他字符，这些字符不参与格式化操作，只原样返回。
·116·
（5）格式化表达式执行时，进行两个操作：一是将被格式化的对象按照格式化字段指定的格式转换为字符串；二是将用这些转换得到的字符串替换格式化字符串中对应的格式字段。
代码3-29格式化表达式应用示例。
>>>name='Zhang' >>>"Hello,thisis%+10.5s，andyou?
"%name 'Hello,thisis Zhang，andyou?
' >>>'I\'m%-05.3dyearsold.Howaboutyou?
'%20 "I'm020yearsold.Howaboutyou?
" >>>'Thebookispricedat%08.3fyuan.'%23.45 'Thebookispricedat0023.450yuan.' #对字符串格式化#对整数格式化#对浮点数格式化 显然，print()的作用仅仅是将被格式化字符串插入到流向标准输出设备的字符流中。
2．format()方法 format()方法是从Python2.6开始新增的一个格式化字符串函数。
它有两种不同的使用形式：一种是由格式化模板字符串调用，用被格式化的对象（字符串和数字）作参数。
另一种是在程序中直接调用，有两个参数：一个是被格式化对象；另一个是格式化模板字段。
这里介绍第一种方式。
在用模板字符串调用format()时，模板字符串中，含有一个或多个可替换的模板字段。
模板字段用大括号括起，其作用是给某种类型的对象提供一个转换为字符串的模板。
format()方法可以有一个或多个类型不同的对象参数。
format()方法执行时，首先进行对象参数与模板字段项的匹配，然后将每个对象参数按照所匹配的模板字段指示格式转换为字符串，并替换所匹配的模板，返回一个被替换后的字符串。
1）format()的匹配方式与字符串格式化表达式相比，format()方法的优势主要在于其对象参数与模板的匹配方式非常灵活。
可以通过位置、序号、名称、索引（下标）进行匹配。
代码3-30format()的匹配方式应用示例。
>>>#位置匹配>>>'{}is{},{}is{}.'.format('This','Zhang','he','Wang')'ThisisZhang,heisWang.'>>>#序号匹配>>>'{2}is{3},{0}is{1}.'.format('he','Wang','This','Zhang')'ThisisZhang,heisWang.'>>>#名字匹配>>>'{pronoun1}is{name1},{pronoun2}is{name2}.' .format(name2='Wang',pronoun1='This',pronoun2='he',name1='Zhang')'ThisisZhang,heisWang.'>>>#下标匹配>>>pronoun=('he','This');name=('Wang','Zhang')>>>'{1[1]}is{0[1]},{1[0]}is{0[0]}.'.format(name,pronoun)'ThisisZhang,heisWang.' ·117· 2）format()格式规约格式规约用于对格式进行精细控制，并采用冒号（:）后面的格式限定符控制。
这些格式限定符主要有如下几类。

（1）对齐、填充、宽度。
出现模板字段的前面部分，对所有对象都适用，主要包括3种。
①对齐，包括<（左对齐）、^（居中）和>（右对齐）。
②填充，用一个字符表示，默认为空格。
③宽度一般是最小宽度。
如果需要最大宽度，就在最小宽度后加一个圆点（.），后跟一个整数。
这三者的排列顺序是填充、对齐、最小宽度。
代码3-31格式化字符串中的对齐与填充示例。
>>>ls='leftaligned';cs='centered';rs='rightaligned' >>>'{:<30}'.format(ls) 'leftaligned ' >>>'{:>30}'.format(rs) ' rightaligned' >>>'{:^30}'.format(cs) ' centered ' >>>'{:=^30}'.format(cs) '===========centered===========' >>>'{:>>30}'.format(rs) '>>>>>>>>>>>>>>>>>rightaligned' >>>'{:<<30}'.format(ls) 'leftaligned<<<<<<<<<<<<<<<<<<'
（2）对数值数据，增加如下限定符。
①=，用于填充0与宽度之间的分隔。
②可选的符号字符：+（必须带符号的数值）、-（仅用于负数）、空格（让正数前空一格、负数带字符-）。
代码3-32数值填充与符号指定符应用示例。
>>>m=12345678 >>>'{:=20}'.format(m) ' 12345678' >>>'{:0=20}'.format(m) '45678' >>>'{:0=20}'.format(-m) '-5678' >>>'{:#^20}'.format(m) '######12345678######' >>>'{:%>20}'.format(m) '%%%%%%%%%%%%12345678' ·118·
（3）仅用于整数的进制指定符：d（十进制）、x与#x（小写十六进制）、X与#X（大写十六进制）、o与#o（八进制）、b与#b（二进制）。
其中，在#引导下可以获取前缀。
代码3-33进制指定符应用示例。
>>>"int:{0:d};hex:{0:x};oct:{0:o};bin:{0:b}".format(56)'int:56;hex:38;oct:70;bin:111000'>>>"int:{0:d};hex:{0:#x};oct:{0:#o};bin:{0:#b}".format(56)'int:56;hex:0x38;oct:0o70;bin:0b111000'>>>"hex:{0:x}(x);{0:#x}(#x);{0:X}(X);{0:#X}(#X)".format(56)'hex:38(x);0x38(#x);38(X);0X38(#X)' #不获取前缀#获取前缀#十六进制前缀大小写
（4）仅用于浮点数的格式限定符有如下两项，它们要一起使用。
①小数点后的精度：在最小宽度后面加一个圆点（.），后跟一个整数。
②类型字符：e或E（科学记数法表示）、f（标准浮点形式）、g（浮点通用格式）、%（百分数格式）。
这类符号位于最后。
代码3-34浮点数格式指定符应用示例。
>>>x=0.123456 >>>'{0:15.3e},{0:15.3f},{0:15.3%}'.format(x) ' 1.235e-01, 0.123, 12.346%' >>>'{0:*<15.3e},{0:#^15.3f},{0:*>15.3%}'.format(x) '1.235e-01******,#####0.123#####,********12.346%' 3.1.7正则表达式 正则表达式（regularexpression，简写为regex、regexp、RE，复数为regexps、regexes、regexen、REs，又称为正规表示法、常规表示法）最早由神经生理家WarrenMcCulloch和WalterPitts提出，作为描述神经网络模型的数学符号系统。
1956年，StephenKleene在其论文《神经网事件的表示法》中将其命名为正则表达式。
后来被UNIX之父KenThompson把这一成果应用于计算机领域。
现在，在很多文本编辑器中，正则表达式被用来检索、替换那些符合某个模式的文本。

1.模式与匹配 模式（pattern）是关于规则、规律的表达或命名，是一个与问题（problem）、解决方案（solution）和效果（consequences）相关的概念。
在文本处理时，会遇到许多问题，例如： 在一段文本中，是否含有数字？在一段文本中，是否含有手机号码？在一段文本中，是否含有E-mail地址？#对于这些问题，需要制定一些规则。
例如，如何判断什么是手机号码等。
正则表达式就是一套用于制定在文本处理时进行模式描述的小型语言。
在一段文本中，查找满足模式的字符串的过程，就称为匹配（matching）。
通常，匹配成功就返回一个match对象。
·119·