Python核心编程--学习笔记--6--序列（上）字符串

　　本章研究Python中的序列：字符串、列表和元组。因为这些类型其实都是由一些成员共同组成的一个序列整体，所以我们把它们统称为序列。序列的存储结构可以表示为：

　　

1 序列

　　序列类型有着相同的访问模式：按下标访问某一元素[0, N-1]，也可以通过切片操作一次得到多个元素。

1.1 标准类型操作符

　　比较运算、逻辑运算（见4.5节），一般都能适用于所有序列类型。

1.2 序列类型操作符

in, not in  #成员关系操作符
+           #连接操作符
*           #重复操作符
[]          #切片操作符

　　成员关系操作符——obj [not] int sequence，判断对象obj是否属于序列sequence：

>>> 'py' in 'python'
True
>>> 4 not in range(6)
False

　　连接操作符——sequence1+sequence2，将两个序列合并在一起，返回一个新序列：

>>> 'Py' + 'thon'
'Python'
>>> range(4) + range(4,8)
[0, 1, 2, 3, 4, 5, 6, 7]

　　重复操作符——sequence * copies_int，返回一个新序列，包含copies_int个重复的sequence：

>>> '-' * 20
'--------------------'

　　切片操作符——seq[index]，seq[start:stop]，seq[start:stop:step]，访问 元素/子序列/按步长访问：

>>> aList = range(10)
>>> aList
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> aList[4]     #按下标访问单个元素
4
>>> aList[10]    #下标范围：0～len(seq)，超出范围则产生异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> aList[:]       #切片操作，不指定起点和终点，则复制全部元素
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> aList[None:8]  #起始为None，则默认从第一个元素开始
[0, 1, 2, 3, 4, 5, 6, 7]
>>> aList[3:]      #终点为空，则默认直到最后一个元素
[3, 4, 5, 6, 7, 8, 9]
>>> aList[1::3]    #步长为3
[1, 4, 7]
>>> aList[-1:-len(aList)]    #负索引。不管正负索引，起始元素一定要在终点元素的左边，否则返回空
[]
>>> aList[-len(aList):-1]    #负索引
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> aList[-100:100:2]    　　 #切片操作可以超出范围
[0, 2, 4, 6, 8]

　　逆序访问序列，以及循环输出每次都去掉最后一个字符的序列：

>>> aList = range(5)
>>> aList
[0, 1, 2, 3, 4]
>>> aList[::-1]　　#逆序输出
[4, 3, 2, 1, 0]
>>> for i in [None] + range(-1, -len(aList), -1):　#加[None]，否则第一个输出不包含最后一个元素
...     print aList[ :i]
...
[0, 1, 2, 3, 4]
[0, 1, 2, 3]
[0, 1, 2]
[0, 1]
[0]

1.3 内建函数

　　类型转换工厂函数：

str(obj)     #把obj对象转换成字符串(对象的字符串表示法)
list(iter)   #把可迭代对象转换成一个列表对象
tuple(iter)  #把可迭代对象转换成一个元组对象
unicode(obj) #把对象转换成Unicode字符串(使用默认编码)
basestring() #抽象工厂函数，其作用仅仅是为str和unicode函数提供父类，所以不能被实例化，也不能被调用(详见第2节)

>>> str([1,2,3])
'[1, 2, 3]'
>>> list('abcd')
['a', 'b', 'c', 'd']
>>> tuple('abcd')
('a', 'b', 'c', 'd')

　　一些可操作的内建函数：

len(seq)          #返回seq的长度
sum(seq, init=0)  #返回seq和可选参数init的总和
reversed(seq)　　  #接受一个序列作为参数，返回一个以逆序访问的迭代器

#接受一个可迭代对象作为参数，返回一个enumerate对象(也是一个迭代器)，该对象生成由iter每个元素的index值和item值组成的元组
enumerate(iter)

#返回iter或(arg0,arg1,...)中的最大值；如果指定了key，则key必须是一个可以传给sort()方法的用于比较的回调函数
max(iter,key=None) or
max(arg0, arg1, ..., key=None)
min(iter, key=None) or
min(arg0, arg1, ..., key=None)#返回iter或(arg0,arg1,...)中的最小值；如果指定了key，key同上

#接受一个可迭代对象作为参数，返回一个有序的列表;可选参数func,key 和 reverse 的含义跟 list.sort()内建函数的参数含义一样.
sorted(iter, func=None, key=None, reverse=False)

zip([it0, it1,... itN])#返回一个列表，其第一个元素是it0,it1,...这些迭代对象各自第一个元素组成的一个元组，以此类推。返回列表长度等于it..中的最小值。

2 字符串

　　字符串即单/双/三引号括起来的内容；通常的字符串（str）和Unicode字符串（unicode）都是抽象类basestring的子类，这个basestring不能被实例化。

>>> basestring('abc')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: The basestring type cannot be instantiated

　　访问：字符串可以通过下标和切片访问字符和子串，不允许通过下标更改其内容，因为字符串是不可变类型。

>>> aStr = 'Hello Python'
>>> aStr[4]
'o'
>>> aStr[4] = 'O'    #下标操作，实际上返回一个长为1的子串，字符串对象不可更改
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

　　更新：同整数一样，更新字符串的值，实际上是创建了一个新对象，并将其引用赋值给原来的变量。

>>> bStr is aStr
True
>>> bStr += 'er'
>>> bStr
'Hello Pythoner'
>>> aStr　　　　　　#原对象未变
'Hello Python'

　　删除：要么赋一个空字符串值（其实是减少原对象的引用计数），要么显示的del掉这个变量引用。不能直接删除其中字符或子串。

3 字符串和操作符

3.1 标准类型操作符

　　比较运算、逻辑运算都适合于字符串，实际按照字符ASCII值来比较。

3.2 序列操作符

　　切片操作符[]、成员操作符[not] in、连接操作符+、重复操作符* 都适用于字符串。

　　一些string模块预定义的字符串：

>>> import string
>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'
>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.digits
'0123456789'

>>> a = 'hello' + ' ' + 'world'  #运行时连接字符串
>>> a
'hello world'
>>> b = 'hello' ' ' "word"    　　#编译时连接字符串，同其他语言，Python默认将相邻的字符串连接为一个
>>> b
'hello word'

　　如果一个普通字符串和一个Unicode字符串连接，则普通字符串会被先转换成Unicode字符串，再连接：

>>> 'hello' + u' ' + 'world'
u'hello world'

4 只适用于字符串的操作符

4.1 格式化操作符

　　类似于C语言里printf()函数的格式。字符串格式化符号：

%c    #转换成字符(ASCII码值，或者长度为一的字符串)
%r    #优先用repr()函数进行字符串转换
%s    #优先用 str()函数进行字符串转换
%d/%i #转成十进制数
%u    #转成十进制数
%o    #转成八进制数
%x/%X #转成十六进制数(x/X代表转换后的十六进制字符的大小写)
%e/%E #转成科学计数法(e/E控制输出e/E)
%f/%F #转成浮点数(小数部分自然截断)
%g/%G #%e和%f / %E和%F的简写
%%    #输出%

　　格式化操作符辅助命令：

*     #定义宽度或者小数点精度
-     #左对齐
+     #在正数前面显示加号( + )
<sp>  #在正数前面显示空格
#     #在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0     #显示的数字前面填充‘0’而不是默认的空格
%     #'%%'输出一个单一的'%'
(var) #映射变量(字典参数)
m.n   #m是显示的最小总宽度,n是小数点后的位数(如果可用的话)

　　例子：

>>> '%x' % 108     #返回其十六进制的字符串表示
'6c'
>>> '%#X' % 108    #打印十六进制的前缀，大写X
'0X6C'
>>> '%.2f' % 1234.567890    #保留两位小数位，默认为六位
'1234.57'
>>> '%e' % 1234.567890      #科学计数法，默认小数点后六位
'1.234568e+03'
>>> '%G' % 1234.567890      #默认整数位和小数位一共保留6位，从左到右第一个非0数字开始计算
'1234.57'
>>> '%g' % 0.001234567890　 #前面的0不计入这六位数
'0.00123457'
>>> "%+d" % 4    #整数加符号
'+4'
>>> "% d" % 4    #整数前加空格
' 4'
>>> "we are at %d%%" % 100    #输出%
'we are at 100%'
>>> num = 123
>>> 'dec: %d/ oct: %#o/ hex: %#X' % (num, num, num) #分别输出十进制、带前缀的八进制和十六进制
'dec: 123/ oct: 0173/ hex: 0X7B'
>>> "MM/DD/YY = %02d/%02d/%02d" % (5, 15, 2014)     #输出宽度至少为2，不够的前面补0
'MM/DD/YY = 05/15/2014'
>>> 'There are %(howmany)d %(lang)s Quotation Symbols' % \
... {'lang': 'Python', 'howmany': 3}    #字典的键作为格式符，输出对应值的相应格式
'There are 3 Python Quotation Symbols'

　　字符串格式化操作符是一个很有用的调试工具，print语句自动为每个对象调用str()函数，获得一个适当的描述信息。

4.2 字符串模板：更简单的替代品

　　对于上一节最后一个例子，如果忘记了%(lang)s等这种转换类型参数，就会产生错误。

　　而新的字符串模板Template对象使用类似shell中变量一样的$符号，还有两个方法substitute()和safe_substitute()，来显示字符串：

>>> from string import Template
>>> s = Template('There are ${howmany} ${lang} Quotation Symbols')    #两个变量
>>> print s.substitute(howmany=3, lang='Python')　　#使用模板
There are 3 Python Quotation Symbols
>>> print s.substitute(lang='Python')      #只提供了一个变量实参，引发异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/usr/lib/python2.7/string.py", line 172, in substitute
return self.pattern.sub(convert, self.template)
File "/usr/lib/python2.7/string.py", line 162, in convert
val = mapping[named]
KeyError: 'howmany'
>>> print s.safe_substitute(lang='Python')  #安全函数，虽然只提供一个参数，仍然输出
There are ${howmany} Python Quotation Symbols

4.3 原始字符串操作符（r/R）

　　字符串前面加r，取消串内的转义：

>>> f = open('C:\windows\temp\readme.txt', 'r')    #\t \r被转义
Traceback (most recent call last):
Edit By Vheavens Edit By Vheavens
File "<stdin>", line 1, in ?
f = open('C:\windows\temp\readme.txt', 'r')
IOError: [Errno 2] No such file or directory: 'C:\\windows\\temp\readme.txt'
>>> f = open(r'C:\windows\temp\readme.txt', 'r')   #取消转移
>>> f.readline()
'Table of Contents (please check timestamps for last update!)\n'
>>> f.close()

4.4 Unicode字符串操作符（u/U）　　

>>> u'abc'
u'abc'
>>> ur'Hello\nWorld'    #u必须在r之前
u'Hello\\nWorld'

5 内建函数

5.1 标准类型函数

　　cmp(obj1, obj2)——对于字符串，则是按照ASCII值来比较大小的。左边大，返回1；左边小，返回-1；相等则返回0。

5.2 序列类型函数

　　len()返回字符个数、max()和min()分别返回ASCII值最大和最小的字符、enumerate()返回包含下标和字符的元组组成的迭代对象、zip()返回一个列表：

>>> enumerate('abc')
<enumerate object at 0xb72b0cac>
>>> for i in enumerate('abc'):    #返回一个可迭代对象
...     print i
...
(0, 'a')
(1, 'b')
(2, 'c')
>>> for i,c in enumerate('abc'):
...     print i,c
...
0 a
1 b
2 c
>>> zip('123', 'ABC', 'abc')    #各自第n个元素组成的元组，成为返回值列表的第n个元素
[('1', 'A', 'a'), ('2', 'B', 'b'), ('3', 'C', 'c')]

5.3 字符串类型函数

raw_input() #可以用一个字符串作参数，作为提示，将用户输入转为字符串返回

str()　　　　#工厂函数，将对象转换成可打印的字符串表示
unicode()　 #工厂函数，将对象转换成Unicode的字符串表示

chr()　　　　#接收[0,255]内的数，返回对应的字符
unichr()   #接收一定范围内的数，返回Unicode字符（具体范围视系统配置而定）
ord()　　　　#接收一个字符

>>> unichr(12345)
u'\u3039'
>>> ord('a')
97
>>> ord(u'\u2345')    #\u表明后面是一个Unicode字符，如果不加，就是一个字符串'2345'
9029

6 字符串内建函数

　　字符串是不可变类型，下面这些方法都是生成一个新对象并返回，原字符串并未变化：

string.capitalize()  #把字符串的第一个字符大写
string.center(width) #返回一个原字符串居中，并使用空格填充两边至长度width的新字符串
string.count(str, beg=0, end=len(string))　　#返回str在一定范围里面出现的次数

#以encoding指定的编码格式解码string，出错默认报ValueError的异常，除非errors指定'ignore'或'replace'

string.decode(encoding='UTF-8', errors='strict')
string.encode(encoding='UTF-8', errors='strict') #以encoding指定的编码格式编码string，errors同上
string.endswith(obj, beg=0, end=len(string))　　  #检查一定范围内的子字符串是否以obj结束
string.expandtabs(tabsize=8)　　　　　　　　#把字符串string中的tab符号转为tabsize个空格
string.find(str, beg=0,end=len(string))  #检测str是否在一定范围子串内，在则返回其第一次出现下标，否则返回-1
string.index(str, beg=0,end=len(string)) #跟find()方法一样，不过如果str不在string中会报一个异常
string.format(*args, **kwargs)　　#格式化输出字符串，用参数代替字符串内的{}占位符
string.isalnum()  #如果string非空，且所有字符都是字母或数字，则返回True
string.isalpha()  #如果string非空，且所有字符都是字母，则返回True
string.isdigit()  #如果string非空，且所有字符都是数字，则返回True
string.islower()  #如果string非空，且所包含的字母都是小写，则返回True
string.isspace()  #如果string中只包含空格，则返回True
string.istitle()  #如果string是标题化的(见title())则返回True
string.isupper()  #如果string非空，且所包含的字母都是大写，则返回True
string.join(seqs) #以string作为分隔符，将seqs中所有的元素(的字符串表示)合并为一个新的字符串
string.ljust(width)  #返回一个原字符串左对齐，并使用空格填充至长度width的新字符串
string.lower()    #将string中存在的所有大写字符转为小写
string.lstrip()   #截掉string左边的空格
string.partition(str)  #把string分成一个以str为中间元素的3元素元组，如果string中不包含str，则string为第一个元素
string.replace(str1, str2, num=string.count(str1)) #把string中的前num个str1替换成str2
string.rfind(str, beg=0, end=len(string))  #类似于find()函数，不过是从右边开始查找
string.rindex(str, beg=0, end=len(string)) #类似于index()，不过是从右边开始
string.rjust(width)    #返回一个原字符串右对齐，并使用空格填充至长度width的新字符串
string.rpartition(str) #类似于partition()函数，不过是从右边开始查找
string.rsplit()   #见split()函数，不过从右边开始计算
string.rstrip()   #删除string字符串末尾的空格
string.split(str=" ", num=string.count(str))    #以str为分隔符，将string从前num个分隔符上切开
string.splitlines(num=string.count('\n'))       #同上，不过分隔符改成换行符
string.startswith(obj, beg=0, end=len(string))  #检查一定范围内的子字符串是否是以obj开头
string.strip([obj])  #在string上执行lstrip()和rstrip()
string.swapcase()    #翻转string中的大小写
string.title()       #返回"标题化"的string，即所有单词都是以大写开始，其余字母均为小写
string.translate(str, del="")  #根据str给出的表(包含256个字符)转换string的字符，要过滤掉的字符放到del参数中
string.upper()      #将string中的所有的小写字母转换为大写
string.zfill(width) #返回长度为width的字符串，原字符串string右对齐，前面填充0

　　第十个format()函数在原书中没有，但是本人机器上的python版本有（dir(str)可看到），所以举几个例子：

>>> '{1},{0}'.format('world', 'hello')    #{}占位符，可以调整顺序
'hello,world'
>>> '{1},{0},{py}'.format('world', 'hello', py = 'pythoner')   #{变量}占位符
'hello,world,pythoner'

7 字符串的独特特性

7.1 特殊字符串和控制字符

　　即转义字符，控制字符的一个用处就是用作定界符，它们不可打印：

八进制  十进制  十六进制  字符    说明
\0　　000     0     0x00   NUL  空字符 Nul 　　#Python中不是字符串的结束符
\a　　007  　　7　　　0x07   BEL  响铃字符
\b　　010  　　8　　　0x08   BS   退格
\t　　011  　　9　　　0x09   HT   横向制表符
\n　　012 　　10　　　0x0A   LF   换行
\v　　013 　　11　　　0x0B   VT   纵向制表符
\f　　014 　　12　　　0x0C   FF   换页
\r　　015 　　13　　　0x0D   CR   回车
\e　　033 　　27　　　0x1B   ESC  转义
\"　　042 　　34　　　0x22   "    双引号
\'　　047 　　39　　　0x27   '    单引号
\\　　134 　　92　　　0x5C   \    反斜杠

\000 ~ \177   八进制值
\x00 ~ \xff   x开头的十六进制值
\ 　　　　　　　连字符，将本行和下一行的内容连接起来

7.2 三引号

　　允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。对于HTML或SQL很有用：

>>> s='''hello
... world
... \tI'm
... here'''
>>> s
"hello\nworld\n\tI'm\nhere"
>>> print s
hello
world
I'm
here

7.3 字符串不变性

　　字符串是不可变类型：

>>> s = 'abc'
>>> id(s)
139902686038944
>>> s += 'def'
>>> id(s)    #新分配内存，生成一个新对象，原对象被回收
139902685293376

8 Unicode

8.1 术语

名词 　　　　　　　　 意思
ASCII  　　　　#美国标准信息交换码
BMP    　　　　#基本多文种平面(第零平面)
BOM    　　　　#字节顺序标记(标识字节顺序的字符)
CJK/CJKV 　　 #中文-日文-韩文(和越南语)的缩写
Code point 　 #类似于ASCII值，代表Unicode字符的值，范围在range(1114112)或者说0x000000到0x10FFFF
Octet   　　  #八位二进制数的位组
UCS  　　　　  #通用字符集
UCS2 　　　　  #UCS的双字节编码方式(见 UTF-16)
UCS4 　　　　  #UCS的四字节编码方式
UTF  　　　　  #Unicode或者UCS的转换格式
UTF-8  　　　　#八位UTF转换格式(无符号字节序列，长度为1~4个字节)
UTF-16  　　　 #16位UTF转换格式(无符号字节序列，通常是16位长[两个字节]，见 UCS2)

8.2 什么是Unicode

　　ASCII字符只有1个字节，无法支持像汉语这种字符，因此使用Unicode字符，它使用1个或多个字节，可表示90,000+字符。

8.3 怎么用Unicode

　　Python中字符串已经不再是个类型，而是对象。ASCII字符串是StringType，Unicode字符串是UnicodeType。　　

　　以上两种的行为是非常相近的。string模块里面都有相应的处理函数，string模块已经停止了更新，只保留了ASCII 码的支持，string模块已经不推荐使用。在任何需要跟Unicode兼容的代码里都不要再用该模块，保留该模块仅仅是为了向后兼容。

　　str()和chr()处理Unicode字符串时会先转换成ASCII字符串，超出范围则报错；unicode()和unichr()则是Unicode版本的str()和chr()。

8.4 Codecs是什么

　　codec是COder/DECoder的首字母组合，它定义了文本跟二进制值的转换方式。Unicode用的是多字节，所以它支持多种不同的编码方式，比如说codec支持的四种耳熟能详的编码方式是：ASCII，ISO8859-1/Latin-1，UTF-8和UTF-16。

　　其中最著名的是UTF-8编码，它也用一个字节来编码ASCII 字符，跟ASCII编码完全相同。UTF-8编码用1~4个字节来表示其他语言的字符，汉语一般都是用3个字节来表示。Python替我们完成了相关细节，我们无须为处理多字节字符的复杂问题而担心。

　　UTF-16以后可能会常用。它容易读写，因为所有字符都是用2B来存储，而这两个字节的顺序需要定义一下（大小端的问题），一般的UTF-16编码文件都需要一个BOM(Byte Order Mark)，或者显式地定义UTF-16-LE（小端）或者 UTF-16-BE（大端）字节序。

8.5 编码解码　　

　　Unicode支持多种编码格式，写文件时必须定义一个编码(encoding参数)用于把对应的Unicode内容转换成定义的格式。

　　Unicode字符串的encode()用于编码，该函数接受字符串中的字符为参数，输出指定的编码格式的内容。

#!/usr/bin/env python

'''
An example of reading and writing Unicode strings:
Writes a Unicode string to a file in utf-8 and reads it back in.
'''

CODEC = 'utf-8'
FILE  = 'unicode.txt'

hello_out = u"Hello world\n"
bytes_out = hello_out.encode(CODEC) #编码

f = open(FILE, "w")
f.write(bytes_out)   #将编码的内容写入文件
f.close()

f = open(FILE, "r")
bytes_in = f.read()  #读文件
f.close()

hello_in = bytes_in.decode(CODEC) #解码
print hello_in,　　　　　　　　　　　#输出，去掉print的换行符（即逗号的作用）

$ python pytest.py #执行
Hello world
$ cat unicode.txt  #显示生成的文件内容
Hello world

8.6 Unicode应用到实际应用中

　　以下经验可以避免很多错误：

程序中出现字符串时一定要加个前缀u。

不要用str()函数，用unicode()代替。

不要用过时的string模块——如果传给它的是非ASCII字符，它会把一切搞砸。

尽量不在程序里面编解码Unicod字符，只在写入文件/数据库/网络时才调用encode()函数；只在读数据时才调用decode()函数。

8.7 Python的Unicode支持

　　内建的unicode()、encode()、decode()函数，接受一个字符串为参数，分别返回一个unicode对象、编码/解码后的字符串。

　　类型：Unicode类型是basestring的子类，用unicode()工厂函数/字符串前加u来创建实例。

　　序数：ord()接受一个unicode字符，返回其码值；unichr()接受一个码值，返回一个Unicode字符。

　　转换：普通字符串和Unicode字符串运算，会将普通串强制转换为Unicode串。

　　异常：所有关于Unicode编解码的异常都继承自UnicodeError，这是exceptions模块中ValueError的子类。

　　RE：正则表达式引擎需要Unicode支持。

　　格式化操作：如果格式化字符串是Unicode对象（比如u"%s"），或输出中包含Unicode串，则执行转换 数字->普通字符串->Unicode字符串。

>>> '%s' % 'abc'
'abc'
>>> u'%s' % 'abc'    #格式化字符串是Unicode对象
u'abc'
>>> '%s' % u'abc'    #输出是Unicode对象
u'abc'
>>> '%s-%s' % (u'abc', 12)    #数字->字符串->Unicode串
u'abc-12'

　　常用Unicode编码：

utf-8      #变量长度为8的编码(默认编码)
utf-16     #变量长度为16的编码(大/小端)
utf-16-le  #小端UTF-16编码
utf-16-be  #大端UTF-16编码
ascii      #7位ASCII码表
iso-8859-1 #ISO8859-1(Latin-1)码表
unicode-escape     #(定义见Python Unicode构造函数)
raw-unicode-escape #(定义见Python Unicode构造函数)
native     #Python用的内部格式

9 相关模块

string      #字符串操作相关函数和工具，比如Template类
re          #正则表达式：强大的字符串模式匹配模块
struct      #字符串和二进制之间的转换
c/StringIO  #字符串缓冲对象，操作方法类似于file对象
base64      #Base 16,32,64数据编解码
codecs      #解码器注册和基类
crypt       #进行单方面加密
difflib     #找出序列间的不同
hashlib     #多种不同安全哈希算法和信息摘要算法的API
hma         #HMAC信息鉴权算法的Python实现
md5         #RSA的MD5信息摘要鉴权
rotor       #提供多平台的加解密服务
sha         #NIAT的安全哈希算法SHA
stringprep  #提供用于IP协议的Unicode字符串
textwrap    #文本打包和填充
unicodedata #Unicode数据库

　　正则表达式的用处自不必说，第15会做详细介绍。re模块中重要的函数有：　　

compile() - 将一个RE表达式编译成一个可重用的RE对象

match() - 试图从字符串的开始匹配一个模式

search() - 找出字符串中所有匹配的项

sub() - 进行查找替换操作。其中的一些函数返回匹配到的对象，可以通过组匹配来访问（如果找到的话）。

10 字符串关键点总结

单/双引号包围

不可变类型

格式化操作符%

三引号

取消转义

NUL或'\0'不是结束符